@useinsider/eslint-config 4.0.0-beta.2 → 4.0.0-beta.3

package/dist/cli.cjs

@@ -741,6 +741,22 @@ async function installWithRetry(opts) {
 	}
 }
 //#endregion
+//#region src/cli/detectIndent.ts
+var DEFAULT_INDENT = "    ";
+/**
+* The indentation a JSON source already uses, as the string `JSON.stringify` takes for its third
+* argument. A width would be wrong: `JSON.stringify` emits that many *spaces*, so a tab-indented
+* manifest comes back re-indented with spaces and every line of it shows up in the diff.
+* @example
+* detectIndent('{\n\t"name": "app"\n}'); // '\t'
+* @example
+* detectIndent('{"name":"app"}', '  '); // '  '
+*/
+function detectIndent(raw, fallback = DEFAULT_INDENT) {
+	const match = /\n([\t ]+)\S/u.exec(raw);
+	return match ? match[1] : fallback;
+}
+//#endregion
 //#region src/cli/lintLayout.ts
 var OXLINT_COMMAND = "oxlint --disable-nested-config";
 var OXLINT_LINT_SCRIPT = `${OXLINT_COMMAND} && eslint .`;
@@ -842,14 +858,7 @@ function renderLintLayoutFiles(layout) {
 		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;
-}
+var DEFAULT_MANIFEST_INDENT = "  ";
 var SEGMENT_SEPARATOR = /&&|\|\||[;|]/u;
 var ASSIGNMENT = /^[A-Za-z_]\w*=/u;
 var WRAPPER_COMMANDS = /* @__PURE__ */ new Set([
@@ -1003,7 +1012,7 @@ function setLintScript(rawManifest) {
 		parsed.scripts[change.script] = change.next;
 	});
 	return {
-		manifest: `${JSON.stringify(parsed, null, detectIndent$1(rawManifest))}\n`,
+		manifest: `${JSON.stringify(parsed, null, detectIndent(rawManifest, DEFAULT_MANIFEST_INDENT))}\n`,
 		changed: true,
 		changes,
 		alreadyRunsOxlint,
@@ -1785,6 +1794,18 @@ var ALL_PRESET_DEPS = [
 	...Object.values(SCOPE_TO_DEPS)
 ];
 var PRESET_DEPENDENCY_KEYS = new Set(ALL_PRESET_DEPS.flatMap((record) => Object.keys(record)));
+var MIGRATABLE_SCOPES = new Set(Object.keys(SCOPE_TO_DEPS));
+/**
+* Whether a `useInsider()` option key is a scope this migration can derive dependencies for. The
+* four `*OptionsApi` scopes are deliberately absent from the registry, so a config using one is
+* carried over untouched while its dependencies are reported as unresolved.
+* @example
+* isMigratableScope('vue3Typescript'); // true
+* isMigratableScope('vue3OptionsApi'); // false
+*/
+function isMigratableScope(key) {
+	return MIGRATABLE_SCOPES.has(key);
+}
 function isEslintRelatedDependency(name) {
 	if (SAFELIST.has(name)) return false;
 	if (EXACT_PATTERNS.has(name)) return true;
@@ -1899,11 +1920,6 @@ function buildInstallList(scopes, manifest) {
 var readOwnEslintConfigManifest = readOwnEslintConfigManifest$1;
 //#endregion
 //#region src/cli/prunePackageJson.ts
-function detectIndent(raw) {
-	const match = /\n([ \t]+)"/u.exec(raw);
-	if (!match) return "    ";
-	return match[1];
-}
 function serializeManifest(manifest, indent) {
 	return `${JSON.stringify(manifest, null, indent)}\n`;
 }
@@ -1952,7 +1968,6 @@ var TS_EXTENSIONS_SNIPPET = [
 	"    }",
 	"}"
 ].join("\n");
-var DEFAULT_INDENT_UNIT = "    ";
 function acceptsTsExtensionsFlag(options) {
 	return options.noEmit === true || options.emitDeclarationOnly === true || options.rewriteRelativeImportExtensions === true;
 }
@@ -2049,10 +2064,6 @@ function indentAt(raw, position) {
 	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);
 }
@@ -2062,14 +2073,14 @@ function setExistingFlag(raw, source, property) {
 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,`);
+	if (first) return splice(raw, openBrace, openBrace, `\n${indentAt(raw, first.getStart(source)) || detectIndent(raw).repeat(2)}"${TS_EXTENSIONS_FLAG}": true,`);
 	const outer = indentAt(raw, compilerOptions.getStart(source));
-	const unit = detectIndentUnit(raw);
+	const unit = detectIndent(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 unit = detectIndent(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}}`;
@@ -2354,35 +2365,75 @@ function collectFiles(directory, accumulator, visited) {
 		if (entry.isFile() && isLintedFile(full)) accumulator.push(full);
 	});
 }
+function readSource(filePath) {
+	try {
+		return (0, node_fs.readFileSync)(filePath, "utf8");
+	} catch {
+		return null;
+	}
+}
 /**
 * Every file whose `eslint-disable` comments would be re-pointed, and the rewritten source, without
 * touching disk. The directive rewrite is the largest diff a migration produces, so the count is
-* reported — and confirmed — before anything is written.
+* reported — and confirmed — before anything is written. Files that could not be read come back in
+* `skipped` instead of aborting the walk.
 * @example
-* previewDisableDirectives('/repo').length; // 131
+* previewDisableDirectives('/repo').candidates.length; // 131
 */
 function previewDisableDirectives(cwd) {
 	const files = [];
+	const candidates = [];
+	const skipped = [];
 	collectFiles(cwd, files, /* @__PURE__ */ new Set());
-	return files.reduce((candidates, filePath) => {
-		const result = rewriteDirectives((0, node_fs.readFileSync)(filePath, "utf8"), (0, node_path.extname)(filePath));
-		if (!result.changed) return candidates;
-		return [...candidates, {
+	files.forEach((filePath) => {
+		const source = readSource(filePath);
+		if (source === null) {
+			skipped.push(filePath);
+			return;
+		}
+		const result = rewriteDirectives(source, (0, node_path.extname)(filePath));
+		if (result.changed) candidates.push({
 			path: filePath,
 			source: result.source
-		}];
-	}, []);
+		});
+	});
+	return {
+		candidates,
+		skipped
+	};
+}
+/**
+* What the consumer is told about the files the rewrite could not touch: the paths, then why it
+* matters and how to finish the job. Nothing else in the migration is affected, and saying so is the
+* point — the layout was already written by the time the walk ran.
+* @example
+* formatUntouchedDirectiveFiles(['/repo/src/vendor.ts']); // '/repo/src/vendor.ts\n\nThese could not…'
+*/
+function formatUntouchedDirectiveFiles(skipped) {
+	return `${skipped.join("\n")}\n\nThese could not be read or written, so their \`eslint-disable\` comments still name rules oxlint now owns and ESLint will report each one as an unused directive. Everything else was migrated. Fix the access and re-run \`npx @useinsider/eslint-config migrate\` to pick them up.`;
 }
 /**
 * Applies {@link rewriteDirectives} across a consumer tree, skipping build output and dependencies.
+* A candidate whose write fails comes back in `skipped`, so one failed write costs its own
+* directives rather than every later file's.
 * @example
 * rewriteDisableDirectives('/repo').rewritten; // ['/repo/src/logger.ts']
 */
-function rewriteDisableDirectives(cwd, candidates = previewDisableDirectives(cwd)) {
+function rewriteDisableDirectives(cwd, candidates = previewDisableDirectives(cwd).candidates) {
+	const rewritten = [];
+	const skipped = [];
 	candidates.forEach((candidate) => {
-		(0, node_fs.writeFileSync)(candidate.path, candidate.source, "utf8");
+		try {
+			(0, node_fs.writeFileSync)(candidate.path, candidate.source, "utf8");
+			rewritten.push(candidate.path);
+		} catch {
+			skipped.push(candidate.path);
+		}
 	});
-	return { rewritten: candidates.map((candidate) => candidate.path) };
+	return {
+		rewritten,
+		skipped
+	};
 }
 //#endregion
 //#region src/cli/migrate/stringEntry.ts
@@ -2411,7 +2462,7 @@ function leadingCommentTextFor(sourceFile, node) {
 }
 //#endregion
 //#region src/cli/migrate/eslintrc/parse.ts
-function lineOf$1(sourceFile, node) {
+function lineOf$2(sourceFile, node) {
 	const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
 	return line + 1;
 }
@@ -2705,7 +2756,7 @@ function readSharedBlockFields(input) {
 	};
 }
 function readOverride(object, context, elementNode) {
-	const line = lineOf$1(context.sourceFile, object);
+	const line = lineOf$2(context.sourceFile, object);
 	const filesProperty = findProperty$1(object, "files");
 	const files = filesProperty ? readStringOrEntries(filesProperty.initializer, context.sourceFile) : [];
 	if (files.length === 0) {
@@ -2762,7 +2813,7 @@ function findExportObject(sourceFile) {
 	return result;
 }
 function buildRoot(object, context) {
-	const line = lineOf$1(context.sourceFile, object);
+	const line = lineOf$2(context.sourceFile, object);
 	const shared = readSharedBlockFields({
 		object,
 		line,
@@ -3392,7 +3443,7 @@ var knownPresets = /* @__PURE__ */ new Set([
 	"dom",
 	"node"
 ]);
-function lineOf(sourceFile, node) {
+function lineOf$1(sourceFile, node) {
 	const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
 	return line + 1;
 }
@@ -3695,7 +3746,7 @@ function classifyPresets(presetList, line, warnings) {
 	};
 }
 function parseUseInsiderCall(callExpression, sourceFile, warnings) {
-	const line = lineOf(sourceFile, callExpression);
+	const line = lineOf$1(sourceFile, callExpression);
 	const [firstArgument] = callExpression.arguments;
 	if (!firstArgument || !typescript.isObjectLiteralExpression(firstArgument)) {
 		warnings.push({
@@ -3795,7 +3846,7 @@ function tryClassifyStandaloneGlobals(objectLiteral, keys, line, sourceFile) {
 	};
 }
 function classifyObjectElement(objectLiteral, sourceFile, warnings) {
-	const line = lineOf(sourceFile, objectLiteral);
+	const line = lineOf$1(sourceFile, objectLiteral);
 	const keys = objectLiteral.properties.map(propertyKeyName).filter((name) => name !== null);
 	const ignoresBlock = tryClassifyIgnoresBlock(objectLiteral, keys, line, sourceFile);
 	if (ignoresBlock) return ignoresBlock;
@@ -3832,7 +3883,7 @@ function classifyArrayElement(element, sourceFile, warnings) {
 		if (leadingComment !== void 0) parsed.leadingComment = leadingComment;
 		return parsed;
 	}
-	const line = lineOf(sourceFile, element);
+	const line = lineOf$1(sourceFile, element);
 	warnings.push({
 		kind: "unrecognized-block",
 		line,
@@ -3849,18 +3900,19 @@ function classifyArrayElement(element, sourceFile, warnings) {
 function isDefineConfigCall(expression) {
 	return typescript.isCallExpression(expression) && typescript.isIdentifier(expression.expression) && expression.expression.text === "defineConfig";
 }
-function findDefaultExportArray(sourceFile) {
-	const exportExpressions = sourceFile.statements.filter(typescript.isExportAssignment).map((statement) => unwrapTypeCasts(statement.expression));
-	const directArray = exportExpressions.find(typescript.isArrayLiteralExpression);
-	if (directArray) return directArray;
-	const defineConfigCall = exportExpressions.find(isDefineConfigCall);
-	if (!defineConfigCall) return null;
-	const [first] = defineConfigCall.arguments;
+function defineConfigArray(exportExpressions) {
+	const [first] = exportExpressions.find(isDefineConfigCall)?.arguments ?? [];
 	if (!first) return null;
 	const unwrappedFirst = unwrapTypeCasts(first);
 	if (typescript.isArrayLiteralExpression(unwrappedFirst)) return unwrappedFirst;
 	return null;
 }
+function findDefaultExportElements(sourceFile) {
+	const exportExpressions = sourceFile.statements.filter(typescript.isExportAssignment).map((statement) => unwrapTypeCasts(statement.expression));
+	const array = exportExpressions.find(typescript.isArrayLiteralExpression) ?? defineConfigArray(exportExpressions);
+	if (array) return [...array.elements];
+	return exportExpressions;
+}
 function checkDefineConfigWrap(sourceFile) {
 	return sourceFile.statements.some((statement) => {
 		if (!typescript.isExportAssignment(statement)) return false;
@@ -3899,7 +3951,7 @@ function classifyInsiderImport(statement, sourceFile, flags) {
 			return;
 		}
 		flags.hasUseInsider = true;
-		const line = lineOf(sourceFile, statement);
+		const line = lineOf$1(sourceFile, statement);
 		flags.preserved.push({
 			raw: statement.getText(sourceFile),
 			moduleSpecifier: "@useinsider/eslint-config"
@@ -3944,7 +3996,7 @@ function collectSilenceRulesCalls(sourceFile) {
 		if (!rules) return null;
 		const leadingComment = leadingCommentTextFor(sourceFile, statement);
 		const call = {
-			line: lineOf(sourceFile, statement),
+			line: lineOf$1(sourceFile, statement),
 			rules
 		};
 		if (leadingComment !== void 0) call.leadingComment = leadingComment;
@@ -3957,8 +4009,7 @@ function parseV1Config(source, filePath) {
 	const imports = inspectImports(sourceFile);
 	warnings.push(...imports.warnings);
 	const silenceRulesCalls = collectSilenceRulesCalls(sourceFile);
-	const arrayLiteral = findDefaultExportArray(sourceFile);
-	const arrayElements = arrayLiteral ? arrayLiteral.elements.map((element) => classifyArrayElement(element, sourceFile, warnings)).filter((entry) => entry !== null) : [];
+	const arrayElements = findDefaultExportElements(sourceFile).map((element) => classifyArrayElement(element, sourceFile, warnings)).filter((entry) => entry !== null);
 	return {
 		hasUseInsiderImport: imports.hasUseInsider,
 		hasSilenceRulesImport: imports.hasSilenceRules,
@@ -3970,6 +4021,220 @@ function parseV1Config(source, filePath) {
 	};
 }
 //#endregion
+//#region src/cli/migrate/rehouseV3.ts
+var INSIDER_MODULE = "@useinsider/eslint-config";
+var COMPOSER_NAME = "useInsider";
+var DEFINE_CONFIG_NAME = "defineConfig";
+var SILENCE_RULES_NAME = "silenceRules";
+var RENDERER_EXPORT = "export const { useInsiderESLint, useInsiderOXC } = ";
+var RESERVED_KEYS = /* @__PURE__ */ new Set([
+	"ignores",
+	"jquery",
+	"strict",
+	"spellChecker",
+	"silenceRules",
+	"configFiles"
+]);
+function isInsiderImport(statement) {
+	const { moduleSpecifier } = statement;
+	return typescript.isStringLiteral(moduleSpecifier) && moduleSpecifier.text === INSIDER_MODULE;
+}
+function composerAliases(sourceFile) {
+	const aliases = /* @__PURE__ */ new Set();
+	sourceFile.statements.forEach((statement) => {
+		if (!typescript.isImportDeclaration(statement) || !isInsiderImport(statement)) return;
+		const bindings = statement.importClause?.namedBindings;
+		if (!bindings || !typescript.isNamedImports(bindings)) return;
+		bindings.elements.forEach((element) => {
+			if ((element.propertyName?.text ?? element.name.text) === COMPOSER_NAME) aliases.add(element.name.text);
+		});
+	});
+	return aliases;
+}
+function isCallOf(node, names) {
+	return typescript.isCallExpression(node) && typescript.isIdentifier(node.expression) && names.has(node.expression.text);
+}
+function collectCalls(sourceFile, names) {
+	const found = [];
+	const visit = (node) => {
+		if (isCallOf(node, names)) found.push(node);
+		typescript.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return found;
+}
+function peel(expression, state) {
+	if (typescript.isParenthesizedExpression(expression) || typescript.isSpreadElement(expression)) return peel(expression.expression, state);
+	if (typescript.isAsExpression(expression) || typescript.isSatisfiesExpression(expression)) {
+		state.droppedAnnotation = true;
+		return peel(expression.expression, state);
+	}
+	if (typescript.isAwaitExpression(expression)) {
+		state.awaited = true;
+		return peel(expression.expression, state);
+	}
+	return expression;
+}
+function peelArray(expression, state) {
+	if (!typescript.isArrayLiteralExpression(expression) || expression.elements.length === 0) return expression;
+	state.arrayWrapped = true;
+	state.siblingElements = expression.elements.length - 1;
+	return peel(expression.elements[0], state);
+}
+function unwrapDefaultExport(expression, state) {
+	const peeled = peel(expression, state);
+	if (isCallOf(peeled, /* @__PURE__ */ new Set([DEFINE_CONFIG_NAME]))) {
+		state.definedConfig = true;
+		return peeled;
+	}
+	return peelArray(peeled, state);
+}
+function argumentObject(call) {
+	const [first] = call.arguments;
+	if (!first || !typescript.isObjectLiteralExpression(first)) return null;
+	return first;
+}
+function propertyKey(property) {
+	const { name } = property;
+	if (name === void 0) return null;
+	if (typescript.isIdentifier(name) || typescript.isStringLiteral(name)) return name.text;
+	return null;
+}
+function unreadableReason(argument, keysRead) {
+	if (!argument) return "is not an object literal";
+	if (argument.properties.some(typescript.isSpreadAssignment)) return "spreads another object";
+	return keysRead < argument.properties.length ? "has a property whose key is not a literal name" : null;
+}
+function readArgument(call) {
+	const argument = argumentObject(call);
+	const optionKeys = (argument?.properties ?? []).map(propertyKey).filter((key) => key !== null);
+	const candidates = optionKeys.filter((key) => !RESERVED_KEYS.has(key));
+	return {
+		optionKeys,
+		scopes: candidates.filter(isMigratableScope),
+		unregisteredKeys: candidates.filter((key) => !isMigratableScope(key)),
+		unreadable: unreadableReason(argument, optionKeys.length)
+	};
+}
+function refuse(reason) {
+	return {
+		kind: "refused",
+		reason
+	};
+}
+function multipleCallsReason(name) {
+	return `${name} calls ${COMPOSER_NAME}() more than once. v4 has exactly one call — in the lint module — and it returns the two renderers instead of a config array, so the results cannot be concatenated. Merge them into a single call, one entry per scope key, then re-run the migration.`;
+}
+function mixedArrayReason(name, siblings) {
+	return `${name}'s default export combines ${COMPOSER_NAME}() with ${siblings} other flat-config ${siblings === 1 ? "block" : "blocks"}, which have nowhere to go in a lint module. Fold them into the call first — directory ignores into \`ignores\`, per-file rule overrides into \`configFiles\` — then re-run the migration.`;
+}
+function indirectCallReason(name) {
+	return `${name} calls ${COMPOSER_NAME}(), but its default export is not that call. The migration re-houses the call itself, so make it the default export (\`export default ${COMPOSER_NAME}({ ... })\`) and re-run the migration.`;
+}
+function defineConfigReason(name) {
+	return `${name} wraps ${COMPOSER_NAME}() in ${DEFINE_CONFIG_NAME}(). v4's lint module exports the two renderers rather than a flat-config array, so there is nothing left for ${DEFINE_CONFIG_NAME}() to validate — drop the wrapper and re-run the migration.`;
+}
+function presetReason(name) {
+	return `${name} still passes the v1 \`preset\` option, and this release could not read it — the preset list has to be an array of string literals. Restore the literal list and re-run the migration, or convert the call to the scope-keyed form by hand.`;
+}
+function annotationWarning(line) {
+	return {
+		kind: "dropped-type-annotation",
+		line,
+		message: `The type annotation on the default export was dropped — ${COMPOSER_NAME}() now returns \`{ useInsiderESLint, useInsiderOXC }\` rather than a config array. Delete the type import if nothing else uses it.`
+	};
+}
+function unregisteredScopeWarning(key, line) {
+	return {
+		kind: "unregistered-scope",
+		line,
+		message: `\`${key}\` has no dependency manifest in the migration, so nothing was added to the install list for it. The key itself was carried over untouched — check its plugins are installed.`
+	};
+}
+function unreadableArgumentWarning(line, reason) {
+	return {
+		kind: "unrecognized-block",
+		line,
+		message: `The ${COMPOSER_NAME}() argument ${reason}, so its scope list could not be read in full. The call was carried over untouched; the dependency list may be incomplete.`
+	};
+}
+function lineOf(sourceFile, node) {
+	return sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1;
+}
+function collectWarnings(line, reading, state) {
+	const warnings = [];
+	if (state.droppedAnnotation) warnings.push(annotationWarning(line));
+	if (reading.unreadable) warnings.push(unreadableArgumentWarning(line, reading.unreadable));
+	reading.unregisteredKeys.forEach((key) => {
+		warnings.push(unregisteredScopeWarning(key, line));
+	});
+	return warnings;
+}
+function spliceExport(input) {
+	const start = input.statement.getStart(input.sourceFile);
+	const prefix = input.source.slice(0, start);
+	const suffix = input.source.slice(input.statement.getEnd());
+	const rehoused = `${prefix}${RENDERER_EXPORT}${input.callText};${suffix}`;
+	return rehoused.endsWith("\n") ? rehoused : `${rehoused}\n`;
+}
+function defaultExports(sourceFile) {
+	return sourceFile.statements.filter(typescript.isExportAssignment).filter((statement) => statement.isExportEquals !== true);
+}
+function emptyState() {
+	return {
+		awaited: false,
+		arrayWrapped: false,
+		droppedAnnotation: false,
+		siblingElements: 0,
+		definedConfig: false
+	};
+}
+/**
+* Re-houses a v3 single-file config as a v4 lint module. Nothing about the configuration itself
+* changes between the two majors — only where the call lives — so the source is spliced rather than
+* re-rendered: every import, `silenceRules(...)` call, comment and blank line outside the export
+* statement survives byte-for-byte.
+* @example
+* rehouseV3Config("import { useInsider } from '@useinsider/eslint-config';\nexport default useInsider({});", 'eslint.config.js');
+* // { kind: 'rehoused', rehoused: { lintModule: '…export const { useInsiderESLint, useInsiderOXC } = useInsider({});\n', … } }
+*/
+function rehouseV3Config(source, filePath) {
+	const name = (0, node_path.basename)(filePath);
+	const sourceFile = typescript.createSourceFile(filePath, source, typescript.ScriptTarget.Latest, true);
+	const aliases = composerAliases(sourceFile);
+	const calls = collectCalls(sourceFile, aliases);
+	const exportStatements = defaultExports(sourceFile);
+	if (calls.length === 0) return { kind: "not-v3" };
+	if (exportStatements.length !== 1) return refuse(indirectCallReason(name));
+	if (calls.length > 1) return refuse(multipleCallsReason(name));
+	const [statement] = exportStatements;
+	const state = emptyState();
+	const unwrapped = unwrapDefaultExport(statement.expression, state);
+	if (state.definedConfig) return refuse(defineConfigReason(name));
+	if (state.siblingElements > 0) return refuse(mixedArrayReason(name, state.siblingElements));
+	if (!isCallOf(unwrapped, aliases)) return refuse(indirectCallReason(name));
+	const reading = readArgument(unwrapped);
+	if (reading.optionKeys.includes("preset")) return refuse(presetReason(name));
+	return {
+		kind: "rehoused",
+		rehoused: {
+			lintModule: spliceExport({
+				source,
+				sourceFile,
+				statement,
+				callText: unwrapped.getText(sourceFile)
+			}),
+			scopes: reading.scopes,
+			optionKeys: reading.optionKeys,
+			unregisteredKeys: reading.unregisteredKeys,
+			silenceRulesCallCount: collectCalls(sourceFile, /* @__PURE__ */ new Set([SILENCE_RULES_NAME])).length,
+			droppedAwait: state.awaited,
+			droppedArrayWrapper: state.arrayWrapped,
+			warnings: collectWarnings(lineOf(sourceFile, unwrapped), reading, state)
+		}
+	};
+}
+//#endregion
 //#region src/cli/migrate/pruneUnusedImports.ts
 var INSIDER_MODULE_SPECIFIER = "@useinsider/eslint-config";
 function readModuleSpecifier(statement) {
@@ -4800,6 +5065,22 @@ function describeStrict(plan) {
 	if (plan.config.strictGlobs.length > 0) return `Strict scopes: 1 (${plan.config.strictGlobs.length} globs)`;
 	return "Strict scopes: 0";
 }
+function describeRehousedKeys(label, keys) {
+	return keys.length === 0 ? `${label}: (none)` : `${label}: ${keys.join(", ")}`;
+}
+function rehouseSummary(rehoused) {
+	const lines = [
+		"Source: v3 single-file eslint.config.*",
+		"Re-housed as the lint module: only the export statement changed, every other line is byte-for-byte.",
+		describeRehousedKeys("Options carried over", rehoused.optionKeys),
+		describeRehousedKeys("Scopes with dependencies", rehoused.scopes),
+		`silenceRules() calls kept: ${rehoused.silenceRulesCallCount}`
+	];
+	if (rehoused.droppedAwait) lines.push("Dropped the `await` on the call — useInsider() is synchronous in v4.");
+	if (rehoused.droppedArrayWrapper) lines.push("Dropped the array wrapper around the call — the lint module exports the renderers.");
+	lines.push(`Warnings: ${rehoused.warnings.length}`);
+	return lines.join("\n");
+}
 function summary(plan, format) {
 	const lines = [];
 	if (format === "eslintrc") lines.push("Source: legacy .eslintrc");
@@ -4812,13 +5093,47 @@ function summary(plan, format) {
 	lines.push(`Warnings: ${plan.warnings.length}`);
 	return lines.join("\n");
 }
-function planFromSource(source, filePath, format) {
-	if (format === "flat") {
-		const parseResult = parseV1Config(source, filePath);
-		return isV1Shape(parseResult) ? transformToV2(parseResult) : null;
+function sourceModelFrom(resolved) {
+	if (resolved.format !== "flat") {
+		const parseResult = parseEslintrc(resolved.source, resolved.targetPath);
+		return parseResult.found ? {
+			ok: true,
+			model: {
+				kind: "plan",
+				plan: transformEslintrcToV2(parseResult)
+			}
+		} : {
+			ok: false,
+			reason: null
+		};
 	}
-	const parseResult = parseEslintrc(source, filePath);
-	return parseResult.found ? transformEslintrcToV2(parseResult) : null;
+	const parseResult = parseV1Config(resolved.source, resolved.targetPath);
+	if (isV1Shape(parseResult)) return {
+		ok: true,
+		model: {
+			kind: "plan",
+			plan: transformToV2(parseResult)
+		}
+	};
+	const outcome = rehouseV3Config(resolved.source, resolved.targetPath);
+	if (outcome.kind === "rehoused") return {
+		ok: true,
+		model: {
+			kind: "rehouse",
+			rehoused: outcome.rehoused
+		}
+	};
+	return {
+		ok: false,
+		reason: outcome.kind === "refused" ? outcome.reason : null
+	};
+}
+function scopesOf(model) {
+	if (model.kind === "plan") return new Set(model.plan.config.scopes.keys());
+	return new Set(model.rehoused.scopes);
+}
+function warningsOf(model) {
+	return model.kind === "plan" ? model.plan.warnings : model.rehoused.warnings;
 }
 function targetWritePath(cwd, sourcePath) {
 	const directory = (0, node_path.dirname)(sourcePath) || cwd;
@@ -4903,9 +5218,11 @@ function emitInstallNextSteps(clack, depSummary, cwd) {
 	if (message === null) return;
 	clack.note(message, "Next steps");
 }
-function emitSummary(clack, plan, format) {
-	if (clack.note) clack.note(summary(plan, format), "Migration summary");
-	if (plan.warnings.length > 0 && clack.note) clack.note(formatWarnings(plan.warnings), "Warnings");
+function emitSummary(clack, model, format) {
+	if (!clack.note) return;
+	clack.note(model.kind === "plan" ? summary(model.plan, format) : rehouseSummary(model.rehoused), "Migration summary");
+	const warnings = warningsOf(model);
+	if (warnings.length > 0) clack.note(formatWarnings(warnings), "Warnings");
 }
 function writeAndAnnounce(clack, targetPath, writePath, rendered, format) {
 	const result = format === "eslintrc" ? writeMigrationLegacy(targetPath, writePath, rendered) : writeMigration(targetPath, rendered);
@@ -4955,17 +5272,24 @@ function resolveSource(input, clack) {
 		}
 	};
 }
+function renderModel(model, eslintIgnore) {
+	if (model.kind === "rehouse") return model.rehoused.lintModule;
+	if (eslintIgnore && eslintIgnore.patterns.length > 0) mergeIgnorePatterns(model.plan, eslintIgnore.patterns);
+	return renderV2(model.plan);
+}
 function prepareMigration(resolved, input) {
-	const plan = planFromSource(resolved.source, resolved.targetPath, resolved.format);
-	if (!plan) return null;
+	const outcome = sourceModelFrom(resolved);
+	if (!outcome.ok) return outcome;
 	const writePath = targetWritePath(input.cwd, resolved.targetPath);
 	const eslintIgnore = findEslintIgnore(resolved.targetPath);
-	if (eslintIgnore && eslintIgnore.patterns.length > 0) mergeIgnorePatterns(plan, eslintIgnore.patterns);
 	return {
-		plan,
-		rendered: renderV2(plan),
-		writePath,
-		eslintIgnore
+		ok: true,
+		prepared: {
+			model: outcome.model,
+			rendered: renderModel(outcome.model, eslintIgnore),
+			writePath,
+			eslintIgnore
+		}
 	};
 }
 async function runConfirmations(clack, input, targetPath, writePath, previous) {
@@ -4995,7 +5319,7 @@ function tryReadConsumerManifest(path) {
 		return null;
 	}
 }
-function computeDepSummary(plan, writePath, overrides) {
+function computeDepSummary(model, writePath, overrides) {
 	const pkgPath = consumerPackageJsonPath(writePath);
 	const manifest = tryReadConsumerManifest(pkgPath);
 	if (!manifest) return {
@@ -5008,7 +5332,7 @@ function computeDepSummary(plan, writePath, overrides) {
 	};
 	const pruneOutcome = pruneEslintDependencies(manifest);
 	const ownManifest = (overrides?.readEslintConfigManifest ?? readOwnEslintConfigManifest)();
-	const install = buildInstallList(new Set(plan.config.scopes.keys()), ownManifest);
+	const install = buildInstallList(scopesOf(model), ownManifest);
 	return {
 		removed: pruneOutcome.removed,
 		install,
@@ -5063,7 +5387,7 @@ async function applyDepChanges(clack, depSummary, input) {
 }
 function performWriteAndCleanup(clack, resolved, prepared) {
 	const outcome = writeAndAnnounce(clack, resolved.targetPath, prepared.writePath, prepared.rendered, resolved.format);
-	if (prepared.eslintIgnore) safeUnlink(prepared.eslintIgnore.path, clack, ".eslintignore");
+	if (prepared.eslintIgnore && prepared.model.kind === "plan") safeUnlink(prepared.eslintIgnore.path, clack, ".eslintignore");
 	outcome.deletedSourceCandidates.forEach((path) => {
 		safeUnlink(path, clack, "superseded config");
 	});
@@ -5089,8 +5413,13 @@ function applyLintScript$1(clack, directory) {
 	if (result.changed) (0, node_fs.writeFileSync)(manifestPath, result.manifest, "utf8");
 	noteLintScriptOutcome$1(clack, result);
 }
+function noteUntouchedDirectiveFiles(clack, skipped) {
+	if (skipped.length === 0 || !clack.note) return;
+	clack.note(formatUntouchedDirectiveFiles(skipped), `${skipped.length} file(s) left untouched`);
+}
 async function rewriteDirectivesWithNote(clack, directory, autoConfirm) {
-	const candidates = previewDisableDirectives(directory);
+	const { candidates, skipped } = previewDisableDirectives(directory);
+	noteUntouchedDirectiveFiles(clack, skipped);
 	if (candidates.length === 0) return;
 	const count = candidates.length;
 	if (clack.note) clack.note(`${count} file(s) carry an \`eslint-disable\` naming a rule oxlint now owns. Left as they are, ESLint reports each one as an unused directive.
@@ -5106,8 +5435,9 @@ This is a separate, source-wide diff — review it on its own commit.`, "Disable
 			return;
 		}
 	}
-	const { rewritten } = rewriteDisableDirectives(directory, candidates);
+	const { rewritten, skipped: unwritten } = rewriteDisableDirectives(directory, candidates);
 	if (clack.note) clack.note(`Re-pointed directives in ${rewritten.length} file(s).`, "Disable directives");
+	noteUntouchedDirectiveFiles(clack, unwritten);
 }
 function loadPreviousMigrate(clack, cwd) {
 	const restored = loadSession({ cwd });
@@ -5116,7 +5446,12 @@ function loadPreviousMigrate(clack, cwd) {
 	return previousMigrate;
 }
 function emitNothingToMigrate(clack, format) {
-	clack.outro(format === "eslintrc" ? "No legacy `.eslintrc` shape found — nothing to migrate." : "No v1 useInsider patterns found — nothing to migrate.");
+	clack.outro(format === "eslintrc" ? "No legacy `.eslintrc` shape found — nothing to migrate." : "No v1 or v3 useInsider patterns found — nothing to migrate.");
+}
+function noteUnfoldedEslintIgnore(clack, prepared) {
+	const patterns = prepared.eslintIgnore?.patterns ?? [];
+	if (!clack.note || prepared.model.kind !== "rehouse" || patterns.length === 0) return;
+	clack.note(`${prepared.eslintIgnore?.path} still holds ${patterns.length} pattern(s). Flat config does not read it, and the v3 config was carried over verbatim, so they were not folded into \`ignores\`. Move the ones you still need into the \`ignores\` array and delete the file.`, ".eslintignore left alone");
 }
 function persistMigrateSession(input, prepared, resolved) {
 	const overwriteExisting = supersededFlatConfigs(resolved.targetPath, prepared.writePath).length > 0;
@@ -5151,14 +5486,20 @@ async function runMigrate(input, clackOverride) {
 		return declinedExitCode;
 	}
 	const previousMigrate = loadPreviousMigrate(clack, input.cwd);
-	const prepared = prepareMigration(resolved, input);
-	if (!prepared) {
-		emitNothingToMigrate(clack, resolved.format);
-		return declinedExitCode;
+	const outcome = prepareMigration(resolved, input);
+	if (!outcome.ok) {
+		if (outcome.reason === null) {
+			emitNothingToMigrate(clack, resolved.format);
+			return declinedExitCode;
+		}
+		clack.cancel(outcome.reason);
+		return 1;
 	}
-	emitSummary(clack, prepared.plan, resolved.format);
+	const { prepared } = outcome;
+	emitSummary(clack, prepared.model, resolved.format);
+	noteUnfoldedEslintIgnore(clack, prepared);
 	noteConfigRename(clack, resolved.targetPath, prepared.writePath);
-	const depSummary = computeDepSummary(prepared.plan, prepared.writePath, input.overrides);
+	const depSummary = computeDepSummary(prepared.model, prepared.writePath, input.overrides);
 	if (!await runConfirmations(clack, input, resolved.targetPath, prepared.writePath, previousMigrate)) return declinedExitCode;
 	persistMigrateSession(input, prepared, resolved);
 	performWriteAndCleanup(clack, resolved, prepared);