@coryrylan/tools 0.1.0

package/dist/stylelint/index.js

@@ -0,0 +1,50 @@
+//#region src/stylelint/index.ts
+/**
+* Personal Stylelint preferences layered on `stylelint-config-standard`.
+* Point a `stylelint.config.js` at it with
+* `export { default } from '@coryrylan/tools/stylelint';`, or import the
+* default export and add `rules`/`overrides` on top for project-specific
+* exceptions.
+*/
+var config = {
+	extends: ["stylelint-config-standard"],
+	ignoreFiles: [
+		"**/node_modules/**",
+		"**/dist/**",
+		"**/.wireit/**",
+		"**/.eslintcache/**",
+		"**/coverage/**"
+	],
+	rules: {
+		"alpha-value-notation": "number",
+		"hue-degree-notation": "number",
+		"property-no-vendor-prefix": null,
+		"declaration-empty-line-before": null,
+		"custom-property-empty-line-before": null,
+		"import-notation": null,
+		"custom-property-pattern": "^_?[a-z][a-z0-9]*(-[a-z0-9]+)*$",
+		"value-keyword-case": ["lower", { ignoreKeywords: ["currentColor"] }],
+		"declaration-block-no-redundant-longhand-properties": [true, { ignoreShorthands: ["grid-template"] }],
+		"no-duplicate-selectors": null,
+		"no-descending-specificity": null,
+		"comment-empty-line-before": null,
+		"property-disallowed-list": [
+			"margin-left",
+			"margin-right",
+			"margin-top",
+			"margin-bottom",
+			"padding-left",
+			"padding-right",
+			"padding-top",
+			"padding-bottom"
+		],
+		"declaration-property-value-disallowed-list": [{
+			"/^(margin|padding)(-(top|right|bottom|left|inline|block|inline-start|inline-end|block-start|block-end))?$/": ["/(?<!\\w)\\d+px/"],
+			"/^(gap|row-gap|column-gap)$/": ["/(?<!\\w)\\d+px/"],
+			"/^(top|right|bottom|left)$/": ["/(?<!\\w)\\d+px/"],
+			"/^inset(-(inline|block)(-(start|end))?)?$/": ["/(?<!\\w)\\d+px/"]
+		}, { message: "Use a CSS custom property (design token) instead of a hardcoded pixel value." }]
+	}
+};
+//#endregion
+export { config as default };

package/dist/vale/styles/config/vocabularies/Tools/accept.txt

