@useinsider/eslint-config 3.0.2 → 4.0.0-beta.1

package/dist/cli.cjs

@@ -1,15 +1,17 @@
 #!/usr/bin/env node
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
+const require_oxlintOwnership = require("./oxlintOwnership-7hpdB3d1.cjs");
 let globals = require("globals");
-globals = require_rolldown_runtime.__toESM(globals, 1);
+globals = require_oxlintOwnership.__toESM(globals, 1);
 let node_fs = require("node:fs");
 let node_path = require("node:path");
 let node_url = require("node:url");
+let _typescript_eslint_types = require("@typescript-eslint/types");
 let node_crypto = require("node:crypto");
 let node_os = require("node:os");
 let typescript = require("typescript");
-typescript = require_rolldown_runtime.__toESM(typescript, 1);
+typescript = require_oxlintOwnership.__toESM(typescript, 1);
+let _typescript_eslint_parser = require("@typescript-eslint/parser");
 //#region src/cli/detect.ts
 var FLAT_CONFIG_FILENAMES = [
 	"eslint.config.mjs",
@@ -329,12 +331,13 @@ function parseScaffoldArgs(argv) {
 function printUsage(stderr, unknown) {
 	stderr(`[useinsider/eslint-config] Unknown subcommand: ${unknown}`);
 	stderr("Usage:");
-	stderr("  npx @useinsider/eslint-config [--yes|-y]   Scaffold a new eslint.config.mjs");
+	stderr("  npx @useinsider/eslint-config [--yes|-y]");
+	stderr("      Scaffold insider.lint.*, eslint.config.* and oxlint.config.*");
 	stderr("  npx @useinsider/eslint-config migrate [path] [--yes|-y] [--no-install]");
-	stderr("                                              Migrate an existing v1 useInsider() config to v2");
+	stderr("      Split an existing useInsider() or .eslintrc* config into the three-file layout");
 }
 function isScaffoldArgv(argv) {
-	return argv.length === 0 || argv.every((arg) => isYesFlag(arg));
+	return argv.every((arg) => isYesFlag(arg));
 }
 async function dispatch(argv, cwd, deps) {
 	if (isScaffoldArgv(argv)) {
@@ -358,6 +361,9 @@ async function dispatch(argv, cwd, deps) {
 	return 1;
 }
 //#endregion
+//#region src/configs/dependencies.ts
+var dependencies$14 = { oxlint: true };
+//#endregion
 //#region src/configs/jest/dependencies.ts
 var dependencies$13 = { "eslint-plugin-jest": true };
 //#endregion
@@ -471,6 +477,7 @@ function buildDependencyList(answers, rawManifest = readOwnEslintConfigManifest$
 	deps.add(`@useinsider/eslint-config@${manifest.version}`);
 	deps.add(pinned(manifest, "eslint"));
 	deps.add(pinned(manifest, "globals"));
+	applyRecord(deps, manifest, dependencies$14);
 	const wantsTypescript = answers.languages.includes("typescript");
 	if (answers.framework === "vue") applyRecord(deps, manifest, vueDepsFor(answers.vueMajor ?? 3, wantsTypescript));
 	else if (wantsTypescript) applyRecord(deps, manifest, dependencies$12);
@@ -702,6 +709,132 @@ async function installWithRetry(opts) {
 	}
 }
 //#endregion
+//#region src/cli/lintLayout.ts
+var OXLINT_LINT_SCRIPT = "oxlint --disable-nested-config && eslint .";
+/**
+* Extension for the lint module and the oxlint config. oxlint only discovers `oxlint.config.ts` and
+* `oxlint.config.mts`, and Node warns on a bare `.ts` file inside a package that declares no
+* `"type"`, so such a consumer gets the unambiguous `.mts` form.
+* @example
+* resolveLayoutExtension('/repo'); // 'ts' when /repo/package.json declares "type": "module"
+*/
+function resolveLayoutExtension(cwd) {
+	try {
+		const raw = (0, node_fs.readFileSync)((0, node_path.join)(cwd, "package.json"), "utf8");
+		return JSON.parse(raw).type === "module" ? "ts" : "mts";
+	} catch {
+		return "mts";
+	}
+}
+function findExistingEslintConfig(cwd, fallback) {
+	return [
+		"ts",
+		"mts",
+		"cts",
+		"js",
+		"mjs",
+		"cjs"
+	].map((ext) => `eslint.config.${ext}`).find((filename) => (0, node_fs.existsSync)((0, node_path.join)(cwd, filename))) ?? fallback;
+}
+/**
+* The three filenames `useInsider()` requires, resolved against a consumer directory. An existing
+* `eslint.config.*` keeps its name so a migration does not leave two flat configs behind.
+* @example
+* resolveLintLayout('/repo'); // { lintModule: 'insider.lint.mts', eslintConfig: 'eslint.config.mjs', ... }
+*/
+function resolveLintLayout(cwd, eslintConfigFallback = "eslint.config.mjs") {
+	const extension = resolveLayoutExtension(cwd);
+	return {
+		extension,
+		lintModule: `insider.lint.${extension}`,
+		oxlintConfig: `oxlint.config.${extension}`,
+		eslintConfig: findExistingEslintConfig(cwd, eslintConfigFallback)
+	};
+}
+/**
+* Body of the generated `eslint.config.*`. The import names the lint module's real extension
+* because neither linter's loader applies TypeScript's `.js` → `.ts` specifier rewriting.
+* @example
+* renderEslintConfigFile('insider.lint.ts'); // "import { useInsiderESLint } from './insider.lint.ts';\n…"
+*/
+function renderEslintConfigFile(lintModule) {
+	return [
+		`import { useInsiderESLint } from './${lintModule}';`,
+		"",
+		"export default useInsiderESLint();",
+		""
+	].join("\n");
+}
+/**
+* Body of the generated `oxlint.config.*`.
+* @example
+* renderOxlintConfigFile('insider.lint.mts'); // "…export default await useInsiderOXC();\n"
+*/
+function renderOxlintConfigFile(lintModule) {
+	return [
+		`import { useInsiderOXC } from './${lintModule}';`,
+		"",
+		"export default await useInsiderOXC();",
+		""
+	].join("\n");
+}
+/**
+* The two thin files that sit beside a lint module, ready to write.
+* @example
+* renderLintLayoutFiles(resolveLintLayout('/repo')).map(file => file.filename);
+* // ['eslint.config.mjs', 'oxlint.config.mts']
+*/
+function renderLintLayoutFiles(layout) {
+	return [{
+		filename: layout.eslintConfig,
+		source: renderEslintConfigFile(layout.lintModule)
+	}, {
+		filename: layout.oxlintConfig,
+		source: renderOxlintConfigFile(layout.lintModule)
+	}];
+}
+var DEFAULT_INDENT = 2;
+function detectIndent$1(raw) {
+	const firstBreak = raw.indexOf("\n");
+	if (firstBreak === -1) return DEFAULT_INDENT;
+	const rest = raw.slice(firstBreak + 1);
+	const width = rest.length - rest.trimStart().length;
+	return width > 0 ? width : DEFAULT_INDENT;
+}
+/**
+* Rewrites the consumer's `lint` script so both linters run. Returns the manifest untouched when it
+* already runs oxlint, so re-running the CLI is idempotent.
+* @example
+* setLintScript('{"scripts":{"lint":"eslint ."}}').manifest;
+* // '…"lint": "oxlint --disable-nested-config && eslint ."…'
+*/
+function setLintScript(rawManifest) {
+	let parsed;
+	try {
+		parsed = JSON.parse(rawManifest);
+	} catch {
+		return {
+			manifest: rawManifest,
+			changed: false
+		};
+	}
+	const previous = parsed.scripts?.lint;
+	if (previous?.includes("oxlint")) return {
+		manifest: rawManifest,
+		changed: false,
+		previous
+	};
+	parsed.scripts = {
+		...parsed.scripts,
+		lint: OXLINT_LINT_SCRIPT
+	};
+	return {
+		manifest: `${JSON.stringify(parsed, null, detectIndent$1(rawManifest))}\n`,
+		changed: true,
+		previous
+	};
+}
+//#endregion
 //#region src/cli/quote.ts
 function quote(value) {
 	return `'${JSON.stringify(value).slice(1, -1).replace(/\\"/g, "\"").replace(/'/g, "\\'")}'`;
@@ -995,11 +1128,17 @@ function formatScope$1(scope, entries, baseIndent) {
 function renderUseInsiderBody(merged) {
 	return [...merged.entries()].map(([scope, entries]) => formatScope$1(scope, entries, indent$1)).join("\n");
 }
-function renderConfigFile(answers) {
+/**
+* Body of the generated `insider.lint.*` module — the one file that calls `useInsider()` and the
+* only one both linter configs import.
+* @example
+* renderLintModuleFile(answers); // "…export const { useInsiderESLint, useInsiderOXC } = useInsider({…"
+*/
+function renderLintModuleFile(answers) {
 	return [
 		"import { useInsider } from '@useinsider/eslint-config';",
 		"",
-		"export default useInsider({",
+		"export const { useInsiderESLint, useInsiderOXC } = useInsider({",
 		renderUseInsiderBody(mergeByScope(buildScopedConfigs(answers))),
 		"});",
 		""
@@ -1440,7 +1579,11 @@ var SCOPE_TO_DEPS = {
 	vitest: dependencies$11,
 	jsdocBasedTs: dependencies$3
 };
-var ALL_PRESET_DEPS = [dependencies$2, ...Object.values(SCOPE_TO_DEPS)];
+var ALL_PRESET_DEPS = [
+	dependencies$14,
+	dependencies$2,
+	...Object.values(SCOPE_TO_DEPS)
+];
 var PRESET_DEPENDENCY_KEYS = new Set(ALL_PRESET_DEPS.flatMap((record) => Object.keys(record)));
 function isEslintRelatedDependency(name) {
 	if (SAFELIST.has(name)) return false;
@@ -1538,6 +1681,9 @@ function buildInstallList(scopes, manifest) {
 	const fallbacks = [];
 	appendSpec(specs, "@useinsider/eslint-config@latest");
 	appendSpec(specs, resolveSpec("eslint", manifest, fallbacks));
+	Object.entries(dependencies$14).forEach(([packageName, shouldInstall]) => {
+		if (shouldInstall) appendSpec(specs, resolveSpec(packageName, manifest, fallbacks));
+	});
 	[...scopes].forEach((scope) => {
 		const record = SCOPE_TO_DEPS[scope];
 		if (!record) return;
@@ -1597,6 +1743,340 @@ function pruneConsumerPackageJson(cwd) {
 	};
 }
 //#endregion
+//#region src/cli/tsconfigFlag.ts
+var TS_EXTENSIONS_FLAG = "allowImportingTsExtensions";
+var TS_EXTENSIONS_SNIPPET = [
+	"{",
+	"    \"compilerOptions\": {",
+	`        "${TS_EXTENSIONS_FLAG}": true`,
+	"    }",
+	"}"
+].join("\n");
+var DEFAULT_INDENT_UNIT = "    ";
+function readEffectiveFlag(path, raw) {
+	const { config } = typescript.parseConfigFileTextToJson(path, raw);
+	if (!config) return false;
+	return typescript.parseJsonConfigFileContent(config, typescript.sys, (0, node_path.dirname)(path), void 0, path).options.allowImportingTsExtensions === true;
+}
+/**
+* The consumer's root `tsconfig.json` plus whether `allowImportingTsExtensions` already resolves to
+* `true` — including when it arrives through `extends`, which is followed the same way `tsc` does.
+* @example
+* readTsconfigState('/repo')?.enabled; // true when /repo/tsconfig.json extends a base that sets it
+*/
+function readTsconfigState(cwd) {
+	const path = (0, node_path.join)(cwd, "tsconfig.json");
+	if (!(0, node_fs.existsSync)(path)) return null;
+	try {
+		const raw = (0, node_fs.readFileSync)(path, "utf8");
+		return {
+			path,
+			raw,
+			enabled: readEffectiveFlag(path, raw)
+		};
+	} catch {
+		return null;
+	}
+}
+function rootObject(source) {
+	const [statement] = source.statements;
+	const expression = statement?.expression;
+	return expression && typescript.isObjectLiteralExpression(expression) ? expression : null;
+}
+function findProperty$2(object, name) {
+	return object.properties.find((property) => typescript.isPropertyAssignment(property) && typescript.isStringLiteral(property.name) && property.name.text === name);
+}
+function indentAt(raw, position) {
+	const lineStart = raw.lastIndexOf("\n", position - 1) + 1;
+	const prefix = raw.slice(lineStart, position);
+	return prefix.trim().length === 0 ? prefix : "";
+}
+function detectIndentUnit(raw) {
+	const match = /\n([\t ]+)\S/u.exec(raw);
+	return match ? match[1] : DEFAULT_INDENT_UNIT;
+}
+function splice(raw, start, end, text) {
+	return raw.slice(0, start) + text + raw.slice(end);
+}
+function setExistingFlag(raw, source, property) {
+	return splice(raw, property.initializer.getStart(source), property.initializer.getEnd(), "true");
+}
+function insertIntoCompilerOptions(raw, source, compilerOptions, object) {
+	const openBrace = object.getStart(source) + 1;
+	const [first] = object.properties;
+	if (first) return splice(raw, openBrace, openBrace, `\n${indentAt(raw, first.getStart(source)) || detectIndentUnit(raw).repeat(2)}"${TS_EXTENSIONS_FLAG}": true,`);
+	const outer = indentAt(raw, compilerOptions.getStart(source));
+	const unit = detectIndentUnit(raw);
+	return splice(raw, openBrace, object.getEnd() - 1, `\n${outer}${unit}"${TS_EXTENSIONS_FLAG}": true\n${outer}`);
+}
+function insertCompilerOptions(raw, source, root) {
+	const openBrace = root.getStart(source) + 1;
+	const unit = detectIndentUnit(raw);
+	const [first] = root.properties;
+	const indent = first ? indentAt(raw, first.getStart(source)) || unit : unit;
+	const block = `\n${indent}"compilerOptions": {\n${indent}${unit}"${TS_EXTENSIONS_FLAG}": true\n${indent}}`;
+	if (first) return splice(raw, openBrace, openBrace, `${block},`);
+	return splice(raw, openBrace, root.getEnd() - 1, `${block}\n`);
+}
+/**
+* Turns `allowImportingTsExtensions` on in a `tsconfig.json` source without reformatting it. The
+* file is edited through its JSON syntax tree rather than re-serialized, so comments, key order and
+* indentation survive.
+* @example
+* enableTsExtensionsFlag('{\n  "compilerOptions": {\n    "strict": true\n  }\n}').changed; // true
+*/
+function enableTsExtensionsFlag(raw) {
+	const source = typescript.parseJsonText("tsconfig.json", raw);
+	const root = rootObject(source);
+	if (!root) return {
+		source: raw,
+		changed: false
+	};
+	const compilerOptions = findProperty$2(root, "compilerOptions");
+	if (!compilerOptions) return {
+		source: insertCompilerOptions(raw, source, root),
+		changed: true
+	};
+	if (!typescript.isObjectLiteralExpression(compilerOptions.initializer)) return {
+		source: raw,
+		changed: false
+	};
+	const existing = findProperty$2(compilerOptions.initializer, TS_EXTENSIONS_FLAG);
+	if (existing) {
+		if (existing.initializer.kind === typescript.SyntaxKind.TrueKeyword) return {
+			source: raw,
+			changed: false
+		};
+		return {
+			source: setExistingFlag(raw, source, existing),
+			changed: true
+		};
+	}
+	return {
+		source: insertIntoCompilerOptions(raw, source, compilerOptions, compilerOptions.initializer),
+		changed: true
+	};
+}
+function noteManualStep(clack, lintModule) {
+	if (!clack.note) return;
+	clack.note(`\`eslint.config.*\` imports \`./${lintModule}\` by its real extension, which \`tsc\` rejects with TS5097 unless \`${TS_EXTENSIONS_FLAG}\` is on. Add this to your tsconfig.json:\n\n${TS_EXTENSIONS_SNIPPET}`, "tsconfig.json not updated");
+}
+async function confirmFlag(clack, path) {
+	const result = await clack.confirm({
+		message: `Set \`${TS_EXTENSIONS_FLAG}: true\` in ${path}? Without it \`tsc\` fails with TS5097 on the generated config files.`,
+		initialValue: true
+	});
+	return !clack.isCancel(result) && result === true;
+}
+/**
+* Offers to set `allowImportingTsExtensions` on the consumer's `tsconfig.json`, and prints the exact
+* snippet when the offer is declined. A no-op when there is no `tsconfig.json` or the flag already
+* resolves to `true` through the `extends` chain.
+* @example
+* await applyTsExtensionsFlag(clack, { cwd: '/repo', lintModule: 'insider.lint.ts' });
+*/
+async function applyTsExtensionsFlag(clack, input) {
+	const state = readTsconfigState(input.cwd);
+	if (!state || state.enabled) return;
+	if (!(input.autoConfirm || await confirmFlag(clack, state.path))) {
+		noteManualStep(clack, input.lintModule);
+		return;
+	}
+	const result = enableTsExtensionsFlag(state.raw);
+	if (!result.changed) {
+		noteManualStep(clack, input.lintModule);
+		return;
+	}
+	(0, node_fs.writeFileSync)(state.path, result.source, "utf8");
+	if (clack.note) clack.note(`Set \`${TS_EXTENSIONS_FLAG}: true\` in ${state.path}.`, "Updated tsconfig.json");
+}
+//#endregion
+//#region src/cli/migrate/disableDirectives.ts
+var DIRECTIVE_HEAD = /^\s*eslint-disable(-next-line|-line)?(?![\w-])/u;
+var SCRIPT_BLOCK = /<script\b[^>]*>([\s\S]*?)<\/script>/giu;
+var SFC_EXTENSIONS = [
+	".astro",
+	".svelte",
+	".vue"
+];
+var JSX_EXTENSIONS = [
+	".cjs",
+	".js",
+	".jsx",
+	".mjs",
+	".tsx"
+];
+var LINTED_EXTENSIONS = [
+	".astro",
+	".cjs",
+	".cts",
+	".js",
+	".jsx",
+	".mjs",
+	".mts",
+	".svelte",
+	".ts",
+	".tsx",
+	".vue"
+];
+var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set([
+	".git",
+	"coverage",
+	"dist",
+	"build",
+	"node_modules",
+	"out",
+	"vendor"
+]);
+function parseDirectiveBody(body) {
+	const [ruleList, ...reasonParts] = body.split("--");
+	return {
+		rules: ruleList.split(",").map((rule) => rule.trim()).filter((rule) => rule.length > 0),
+		reason: reasonParts.join("--").trim()
+	};
+}
+function formatDirective(owner, block, kind, rules, reason) {
+	const text = `${owner}-disable${kind} ${reason ? `${rules.join(", ")} -- ${reason}` : rules.join(", ")}`;
+	return block ? `/* ${text} */` : `// ${text}`;
+}
+/**
+* Whether the split hands this rule to oxlint for the given file, so an `eslint-disable` comment
+* naming it would read as an unused directive to ESLint.
+* @example
+* movesToOxlint('no-console', '.ts'); // true
+* movesToOxlint('@typescript-eslint/no-unused-vars', '.vue'); // false — ESLint still runs it in SFCs
+*/
+function movesToOxlint(rule, fileExtension) {
+	if (!require_oxlintOwnership.isOxlintOwned(rule)) return false;
+	return !(SFC_EXTENSIONS.includes(fileExtension) && require_oxlintOwnership.isVueUnsafeRule(rule));
+}
+function toSpans(comments, offset) {
+	return comments.map((comment) => ({
+		start: comment.range[0] + offset,
+		end: comment.range[1] + offset,
+		block: comment.type === _typescript_eslint_types.AST_TOKEN_TYPES.Block,
+		value: comment.value
+	}));
+}
+function parseComments(source, jsx) {
+	try {
+		return (0, _typescript_eslint_parser.parse)(source, {
+			comment: true,
+			jsx,
+			range: true
+		}).comments ?? [];
+	} catch {
+		return null;
+	}
+}
+function collectFromScript(source, jsx, offset) {
+	const comments = parseComments(source, jsx) ?? parseComments(source, !jsx);
+	return comments ? toSpans(comments, offset) : [];
+}
+var CLOSING_SCRIPT_TAG_LENGTH = 9;
+function collectSfcComments(source, jsx) {
+	return [...source.matchAll(SCRIPT_BLOCK)].flatMap((match) => {
+		const [whole, body] = match;
+		return collectFromScript(body, jsx, (match.index ?? 0) + whole.length - body.length - CLOSING_SCRIPT_TAG_LENGTH);
+	});
+}
+/**
+* Every real comment node in the file, with ranges relative to the whole source. Only comments are
+* returned, so a string or template literal that happens to spell out a directive is invisible here.
+* @example
+* collectComments("const label = '// eslint-disable-next-line';\n", '.ts'); // []
+*/
+function collectComments(source, fileExtension) {
+	const jsx = JSX_EXTENSIONS.includes(fileExtension);
+	if (SFC_EXTENSIONS.includes(fileExtension)) return collectSfcComments(source, jsx);
+	return collectFromScript(source, jsx, 0);
+}
+function startsItsOwnLine(source, start) {
+	const lineStart = source.lastIndexOf("\n", start - 1) + 1;
+	return source.slice(lineStart, start).trim().length === 0;
+}
+function splitLayout(source, span, kind) {
+	if (kind !== "" || !startsItsOwnLine(source, span.start)) return {
+		block: true,
+		separator: " "
+	};
+	const indent = " ".repeat(span.start - (source.lastIndexOf("\n", span.start - 1) + 1));
+	return {
+		block: span.block,
+		separator: `\n${indent}`
+	};
+}
+function replacementFor(source, span, fileExtension) {
+	const head = DIRECTIVE_HEAD.exec(span.value);
+	if (!head) return null;
+	const kind = head[1] ?? "";
+	const { rules, reason } = parseDirectiveBody(span.value.slice(head[0].length));
+	if (rules.length === 0) return null;
+	const moved = rules.filter((rule) => movesToOxlint(rule, fileExtension));
+	if (moved.length === 0) return null;
+	const kept = rules.filter((rule) => !moved.includes(rule));
+	if (kept.length === 0) return {
+		start: span.start,
+		end: span.end,
+		text: formatDirective("oxlint", span.block, kind, moved, reason)
+	};
+	const { block, separator } = splitLayout(source, span, kind);
+	const text = formatDirective("oxlint", block, kind, moved, reason) + separator + formatDirective("eslint", block, kind, kept, reason);
+	return {
+		start: span.start,
+		end: span.end,
+		text
+	};
+}
+/**
+* Re-points the rules oxlint now owns onto an `oxlint-disable` comment, leaving the ESLint-owned
+* ones behind. Only real comment nodes are rewritten, so a string or template literal spelling out
+* a directive is left alone.
+* @example
+* rewriteDirectives('// <eslint>-disable-next-line no-console\nlog();', '.ts').source;
+* // '// oxlint-disable-next-line no-console\nlog();'
+*/
+function rewriteDirectives(source, fileExtension) {
+	const replacements = collectComments(source, fileExtension).map((span) => replacementFor(source, span, fileExtension)).filter((replacement) => replacement !== null).sort((left, right) => right.start - left.start);
+	if (replacements.length === 0) return {
+		source,
+		changed: false
+	};
+	return {
+		source: replacements.reduce((accumulator, replacement) => accumulator.slice(0, replacement.start) + replacement.text + accumulator.slice(replacement.end), source),
+		changed: true
+	};
+}
+function isLintedFile(filePath) {
+	return LINTED_EXTENSIONS.includes((0, node_path.extname)(filePath));
+}
+function collectFiles(directory, accumulator) {
+	(0, node_fs.readdirSync)(directory).forEach((entry) => {
+		if (SKIPPED_DIRECTORIES.has(entry)) return;
+		const full = (0, node_path.join)(directory, entry);
+		if ((0, node_fs.statSync)(full).isDirectory()) {
+			collectFiles(full, accumulator);
+			return;
+		}
+		if (isLintedFile(full)) accumulator.push(full);
+	});
+}
+/**
+* Applies {@link rewriteDirectives} across a consumer tree, skipping build output and dependencies.
+* @example
+* rewriteDisableDirectives('/repo').rewritten; // ['/repo/src/logger.ts']
+*/
+function rewriteDisableDirectives(cwd) {
+	const files = [];
+	collectFiles(cwd, files);
+	return { rewritten: files.filter((filePath) => {
+		const result = rewriteDirectives((0, node_fs.readFileSync)(filePath, "utf8"), (0, node_path.extname)(filePath));
+		if (!result.changed) return false;
+		(0, node_fs.writeFileSync)(filePath, result.source, "utf8");
+		return true;
+	}) };
+}
+//#endregion
 //#region src/cli/migrate/stringEntry.ts
 function toEntries(values) {
 	return values.map((value) => ({ value }));
@@ -2214,7 +2694,7 @@ function appendScope$1(config, scope, entry) {
 }
 function mergeGlobals(base, extra) {
 	if (!base && !extra) return;
-	const merged = { ...base ?? {} };
+	const merged = { ...base };
 	if (extra) Object.entries(extra).forEach(([key, value]) => {
 		if (!(key in merged)) merged[key] = value;
 	});
@@ -3539,11 +4019,11 @@ function renderV2(plan) {
 	parts.push("");
 	if (plan.useInsiderLeadingComment !== void 0) parts.push(plan.useInsiderLeadingComment);
 	if (!hasAnyContent(plan)) {
-		parts.push("export default useInsider({});");
+		parts.push("export const { useInsiderESLint, useInsiderOXC } = useInsider({});");
 		parts.push("");
 		return pruneUnusedImports(parts.join("\n"));
 	}
-	parts.push("export default useInsider({");
+	parts.push("export const { useInsiderESLint, useInsiderOXC } = useInsider({");
 	parts.push(renderConfigBody(plan));
 	parts.push("});");
 	parts.push("");
@@ -3903,14 +4383,52 @@ function formatWarnings(warnings) {
 }
 //#endregion
 //#region src/cli/migrate/writer.ts
+function writeLayout(eslintConfigPath, lintModuleSource) {
+	const directory = (0, node_path.dirname)(eslintConfigPath);
+	const layout = resolveLintLayout(directory, (0, node_path.basename)(eslintConfigPath));
+	const lintModulePath = (0, node_path.join)(directory, layout.lintModule);
+	(0, node_fs.writeFileSync)(lintModulePath, lintModuleSource, "utf8");
+	const writtenPaths = [lintModulePath];
+	renderLintLayoutFiles({
+		...layout,
+		eslintConfig: (0, node_path.basename)(eslintConfigPath)
+	}).forEach((file) => {
+		const path = (0, node_path.join)(directory, file.filename);
+		(0, node_fs.writeFileSync)(path, file.source, "utf8");
+		writtenPaths.push(path);
+	});
+	return {
+		lintModulePath,
+		writtenPaths
+	};
+}
+/**
+* Writes the three-file layout beside an existing flat config: the rendered `useInsider()` call
+* becomes `insider.lint.*`, and `eslint.config.*` / `oxlint.config.*` become thin re-exports.
+* @example
+* writeMigration('/repo/eslint.config.mjs', source).writtenPaths.length; // 3
+*/
 function writeMigration(targetPath, newSource) {
-	(0, node_fs.writeFileSync)(targetPath, newSource, "utf8");
-	return { targetPath };
+	const { lintModulePath, writtenPaths } = writeLayout(targetPath, newSource);
+	return {
+		targetPath,
+		lintModulePath,
+		writtenPaths
+	};
 }
+/**
+* Same as {@link writeMigration}, but for a legacy `.eslintrc*` source that has to be replaced by a
+* differently-named flat config. Nominates the old file for deletion when the name changed.
+* @example
+* writeMigrationLegacy('/repo/.eslintrc.cjs', '/repo/eslint.config.mjs', source).deletedSourceCandidate;
+* // '/repo/.eslintrc.cjs'
+*/
 function writeMigrationLegacy(sourcePath, writePath, newSource) {
-	(0, node_fs.writeFileSync)(writePath, newSource, "utf8");
+	const { lintModulePath, writtenPaths } = writeLayout(writePath, newSource);
 	return {
 		targetPath: writePath,
+		lintModulePath,
+		writtenPaths,
 		deletedSourceCandidate: (0, node_path.basename)(sourcePath) === (0, node_path.basename)(writePath) ? void 0 : sourcePath
 	};
 }
@@ -4080,14 +4598,9 @@ function emitSummary(clack, plan, format) {
 	if (plan.warnings.length > 0 && clack.note) clack.note(formatWarnings(plan.warnings), "Warnings");
 }
 function writeAndAnnounce(clack, targetPath, writePath, rendered, format) {
-	if (format === "eslintrc") {
-		const result = writeMigrationLegacy(targetPath, writePath, rendered);
-		clack.outro(`Wrote ${writePath}`);
-		return { deletedSourceCandidate: result.deletedSourceCandidate };
-	}
-	writeMigration(targetPath, rendered);
-	clack.outro(`Wrote ${targetPath}`);
-	return {};
+	const result = format === "eslintrc" ? writeMigrationLegacy(targetPath, writePath, rendered) : writeMigration(targetPath, rendered);
+	clack.outro(`Wrote ${result.writtenPaths.join(", ")}`);
+	return { deletedSourceCandidate: result.deletedSourceCandidate };
 }
 async function confirmOverwriteExistingOutput(clack, writePath, sourcePath, initial = false) {
 	const message = `An \`${(0, node_path.basename)(writePath)}\` already exists. Overwrite + delete \`${(0, node_path.basename)(sourcePath)}\`?`;
@@ -4232,6 +4745,22 @@ function performWriteAndCleanup(clack, resolved, prepared) {
 	if (prepared.eslintIgnore) safeUnlink(prepared.eslintIgnore.path, clack, ".eslintignore");
 	if (outcome.deletedSourceCandidate) safeUnlink(outcome.deletedSourceCandidate, clack, "source config");
 }
+function applyLintScript$1(clack, directory) {
+	const manifestPath = (0, node_path.join)(directory, "package.json");
+	if (!(0, node_fs.existsSync)(manifestPath)) return;
+	const result = setLintScript((0, node_fs.readFileSync)(manifestPath, "utf8"));
+	if (!result.changed) return;
+	(0, node_fs.writeFileSync)(manifestPath, result.manifest, "utf8");
+	if (clack.note) {
+		const previous = result.previous ?? "(none)";
+		clack.note(`lint: ${previous} -> oxlint --disable-nested-config && eslint .`, "Updated package.json script");
+	}
+}
+function rewriteDirectivesWithNote(clack, directory) {
+	const { rewritten } = rewriteDisableDirectives(directory);
+	if (rewritten.length === 0 || !clack.note) return;
+	clack.note(`Re-pointed eslint-disable comments onto oxlint-disable in ${rewritten.length} file(s).`, "Disable directives");
+}
 function loadPreviousMigrate(clack, cwd) {
 	const restored = loadSession({ cwd });
 	const previousMigrate = restored?.command === "migrate" ? restored.migrate : void 0;
@@ -4271,6 +4800,14 @@ async function runMigrate(input, clackOverride) {
 	if (!await runConfirmations(clack, input, resolved.targetPath, prepared.writePath, previousMigrate)) return 0;
 	persistMigrateSession(input, prepared, resolved);
 	performWriteAndCleanup(clack, resolved, prepared);
+	applyLintScript$1(clack, (0, node_path.dirname)(prepared.writePath));
+	rewriteDirectivesWithNote(clack, (0, node_path.dirname)(prepared.writePath));
+	const consumerDir = (0, node_path.dirname)(prepared.writePath);
+	await applyTsExtensionsFlag(clack, {
+		cwd: consumerDir,
+		lintModule: resolveLintLayout(consumerDir).lintModule,
+		autoConfirm: input.yes
+	});
 	if (depSummary) await applyDepChanges(clack, depSummary, input);
 	clearSession({ cwd: input.cwd });
 	return 0;
@@ -4438,6 +4975,22 @@ async function resolveHybridAnswers(clack, input, answers) {
 	};
 	return answers;
 }
+function applyLintScript(cwd) {
+	const manifestPath = (0, node_path.join)(cwd, "package.json");
+	if (!(0, node_fs.existsSync)(manifestPath)) return;
+	const result = setLintScript((0, node_fs.readFileSync)(manifestPath, "utf8"));
+	if (result.changed) (0, node_fs.writeFileSync)(manifestPath, result.manifest, "utf8");
+}
+function writeLintLayout(cwd, lintModuleSource) {
+	const layout = resolveLintLayout(cwd);
+	const lintModulePath = (0, node_path.join)(cwd, layout.lintModule);
+	(0, node_fs.writeFileSync)(lintModulePath, lintModuleSource, "utf8");
+	renderLintLayoutFiles(layout).forEach((file) => {
+		(0, node_fs.writeFileSync)((0, node_path.join)(cwd, file.filename), file.source, "utf8");
+	});
+	applyLintScript(cwd);
+	return lintModulePath;
+}
 async function installAndWrite(clack, input, answers, options) {
 	if (options.pruneBeforeInstall) noteOverridePrune(clack, pruneConsumerPackageJson(input.cwd).removed);
 	const deps = buildDependencyList(answers);
@@ -4450,9 +5003,7 @@ async function installAndWrite(clack, input, answers, options) {
 		installer: input.overrides?.installer ?? installDependencies,
 		fsOps: input.overrides?.wipeFs
 	});
-	const targetPath = (0, node_path.join)(input.cwd, "eslint.config.mjs");
-	(0, node_fs.writeFileSync)(targetPath, renderConfigFile(answers), "utf8");
-	return targetPath;
+	return writeLintLayout(input.cwd, renderLintModuleFile(answers));
 }
 async function runScaffold(input, clackOverride) {
 	const clack = clackOverride ?? await loadClack();
@@ -4474,8 +5025,13 @@ async function runScaffold(input, clackOverride) {
 		}
 	}, { cwd: input.cwd });
 	const targetPath = await installAndWrite(clack, input, resolvedAnswers, { pruneBeforeInstall: viaOverride });
+	await applyTsExtensionsFlag(clack, {
+		cwd: input.cwd,
+		lintModule: resolveLintLayout(input.cwd).lintModule,
+		autoConfirm: input.yes
+	});
 	clearSession({ cwd: input.cwd });
-	clack.outro(`Wrote ${targetPath}`);
+	clack.outro(`Wrote ${targetPath} and its sibling linter configs`);
 	return 0;
 }
 async function runScaffoldSubcommand(scaffoldInput) {
@@ -4514,5 +5070,6 @@ if (!isUnderTest()) main().then(exitCleanly).catch((error) => {
 });
 //#endregion
 exports.runScaffold = runScaffold;
+exports.writeLintLayout = writeLintLayout;
 
 //# sourceMappingURL=cli.cjs.map