lintmax 0.0.10 → 0.0.12

package/dist/index.js

@@ -1,91 +1,28 @@
-import { file, spawnSync, write } from 'bun';
+import { file, write } from 'bun';
+import { BIOME_IGNORE_PATTERNS, BIOME_PATTERN_RULE_OVERRIDES, BIOME_RULES_OFF, DEFAULT_SHARED_IGNORE_PATTERNS, OXLINT_PATTERN_RULE_OVERRIDES, SHARED_OVERRIDE_SYMBOL_KEY } from './constants.js';
+import { cacheDir, ensureDirectory, readRequiredJson } from './core.js';
+import { assertJsonSerializable, assertObject, assertOptionalString, findUnknownRules, normalizeIgnorePattern, normalizeObjectListInput, normalizePathListInput, normalizeRulesOffInput, normalizeTailwindOption, stripPluginNamespace } from './normalize.js';
 import { dirnamePath, fromFileUrl, joinPath } from './path.js';
-const decoder = new TextDecoder(), pkgRoot = dirnamePath(fromFileUrl(import.meta.resolve('../package.json'))), biomeRulesOff = [
-    'noBarrelFile',
-    'noConditionalExpect',
-    'noConsole',
-    'noDefaultExport',
-    'noExcessiveCognitiveComplexity',
-    'noExcessiveLinesPerFile',
-    'noExcessiveLinesPerFunction',
-    'noExportedImports',
-    'noImplicitBoolean',
-    'noJsxLiterals',
-    'noJsxPropsBind',
-    'noMagicNumbers',
-    'noNestedTernary',
-    'noNodejsModules',
-    'noProcessGlobal',
-    'noReactSpecificProps',
-    'noSecrets',
-    'noSolidDestructuredProps',
-    'noTernary',
-    'noUndeclaredDependencies',
-    'noUnresolvedImports',
-    'useBlockStatements',
-    'useComponentExportOnlyModules',
-    'useDestructuring',
-    'useExplicitType',
-    'useImportExtensions',
-    'useNamingConvention',
-    'useQwikValidLexicalScope',
-    'useSingleVarDeclarator',
-    'useSolidForComponent',
-    'useSortedClasses'
-], biomeIgnorePatterns = [
-    '!!**/.build',
-    '!!**/.cache',
-    '!!**/.next',
-    '!!**/.output',
-    '!!**/.turbo',
-    '!!**/.venv',
-    '!!**/.wxt',
-    '!!**/_generated',
-    '!!**/Android',
-    '!!**/Darwin',
-    '!!**/dist',
-    '!!**/maestro',
-    '!!**/module_bindings',
-    '!!**/playwright-report',
-    '!!**/test-results',
-    '!!**/*.xcassets'
-], normalizeBiomeIgnorePattern = ({ pattern }) => {
+const SHARED_OVERRIDE_KEYS = ['biome', 'eslint', 'oxlint'];
+const pkgRoot = dirnamePath(fromFileUrl(import.meta.resolve('../package.json'))), normalizeBiomeIgnorePattern = ({ pattern }) => {
     if (pattern.startsWith('!!'))
         return pattern;
-    const trimmed = pattern.startsWith('./') ? pattern.slice(2) : pattern;
+    const trimmed = normalizeIgnorePattern({ pattern });
     return trimmed.startsWith('**/') ? `!!${trimmed}` : `!!**/${trimmed}`;
-}, decodeBytes = (bytes) => decoder.decode(bytes ?? new Uint8Array()), ensureDirectory = ({ directory }) => {
-    const result = spawnSync({
-        cmd: ['mkdir', '-p', directory],
-        stderr: 'pipe',
-        stdout: 'pipe'
-    });
-    if (result.exitCode === 0)
-        return;
-    const stderr = decodeBytes(result.stderr).trim();
-    throw new Error(stderr.length > 0 ? stderr : `Failed to create directory: ${directory}`);
-}, resolveBundledModule = ({ specifier }) => {
+}, resolveSchemaPath = async ({ cwd }) => {
     try {
-        return fromFileUrl(import.meta.resolve(specifier));
+        return fromFileUrl(import.meta.resolve('@biomejs/biome/configuration_schema.json'));
     }
-    catch {
-        return null;
+    catch (error) {
+        if (!(error instanceof Error))
+            throw error;
     }
-}, readJsonFile = async ({ filePath }) => {
-    const text = await file(filePath).text();
-    return JSON.parse(text);
-}, resolveSchemaPath = async ({ cwd }) => {
-    const bundled = resolveBundledModule({
-        specifier: '@biomejs/biome/configuration_schema.json'
-    });
-    if (bundled)
-        return bundled;
     const consumerCandidate = joinPath(cwd, 'node_modules', '@biomejs', 'biome', 'configuration_schema.json');
     if (await file(consumerCandidate).exists())
         return consumerCandidate;
     throw new Error('Cannot find module @biomejs/biome/configuration_schema.json');
 }, resolveBiomeSchema = async ({ cwd }) => {
-    const schemaPath = await resolveSchemaPath({ cwd }), schema = await readJsonFile({ filePath: schemaPath }), rulesProps = schema.$defs.Rules?.properties ?? {}, categories = Object.keys(rulesProps).filter(k => k !== 'recommended'), ruleMap = new Map();
+    const schemaPath = await resolveSchemaPath({ cwd }), schema = await readRequiredJson({ path: schemaPath }), rulesProps = schema.$defs.Rules?.properties ?? {}, categories = Object.keys(rulesProps).filter(k => k !== 'recommended'), ruleMap = new Map();
     for (const cat of categories) {
         const key = cat.charAt(0).toUpperCase() + cat.slice(1), props = schema.$defs[key]?.properties;
         if (props)
@@ -97,8 +34,23 @@ const decoder = new TextDecoder(), pkgRoot = dirnamePath(fromFileUrl(import.meta
 }, extractRuleNames = (rules) => {
     const names = [];
     for (const key of Object.keys(rules))
-        names.push(key.includes('/') ? key.slice(key.indexOf('/') + 1) : key);
+        names.push(stripPluginNamespace({ rule: key }));
     return names;
+}, assertKnownBiomeRuleNames = ({ categoryMap, label, rules }) => {
+    const unknown = findUnknownRules({
+        knownRules: new Set(categoryMap.keys()),
+        normalizeRule: (rule) => stripPluginNamespace({ rule }),
+        rules
+    });
+    if (unknown.length > 0)
+        throw new Error(`${label} contains unknown biome rules: ${unknown.join(', ')}`);
+}, assertKnownOxlintRuleNames = ({ label, rules, knownRules }) => {
+    const unknown = findUnknownRules({
+        knownRules,
+        rules
+    });
+    if (unknown.length > 0)
+        throw new Error(`${label} contains unknown oxlint rules: ${unknown.join(', ')}`);
 }, groupByCategory = ({ categoryMap, ruleNames }) => {
     const result = {};
     for (const rule of ruleNames) {
@@ -109,15 +61,336 @@ const decoder = new TextDecoder(), pkgRoot = dirnamePath(fromFileUrl(import.meta
         }
     }
     return result;
-}, createBiomeConfig = async ({ cwd, globalIgnorePatterns, options }) => {
-    const { categories, ruleMap } = await resolveBiomeSchema({ cwd }), allRulesOff = [...biomeRulesOff];
-    if (options?.rules)
-        for (const key of Object.keys(options.rules)) {
-            const ruleName = key.includes('/') ? key.slice(key.indexOf('/') + 1) : key;
+}, normalizeSharedOverrideItem = ({ index, item, label }) => {
+    const files = normalizePathListInput({
+        label: `${label}[${index}].files`,
+        value: item.files
+    }), biomeRules = normalizeRulesOffInput({ label: `${label}[${index}].biome`, value: item.biome }), eslintRules = normalizeRulesOffInput({ label: `${label}[${index}].eslint`, value: item.eslint }), oxlintRules = normalizeRulesOffInput({ label: `${label}[${index}].oxlint`, value: item.oxlint });
+    if (!(biomeRules || eslintRules || oxlintRules))
+        throw new Error(`${label}[${index}] must define at least one action: biome, eslint, or oxlint`);
+    return {
+        biomeRules,
+        eslintRules,
+        files,
+        oxlintRules
+    };
+}, normalizeSharedOverrides = ({ label, value }) => {
+    const out = [];
+    if (value === undefined)
+        return out;
+    const obj = assertObject({ label, value }), entries = [];
+    for (const [pattern, rawOverride] of Object.entries(obj)) {
+        const override = assertObject({
+            label: `${label}.${pattern}`,
+            value: rawOverride
+        });
+        for (const key of Object.keys(override))
+            if (!SHARED_OVERRIDE_KEYS.includes(key))
+                throw new Error(`${label}.${pattern}.${key} is not supported. Use biome, eslint, or oxlint.`);
+        entries.push({
+            ...override,
+            files: [pattern]
+        });
+    }
+    for (const [i, item] of entries.entries())
+        out.push(normalizeSharedOverrideItem({
+            index: i,
+            item,
+            label
+        }));
+    return out;
+}, collectSharedRuleOverrides = ({ ruleKey, sharedOverrides }) => {
+    const out = [];
+    for (const override of sharedOverrides) {
+        const rules = override[ruleKey];
+        if (rules)
+            out.push({ files: override.files, rules });
+    }
+    return out;
+}, parseLinterOffOverrides = ({ assertKnownRules, fileKey, label, requireOff = false, value }) => {
+    const out = [];
+    for (const [i, override] of normalizeObjectListInput({
+        label,
+        value
+    }).entries()) {
+        const itemLabel = requireOff ? `${label}[${i}]` : label;
+        if (requireOff && override[fileKey] === undefined)
+            throw new Error(`${label}[${i}].${fileKey} is required`);
+        if (requireOff && override.off === undefined)
+            throw new Error(`${label}[${i}].off is required`);
+        const normalizedOverrideRules = normalizeRulesOffInput({
+            label: `${itemLabel}.off`,
+            value: override.off
+        });
+        if (normalizedOverrideRules) {
+            assertKnownRules?.(normalizedOverrideRules);
+            out.push({
+                files: normalizePathListInput({
+                    label: `${itemLabel}.${fileKey}`,
+                    value: override[fileKey]
+                }),
+                rules: normalizedOverrideRules
+            });
+        }
+    }
+    return out;
+}, parseTopLevelSyncScalars = ({ options }) => {
+    if (options.compact !== undefined && typeof options.compact !== 'boolean')
+        throw new Error('compact must be a boolean');
+    const tailwind = normalizeTailwindOption({
+        label: 'tailwind',
+        value: options.tailwind
+    });
+    assertOptionalString({
+        label: 'tsconfigRootDir',
+        value: options.tsconfigRootDir
+    });
+    const sharedOverrides = options.overrides === undefined
+        ? []
+        : normalizeSharedOverrides({
+            label: 'overrides',
+            value: options.overrides
+        }), topLevelIgnores = options.ignores === undefined
+        ? []
+        : normalizePathListInput({
+            label: 'ignores',
+            value: options.ignores
+        });
+    return {
+        sharedOverrides,
+        tailwind,
+        topLevelIgnores,
+        tsconfigRootDir: options.tsconfigRootDir
+    };
+}, parseLinterSyncCommon = ({ linter, value }) => {
+    const parsed = {};
+    if (value.ignores !== undefined)
+        parsed.ignores = normalizePathListInput({
+            label: `${linter}.ignores`,
+            value: value.ignores
+        });
+    const normalizedOffRules = normalizeRulesOffInput({
+        label: `${linter}.off`,
+        value: value.off
+    });
+    if (normalizedOffRules)
+        parsed.off = Object.keys(normalizedOffRules);
+    return parsed;
+}, validateBiomeSyncConfig = ({ biome }) => {
+    const biomeValue = assertObject({ label: 'biome config', value: biome }), parsedCommon = parseLinterSyncCommon({
+        linter: 'biome',
+        value: biomeValue
+    }), parsedOverrides = parseLinterOffOverrides({
+        fileKey: 'includes',
+        label: 'biome.overrides',
+        requireOff: true,
+        value: biomeValue.overrides
+    }).map(override => ({
+        includes: override.files,
+        off: Object.keys(override.rules)
+    })), parsed = {
+        ...parsedCommon
+    };
+    if (parsedOverrides.length > 0)
+        parsed.overrides = parsedOverrides;
+    return parsed;
+}, validateEslintSyncConfig = ({ eslint }) => {
+    const eslintValue = assertObject({ label: 'eslint config', value: eslint }), parsedCommon = parseLinterSyncCommon({
+        linter: 'eslint',
+        value: eslintValue
+    }), parsed = {
+        ...parsedCommon
+    };
+    if (eslintValue.tailwind !== undefined)
+        throw new Error('eslint.tailwind is not supported in sync config. Use top-level tailwind.');
+    if (eslintValue.tsconfigRootDir !== undefined)
+        throw new Error('eslint.tsconfigRootDir is not supported in sync config. Use top-level tsconfigRootDir.');
+    if (eslintValue.append !== undefined) {
+        const appendEntries = normalizeObjectListInput({
+            label: 'eslint.append',
+            value: eslintValue.append
+        });
+        for (const [i, item] of appendEntries.entries())
+            assertJsonSerializable({
+                label: `eslint.append[${i}]`,
+                value: item
+            });
+        parsed.append = appendEntries;
+    }
+    return parsed;
+}, validateOxlintSyncConfig = ({ oxlint }) => {
+    const oxlintValue = assertObject({ label: 'oxlint config', value: oxlint }), parsedCommon = parseLinterSyncCommon({
+        linter: 'oxlint',
+        value: oxlintValue
+    }), parsedOverrides = parseLinterOffOverrides({
+        fileKey: 'files',
+        label: 'oxlint.overrides',
+        requireOff: true,
+        value: oxlintValue.overrides
+    }).map(override => ({
+        files: override.files,
+        off: Object.keys(override.rules)
+    })), parsed = {
+        ...parsedCommon
+    };
+    if (parsedOverrides.length > 0)
+        parsed.overrides = parsedOverrides;
+    return parsed;
+}, validateSyncOptions = ({ options }) => {
+    if (!options)
+        return {
+            sharedOverrides: [],
+            topLevelIgnores: []
+        };
+    const parsedTopLevelScalars = parseTopLevelSyncScalars({ options }), parsed = {
+        ...parsedTopLevelScalars
+    };
+    if (options.biome)
+        parsed.biome = validateBiomeSyncConfig({ biome: options.biome });
+    if (options.eslint)
+        parsed.eslint = validateEslintSyncConfig({ eslint: options.eslint });
+    if (options.oxlint)
+        parsed.oxlint = validateOxlintSyncConfig({ oxlint: options.oxlint });
+    return parsed;
+}, mergeUniquePatterns = ({ into, patterns }) => {
+    if (!patterns)
+        return;
+    for (const raw of patterns) {
+        const pattern = normalizeIgnorePattern({ pattern: raw });
+        if (pattern.length > 0 && !into.includes(pattern))
+            into.push(pattern);
+    }
+}, mergeIgnorePatternGroups = ({ groups }) => {
+    const merged = [];
+    for (const group of groups)
+        mergeUniquePatterns({ into: merged, patterns: group });
+    return merged;
+}, buildUserIgnorePatterns = ({ topLevelIgnores }) => mergeIgnorePatternGroups({
+    groups: [topLevelIgnores]
+}), buildLinterOptionsWithSharedOverrides = ({ createEmpty, ruleKey, sharedOverrides, source, mapSharedOverride }) => {
+    if (!(source || sharedOverrides.length > 0))
+        return source;
+    const next = source ? { ...source } : createEmpty();
+    next.off = source?.off;
+    const sharedRuleOverrides = collectSharedRuleOverrides({
+        ruleKey,
+        sharedOverrides
+    }).map(mapSharedOverride), localOverrides = source?.overrides ?? [], mergedOverrides = [...sharedRuleOverrides, ...localOverrides];
+    if (mergedOverrides.length > 0)
+        next.overrides = mergedOverrides;
+    return next;
+}, buildBiomeOptions = ({ biomeSource, sharedOverrides }) => buildLinterOptionsWithSharedOverrides({
+    createEmpty: () => ({}),
+    mapSharedOverride: override => ({
+        includes: override.files,
+        off: Object.keys(override.rules)
+    }),
+    ruleKey: 'biomeRules',
+    sharedOverrides,
+    source: biomeSource
+}), buildOxlintOptions = ({ oxlintSource, sharedOverrides }) => buildLinterOptionsWithSharedOverrides({
+    createEmpty: () => ({}),
+    mapSharedOverride: override => ({
+        files: override.files,
+        off: Object.keys(override.rules)
+    }),
+    ruleKey: 'oxlintRules',
+    sharedOverrides,
+    source: oxlintSource
+}), buildEslintIgnorePatterns = ({ eslintSource, userIgnorePatterns }) => mergeIgnorePatternGroups({
+    groups: [
+        userIgnorePatterns,
+        eslintSource?.ignores === undefined
+            ? undefined
+            : normalizePathListInput({
+                label: 'eslint.ignores',
+                value: eslintSource.ignores
+            })
+    ]
+}), buildEslintOptions = ({ eslintSource, sharedOverrides, tailwind, tsconfigRootDir, userIgnorePatterns }) => {
+    const eslintIgnores = buildEslintIgnorePatterns({
+        eslintSource,
+        userIgnorePatterns
+    }), sharedRuleOverrides = collectSharedRuleOverrides({
+        ruleKey: 'eslintRules',
+        sharedOverrides
+    }).map(override => ({
+        files: override.files,
+        rules: override.rules
+    })), sharedOverrideAppendIndexes = sharedRuleOverrides.map((_, index) => index);
+    if (eslintSource || sharedOverrides.length > 0 || tailwind !== undefined || tsconfigRootDir !== undefined) {
+        const eslintOptions = {
+            off: eslintSource?.off
+        };
+        if (eslintIgnores.length > 0)
+            eslintOptions.ignores = eslintIgnores;
+        const appendEntries = (eslintSource?.append ?? []).map(entry => entry), mergedAppend = [...sharedRuleOverrides, ...appendEntries];
+        if (mergedAppend.length > 0)
+            eslintOptions.append = mergedAppend;
+        const mergedTailwind = normalizeTailwindOption({
+            label: 'tailwind',
+            value: tailwind
+        });
+        eslintOptions.tailwind = mergedTailwind ?? true;
+        eslintOptions.tsconfigRootDir = tsconfigRootDir;
+        return {
+            eslintOptions,
+            sharedOverrideAppendIndexes
+        };
+    }
+    if (eslintIgnores.length === 0)
+        return {
+            eslintOptions: undefined,
+            sharedOverrideAppendIndexes
+        };
+    return {
+        eslintOptions: {
+            ignores: eslintIgnores,
+            tailwind: true
+        },
+        sharedOverrideAppendIndexes
+    };
+}, normalizeLinterOffOverrides = ({ assertKnownRules, fileKey, label, value }) => parseLinterOffOverrides({
+    assertKnownRules,
+    fileKey,
+    label,
+    value
+}), normalizeKnownOffRules = ({ assertKnownRules, label, value }) => {
+    const normalizedRules = normalizeRulesOffInput({
+        label,
+        value
+    });
+    if (!normalizedRules)
+        return;
+    assertKnownRules?.(normalizedRules);
+    return normalizedRules;
+}, createBiomeConfig = async ({ cwd, options, sharedIgnorePatterns }) => {
+    const { categories, ruleMap } = await resolveBiomeSchema({ cwd }), allRulesOff = [...BIOME_RULES_OFF], normalizedRules = normalizeKnownOffRules({
+        assertKnownRules: rules => assertKnownBiomeRuleNames({
+            categoryMap: ruleMap,
+            label: 'biome.off',
+            rules
+        }),
+        label: 'biome.off',
+        value: options?.off
+    });
+    if (normalizedRules)
+        for (const key of Object.keys(normalizedRules)) {
+            const ruleName = stripPluginNamespace({ rule: key });
             if (!allRulesOff.includes(ruleName))
                 allRulesOff.push(ruleName);
         }
-    const ignorePatterns = [...biomeIgnorePatterns], mergedIgnorePatterns = [...(globalIgnorePatterns ?? []), ...(options?.ignorePatterns ?? [])];
+    const ignorePatterns = [...BIOME_IGNORE_PATTERNS], mergedIgnorePatterns = mergeIgnorePatternGroups({
+        groups: [
+            sharedIgnorePatterns,
+            options?.ignores === undefined
+                ? undefined
+                : normalizePathListInput({
+                    label: 'biome.ignores',
+                    value: options.ignores
+                })
+        ]
+    });
     for (const pattern of mergedIgnorePatterns) {
         const negated = normalizeBiomeIgnorePattern({ pattern });
         if (!ignorePatterns.includes(negated))
@@ -135,23 +408,35 @@ const decoder = new TextDecoder(), pkgRoot = dirnamePath(fromFileUrl(import.meta
             }
         }
     ];
-    if (options?.overrides)
-        for (const override of options.overrides)
-            if (override.disableLinter)
-                overrides.push({
-                    includes: override.includes,
-                    linter: { enabled: false }
-                });
-            else if (override.rules)
-                overrides.push({
-                    includes: override.includes,
-                    linter: {
-                        rules: groupByCategory({
-                            categoryMap: ruleMap,
-                            ruleNames: extractRuleNames(override.rules)
-                        })
-                    }
-                });
+    for (const override of BIOME_PATTERN_RULE_OVERRIDES)
+        overrides.push({
+            includes: [...override.includes],
+            linter: {
+                rules: groupByCategory({
+                    categoryMap: ruleMap,
+                    ruleNames: override.rules
+                })
+            }
+        });
+    for (const override of normalizeLinterOffOverrides({
+        assertKnownRules: rules => assertKnownBiomeRuleNames({
+            categoryMap: ruleMap,
+            label: 'biome.overrides.off',
+            rules
+        }),
+        fileKey: 'includes',
+        label: 'biome.overrides',
+        value: options?.overrides
+    }))
+        overrides.push({
+            includes: override.files,
+            linter: {
+                rules: groupByCategory({
+                    categoryMap: ruleMap,
+                    ruleNames: extractRuleNames(override.rules)
+                })
+            }
+        });
     return {
         $schema: 'https://biomejs.dev/schemas/latest/schema.json',
         assist: { actions: { source: { organizeImports: 'off' } } },
@@ -187,8 +472,28 @@ const decoder = new TextDecoder(), pkgRoot = dirnamePath(fromFileUrl(import.meta
         },
         overrides
     };
-}, createOxlintConfig = async ({ globalIgnorePatterns, options }) => {
-    const base = await readJsonFile({ filePath: joinPath(pkgRoot, 'oxlintrc.json') }), mergedIgnorePatterns = [...(globalIgnorePatterns ?? []), ...(options?.ignorePatterns ?? [])];
+}, createOxlintConfig = async ({ options, sharedIgnorePatterns }) => {
+    const base = await readRequiredJson({ path: joinPath(pkgRoot, 'oxlintrc.json') }), knownRules = new Set([
+        ...Object.keys(base.rules),
+        ...(base.overrides ?? []).flatMap(override => Object.keys(override.rules)),
+        ...OXLINT_PATTERN_RULE_OVERRIDES.flatMap(override => Object.keys(override.rules))
+    ]), mergedIgnorePatterns = mergeIgnorePatternGroups({
+        groups: [
+            sharedIgnorePatterns,
+            options?.ignores === undefined
+                ? undefined
+                : normalizePathListInput({
+                    label: 'oxlint.ignores',
+                    value: options.ignores
+                })
+        ]
+    });
+    base.overrides ??= [];
+    for (const override of OXLINT_PATTERN_RULE_OVERRIDES)
+        base.overrides.push({
+            files: [...override.files],
+            rules: { ...override.rules }
+        });
     if (mergedIgnorePatterns.length > 0) {
         base.ignorePatterns ??= [];
         for (const pattern of mergedIgnorePatterns)
@@ -197,55 +502,69 @@ const decoder = new TextDecoder(), pkgRoot = dirnamePath(fromFileUrl(import.meta
     }
     if (!options)
         return base;
-    if (options.rules)
-        for (const [key, value] of Object.entries(options.rules))
+    const normalizedRules = normalizeKnownOffRules({
+        assertKnownRules: rules => assertKnownOxlintRuleNames({
+            knownRules,
+            label: 'oxlint.off',
+            rules
+        }),
+        label: 'oxlint.off',
+        value: options.off
+    });
+    if (normalizedRules)
+        for (const [key, value] of Object.entries(normalizedRules))
             base.rules[key] = value;
-    if (options.overrides) {
-        base.overrides ??= [];
-        for (const override of options.overrides)
-            base.overrides.push({ files: override.files, rules: override.rules });
-    }
+    for (const override of normalizeLinterOffOverrides({
+        assertKnownRules: rules => assertKnownOxlintRuleNames({
+            knownRules,
+            label: 'oxlint.overrides.off',
+            rules
+        }),
+        fileKey: 'files',
+        label: 'oxlint.overrides',
+        value: options.overrides
+    }))
+        base.overrides.push({
+            files: override.files,
+            rules: override.rules
+        });
     return base;
-}, warnToError = (rules) => {
-    const result = {};
-    for (const [key, value] of Object.entries(rules))
-        if (value === undefined)
-            result[key] = 'error';
-        else if (value === 'warn' || value === 1)
-            result[key] = 'error';
-        else if (Array.isArray(value) && (value[0] === 'warn' || value[0] === 1))
-            result[key] = ['error', ...value.slice(1)];
-        else
-            result[key] = value;
-    return result;
-}, cacheDir = joinPath('node_modules', '.cache', 'lintmax'), sync = async (options) => {
-    const cwd = process.cwd(), dir = joinPath(cwd, cacheDir), globalIgnorePatterns = options?.globalIgnorePatterns ?? [], mergedEslintIgnores = [...globalIgnorePatterns];
-    if (options?.eslint?.ignores)
-        for (const pattern of options.eslint.ignores)
-            if (!mergedEslintIgnores.includes(pattern))
-                mergedEslintIgnores.push(pattern);
-    const eslintOptions = options?.eslint
-        ? { ...options.eslint }
-        : mergedEslintIgnores.length > 0
-            ? { ignores: mergedEslintIgnores }
-            : undefined;
-    if (eslintOptions && mergedEslintIgnores.length > 0)
-        eslintOptions.ignores = mergedEslintIgnores;
+}, sync = async (options) => {
+    const { biome, eslint, oxlint, sharedOverrides, tailwind, topLevelIgnores, tsconfigRootDir } = validateSyncOptions({
+        options
+    }), cwd = process.cwd(), dir = joinPath(cwd, cacheDir), userIgnorePatterns = buildUserIgnorePatterns({ topLevelIgnores }), sharedIgnorePatterns = mergeIgnorePatternGroups({
+        groups: [DEFAULT_SHARED_IGNORE_PATTERNS, userIgnorePatterns]
+    }), biomeOptions = buildBiomeOptions({
+        biomeSource: biome,
+        sharedOverrides
+    }), oxlintOptions = buildOxlintOptions({
+        oxlintSource: oxlint,
+        sharedOverrides
+    }), { eslintOptions, sharedOverrideAppendIndexes } = buildEslintOptions({
+        eslintSource: eslint,
+        sharedOverrides,
+        tailwind,
+        tsconfigRootDir,
+        userIgnorePatterns
+    });
     ensureDirectory({ directory: dir });
     const biomeConfig = await createBiomeConfig({
         cwd,
-        globalIgnorePatterns,
-        options: options?.biome
+        options: biomeOptions,
+        sharedIgnorePatterns
     }), oxlintConfig = await createOxlintConfig({
-        globalIgnorePatterns,
-        options: options?.oxlint
+        options: oxlintOptions,
+        sharedIgnorePatterns
     }), eslintConfig = eslintOptions
-        ? `import { eslint } from 'lintmax/eslint'\nexport default eslint(${JSON.stringify(eslintOptions)})\n`
-        : "export { default } from 'lintmax/eslint'\n", runtimeConfig = { compact: options?.compact === true };
+        ? `import { eslint } from 'lintmax/eslint'\nconst options = ${JSON.stringify(eslintOptions)}\nfor (const index of ${JSON.stringify(sharedOverrideAppendIndexes)}) {\n  const entry = options.append?.[index]\n  if (entry && typeof entry === 'object') entry[Symbol.for(${JSON.stringify(SHARED_OVERRIDE_SYMBOL_KEY)})] = true\n}\nexport default eslint(options)\n`
+        : "export { default } from 'lintmax/eslint'\n", runtimeConfig = { compact: options?.compact !== false };
     await write(joinPath(dir, 'biome.json'), `${JSON.stringify(biomeConfig, null, 2)}\n`);
     await write(joinPath(dir, '.oxlintrc.json'), `${JSON.stringify(oxlintConfig, null, 2)}\n`);
-    await write(joinPath(dir, 'eslint.config.mjs'), eslintConfig);
+    await write(joinPath(dir, 'eslint.generated.mjs'), eslintConfig);
     await write(joinPath(dir, 'lintmax.json'), `${JSON.stringify(runtimeConfig, null, 2)}\n`);
-}, defineConfig = (options) => options;
-export { cacheDir, defineConfig, sync, warnToError };
+}, defineConfig = (options) => {
+    validateSyncOptions({ options });
+    return options;
+};
+export { defineConfig, sync };
 //# sourceMappingURL=index.js.map