@@ -0,0 +1,80 @@
+(H|h)ardcoded
+a11y
+allowlist(s)?
+API(s)?
+ARIA
+blocklist(s)?
+boolean(s)?
+bundler(s)?
+changelog
+CLI
+codebase(s)?
+config(s)?
+CSS
+declaratively
+dedupe(d|s)?
+deduplicate(d|s)?
+deduplication
+dev
+devDependenc(y|ies)
+DOM
+downlevel
+Eleventy
+ESLint
+ESM
+extensionless
+flexbox
+frontmatter
+GitHub
+globals
+greppable
+HTML
+i18n
+IDE
+ini
+inlined
+istanbul
+JSDoc
+JSON(C)?
+linter(s)?
+linting
+lockfile
+longhand(s)?
+lookup(s)?
+MCP
+middleware
+mise
+mixin(s)?
+monorepo(s)?
+multiline
+namespace(d|s)?
+npm
+NVIDIA
+parens
+Playwright
+pluggable
+pnpm
+polyfill(s)?
+pre-release
+Prettier
+repo(s)?
+Rolldown
+Rollup('s)?
+Rylan
+semver
+SSR
+Stylelint
+stylesheet(s)?
+subclass(ers|es|ing)?
+superclass('s|es)?
+teardown(s)?
+toolchain(s)?
+tsconfig
+TypeScript
+typescript-eslint
+uncomment(ed)?
+Vale
+Vite
+Vitest
+wireit
+write-good

package/dist/vale/styles/config/vocabularies/Tools/reject.txt

@@ -0,0 +1,5 @@
+blacklist
+e-mail
+repo(sitory)? admin
+web site
+whitelist

package/dist/vale/vale.ini

@@ -0,0 +1,27 @@
+# StylesPath assumes a consumer's .vale.ini lives at the project root, so
+# node_modules/@coryrylan/tools resolves relative to it - adjust the path if
+# this template is copied elsewhere. Run `vale sync` once after installing to
+# download the Google and write-good packages into StylesPath.
+StylesPath = node_modules/@coryrylan/tools/dist/vale/styles
+MinAlertLevel = warning
+Vocab = Tools
+Packages = Google, write-good
+
+[*.md]
+BasedOnStyles = Vale, Google, write-good
+TokenIgnores = (\{%[\s\S]*?%\}), (\{\{[^}]*\}\})
+Vale.Terms = NO
+Google.Headings = NO
+Google.WordList = NO
+; Spaced em dashes, `e.g.`/`i.e.`, and logical quote punctuation
+; (periods outside quotation marks) are the house style.
+Google.EmDash = NO
+Google.Latin = NO
+Google.Quotes = NO
+
+[*.ts]
+BasedOnStyles = Vale, write-good
+write-good.TooWordy = error
+write-good.Passive = error
+Vale.Spelling = NO
+Vale.Terms = NO

package/dist/vite/index.d.ts

@@ -0,0 +1,37 @@
+import type { LibraryOptions, UserConfig } from 'vite';
+/** Options for {@link createNodeLibraryBuildConfig}. */
+export interface NodeLibraryBuildConfigOptions {
+    readonly entry: LibraryOptions['entry'];
+}
+/** Options for {@link createBrowserLibraryBuildConfig}. */
+export interface BrowserLibraryBuildConfigOptions {
+    readonly entry: LibraryOptions['entry'];
+}
+/**
+ * Vite build config for a Node.js library entry point: ESM output only,
+ * targets `node22`, and never bundles a dependency - every bare specifier
+ * (`lit`, `node:path`, `@scope/pkg`) is externalized. `preserveModules`
+ * keeps one output file per source module instead of one monolithic
+ * bundle, so `package.json#exports` can expose deep-import paths.
+ *
+ * Extend it with `mergeConfig` rather than hand-rolling the shape again:
+ *
+ * ```ts
+ * import { mergeConfig } from 'vite';
+ * import { createNodeLibraryBuildConfig } from '@coryrylan/tools/vite';
+ *
+ * export default mergeConfig(
+ *   createNodeLibraryBuildConfig({ entry: { index: 'src/index.ts' } }),
+ *   { plugins: [] },
+ * );
+ * ```
+ */
+export declare function createNodeLibraryBuildConfig(options: NodeLibraryBuildConfigOptions): UserConfig;
+/**
+ * Vite build config for a browser library entry point. Same shape as
+ * {@link createNodeLibraryBuildConfig} - ESM-only, everything external,
+ * `preserveModules` - except it targets `esnext` instead of a Node.js
+ * runtime, since the consuming browser (or a downstream bundler) declares
+ * its own compilation baseline.
+ */
+export declare function createBrowserLibraryBuildConfig(options: BrowserLibraryBuildConfigOptions): UserConfig;

package/dist/vite/index.js

@@ -0,0 +1,61 @@
+//#region src/vite/index.ts
+/**
+* The build shape both factories below share: ESM-only, every bare
+* specifier externalized (a dependency stays a real `package.json`
+* dependency instead of getting inlined, so tree-shaking stays viable
+* downstream), and `preserveModules` so `dist` mirrors `src` 1:1 - one
+* output file per source module, which is what lets `package.json#exports`
+* map deep-import paths straight to build output.
+*/
+function createLibraryBuildConfig(target, entry) {
+	return { build: {
+		target,
+		minify: false,
+		lib: {
+			entry,
+			formats: ["es"]
+		},
+		rollupOptions: {
+			external: (id) => !id.startsWith(".") && !id.startsWith("/"),
+			output: {
+				preserveModules: true,
+				preserveModulesRoot: "src",
+				entryFileNames: "[name].js"
+			}
+		}
+	} };
+}
+/**
+* Vite build config for a Node.js library entry point: ESM output only,
+* targets `node22`, and never bundles a dependency - every bare specifier
+* (`lit`, `node:path`, `@scope/pkg`) is externalized. `preserveModules`
+* keeps one output file per source module instead of one monolithic
+* bundle, so `package.json#exports` can expose deep-import paths.
+*
+* Extend it with `mergeConfig` rather than hand-rolling the shape again:
+*
+* ```ts
+* import { mergeConfig } from 'vite';
+* import { createNodeLibraryBuildConfig } from '@coryrylan/tools/vite';
+*
+* export default mergeConfig(
+*   createNodeLibraryBuildConfig({ entry: { index: 'src/index.ts' } }),
+*   { plugins: [] },
+* );
+* ```
+*/
+function createNodeLibraryBuildConfig(options) {
+	return createLibraryBuildConfig("node22", options.entry);
+}
+/**
+* Vite build config for a browser library entry point. Same shape as
+* {@link createNodeLibraryBuildConfig} - ESM-only, everything external,
+* `preserveModules` - except it targets `esnext` instead of a Node.js
+* runtime, since the consuming browser (or a downstream bundler) declares
+* its own compilation baseline.
+*/
+function createBrowserLibraryBuildConfig(options) {
+	return createLibraryBuildConfig("esnext", options.entry);
+}
+//#endregion
+export { createBrowserLibraryBuildConfig, createNodeLibraryBuildConfig };

package/dist/vite/plugins/dts.d.ts

@@ -0,0 +1,26 @@
+import type { Plugin } from 'vite';
+/** Options for {@link dts}. */
+export interface DtsPluginOptions {
+    /** Path to the `tsconfig` used for declaration emit, resolved against `process.cwd()`. @default 'tsconfig.build.json' */
+    readonly project?: string;
+    /** Directory declarations are emitted into, resolved against `process.cwd()`. @default 'dist' */
+    readonly outDir?: string;
+    /** Package providing the `bin/tsc` entry point to shell out to - swap in `'typescript-go'` for the native compiler alias. @default 'typescript' */
+    readonly compilerPackage?: string;
+}
+/**
+ * Generates the type declaration files that accompany a library's published
+ * JS build. Shells out to the consumer's own TypeScript compiler (or the
+ * `typescript-go` native-compiler alias, via `compilerPackage`) at build
+ * start so declarations are always in sync with the code that just built,
+ * then copies over any hand-written `.d.ts` files `tsc` wouldn't otherwise
+ * emit - for example, ambient module declarations. The compiler runs
+ * asynchronously; watch builds additionally pass `--incremental` with build
+ * info stored at `<outDir>/.tsbuildinfo` so a rebuild reuses tsc's prior
+ * state instead of retypechecking from scratch.
+ *
+ * If `compilerPackage` can't be resolved from the consumer's dependency
+ * tree, this warns and no-ops rather than throwing - library code never
+ * crashes a consumer's build over a misconfigured option.
+ */
+export declare function dts(options?: DtsPluginOptions): Plugin;

package/dist/vite/plugins/dts.js

@@ -0,0 +1,106 @@
+import { copyFileSync, existsSync, mkdirSync, readdirSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+//#region src/vite/plugins/dts.ts
+var DEFAULT_PROJECT = "tsconfig.build.json";
+var DEFAULT_OUT_DIR = "dist";
+var DEFAULT_COMPILER_PACKAGE = "typescript";
+/**
+* Resolves `<compilerPackage>/bin/tsc` from the *consuming* project's own
+* dependency tree, not this package's - a monorepo consumer commonly pins a
+* different TypeScript (or the `typescript-go` native-compiler alias) than
+* whatever this package itself was built with.
+*/
+function resolveTscBinaryPath(compilerPackage) {
+	try {
+		return resolve(dirname(createRequire(pathToFileURL(join(process.cwd(), "package.json"))).resolve(`${compilerPackage}/package.json`)), "bin/tsc");
+	} catch {
+		return;
+	}
+}
+/**
+* Copies every hand-written `src/**\/*.d.ts` (excluding `*.test.d.ts`) into
+* `outDir`, preserving its path relative to `srcDir` - `tsc` only emits
+* declarations for `.ts` sources, so ambient/hand-authored `.d.ts` files
+* never make it into the build output on their own.
+*/
+function copyHandWrittenDeclarationFiles(srcDir, outDir) {
+	if (!existsSync(srcDir)) return;
+	const declarationFilePaths = readdirSync(srcDir, { recursive: true }).filter((entry) => typeof entry === "string").filter((entry) => entry.endsWith(".d.ts") && !entry.endsWith(".test.d.ts"));
+	for (const relativePath of declarationFilePaths) {
+		const destination = resolve(outDir, relativePath);
+		mkdirSync(dirname(destination), { recursive: true });
+		copyFileSync(resolve(srcDir, relativePath), destination);
+	}
+}
+/**
+* Runs the resolved tsc binary without blocking the event loop. Rejects on a
+* nonzero exit so type errors still fail the build - the one place this
+* package's warn-and-no-op rule doesn't apply, because a silently skipped
+* typecheck would publish broken declarations.
+*/
+function runTsc(args) {
+	return new Promise((resolvePromise, rejectPromise) => {
+		const child = spawn(process.execPath, args, { stdio: "inherit" });
+		child.on("error", rejectPromise);
+		child.on("close", (code) => {
+			if (code === 0) resolvePromise();
+			else rejectPromise(/* @__PURE__ */ new Error(`tsc exited with code ${String(code)}`));
+		});
+	});
+}
+/**
+* Generates the type declaration files that accompany a library's published
+* JS build. Shells out to the consumer's own TypeScript compiler (or the
+* `typescript-go` native-compiler alias, via `compilerPackage`) at build
+* start so declarations are always in sync with the code that just built,
+* then copies over any hand-written `.d.ts` files `tsc` wouldn't otherwise
+* emit - for example, ambient module declarations. The compiler runs
+* asynchronously; watch builds additionally pass `--incremental` with build
+* info stored at `<outDir>/.tsbuildinfo` so a rebuild reuses tsc's prior
+* state instead of retypechecking from scratch.
+*
+* If `compilerPackage` can't be resolved from the consumer's dependency
+* tree, this warns and no-ops rather than throwing - library code never
+* crashes a consumer's build over a misconfigured option.
+*/
+function dts(options = {}) {
+	const project = options.project ?? DEFAULT_PROJECT;
+	const outDir = options.outDir ?? DEFAULT_OUT_DIR;
+	const compilerPackage = options.compilerPackage ?? DEFAULT_COMPILER_PACKAGE;
+	let isWatchBuild = false;
+	return {
+		name: "dts",
+		apply: "build",
+		configResolved(config) {
+			isWatchBuild = config.build.watch !== null;
+		},
+		async buildStart() {
+			const cwd = process.cwd();
+			const tscPath = resolveTscBinaryPath(compilerPackage);
+			if (tscPath === void 0) {
+				console.warn(`[@coryrylan/tools/vite] Could not resolve compiler package "${compilerPackage}" from ${cwd} - skipping declaration generation.`);
+				return;
+			}
+			const projectPath = resolve(cwd, project);
+			const outDirPath = resolve(cwd, outDir);
+			await runTsc([
+				tscPath,
+				"--project",
+				projectPath,
+				"--outDir",
+				outDirPath,
+				...isWatchBuild ? [
+					"--incremental",
+					"--tsBuildInfoFile",
+					join(outDirPath, ".tsbuildinfo")
+				] : []
+			]);
+			copyHandWrittenDeclarationFiles(resolve(cwd, "src"), outDirPath);
+		}
+	};
+}
+//#endregion
+export { dts };

package/dist/vite/plugins/write-if-changed.d.ts

@@ -0,0 +1,20 @@
+import type { Plugin } from 'vite';
+/** Options for {@link writeIfChanged}. */
+export interface WriteIfChangedPluginOptions {
+    /**
+     * Output directory to resolve emitted chunk file names against. Only
+     * consulted when Rollup's own `output.dir` isn't set on the build.
+     */
+    readonly outDir?: string;
+}
+/**
+ * Vite plugin that only writes bundle files to disk if their content has
+ * changed. Prevents unnecessary file system writes - and the downstream
+ * rebuilds/HMR churn a file watcher would otherwise trigger - when a
+ * rebuild produces byte-identical output.
+ *
+ * Uses `writeBundle` instead of `generateBundle` for Rolldown compatibility:
+ * Rolldown does not support mutating the bundle object, so the write has to
+ * happen after Rollup/Rolldown's own bundle-writing step, not in place of it.
+ */
+export declare function writeIfChanged(options?: WriteIfChangedPluginOptions): Plugin;

package/dist/vite/plugins/write-if-changed.js

@@ -0,0 +1,33 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { extname, resolve } from "node:path";
+//#region src/vite/plugins/write-if-changed.ts
+var writtenFileContentsByPath = /* @__PURE__ */ new Map();
+/**
+* Vite plugin that only writes bundle files to disk if their content has
+* changed. Prevents unnecessary file system writes - and the downstream
+* rebuilds/HMR churn a file watcher would otherwise trigger - when a
+* rebuild produces byte-identical output.
+*
+* Uses `writeBundle` instead of `generateBundle` for Rolldown compatibility:
+* Rolldown does not support mutating the bundle object, so the write has to
+* happen after Rollup/Rolldown's own bundle-writing step, not in place of it.
+*/
+function writeIfChanged(options = {}) {
+	return {
+		name: "write-if-changed",
+		writeBundle(outputOptions, bundle) {
+			const dir = outputOptions.dir ?? options.outDir;
+			if (dir === void 0) return;
+			for (const bundleFile of Object.values(bundle)) {
+				if (bundleFile.type !== "chunk" || extname(bundleFile.fileName) !== ".js") continue;
+				const filePath = resolve(dir, bundleFile.fileName);
+				if (writtenFileContentsByPath.get(filePath) === bundleFile.code) continue;
+				writtenFileContentsByPath.set(filePath, bundleFile.code);
+				mkdirSync(resolve(filePath, ".."), { recursive: true });
+				writeFileSync(filePath, bundleFile.code);
+			}
+		}
+	};
+}
+//#endregion
+export { writeIfChanged };

package/dist/vitest/browser.d.ts

@@ -0,0 +1,31 @@
+import type { ViteUserConfig } from 'vitest/config';
+/**
+ * Preset Vitest config for browser-mode component tests against a real
+ * Chromium instance via the Playwright provider. Separate entry point from
+ * `./index.js` so a consumer without `@vitest/browser-playwright` installed
+ * never loads this module's import of it.
+ *
+ * Extend it with `mergeConfig`:
+ *
+ * ```ts
+ * // vitest.config.ts
+ * import { mergeConfig, defineConfig } from 'vitest/config';
+ * import { browserTestConfig } from '@coryrylan/tools/vitest/browser';
+ *
+ * export default mergeConfig(
+ *   browserTestConfig,
+ *   defineConfig({
+ *     test: { setupFiles: ['./test-setup.ts'] },
+ *   }),
+ * );
+ * ```
+ *
+ * Requires the optional peers `@vitest/browser-playwright`,
+ * `@vitest/coverage-istanbul`, and `playwright`, plus a browser installed
+ * via `pnpm exec playwright install chromium`.
+ *
+ * `CI`/`--watch` detection is resolved once at import time (see `isCi` and
+ * `isWatchMode` above) - changing either after this module loads has no
+ * effect on an already-built config.
+ */
+export declare const browserTestConfig: ViteUserConfig;

package/dist/vitest/browser.js

@@ -0,0 +1,105 @@
+import process from "node:process";
+import { playwright } from "@vitest/browser-playwright";
+//#region src/vitest/browser.ts
+var isCi = process.env["CI"] !== void 0;
+var isWatchMode = process.argv.includes("--watch");
+/**
+* Preset Vitest config for browser-mode component tests against a real
+* Chromium instance via the Playwright provider. Separate entry point from
+* `./index.js` so a consumer without `@vitest/browser-playwright` installed
+* never loads this module's import of it.
+*
+* Extend it with `mergeConfig`:
+*
+* ```ts
+* // vitest.config.ts
+* import { mergeConfig, defineConfig } from 'vitest/config';
+* import { browserTestConfig } from '@coryrylan/tools/vitest/browser';
+*
+* export default mergeConfig(
+*   browserTestConfig,
+*   defineConfig({
+*     test: { setupFiles: ['./test-setup.ts'] },
+*   }),
+* );
+* ```
+*
+* Requires the optional peers `@vitest/browser-playwright`,
+* `@vitest/coverage-istanbul`, and `playwright`, plus a browser installed
+* via `pnpm exec playwright install chromium`.
+*
+* `CI`/`--watch` detection is resolved once at import time (see `isCi` and
+* `isWatchMode` above) - changing either after this module loads has no
+* effect on an already-built config.
+*/
+var browserTestConfig = { test: {
+	globals: true,
+	include: ["src/**/*.test.ts"],
+	retry: 2,
+	...isCi ? {
+		maxWorkers: 1,
+		maxConcurrency: 1
+	} : {},
+	testTimeout: 6e4,
+	hookTimeout: 3e4,
+	browser: {
+		fileParallelism: !isCi,
+		enabled: true,
+		provider: playwright({ launchOptions: {
+			args: [
+				"--disable-dev-shm-usage",
+				"--disable-setuid-sandbox",
+				"--disable-software-rasterizer",
+				"--no-sandbox",
+				"--disable-gpu",
+				"--disable-extensions",
+				"--disable-background-networking",
+				"--disable-default-apps",
+				"--disable-sync",
+				"--disable-translate",
+				"--metrics-recording-only",
+				"--mute-audio",
+				"--no-first-run",
+				"--safebrowsing-disable-auto-update",
+				"--disable-features=TranslateUI",
+				"--disable-features=BlinkGenPropertyTrees",
+				"--disable-ipc-flooding-protection"
+			],
+			timeout: 12e4
+		} }),
+		headless: !isWatchMode,
+		instances: [{ browser: "chromium" }]
+	},
+	coverage: {
+		provider: "istanbul",
+		reportsDirectory: "./coverage/unit",
+		reporter: [
+			["lcov", { file: "coverage.dat" }],
+			"html",
+			"json-summary"
+		],
+		thresholds: {
+			lines: 90,
+			branches: 90,
+			functions: 90,
+			statements: 90
+		},
+		watermarks: {
+			statements: [80, 90],
+			functions: [80, 90],
+			branches: [80, 90],
+			lines: [80, 90]
+		},
+		include: ["src/**/*.ts"],
+		exclude: [
+			"**/dist/**",
+			"**/*.test.ts",
+			"**/*.d.ts",
+			"**/*.examples.ts",
+			"vite.*.ts",
+			"vitest.*.ts"
+		]
+	}
+} };
+//#endregion
+export { browserTestConfig };

package/dist/vitest/index.d.ts

@@ -0,0 +1,28 @@
+import type { ViteUserConfig } from 'vitest/config';
+/**
+ * Preset Vitest config for node-environment unit tests of libraries and
+ * tooling: Node globals, no DOM, `test.globals` enabled so specs can call
+ * `describe`/`it`/`expect` without importing them.
+ *
+ * Extend it with `mergeConfig` rather than spreading manually, so array
+ * fields (e.g. `test.include`) merge instead of getting clobbered:
+ *
+ * ```ts
+ * // vitest.config.ts
+ * import { mergeConfig, defineConfig } from 'vitest/config';
+ * import { nodeTestConfig } from '@coryrylan/tools/vitest';
+ *
+ * export default mergeConfig(
+ *   nodeTestConfig,
+ *   defineConfig({
+ *     test: { coverage: { provider: 'istanbul' } },
+ *   }),
+ * );
+ * ```
+ *
+ * This module has zero runtime dependency on `@vitest/browser-playwright` -
+ * it is safe to import without that optional peer installed. Browser-mode
+ * config lives in the sibling `./browser.js` entry point instead, so a
+ * plain node consumer never pulls in a Playwright import transitively.
+ */
+export declare const nodeTestConfig: ViteUserConfig;

package/dist/vitest/index.js

@@ -0,0 +1,34 @@
+//#region src/vitest/index.ts
+/**
+* Preset Vitest config for node-environment unit tests of libraries and
+* tooling: Node globals, no DOM, `test.globals` enabled so specs can call
+* `describe`/`it`/`expect` without importing them.
+*
+* Extend it with `mergeConfig` rather than spreading manually, so array
+* fields (e.g. `test.include`) merge instead of getting clobbered:
+*
+* ```ts
+* // vitest.config.ts
+* import { mergeConfig, defineConfig } from 'vitest/config';
+* import { nodeTestConfig } from '@coryrylan/tools/vitest';
+*
+* export default mergeConfig(
+*   nodeTestConfig,
+*   defineConfig({
+*     test: { coverage: { provider: 'istanbul' } },
+*   }),
+* );
+* ```
+*
+* This module has zero runtime dependency on `@vitest/browser-playwright` -
+* it is safe to import without that optional peer installed. Browser-mode
+* config lives in the sibling `./browser.js` entry point instead, so a
+* plain node consumer never pulls in a Playwright import transitively.
+*/
+var nodeTestConfig = { test: {
+	globals: true,
+	environment: "node",
+	include: ["src/**/*.test.ts"]
+} };
+//#endregion
+export { nodeTestConfig };