@evertondgn/solid-tooling 0.2.0 → 0.3.0

package/README.md

@@ -1,9 +1,9 @@
 # @evertondgn/solid-tooling
 
-Lint preset, formatter config and TypeScript base for SolidJS 2 applications
-built with [Vite+](https://viteplus.dev/guide/).
+Lint preset, formatter config, TypeScript configs and test configs for SolidJS 2
+applications built with [Vite+](https://viteplus.dev/guide/).
 
-The package contains the lint, format and TypeScript setup of
+The package contains the lint, format, TypeScript and test setup of
 [boilerplate_solidjs](https://github.com/everton-dgn/boilerplate_solidjs), a
 SolidJS application template. Applications created from it install the package
 instead of copying the files, so a rule change reaches them through a version
@@ -27,6 +27,13 @@ with the version in its `devDependencies`.
 `eslint-plugin-solid` comes with the package, so the application does not
 declare it.
 
+The test entries need the test tools the application already runs:
+
+| Entry          | The application installs                                                       |
+| -------------- | ------------------------------------------------------------------------------ |
+| `./vitest`     | `@vitest/browser-playwright`, `@vitest/coverage-v8`, `happy-dom`, `playwright` |
+| `./playwright` | `@playwright/test`, an optional peer dependency pinned like the others         |
+
 ## Install
 
 `vp` is the Vite+ CLI. An application built with Vite+ already has `vite-plus`
@@ -68,6 +75,63 @@ export default defineConfig({ fmt, lint })
 
 `vp check`, `vp lint` and `vp fmt` read both configs from `vite.config.ts`.
 
+## Tests
+
+`solidTest` returns the `test` block of `vite.config.ts`, with three Vitest
+projects:
+
+| Project   | Files                            | Environment                                      |
+| --------- | -------------------------------- | ------------------------------------------------ |
+| `node`    | `src/**/*.node.test.{ts,tsx}`    | Node, with stand-ins for the build-only modules  |
+| `dom`     | `src/**/*.dom.test.{ts,tsx}`     | happy-dom at `http://localhost/en`               |
+| `browser` | `src/**/*.browser.test.{ts,tsx}` | Chromium through Playwright, with the CSS loaded |
+
+```ts
+// vite.config.ts
+import { solidTest } from '@evertondgn/solid-tooling/vitest'
+
+export default defineConfig({
+  test: solidTest({ root: import.meta.dirname, plugins: componentPlugins })
+})
+```
+
+`plugins` is a function that returns the Vite plugins the `dom` and `browser`
+projects need to compile components: Solid, routes, icons and i18n. The preset
+calls it once per project, because each project starts its own Vite server and a
+plugin instance keeps the state of one server. The preset also sets the coverage
+thresholds, the reporters and the workers on CI, passes `BASE_URL_TEST`, `HOST`
+and `PORT` to the tests when they are set, and resets the Paraglide locale
+before each browser test.
+
+The `node` project does not load the Solid and routing plugins, so a plugin of
+the preset serves `server-only`, `virtual:file-routes` and
+`virtual:solid-server-function-handler`. Knip does not know `server-only`, a
+virtual module of `@solidjs/vite-plugin`: list it in `ignoreDependencies`.
+
+`definePlaywrightConfig` builds the Playwright config from the application root:
+
+```ts
+// playwright.config.ts
+import { definePlaywrightConfig } from '@evertondgn/solid-tooling/playwright'
+
+export default definePlaywrightConfig({ root: import.meta.dirname })
+```
+
+It reads `BASE_URL_TEST` from `.env.test`, builds the application (`e2e` mode
+for the fixture routes, `production` with `TEST_PRODUCTION_ROUTES=true`), starts
+the preview, and checks the server log for private markers when the suite ends.
+`TEST_PREBUILT=true` reuses an existing production build.
+
+| Option           | Default           | Use                                                                    |
+| ---------------- | ----------------- | ---------------------------------------------------------------------- |
+| `testDir`        | `src/tests/pages` | Folder of the `*.e2e.test.ts` files                                    |
+| `fixtureServers` | none              | Extra servers for the fixture routes, as `{ command, url }`            |
+| `suites`         | none              | Globs of serial suites: `serverLogs`, `markdown` and `publicationLoad` |
+
+Each serial suite gets its own project: `markdown` runs with one worker,
+`serverLogs` runs last as the teardown of the others, and `publicationLoad` runs
+alone, against two servers, with `TEST_PUBLICATION_LOAD=true`.
+
 ## Project layout the preset expects
 
 The rules match file paths relative to the folder where lint runs, so run it
@@ -205,20 +269,26 @@ overrides: [
 
 ## Entry points
 
-| Entry                   | Content                                                                   |
-| ----------------------- | ------------------------------------------------------------------------- |
-| `./lint`                | `lint`: the lint preset, with the plugins below registered                |
-| `./fmt`                 | `fmt`: the formatter config                                               |
-| `./tsconfig.base.json`  | Compiler options, without application paths                               |
-| `./project-plugin`      | The `project` rules                                                       |
-| `./backend-plugin`      | The `backend` rules                                                       |
-| `./architecture-plugin` | The `architecture` rule                                                   |
-| `./solid-plugin`        | Re-export of `eslint-plugin-solid`                                        |
-| `./css-filename`        | `cssFilenameError(path)`, the CSS naming check, for a script outside lint |
-
-An application only imports `./lint`, `./fmt` and `./tsconfig.base.json`. The
-plugin entries exist because Oxlint loads plugins by specifier, from the
-application.
+| Entry                    | Content                                                                   |
+| ------------------------ | ------------------------------------------------------------------------- |
+| `./lint`                 | `lint`: the lint preset, with the plugins below registered                |
+| `./fmt`                  | `fmt`: the formatter config                                               |
+| `./tsconfig.base.json`   | Compiler options, without application paths                               |
+| `./tsconfig.app.json`    | The base plus the `types` and `include` of the boilerplate layout         |
+| `./vitest`               | `solidTest(options)`, the `test` block of `vite.config.ts`                |
+| `./playwright`           | `definePlaywrightConfig(options)`, the Playwright config                  |
+| `./vitest-setup/browser` | Setup file of the browser project, loaded by `./vitest`                   |
+| `./playwright-teardown`  | Server log check, loaded by `./playwright`                                |
+| `./project-plugin`       | The `project` rules                                                       |
+| `./backend-plugin`       | The `backend` rules                                                       |
+| `./architecture-plugin`  | The `architecture` rule                                                   |
+| `./solid-plugin`         | Re-export of `eslint-plugin-solid`                                        |
+| `./css-filename`         | `cssFilenameError(path)`, the CSS naming check, for a script outside lint |
+
+An application imports `./lint`, `./fmt`, `./vitest`, `./playwright` and one of
+the TypeScript configs. The plugin entries exist because Oxlint loads plugins by
+specifier, from the application; the setup and teardown entries are loaded by
+the test presets.
 
 ## Formatter
 
@@ -230,8 +300,36 @@ generated route types, SVG and lock files.
 
 `tsconfig.base.json` targets ES2024 with bundler resolution, keeps JSX for the
 Solid compiler (`jsxImportSource: @solidjs/web`), emits nothing and turns on the
-unused code and unchecked index checks. It has no `paths`, `include` or `types`:
-those depend on the application and stay in its `tsconfig.json`.
+unused code and unchecked index checks. It has no `paths`, `include` or `types`.
+
+`tsconfig.app.json` extends the base with the `types` of a boilerplate
+application and an `include` resolved from the application folder with
+`${configDir}`, which needs TypeScript 5.5 or later. Each entry of `types` comes
+from a package the application installs:
+
+| Entry of `types`                        | Package                     |
+| --------------------------------------- | --------------------------- |
+| `node`                                  | `@types/node`               |
+| `vite/client`                           | `vite`                      |
+| `vite-plus/test/globals`                | `vite-plus`                 |
+| `@testing-library/jest-dom/vitest`      | `@testing-library/jest-dom` |
+| `@solidjs/vite-plugin/boundary-modules` | `@solidjs/vite-plugin`      |
+| `@solidjs/vite-plugin/virtual-modules`  | `@solidjs/vite-plugin`      |
+
+The application still declares its `paths`:
+
+```json
+{
+  "extends": "@evertondgn/solid-tooling/tsconfig.app.json",
+  "compilerOptions": {
+    "paths": { "@/*": ["./src/*"], "@paraglide/*": ["./paraglide/*"] }
+  }
+}
+```
+
+Playwright reads the `tsconfig.json` of the test files with its own loader,
+which does not expand `${configDir}`, so paths declared in the package would
+break the `@/` imports of the end-to-end tests.
 
 ## Known limits
 
@@ -246,6 +344,10 @@ those depend on the application and stay in its `tsconfig.json`.
   installed even in an application without translations.
 - Some rule messages point to `docs/architecture.md` and `AGENTS.md`. Those
   files belong to the application created from boilerplate_solidjs.
+- The test presets expect the boilerplate layout: tests named by suffix
+  (`.node.test`, `.dom.test`, `.browser.test`, `.e2e.test`), page tests in
+  `src/tests/pages/`, Paraglide output in `paraglide/` and `.env.test` at the
+  root.
 
 ## Versions
 

package/dist/playwright-teardown.d.mts

@@ -0,0 +1 @@
+export default function checkServerLog(): Promise<void>;

package/dist/playwright-teardown.mjs

@@ -0,0 +1,23 @@
+import { env } from "node:process";
+import { readFile } from "node:fs/promises";
+import { stripVTControlCharacters } from "node:util";
+// src/playwright/teardown.ts
+const PRIVATE_MARKER = /PRIVATE_[A-Z0-9_]+/u;
+async function checkLog({ file, baseUrl }) {
+	if (!file || !baseUrl) throw new Error("Server log file is not configured");
+	const log = stripVTControlCharacters(await readFile(file, "utf8"));
+	const { host } = new URL(baseUrl);
+	if (!log.includes(host)) throw new Error(`Server log does not show the preview startup: ${file}`);
+	if (PRIVATE_MARKER.test(log)) throw new Error(`Server log contains a private marker: ${file}`);
+}
+async function checkServerLog() {
+	await checkLog({
+		file: env.SERVER_LOG_FILE,
+		baseUrl: env.BASE_URL_TEST
+	});
+	if (env.TEST_PUBLICATION_LOAD === "true") await checkLog({
+		file: env.SERVER_LOG_SECONDARY,
+		baseUrl: env.PUBLICATION_SECONDARY_URL
+	});
+}
+export { checkServerLog as default };

package/dist/playwright.d.mts

@@ -0,0 +1,18 @@
+import { PlaywrightTestConfig } from "@playwright/test";
+type FixtureServer = {
+  command: string;
+  url: string;
+};
+type SerialSuites = {
+  serverLogs?: string;
+  markdown?: string;
+  publicationLoad?: string;
+};
+type PlaywrightOptions = {
+  root: string;
+  testDir?: string;
+  fixtureServers?: FixtureServer[];
+  suites?: SerialSuites;
+};
+export declare function definePlaywrightConfig({ root, testDir, fixtureServers, suites }: PlaywrightOptions): PlaywrightTestConfig;
+export {};

package/dist/playwright.mjs

@@ -0,0 +1,158 @@
+import path from "node:path";
+import { env, loadEnvFile } from "node:process";
+import { fileURLToPath } from "node:url";
+import { defineConfig, devices } from "@playwright/test";
+import { loadEnv } from "vite-plus";
+// src/playwright/index.ts
+const STARTUP_TIMEOUT = 12e4;
+const SECONDARY_PORT_OFFSET = 2;
+const MAX_PORT = 65535;
+const CI_WORKERS = 2;
+const SECONDARY_LOG = "test-results/server-publication-secondary.log";
+const PREBUILT_GUARD = "if [ -e .vercel/output/static/.vite ]; then echo 'TEST_PREBUILT found an e2e build; run vp run build first' >&2; exit 1; fi && ";
+function readRunMode(suites) {
+	const mode = {
+		isProduction: env.TEST_PRODUCTION_ROUTES === "true",
+		isPublicationLoad: env.TEST_PUBLICATION_LOAD === "true",
+		shouldBuild: env.TEST_PREBUILT !== "true"
+	};
+	if (mode.isPublicationLoad && mode.isProduction) throw new Error("TEST_PUBLICATION_LOAD requires fixture routes");
+	if (mode.isPublicationLoad && !suites.publicationLoad) throw new Error("TEST_PUBLICATION_LOAD requires a publicationLoad suite");
+	if (!mode.shouldBuild && !mode.isProduction) throw new Error("TEST_PREBUILT requires production routes");
+	return mode;
+}
+function readBaseUrl(mode) {
+	if (!env.BASE_URL_TEST) throw new Error(".env.test must define BASE_URL_TEST");
+	const baseUrl = new URL(env.BASE_URL_TEST);
+	if (!baseUrl.port) throw new Error("BASE_URL_TEST must include an explicit port");
+	if (mode.isPublicationLoad && Number(baseUrl.port) + SECONDARY_PORT_OFFSET > MAX_PORT) throw new Error("BASE_URL_TEST leaves no port for the secondary server");
+	return env.BASE_URL_TEST;
+}
+function readWorkers(mode) {
+	if (mode.isPublicationLoad) return 1;
+	return env.CI ? CI_WORKERS : void 0;
+}
+function secondaryUrl(baseUrl) {
+	const url = new URL(baseUrl);
+	url.port = String(Number(url.port) + SECONDARY_PORT_OFFSET);
+	return url;
+}
+function buildProjects({ mode, suites }) {
+	if (mode.isPublicationLoad) return [{
+		name: "publication-load",
+		testMatch: suites.publicationLoad
+	}];
+	if (mode.isProduction) return [{ name: "chromium" }];
+	const teardown = suites.serverLogs ? { teardown: "server-logs" } : {};
+	const projects = [{
+		name: "chromium",
+		testIgnore: ["**/*.production.e2e.test.ts", ...[
+			suites.serverLogs,
+			suites.publicationLoad,
+			suites.markdown
+		].filter((suite) => suite !== void 0)],
+		...teardown
+	}];
+	if (suites.markdown) projects.push({
+		name: "markdown",
+		testMatch: suites.markdown,
+		fullyParallel: false,
+		workers: 1,
+		...teardown
+	});
+	if (suites.serverLogs) projects.push({
+		name: "server-logs",
+		testMatch: suites.serverLogs,
+		fullyParallel: false
+	});
+	return projects;
+}
+function buildServers({ root, mode, fixtureServers, baseUrl, serverLog }) {
+	const buildMode = mode.isProduction ? "production" : "e2e";
+	const build = mode.shouldBuild ? `vp run build --mode ${buildMode} && ` : PREBUILT_GUARD;
+	const shared = {
+		cwd: root,
+		reuseExistingServer: false
+	};
+	const server = {
+		...shared,
+		timeout: STARTUP_TIMEOUT
+	};
+	const fixtures = mode.isProduction ? [] : fixtureServers.map((fixture) => ({
+		...fixture,
+		...shared
+	}));
+	const { hostname, port } = new URL(baseUrl);
+	const secondary = secondaryUrl(baseUrl);
+	return [
+		...fixtures,
+		{
+			...server,
+			command: `${build}mkdir -p test-results && vp run start --strictPort > ${serverLog} 2>&1`,
+			env: {
+				HOST: hostname,
+				PORT: port,
+				NODE_ENV: "production"
+			},
+			url: baseUrl
+		},
+		...mode.isPublicationLoad ? [{
+			...server,
+			command: `vp run start --strictPort > ${SECONDARY_LOG} 2>&1`,
+			env: {
+				HOST: hostname,
+				PORT: secondary.port,
+				NODE_ENV: "production"
+			},
+			url: secondary.href
+		}] : []
+	];
+}
+function definePlaywrightConfig({ root, testDir = "src/tests/pages", fixtureServers = [], suites = {} }) {
+	loadEnvFile(path.join(root, ".env.test"));
+	const mode = readRunMode(suites);
+	const buildMode = mode.isProduction ? "production" : "e2e";
+	Object.assign(env, loadEnv(buildMode, root, "VITE_"));
+	const baseUrl = readBaseUrl(mode);
+	const serverLog = `test-results/server-${buildMode}.log`;
+	env.SERVER_LOG_FILE = path.join(root, serverLog);
+	if (mode.isPublicationLoad) {
+		env.PUBLICATION_SECONDARY_URL = secondaryUrl(baseUrl).href;
+		env.SERVER_LOG_SECONDARY = path.join(root, SECONDARY_LOG);
+	}
+	const reportFolder = mode.isProduction ? "production" : "e2e";
+	return defineConfig({
+		testDir: path.join(root, testDir),
+		testMatch: mode.isProduction ? "**/*.production.e2e.test.ts" : "**/*.e2e.test.ts",
+		outputDir: path.join(root, mode.isProduction ? "test-results/e2e-production" : "test-results/e2e"),
+		globalTeardown: fileURLToPath(new URL("playwright-teardown.mjs", import.meta.url)),
+		fullyParallel: !mode.isPublicationLoad,
+		forbidOnly: true,
+		workers: readWorkers(mode),
+		reporter: [["list"], ["html", {
+			outputFolder: path.join(root, "playwright-report", reportFolder),
+			open: "never",
+			onlyFailures: Boolean(env.CI)
+		}]],
+		use: {
+			...devices["Desktop Chrome"],
+			channel: env.CI ? "chrome" : void 0,
+			baseURL: baseUrl,
+			locale: "en-US",
+			screenshot: "only-on-failure",
+			trace: "retain-on-failure"
+		},
+		projects: buildProjects({
+			mode,
+			suites
+		}),
+		webServer: buildServers({
+			root,
+			mode,
+			fixtureServers,
+			baseUrl,
+			serverLog
+		})
+	});
+}
+export { definePlaywrightConfig };

package/dist/vitest-setup/browser.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/vitest-setup/browser.mjs

@@ -0,0 +1,5 @@
+import { baseLocale, setLocale } from "@paraglide/runtime.js";
+import { beforeEach } from "vite-plus/test";
+// src/vitest/setup/browser.ts
+beforeEach(() => setLocale(baseLocale, { reload: false }));
+export {};

package/dist/vitest.d.mts

@@ -0,0 +1,7 @@
+import { TestUserConfig, ViteUserConfig } from "vite-plus";
+type SolidTestOptions = {
+  root: string;
+  plugins: () => ViteUserConfig['plugins'];
+};
+export declare function solidTest({ root, plugins }: SolidTestOptions): TestUserConfig;
+export {};

package/dist/vitest.mjs

@@ -0,0 +1,129 @@
+import path from "node:path";
+import { env } from "node:process";
+import { fileURLToPath } from "node:url";
+import { playwright } from "vite-plus/test/browser-playwright";
+// src/vitest/index.ts
+const CI_WORKERS = 2;
+const STUB_PREFIX = "\0solid-tooling-stub:";
+const NODE_STUBS = /* @__PURE__ */ new Map([
+	["server-only", "export default undefined"],
+	["virtual:file-routes", "export const pageRoutes = []\nexport default []"],
+	["virtual:solid-server-function-handler", "export const endpoint = '/_server'"]
+]);
+const TEST_ENV_KEYS = [
+	"BASE_URL_TEST",
+	"HOST",
+	"PORT"
+];
+function packageFile(name) {
+	return fileURLToPath(new URL(name, import.meta.url));
+}
+function nodeStubs() {
+	return {
+		name: "solid-tooling:node-stubs",
+		enforce: "pre",
+		resolveId: (id) => NODE_STUBS.has(id) ? `${STUB_PREFIX}${id}` : void 0,
+		load: (id) => id.startsWith(STUB_PREFIX) ? NODE_STUBS.get(id.slice(20)) : void 0
+	};
+}
+function readTestEnv() {
+	return Object.fromEntries(TEST_ENV_KEYS.flatMap((key) => {
+		const value = env[key];
+		return value === void 0 ? [] : [[key, value]];
+	}));
+}
+function solidTest({ root, plugins }) {
+	return {
+		pool: "threads",
+		maxWorkers: env.CI ? CI_WORKERS : void 0,
+		css: false,
+		globals: true,
+		restoreMocks: true,
+		unstubGlobals: true,
+		unstubEnvs: true,
+		expect: {
+			requireAssertions: true,
+			poll: { interval: 10 }
+		},
+		env: readTestEnv(),
+		coverage: {
+			provider: "v8",
+			reporter: ["text", "html"],
+			thresholds: {
+				lines: 80,
+				functions: 80,
+				branches: 75,
+				statements: 80
+			},
+			include: ["src/**/*.{ts,tsx}"],
+			exclude: [
+				"src/**/*.d.ts",
+				"src/**/{constants,types,@types}/**",
+				"src/**/{constants,types}.{ts,tsx}",
+				"src/**/__tests__/**",
+				"src/tests/**",
+				"src/App.tsx",
+				"src/Document.tsx",
+				"src/entry-server.tsx",
+				"src/entry-client.tsx",
+				"src/router.ts"
+			]
+		},
+		reporters: env.GITHUB_ACTIONS ? ["default", "github-actions"] : ["verbose"],
+		projects: [
+			{
+				plugins: [nodeStubs()],
+				test: {
+					name: {
+						label: "node",
+						color: "cyan"
+					},
+					environment: "node",
+					include: ["src/**/*.node.test.{ts,tsx}"]
+				}
+			},
+			{
+				plugins: plugins(),
+				test: {
+					name: {
+						label: "dom",
+						color: "magenta"
+					},
+					environment: "happy-dom",
+					environmentOptions: { happyDOM: { url: "http://localhost/en" } },
+					include: ["src/**/*.dom.test.{ts,tsx}"]
+				}
+			},
+			{
+				plugins: plugins(),
+				resolve: { alias: [{
+					find: /^@paraglide\//u,
+					replacement: `${path.join(root, "paraglide")}/`
+				}] },
+				test: {
+					css: true,
+					name: {
+						label: "browser",
+						color: "yellow"
+					},
+					setupFiles: [packageFile("vitest-setup/browser.mjs")],
+					include: ["src/**/*.browser.test.{ts,tsx}"],
+					browser: {
+						enabled: true,
+						headless: true,
+						trace: {
+							mode: "retain-on-failure",
+							tracesDir: path.join(root, "test-results/browser-traces")
+						},
+						provider: playwright({
+							contextOptions: { locale: "en-US" },
+							launchOptions: env.CI ? { channel: "chrome" } : {}
+						}),
+						instances: [{ browser: "chromium" }]
+					}
+				}
+			}
+		]
+	};
+}
+export { solidTest };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@evertondgn/solid-tooling",
-  "version": "0.2.0",
-  "description": "Lint, formatter and TypeScript presets for SolidJS applications built with Vite+.",
+  "version": "0.3.0",
+  "description": "Lint, formatter, TypeScript and test presets for SolidJS applications built with Vite+.",
   "author": "Éverton Toffanetto",
   "license": "MIT",
   "repository": {
@@ -19,7 +19,8 @@
   "type": "module",
   "files": [
     "dist",
-    "tsconfig.base.json"
+    "tsconfig.base.json",
+    "tsconfig.app.json"
   ],
   "exports": {
     "./architecture-plugin": "./dist/architecture-plugin.mjs",
@@ -27,10 +28,15 @@
     "./css-filename": "./dist/css-filename.mjs",
     "./fmt": "./dist/fmt.mjs",
     "./lint": "./dist/lint.mjs",
+    "./playwright": "./dist/playwright.mjs",
+    "./playwright-teardown": "./dist/playwright-teardown.mjs",
     "./project-plugin": "./dist/project-plugin.mjs",
     "./solid-plugin": "./dist/solid-plugin.mjs",
+    "./vitest": "./dist/vitest.mjs",
+    "./vitest-setup/browser": "./dist/vitest-setup/browser.mjs",
     "./package.json": "./package.json",
-    "./tsconfig.base.json": "./tsconfig.base.json"
+    "./tsconfig.base.json": "./tsconfig.base.json",
+    "./tsconfig.app.json": "./tsconfig.app.json"
   },
   "publishConfig": {
     "access": "public"
@@ -46,13 +52,20 @@
   },
   "peerDependencies": {
     "@inlang/paraglide-js": "3.2.2",
-    "vite-plus": "1.6.0"
+    "vite-plus": "1.6.0",
+    "@playwright/test": "1.65.0"
   },
   "devDependencies": {
     "@inlang/paraglide-js": "3.2.2",
     "@types/node": "24.19.2",
     "typescript": "7.0.2",
     "valibot": "1.5.0",
-    "vite-plus": "1.6.0"
+    "vite-plus": "1.6.0",
+    "@playwright/test": "1.65.0"
+  },
+  "peerDependenciesMeta": {
+    "@playwright/test": {
+      "optional": true
+    }
   }
 }

package/tsconfig.app.json

@@ -0,0 +1,21 @@
+{
+  "extends": "./tsconfig.base.json",
+  "compilerOptions": {
+    "types": [
+      "node",
+      "vite/client",
+      "vite-plus/test/globals",
+      "@testing-library/jest-dom/vitest",
+      "@solidjs/vite-plugin/boundary-modules",
+      "@solidjs/vite-plugin/virtual-modules"
+    ]
+  },
+  "include": [
+    "${configDir}/src",
+    "${configDir}/env.ts",
+    "${configDir}/solid-env.d.ts",
+    "${configDir}/vite.config.ts",
+    "${configDir}/playwright.config.ts",
+    "${configDir}/tooling/**/*.ts"
+  ]
+}