@jterrazz/typescript 9.0.0 → 9.1.0

package/bin/commands/check.sh

@@ -289,13 +289,23 @@ run_checks() {
 
     # Gitignore (artefacts): the convention — every artefact under
     # `.artifacts/<tool>/`, `dist` excepted — read off the project's own
-    # `.gitignore`. Opt-in by existence: a project with no `.gitignore` names no
-    # artefact path, so the gate has no question to ask. Root-only, because
-    # `.artifacts/` sits at the project ROOT. Runs in fix mode too — it is the
-    # one gate whose remedy is a rewrite rather than a deletion.
+    # `.gitignore` AND, in check mode, the nearest ancestor `.gitignore` above it
+    # (the workspace root's — check-gitignore.js walks up to find it). Opt-in by
+    # existence: neither file names an artefact path, the gate has no question to
+    # ask. A workspace whose `lint` delegates to members needs the ancestor probed
+    # here, in bash, because it decides whether to print the pass at all — the
+    # node script decides everything past that. Fix mode stays own-file-only: it
+    # is the one gate whose remedy is a rewrite, and it never rewrites another
+    # project's `.gitignore`.
     local gitignore_pid=""
     local gitignore_status=0
+    local gitignore_applicable=false
     if [ -f ".gitignore" ]; then
+        gitignore_applicable=true
+    elif [ "$FIX_MODE" = false ] && node "$PACKAGE_ROOT/lib/check-gitignore.js" --has-ancestor > /dev/null 2>&1; then
+        gitignore_applicable=true
+    fi
+    if [ "$gitignore_applicable" = true ]; then
         if [ "$FIX_MODE" = true ]; then
             node "$PACKAGE_ROOT/lib/check-gitignore.js" --fix > "$tmp_dir/gitignore.log" 2>&1 &
         else

package/lib/check-gitignore.js

@@ -1,19 +1,38 @@
 #!/usr/bin/env node
 
 /**
- * The artefact convention, read off a project's `.gitignore`.
+ * The artefact convention, read off a project's `.gitignore` — and, in a
+ * workspace, off the ancestor `.gitignore` that covers it too.
  *
  * Every build, test and lint artefact lives under `.artifacts/<tool>/` at the
  * project root — one folder per tool that writes. A `.gitignore` line naming an
  * artefact ANYWHERE else is the old layout, and this gate says so; `.artifacts/`
  * itself must be ignored, so the convention's own folder never reaches a commit.
  *
- * Usage: node check-gitignore.js [--fix] [root]
+ * Two files are read, each judged by the same rules: the package's own
+ * `.gitignore`, and the nearest ANCESTOR `.gitignore` above it — the workspace
+ * root's, found by walking up to the nearest directory holding a lockfile or a
+ * `workspaces` manifest. A workspace whose `lint` delegates to members runs this
+ * gate once per member, cwd'd there; without the ancestor a root that ignores
+ * `.artifacts/` for everyone would look, from a member with no `.gitignore` of
+ * its own, exactly like a project declaring nothing. An ancestor pattern counts
+ * only when it is NOT anchored to the ancestor's own directory (no `/` besides a
+ * trailing one) — the same rule git applies when deciding whether a pattern
+ * reaches into a nested directory.
  *
- * `--fix` rewrites the `.gitignore`: the artefact lines go, `.artifacts/` arrives,
+ * Usage: node check-gitignore.js [--fix] [--has-ancestor] [root]
+ *
+ * `--has-ancestor` answers, silently, whether an ancestor `.gitignore` exists
+ * above `root` — the probe a caller uses to decide whether the gate has
+ * anything to read when `root` itself carries no `.gitignore`.
+ *
+ * `--fix` rewrites the package's OWN `.gitignore` (never the ancestor's, which
+ * is a different project's file): the artefact lines go, `.artifacts/` arrives,
  * and everything else — comments, blank lines, order, the project's own paths —
  * survives untouched. A `!` line is NEVER rewritten: it rescues a tracked file,
  * and deleting the line it negates could hide a real path. Those are reported.
+ * Fix has nothing to do when the package owns no `.gitignore` of its own, even
+ * if an ancestor exists — it never creates a file, only repairs one.
  *
  * Exit code: 0 when the project holds the convention, 1 otherwise. In `--fix`
  * mode only what the rewrite cannot repair — a committed artefact — still fails.
@@ -21,7 +40,7 @@
 
 import { execFileSync } from 'node:child_process';
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { dirname, join, relative, resolve } from 'node:path';
 import { argv, exit, stdout } from 'node:process';
 
 /** The convention's own directory: the one path that MUST be ignored. */
@@ -77,24 +96,104 @@ const EXCEPTIONS = new Set([
 const EXCEPTION_PREFIXES = ['.metro-health-check'];
 
 /**
- * Directories whose every tracked file is a committed artefact. Narrower than
- * the list above on purpose: `bin`, `out`, `build` and `target` are ignorable
- * as OUTPUT, but a tracked file under them may be a project's own source —
- * a `.gitignore` line declares intent, a tracked path declares nothing.
+ * `next.config.*` file names, in resolution order — mirrors what Next.js
+ * itself tries, closely enough for a textual `output` read.
  */
-const TRACKED_ARTEFACT_DIRECTORIES = new Set([
-    '.artifacts',
-    '.cache',
-    '.next',
-    '.turbo',
-    '.vite',
-    'coverage',
-    'playwright-report',
-    'test-results',
-]);
+const NEXT_CONFIG_FILES = [
+    'next.config.js',
+    'next.config.mjs',
+    'next.config.ts',
+    'next.config.mts',
+    'next.config.cjs',
+    'next.config.cts',
+];
 
-/** The extension no tracked file may carry — a buildinfo is never source. */
-const TRACKED_ARTEFACT_EXTENSION = '.tsbuildinfo';
+/**
+ * With `output: 'export'`, Next reads `distDir` as the EXPORT destination and
+ * keeps its working directory at `.next` regardless — `next/dist/export/utils.js`
+ * (`hasCustomExportOutput`) refuses to move it. So `.next` cannot be told to
+ * live under `.artifacts/next/` in that one mode, proven by a real consumer
+ * (clawssify's site). Without `output: 'export'`, nothing pins it, and `.next`
+ * stays an ordinary artefact. Read textually — a project's own config may not
+ * even be valid JS in the tool's own runtime, and a regex answers the one
+ * question this gate has without loading it.
+ */
+function nextConfigDeclaresExport(dir) {
+    for (const name of NEXT_CONFIG_FILES) {
+        const path = join(dir, name);
+        if (!existsSync(path)) {
+            continue;
+        }
+        try {
+            if (/output\s*:\s*['"]export['"]/.test(readFileSync(path, 'utf8'))) {
+                return true;
+            }
+        } catch {
+            // An unreadable config answers no differently than a missing one.
+        }
+    }
+
+    return false;
+}
+
+/** Lockfiles whose presence marks a directory as a package manager's root. */
+const WORKSPACE_LOCKFILES = [
+    'bun.lock',
+    'bun.lockb',
+    'npm-shrinkwrap.json',
+    'package-lock.json',
+    'pnpm-lock.yaml',
+    'yarn.lock',
+];
+
+/** A workspace root: a lockfile lives here, or its manifest declares `workspaces`. */
+function isWorkspaceRoot(dir) {
+    if (WORKSPACE_LOCKFILES.some((name) => existsSync(join(dir, name)))) {
+        return true;
+    }
+
+    const manifest = join(dir, 'package.json');
+    if (!existsSync(manifest)) {
+        return false;
+    }
+
+    try {
+        return JSON.parse(readFileSync(manifest, 'utf8')).workspaces !== undefined;
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * The nearest ancestor ABOVE `root` that is a workspace root, or null. Never
+ * `root` itself — a project reads its OWN `.gitignore` regardless, so only
+ * what sits above it is worth a second file.
+ */
+function findWorkspaceRoot(root) {
+    let dir = dirname(resolve(root));
+    let parent = dirname(dir);
+
+    while (dir !== parent) {
+        if (isWorkspaceRoot(dir)) {
+            return dir;
+        }
+        dir = parent;
+        parent = dirname(dir);
+    }
+
+    return isWorkspaceRoot(dir) ? dir : null;
+}
+
+/**
+ * A pattern anchored to its OWN `.gitignore`'s directory — one that carries a
+ * `/` other than a trailing one, or a leading one — the way git itself reads
+ * it. An anchored pattern in an ANCESTOR's file never reaches a nested package;
+ * only an unanchored one (`.artifacts/`, not `/.artifacts/` or `out/.artifacts/`)
+ * matches at any depth below it.
+ */
+function isAnchored(pattern) {
+    return pattern.replace(/\/+$/, '').includes('/');
+}
 
 /**
  * What a `.gitignore` pattern names, reduced to the one segment that carries
@@ -112,12 +211,15 @@ function subject(pattern) {
 }
 
 /** The `.artifacts/` home of the artefact a pattern names, or null. */
-function artefactHome(pattern) {
+function artefactHome(pattern, { nextIsExportDestination }) {
     const name = subject(pattern);
 
     if (name === '' || name === PRODUCT || EXCEPTIONS.has(name)) {
         return null;
     }
+    if (nextIsExportDestination && name === '.next') {
+        return null;
+    }
     if (EXCEPTION_PREFIXES.some((prefix) => name.startsWith(prefix))) {
         return null;
     }
@@ -133,8 +235,9 @@ function artefactHome(pattern) {
     return null;
 }
 
-/** Every line of the file, classified once — the rewrite reads the same list. */
+/** Every line of a `.gitignore`, classified once — the rewrite reads the same list. */
 function readLines(gitignorePath) {
+    const nextIsExportDestination = nextConfigDeclaresExport(dirname(gitignorePath));
     const text = readFileSync(gitignorePath, 'utf8').split('\n');
 
     // The empty string a trailing newline leaves behind is not a line.
@@ -148,7 +251,10 @@ function readLines(gitignorePath) {
         const isPattern = pattern !== '' && !pattern.startsWith('#');
 
         return {
-            home: isPattern && !pattern.startsWith('!') ? artefactHome(pattern) : null,
+            home:
+                isPattern && !pattern.startsWith('!')
+                    ? artefactHome(pattern, { nextIsExportDestination })
+                    : null,
             isNegation: isPattern && pattern.startsWith('!'),
             pattern,
             text: line,
@@ -156,6 +262,52 @@ function readLines(gitignorePath) {
     });
 }
 
+/**
+ * A `.gitignore` judged on its own: every line classified, plus what it
+ * contributes to the combined verdict. `reach` narrows an ancestor's file to
+ * the patterns that actually cross into a nested package — every line, for
+ * the package's own file, since that file's directory IS the project root.
+ */
+function readSource(path, { own, reach = () => true, root }) {
+    const lines = readLines(path);
+
+    return {
+        isIgnored: lines.some(
+            (line) =>
+                !line.isNegation &&
+                line.home === null &&
+                subject(line.pattern) === ARTIFACTS &&
+                reach(line.pattern),
+        ),
+        label: relative(resolve(root), path).split('\\').join('/'),
+        lines,
+        misplaced: lines.filter((line) => line.home !== null && reach(line.pattern)),
+        negations: lines.filter((line) => line.isNegation),
+        own,
+        path,
+    };
+}
+
+/**
+ * Directories whose every tracked file is a committed artefact. Narrower than
+ * the list above on purpose: `bin`, `out`, `build` and `target` are ignorable
+ * as OUTPUT, but a tracked file under them may be a project's own source —
+ * a `.gitignore` line declares intent, a tracked path declares nothing.
+ */
+const TRACKED_ARTEFACT_DIRECTORIES = new Set([
+    '.artifacts',
+    '.cache',
+    '.next',
+    '.turbo',
+    '.vite',
+    'coverage',
+    'playwright-report',
+    'test-results',
+]);
+
+/** The extension no tracked file may carry — a buildinfo is never source. */
+const TRACKED_ARTEFACT_EXTENSION = '.tsbuildinfo';
+
 /**
  * The artefacts a project COMMITTED. Outside a git tree the question has no
  * answer, and silence is the right one — a fixture directory is not a repo.
@@ -204,45 +356,86 @@ function rewrite(lines) {
 }
 
 const isFix = argv.includes('--fix');
+const isProbe = argv.includes('--has-ancestor');
 const root = argv.slice(2).find((argument) => !argument.startsWith('--')) ?? '.';
-const gitignorePath = join(root, '.gitignore');
 
-// A project with no `.gitignore` declares no artefact path and nothing to fix.
-// The gate has no question to ask of it, and stays silent.
-if (!existsSync(gitignorePath)) {
+const workspaceRoot = findWorkspaceRoot(root);
+const ancestorPath = workspaceRoot ? join(workspaceRoot, '.gitignore') : null;
+
+// The probe answers one question — does an ancestor `.gitignore` exist above
+// `root` — for a caller that already knows how to test `root`'s own.
+if (isProbe) {
+    exit(ancestorPath && existsSync(ancestorPath) ? 0 : 1);
+}
+
+const ownPath = join(root, '.gitignore');
+const sources = [];
+if (existsSync(ownPath)) {
+    sources.push(readSource(ownPath, { own: true, root }));
+}
+if (ancestorPath && existsSync(ancestorPath)) {
+    sources.push(
+        readSource(ancestorPath, { own: false, reach: (pattern) => !isAnchored(pattern), root }),
+    );
+}
+
+/*
+ * Neither the package nor any ancestor above it declares an artefact path —
+ * the gate has no question to ask, and stays silent.
+ */
+if (sources.length === 0) {
     exit(0);
 }
 
-const lines = readLines(gitignorePath);
-const misplaced = lines.filter((line) => line.home !== null);
-const negations = lines.filter((line) => line.isNegation);
-const isIgnored = lines.some(
-    (line) => !line.isNegation && line.home === null && subject(line.pattern) === ARTIFACTS,
+/*
+ * The combined verdict, own file and ancestor alike — an ancestor's line
+ * already narrowed to what actually reaches this package (`readSource`'s
+ * `reach`). Negations keep the original, file-agnostic wording: rescuing a
+ * tracked file is the same judgement call regardless of which file names it.
+ */
+const isIgnored = sources.some((source) => source.isIgnored);
+const misplaced = sources.flatMap((source) =>
+    source.misplaced.map((line) => ({ ...line, source })),
 );
+const negations = sources.flatMap((source) => source.negations);
+
+/*
+ * When nobody ignores it, the file to fix is the shared one when there is
+ * one — a workspace root covers every member, so that is where it belongs.
+ */
+const target = sources.find((source) => !source.own) ?? sources[0];
+
 const tracked = trackedArtefacts(root);
 
 if (isFix) {
-    const changed = misplaced.length > 0 || !isIgnored;
-    if (changed) {
-        writeFileSync(gitignorePath, rewrite(lines));
-        stdout.write('.gitignore rewritten:\n');
-        for (const line of misplaced) {
-            stdout.write(`  - ${line.pattern}\n`);
-        }
-        if (!isIgnored) {
-            stdout.write(`  + ${ARTIFACTS}/\n`);
-        }
-        for (const line of negations) {
-            stdout.write(`  · ${line.pattern} — a negation rescues a tracked file, kept\n`);
+    /*
+     * Fix repairs the package's OWN file only — it never creates one, and it
+     * never rewrites an ancestor, which is a different project's file.
+     */
+    const own = sources.find((source) => source.own);
+    if (own) {
+        const changed = own.misplaced.length > 0 || !own.isIgnored;
+        if (changed) {
+            writeFileSync(own.path, rewrite(own.lines));
+            stdout.write('.gitignore rewritten:\n');
+            for (const line of own.misplaced) {
+                stdout.write(`  - ${line.pattern}\n`);
+            }
+            if (!own.isIgnored) {
+                stdout.write(`  + ${ARTIFACTS}/\n`);
+            }
+            for (const line of own.negations) {
+                stdout.write(`  · ${line.pattern} — a negation rescues a tracked file, kept\n`);
+            }
         }
     }
 } else if (misplaced.length > 0 || !isIgnored) {
     stdout.write('Artefacts belong under .artifacts/<tool>/ at the project root:\n');
     for (const line of misplaced) {
-        stdout.write(`  ✗ .gitignore names ${line.pattern} — its home is ${line.home}\n`);
+        stdout.write(`  ✗ ${line.source.label} names ${line.pattern} — its home is ${line.home}\n`);
     }
     if (!isIgnored) {
-        stdout.write(`  ✗ .gitignore does not ignore ${ARTIFACTS}/ — add it\n`);
+        stdout.write(`  ✗ ${target.label} does not ignore ${ARTIFACTS}/ — add it\n`);
     }
     for (const line of negations) {
         stdout.write(`  · ${line.pattern} — a negation rescues a tracked file, left for you\n`);

package/lib/merge-knip-config.js

@@ -6,6 +6,11 @@
  *
  * Usage: node merge-knip-config.js <base.json> [project-knip.json]
  *
+ * The project file is read as JSONC — comments and trailing commas — so an
+ * ignore can carry the reason it exists. Every entry knip is told to overlook
+ * is a judgement, and a judgement with no reason beside it is re-litigated by
+ * the next reader.
+ *
  * Merge rules:
  *   - Arrays (ignoreDependencies, ignoreBinaries, ignore): concatenated and deduplicated
  *   - Objects (rules, vitest, etc.): project values override base
@@ -29,14 +34,101 @@ import { existsSync, readdirSync, readFileSync } from 'node:fs';
 
 import { workspaceMembers } from './workspace-members.js';
 
+/**
+ * Drops `//` and block comments, leaving everything inside a string literal
+ * alone — a comment marker in a glob (`ignore: ["**\/*.js"]`) is data.
+ */
+function withoutComments(text) {
+    let output = '',
+        index = 0,
+        inString = false;
+
+    while (index < text.length) {
+        const char = text[index];
+
+        if (inString) {
+            const escaped = char === '\\';
+            output += escaped ? char + (text[index + 1] ?? '') : char;
+            inString = escaped || char !== '"';
+            index += escaped ? 2 : 1;
+        } else if (char === '"') {
+            inString = true;
+            output += char;
+            index += 1;
+        } else if (char === '/' && text[index + 1] === '/') {
+            while (index < text.length && text[index] !== '\n') {
+                index += 1;
+            }
+        } else if (char === '/' && text[index + 1] === '*') {
+            const end = text.indexOf('*/', index + 2);
+            index = end === -1 ? text.length : end + 2;
+        } else {
+            output += char;
+            index += 1;
+        }
+    }
+
+    return output;
+}
+
+/** Whether the comma at `index` is the last one of its collection — `["a",]`. */
+function closesCollection(text, index) {
+    if (text[index] !== ',') {
+        return false;
+    }
+
+    let next = index + 1;
+    while (next < text.length && text[next].trim() === '') {
+        next += 1;
+    }
+
+    return text[next] === ']' || text[next] === '}';
+}
+
+/** Drops a comma that closes its collection, outside string literals. */
+function withoutTrailingCommas(text) {
+    let output = '',
+        index = 0,
+        inString = false;
+
+    while (index < text.length) {
+        const char = text[index];
+        const closes = closesCollection(text, index);
+
+        if (inString) {
+            const escaped = char === '\\';
+            output += escaped ? char + (text[index + 1] ?? '') : char;
+            inString = escaped || char !== '"';
+            index += escaped ? 2 : 1;
+        } else {
+            inString = char === '"';
+            output += closes ? '' : char;
+            index += 1;
+        }
+    }
+
+    return output;
+}
+
+/**
+ * Reads a JSONC document. Hand-written on purpose: no JSONC parser is in this
+ * package's tree, and two token classes do not earn a dependency.
+ */
+function readJsonc(path) {
+    const document = readFileSync(path, 'utf8'),
+        json = withoutTrailingCommas(withoutComments(document));
+
+    return JSON.parse(json);
+}
+
 const basePath = process.argv[2];
 const projectPath = process.argv[3];
 
-const base = JSON.parse(readFileSync(basePath, 'utf8'));
+const base = readJsonc(basePath);
 
 let project = {};
 if (projectPath) {
-    project = JSON.parse(readFileSync(projectPath, 'utf8'));
+    project = readJsonc(projectPath);
 }
 
 const ARRAY_KEYS = new Set(['ignore', 'ignoreBinaries', 'ignoreDependencies', 'entry', 'project']);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jterrazz/typescript",
-    "version": "9.0.0",
+    "version": "9.1.0",
     "author": "Jean-Baptiste Terrazzoni <contact@jterrazz.com>",
     "repository": {
         "type": "git",
@@ -23,6 +23,10 @@
             "types": "./src/index.d.ts",
             "default": "./src/index.js"
         },
+        "./oxfmt": {
+            "types": "./src/oxfmt.d.ts",
+            "default": "./src/oxfmt.js"
+        },
         "./oxlint": {
             "types": "./src/oxlint.d.ts",
             "default": "./src/oxlint.js"

package/src/oxfmt.d.ts

@@ -0,0 +1,6 @@
+type ConfigObject = Record<string, unknown>;
+
+declare const base: ConfigObject;
+
+export { defineConfig } from 'oxfmt';
+export { base };

package/src/oxfmt.js

@@ -0,0 +1,14 @@
+/*
+ * The tool-facing oxfmt entry (`@jterrazz/typescript/oxfmt`): the shared
+ * formatting preset plus oxfmt's own `defineConfig`, for the same reason
+ * `oxlint.js` re-exports its tool's — a consumer's config names this package
+ * and nothing else:
+ *
+ *     import { base, defineConfig } from '@jterrazz/typescript/oxfmt';
+ *
+ *     export default defineConfig(base);
+ */
+
+export { defineConfig } from 'oxfmt';
+
+export { default as base } from '../presets/oxfmt/index.js';

package/src/oxfmt.test.ts

@@ -0,0 +1,17 @@
+import { expect, test } from 'vitest';
+
+import { base, defineConfig } from './oxfmt.js';
+
+test('exports the shared formatting preset', () => {
+    // Given - the tool-facing entry
+    // Then - the preset carries the ecosystem's format: four spaces, single quotes, 100 columns
+    expect(base).toMatchObject({ printWidth: 100, singleQuote: true, tabWidth: 4 });
+});
+
+test("re-exports oxfmt's own defineConfig", () => {
+    // Given - a config a consumer would write, with oxfmt declared nowhere in its project
+    const config = { printWidth: 80 };
+
+    // Then - the entry carries the tool's helper, which returns the config unchanged
+    expect(defineConfig(config)).toBe(config);
+});

package/src/oxlint.d.ts

@@ -12,4 +12,5 @@ declare const node: ConfigObject;
  */
 declare function compose(...fragments: ConfigObject[]): ConfigObject;
 
+export { defineConfig } from 'oxlint';
 export { compose, expo, hexagonal, next, node };

package/src/oxlint.js

@@ -1,7 +1,8 @@
 /*
  * The tool-facing oxlint entry (`@jterrazz/typescript/oxlint`): the named
- * presets plus the `compose()` helper. Wiring is EXPLICIT — a consumer
- * composes exactly the fragments it wants, nothing is auto-detected:
+ * presets, the `compose()` helper, and oxlint's own `defineConfig`. Wiring is
+ * EXPLICIT — a consumer composes exactly the fragments it wants, nothing is
+ * auto-detected:
  *
  *     import { testing } from '@jterrazz/test/oxlint';
  *     import { compose, node } from '@jterrazz/typescript/oxlint';
@@ -50,6 +51,13 @@ export function compose(...fragments) {
     return merged;
 }
 
+/* Oxlint's own `defineConfig`, re-exported from here: a bare
+ * `import { defineConfig } from 'oxlint'` in a consumer's config resolves only
+ * where the consumer declares oxlint itself, which pnpm's strict node_modules
+ * refuses to assume. Resolved from THIS package — where oxlint is a real
+ * dependency — the one-devDependency shape holds on every package manager. */
+export { defineConfig } from 'oxlint';
+
 export { default as hexagonal } from '../presets/oxlint/architectures/hexagonal.js';
 export { default as expo } from '../presets/oxlint/expo.js';
 export { default as next } from '../presets/oxlint/next.js';

package/src/oxlint.test.ts

@@ -1,6 +1,6 @@
 import { expect, test } from 'vitest';
 
-import { compose, expo, hexagonal, next, node } from './oxlint.js';
+import { compose, defineConfig, expo, hexagonal, next, node } from './oxlint.js';
 
 test('concatenates and dedupes plugin lists', () => {
     // Given - two fragments sharing one jsPlugin
@@ -77,3 +77,11 @@ test('exports the named presets', () => {
         expect(typeof preset).toBe('object');
     }
 });
+
+test("re-exports oxlint's own defineConfig", () => {
+    // Given - a config a consumer would write, with oxlint declared nowhere in its project
+    const config = { rules: { curly: 'error' } };
+
+    // Then - the entry carries the tool's helper, which returns the config unchanged
+    expect(defineConfig(config)).toBe(config);
+});