@effect/tsgo 0.0.14 → 0.0.16

package/bin/effect-tsgo.js

@@ -34157,14 +34157,14 @@ const defaultFormatter = (options) => {
 * Strips ANSI escape codes from a string to calculate visual width.
 * @internal
 */
-const stripAnsi = (text) => {
+const stripAnsi$1 = (text) => {
 	return text.replace(/\u001B\[[0-9;]*m/g, "");
 };
 /**
 * Gets the visual length of a string (excluding ANSI codes).
 * @internal
 */
-const visualLength = (text) => stripAnsi(text).length;
+const visualLength = (text) => stripAnsi$1(text).length;
 /**
 * Helper function to pad strings to a specified width.
 * @internal
@@ -45596,7 +45596,7 @@ const cursorMove = (column, row = 0) => {
 	return command;
 };
 /** @internal */
-const eraseLines$1 = (rows) => {
+const eraseLines = (rows) => {
 	let command = "";
 	for (let i = 0; i < rows; i++) command += `${ESC}2K` + (i < rows - 1 ? `${ESC}1A` : "");
 	if (rows > 0) command += `${ESC}G`;
@@ -45812,20 +45812,20 @@ const Action$1 = /* @__PURE__ */ taggedEnum();
 /**
 * Clears all lines taken up by the specified `text`.
 */
-const eraseText$1 = (text, columns) => {
+const eraseText = (text, columns) => {
 	if (columns === 0) return eraseLine + cursorTo(0);
 	let rows = 0;
 	const lines = text.split(NEWLINE_REGEXP);
 	for (const line of lines) rows += 1 + Math.floor(Math.max(line.length - 1, 0) / columns);
-	return eraseLines$1(rows);
+	return eraseLines(rows);
 };
 const lines = (prompt, columns) => {
 	const lines = prompt.split(NEWLINE_REGEXP);
 	return columns === 0 ? lines.length : pipe(map$7(lines, (line) => Math.ceil(line.length / columns)), reduce(0, (left, right) => left + right));
 };
 const clearOutputWithError = (outputText, columns, errorText) => {
-	if (errorText !== void 0 && errorText.length > 0) return cursorDown(lines(errorText, columns)) + eraseText$1(`\n${errorText}`, columns) + eraseText$1(outputText, columns);
-	return eraseText$1(outputText, columns);
+	if (errorText !== void 0 && errorText.length > 0) return cursorDown(lines(errorText, columns)) + eraseText(`\n${errorText}`, columns) + eraseText(outputText, columns);
+	return eraseText(outputText, columns);
 };
 const renderBeep = beep;
 const NEWLINE_REGEXP = /\r?\n/;
@@ -45833,7 +45833,7 @@ const handleConfirmClear = (options) => {
 	return fnUntraced(function* (state, _) {
 		const columns = yield* (yield* Terminal).columns;
 		const figures = yield* platformFigures;
-		return eraseText$1(renderConfirmOutput(state.value ? options.placeholder.defaultConfirm : options.placeholder.defaultDeny, "?", figures.pointerSmall, options, { plain: true }), columns) + (eraseLine + cursorLeft);
+		return eraseText(renderConfirmOutput(state.value ? options.placeholder.defaultConfirm : options.placeholder.defaultDeny, "?", figures.pointerSmall, options, { plain: true }), columns) + (eraseLine + cursorLeft);
 	});
 };
 const renderConfirmOutput = (confirm, leadingSymbol, trailingSymbol, options, renderOptions) => renderPrompt(confirm, options.message, leadingSymbol, trailingSymbol, renderOptions);
@@ -45903,7 +45903,7 @@ const renderMultiSelectChoices = (state, options, figures, renderOptions) => {
 	const inverseSelectionText = options?.inverseSelection ?? "Inverse Selection";
 	const metaOptions = [{ title: selectAllText }, { title: inverseSelectionText }];
 	const allChoices = [...metaOptions, ...choices];
-	const toDisplay = entriesToDisplay$1(state.index, allChoices.length, options.maxPerPage);
+	const toDisplay = entriesToDisplay(state.index, allChoices.length, options.maxPerPage);
 	const documents = [];
 	for (let index = toDisplay.startIndex; index < toDisplay.endIndex; index++) {
 		const choice = allChoices[index];
@@ -46039,7 +46039,7 @@ const renderChoiceTitle = (choice, isSelected, renderOptions) => {
 };
 const renderSelectChoices = (state, options, figures, renderOptions) => {
 	const choices = options.choices;
-	const toDisplay = entriesToDisplay$1(state, choices.length, options.maxPerPage);
+	const toDisplay = entriesToDisplay(state, choices.length, options.maxPerPage);
 	const documents = [];
 	for (let index = toDisplay.startIndex; index < toDisplay.endIndex; index++) {
 		const choice = choices[index];
@@ -46086,7 +46086,7 @@ const handleSelectClear = (options) => fnUntraced(function* (state, _) {
 	const columns = yield* (yield* Terminal).columns;
 	const figures = yield* platformFigures;
 	const clearPrompt = eraseLine + cursorLeft;
-	return eraseText$1(`${renderSelectOutput("?", figures.pointerSmall, options, { plain: true })}\n${renderSelectChoices(state, options, figures, { plain: true })}`, columns) + clearPrompt;
+	return eraseText(`${renderSelectOutput("?", figures.pointerSmall, options, { plain: true })}\n${renderSelectChoices(state, options, figures, { plain: true })}`, columns) + clearPrompt;
 });
 const handleSelectProcess = (options) => {
 	return (input, state) => {
@@ -46262,7 +46262,7 @@ const basePrompt = (options, type) => {
 		clear: handleTextClear(opts)
 	});
 };
-const entriesToDisplay$1 = (cursor, total, maxVisible) => {
+const entriesToDisplay = (cursor, total, maxVisible) => {
 	const max = maxVisible === void 0 ? total : maxVisible;
 	let startIndex = Math.min(total - max, cursor - Math.floor(max / 2));
 	if (startIndex < 0) startIndex = 0;
@@ -195732,7 +195732,7 @@ var FileReadError = class extends TaggedError("FileReadError") {
 //#endregion
 //#region package.json
 var name = "@effect/tsgo";
-var version = "0.0.14";
+var version = "0.0.16";
 
 //#endregion
 //#region src/setup/consts.ts
@@ -196029,8 +196029,7 @@ const computePackageJsonChanges = (current, target) => {
 				} else if (isSome(current.prepareScript) && !current.prepareScript.value.hasPatch) {
 					descriptions.push("Update prepare script to include patch command");
 					const newScript = `${current.prepareScript.value.script} && ${PATCH_COMMAND}`;
-					const newPrepareProp = import_typescript.factory.createPropertyAssignment(import_typescript.factory.createStringLiteral("prepare"), import_typescript.factory.createStringLiteral(newScript));
-					tracker.replaceNode(current.sourceFile, prepareProperty, newPrepareProp);
+					tracker.replaceNode(current.sourceFile, prepareProperty.initializer, import_typescript.factory.createStringLiteral(newScript));
 				}
 			}
 		} else if (isNone(target.lspVersion) && isSome(current.prepareScript) && current.prepareScript.value.hasPatch) {
@@ -196078,7 +196077,43 @@ const computeTsConfigChanges = (current, target, lspVersion) => {
 	const rootObj = getRootObject(current.sourceFile);
 	if (!rootObj) return emptyFileChangesResult();
 	const compilerOptionsProperty = findPropertyInObject(rootObj, "compilerOptions");
-	if (!compilerOptionsProperty || !import_typescript.isObjectLiteralExpression(compilerOptionsProperty.initializer)) return emptyFileChangesResult();
+	if (!compilerOptionsProperty || !import_typescript.isObjectLiteralExpression(compilerOptionsProperty.initializer)) {
+		if (isNone(lspVersion)) return emptyFileChangesResult();
+		const ctx = createTrackerContext();
+		const fileChange = tsInternal.textChanges.ChangeTracker.with(ctx, (tracker) => {
+			const schemaProperty = findPropertyInObject(rootObj, "$schema");
+			const shouldAddSchema = !schemaProperty;
+			const shouldUpdateSchema = !!schemaProperty && (!import_typescript.isStringLiteral(schemaProperty.initializer) || schemaProperty.initializer.text !== TSCONFIG_SCHEMA_URL);
+			if (shouldAddSchema) descriptions.push("Add $schema to tsconfig");
+			else if (shouldUpdateSchema) descriptions.push("Update $schema in tsconfig");
+			descriptions.push(`Add compilerOptions with ${LSP_PLUGIN_NAME} plugin`);
+			const schemaPropertyAssignment = import_typescript.factory.createPropertyAssignment(import_typescript.factory.createStringLiteral("$schema"), import_typescript.factory.createStringLiteral(TSCONFIG_SCHEMA_URL));
+			const compilerOptionsAssignment = import_typescript.factory.createPropertyAssignment(import_typescript.factory.createStringLiteral("compilerOptions"), import_typescript.factory.createObjectLiteralExpression([import_typescript.factory.createPropertyAssignment(import_typescript.factory.createStringLiteral("plugins"), import_typescript.factory.createArrayLiteralExpression([createLspPluginObject(target)], true))], true));
+			const nextProperties = rootObj.properties.map((property) => {
+				if (schemaProperty && property === schemaProperty) return schemaPropertyAssignment;
+				return property;
+			});
+			if (shouldAddSchema) nextProperties.push(schemaPropertyAssignment);
+			nextProperties.push(compilerOptionsAssignment);
+			tracker.replaceNode(current.sourceFile, rootObj, import_typescript.factory.createObjectLiteralExpression(nextProperties, true));
+		}).find((fc) => fc.fileName === current.sourceFile.fileName);
+		const changes = fileChange ? fileChange.textChanges : [];
+		if (changes.length === 0) return {
+			codeActions: [],
+			messages
+		};
+		return {
+			codeActions: [{
+				description: descriptions.join("; "),
+				changes: [{
+					fileName: current.sourceFile.fileName,
+					textChanges: changes,
+					isNewFile: false
+				}]
+			}],
+			messages
+		};
+	}
 	const compilerOptions = compilerOptionsProperty.initializer;
 	const ctx = createTrackerContext();
 	const fileChange = tsInternal.textChanges.ChangeTracker.with(ctx, (tracker) => {
@@ -196421,314 +196456,905 @@ const renderCodeActions = (result, assessmentState) => gen(function* () {
 });
 
 //#endregion
-//#region src/rules.json
-var rules_default = [
+//#region src/metadata.json
+var groups = [
 	{
-		"name": "anyUnknownInErrorContext",
-		"description": "Detects 'any' or 'unknown' types in Effect error or requirements channels",
-		"defaultSeverity": "off",
-		"codes": [377030]
+		"id": "correctness",
+		"name": "Correctness",
+		"description": "Wrong, unsafe, or structurally invalid code patterns."
 	},
 	{
-		"name": "catchAllToMapError",
-		"description": "Suggests using Effect.mapError instead of Effect.catch + Effect.fail",
-		"defaultSeverity": "suggestion",
-		"codes": [377010]
+		"id": "antipattern",
+		"name": "Anti-pattern",
+		"description": "Discouraged patterns that often lead to bugs or confusing behavior."
 	},
 	{
-		"name": "catchUnfailableEffect",
-		"description": "Warns when using error handling on Effects that never fail",
-		"defaultSeverity": "suggestion",
-		"codes": [377009]
+		"id": "effectNative",
+		"name": "Effect-native",
+		"description": "Prefer Effect-native APIs and abstractions when available."
+	},
+	{
+		"id": "style",
+		"name": "Style",
+		"description": "Cleanup, consistency, and idiomatic Effect code."
+	}
+];
+var rules = [
+	{
+		"name": "anyUnknownInErrorContext",
+		"group": "correctness",
+		"description": "Detects 'any' or 'unknown' types in Effect error or requirements channels",
+		"defaultSeverity": "off",
+		"fixable": false,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377030],
+		"preview": {
+			"sourceText": "import { Effect } from \"effect\"\n\nexport const preview = Effect.gen(function*() {\n  yield* Effect.services<unknown>()\n  return yield* Effect.fail<any>(\"boom\")\n})\n",
+			"diagnostics": [
+				{
+					"start": 46,
+					"end": 53,
+					"text": "This has unknown in the requirements channel and any in the error channel which is not recommended.\nOnly service identifiers should appear in the requirements channel.\nHaving an unknown or any error type is not useful. Consider instead using specific error types baked by Data.TaggedError for example. effect(anyUnknownInErrorContext)"
+				},
+				{
+					"start": 90,
+					"end": 116,
+					"text": "This has unknown in the requirements channel which is not recommended.\nOnly service identifiers should appear in the requirements channel. effect(anyUnknownInErrorContext)"
+				},
+				{
+					"start": 133,
+					"end": 157,
+					"text": "This has any in the error channel which is not recommended.\nHaving an unknown or any error type is not useful. Consider instead using specific error types baked by Data.TaggedError for example. effect(anyUnknownInErrorContext)"
+				}
+			]
+		}
 	},
 	{
 		"name": "classSelfMismatch",
+		"group": "correctness",
 		"description": "Ensures Self type parameter matches the class name in Service/Tag/Schema classes",
 		"defaultSeverity": "error",
-		"codes": [377046]
-	},
-	{
-		"name": "deterministicKeys",
-		"description": "Enforces deterministic naming for service/tag/error identifiers based on class names",
-		"defaultSeverity": "off",
-		"codes": [377049]
+		"fixable": true,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377046],
+		"preview": {
+			"sourceText": "import * as Effect from \"effect/Effect\"\n\ninterface ServiceShape { value: number }\n\nexport class InvalidContextTag\n  extends Effect.Tag(\"ValidContextTag\")<ValidContextTag, ServiceShape>() {}\n\ndeclare class ValidContextTag {}\n",
+			"diagnostics": [{
+				"start": 154,
+				"end": 169,
+				"text": "Self type parameter should be 'InvalidContextTag'. effect(classSelfMismatch)"
+			}]
+		}
 	},
 	{
 		"name": "duplicatePackage",
+		"group": "correctness",
 		"description": "Warns when multiple versions of an Effect-related package are detected in the program",
 		"defaultSeverity": "warning",
-		"codes": [377051]
+		"fixable": false,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377051],
+		"preview": {
+			"sourceText": "import * as Effect from \"effect/Effect\"\n\n// This preview only reports when the workspace resolves duplicated\n// Effect package versions.\nexport const preview = Effect.succeed(true)\n",
+			"diagnostics": []
+		}
 	},
 	{
-		"name": "effectFnIife",
-		"description": "Effect.fn or Effect.fnUntraced is called as an IIFE; use Effect.gen instead",
+		"name": "floatingEffect",
+		"group": "correctness",
+		"description": "Detects Effect values that are neither yielded nor assigned",
+		"defaultSeverity": "error",
+		"fixable": false,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377001, 377058],
+		"preview": {
+			"sourceText": "import * as Effect from \"effect/Effect\"\n\nEffect.log(\"forgotten\")\n",
+			"diagnostics": [{
+				"start": 41,
+				"end": 64,
+				"text": "Effect must be yielded or assigned to a variable. effect(floatingEffect)"
+			}]
+		}
+	},
+	{
+		"name": "genericEffectServices",
+		"group": "correctness",
+		"description": "Prevents services with type parameters that cannot be discriminated at runtime",
 		"defaultSeverity": "warning",
-		"codes": [377011]
+		"fixable": false,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377043],
+		"preview": {
+			"sourceText": "import { Effect } from \"effect\"\n\nexport class Preview<_A> extends Effect.Service<Preview<any>>()(\"Preview\", {\n  succeed: {}\n}) {}\n",
+			"diagnostics": [{
+				"start": 46,
+				"end": 53,
+				"text": "Effect Services with type parameters are not supported because they cannot be properly discriminated at runtime, which may cause unexpected behavior. effect(genericEffectServices)"
+			}]
+		}
 	},
 	{
-		"name": "effectFnOpportunity",
-		"description": "Suggests using Effect.fn for functions that return an Effect",
-		"defaultSeverity": "suggestion",
-		"codes": [377047]
+		"name": "missingEffectContext",
+		"group": "correctness",
+		"description": "Detects Effect values with unhandled context requirements",
+		"defaultSeverity": "error",
+		"fixable": false,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377004],
+		"preview": {
+			"sourceText": "import { Effect, ServiceMap } from \"effect\"\n\nclass Db extends ServiceMap.Service<Db>()(\"Db\", { make: Effect.succeed({}) }) {}\n\n// @ts-expect-error\nexport const preview: Effect.Effect<void> = Db.asEffect().pipe(Effect.asVoid)\n",
+			"diagnostics": [{
+				"start": 160,
+				"end": 167,
+				"text": "Missing context Db in the expected Effect type. effect(missingEffectContext)"
+			}]
+		}
 	},
 	{
-		"name": "effectGenUsesAdapter",
-		"description": "Warns when using the deprecated adapter parameter in Effect.gen",
-		"defaultSeverity": "warning",
-		"codes": [377027]
+		"name": "missingEffectError",
+		"group": "correctness",
+		"description": "Detects Effect values with unhandled error types",
+		"defaultSeverity": "error",
+		"fixable": true,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377003],
+		"preview": {
+			"sourceText": "import type * as Effect from \"effect/Effect\"\nimport { Data } from \"effect\"\n\nclass Boom extends Data.TaggedError(\"Boom\")<{}> {}\ndeclare const effect: Effect.Effect<number, Boom>\n\n// @ts-expect-error\nexport const preview: () => Effect.Effect<number> = () => effect\n",
+			"diagnostics": [{
+				"start": 256,
+				"end": 262,
+				"text": "Missing errors Boom in the expected Effect type. effect(missingEffectError)"
+			}]
+		}
 	},
 	{
-		"name": "effectInFailure",
-		"description": "Warns when an Effect is used inside an Effect failure channel",
-		"defaultSeverity": "warning",
-		"codes": [377054]
+		"name": "missingLayerContext",
+		"group": "correctness",
+		"description": "Detects Layer values with unhandled context requirements",
+		"defaultSeverity": "error",
+		"fixable": false,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377034],
+		"preview": {
+			"sourceText": "import { Effect, Layer, ServiceMap } from \"effect\"\n\nclass A extends ServiceMap.Service<A>()(\"A\", { make: Effect.succeed({}) }) {\n  static Default = Layer.effect(this, this.make)\n}\ndeclare const layer: Layer.Layer<A, never, A>\n// @ts-expect-error\nexport const preview: Layer.Layer<A> = layer\n",
+			"diagnostics": [{
+				"start": 259,
+				"end": 266,
+				"text": "Missing 'A' in the expected Layer context. effect(missingLayerContext)"
+			}]
+		}
 	},
 	{
-		"name": "effectInVoidSuccess",
-		"description": "Detects nested Effects in void success channels that may cause unexecuted effects",
+		"name": "missingReturnYieldStar",
+		"group": "correctness",
+		"description": "Suggests using return yield* for Effects that never succeed",
+		"defaultSeverity": "error",
+		"fixable": true,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377006],
+		"preview": {
+			"sourceText": "import * as Effect from \"effect/Effect\"\n\nexport const preview = Effect.gen(function*() {\n  yield* Effect.log(\"before\")\n  yield* Effect.fail(\"boom\")\n})\n",
+			"diagnostics": [{
+				"start": 121,
+				"end": 126,
+				"text": "It is recommended to use return yield* for Effects that never succeed to signal a definitive exit point for type narrowing and tooling support. effect(missingReturnYieldStar)"
+			}]
+		}
+	},
+	{
+		"name": "missingStarInYieldEffectGen",
+		"group": "correctness",
+		"description": "Detects bare yield (without *) inside Effect generator scopes",
+		"defaultSeverity": "error",
+		"fixable": true,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377007, 377008],
+		"preview": {
+			"sourceText": "import * as Effect from \"effect/Effect\"\n\nexport const preview = Effect.gen(function*() {\n  const value = yield Effect.succeed(1)\n  return value\n})\n",
+			"diagnostics": [{
+				"start": 105,
+				"end": 110,
+				"text": "When yielding Effects inside Effect.gen, you should use yield* instead of yield. effect(missingStarInYieldEffectGen)"
+			}]
+		}
+	},
+	{
+		"name": "nonObjectEffectServiceType",
+		"group": "correctness",
+		"description": "Ensures Effect.Service types are objects, not primitives",
+		"defaultSeverity": "error",
+		"fixable": false,
+		"supportedEffect": ["v3"],
+		"codes": [377048],
+		"preview": {
+			"sourceText": "import * as Effect from \"effect/Effect\"\n\nexport class BadService extends Effect.Service<BadService>()(\"BadService\", {\n  // @ts-expect-error\n  succeed: \"hello\" as const\n}) {}\n",
+			"diagnostics": [{
+				"start": 142,
+				"end": 149,
+				"text": "Effect.Service requires the service type to be an object {} and not a primitive type. Consider wrapping the value in an object, or manually using Context.Tag or Effect.Tag if you want to use a primitive instead. effect(nonObjectEffectServiceType)"
+			}]
+		}
+	},
+	{
+		"name": "outdatedApi",
+		"group": "correctness",
+		"description": "Detects usage of APIs that have been removed or renamed in Effect v4",
 		"defaultSeverity": "warning",
-		"codes": [377020]
+		"fixable": false,
+		"supportedEffect": ["v4"],
+		"codes": [377052, 377053],
+		"preview": {
+			"sourceText": "import { Effect } from \"effect\"\n\nexport const preview = Effect.gen(function*() {\n  // @ts-expect-error\n  return yield* Effect.runtime()\n})\n",
+			"diagnostics": [{
+				"start": 0,
+				"end": 0,
+				"text": "This project targets Effect v4, but is using Effect v3 APIs. To find the correct API to use, consult the Effect v4 documentation for the corresponding v4 replacement. effect(outdatedApi)"
+			}, {
+				"start": 126,
+				"end": 133,
+				"text": "runtime is an Effect v3 API, but the project is using Effect v4. Runtime has been removed in Effect v4. Use Effect.services to grab services and then run using Effect.runPromiseWith. effect(outdatedApi)"
+			}]
+		}
 	},
 	{
-		"name": "effectMapVoid",
-		"description": "Suggests using Effect.asVoid instead of Effect.map(() => void 0), Effect.map(() => undefined), or Effect.map(() => {})",
-		"defaultSeverity": "suggestion",
-		"codes": [377018]
+		"name": "overriddenSchemaConstructor",
+		"group": "correctness",
+		"description": "Prevents overriding constructors in Schema classes which breaks decoding behavior",
+		"defaultSeverity": "error",
+		"fixable": true,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377044],
+		"preview": {
+			"sourceText": "import * as Schema from \"effect/Schema\"\n\nexport class User extends Schema.Class<User>(\"User\")({ name: Schema.String }) {\n  constructor(readonly input: { name: string }) { super(input) }\n}\n",
+			"diagnostics": [{
+				"start": 123,
+				"end": 134,
+				"text": "Classes extending Schema must not override the constructor; this is because it silently breaks the schema decoding behaviour. If that's needed, we recommend instead to use a static 'new' method that constructs the instance. effect(overriddenSchemaConstructor)"
+			}]
+		}
 	},
 	{
-		"name": "effectSucceedWithVoid",
-		"description": "Suggests using Effect.void instead of Effect.succeed(undefined) or Effect.succeed(void 0)",
+		"name": "catchUnfailableEffect",
+		"group": "antipattern",
+		"description": "Warns when using error handling on Effects that never fail",
 		"defaultSeverity": "suggestion",
-		"codes": [377016]
+		"fixable": false,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377009],
+		"preview": {
+			"sourceText": "import { Effect } from \"effect\"\n\nexport const preview = Effect.succeed(1).pipe(\n  Effect.catch(() => Effect.succeed(0))\n)\n",
+			"diagnostics": [{
+				"start": 82,
+				"end": 94,
+				"text": "Looks like the previous effect never fails, so probably this error handling will never be triggered. effect(catchUnfailableEffect)"
+			}]
+		}
 	},
 	{
-		"name": "extendsNativeError",
-		"description": "Warns when a class directly extends the native Error class",
-		"defaultSeverity": "off",
-		"codes": [377055]
+		"name": "effectFnIife",
+		"group": "antipattern",
+		"description": "Effect.fn or Effect.fnUntraced is called as an IIFE; use Effect.gen instead",
+		"defaultSeverity": "warning",
+		"fixable": true,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377011],
+		"preview": {
+			"sourceText": "import * as Effect from \"effect/Effect\"\n\nexport const preview = Effect.fn(\"preview\")(function*() {\n  return yield* Effect.succeed(1)\n})()\n",
+			"diagnostics": [{
+				"start": 64,
+				"end": 137,
+				"text": "Effect.fn returns a reusable function that can take arguments, but here it's called immediately. Use Effect.gen instead with Effect.withSpan(\"preview\") piped in the end to maintain tracing spans. effect(effectFnIife)"
+			}]
+		}
 	},
 	{
-		"name": "floatingEffect",
-		"description": "Detects Effect values that are neither yielded nor assigned",
-		"defaultSeverity": "error",
-		"codes": [377001, 377058]
+		"name": "effectGenUsesAdapter",
+		"group": "antipattern",
+		"description": "Warns when using the deprecated adapter parameter in Effect.gen",
+		"defaultSeverity": "warning",
+		"fixable": false,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377027],
+		"preview": {
+			"sourceText": "import * as Effect from \"effect/Effect\"\n\nexport const preview = Effect.gen(function*(_) {\n  return yield* Effect.succeed(1)\n})\n",
+			"diagnostics": [{
+				"start": 85,
+				"end": 86,
+				"text": "The adapter of Effect.gen is not required anymore, it is now just an alias of pipe. effect(effectGenUsesAdapter)"
+			}]
+		}
 	},
 	{
-		"name": "genericEffectServices",
-		"description": "Prevents services with type parameters that cannot be discriminated at runtime",
+		"name": "effectInFailure",
+		"group": "antipattern",
+		"description": "Warns when an Effect is used inside an Effect failure channel",
 		"defaultSeverity": "warning",
-		"codes": [377043]
+		"fixable": false,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377054],
+		"preview": {
+			"sourceText": "import { Effect } from \"effect\"\n\nexport const preview = Effect.try({\n  try: () => JSON.parse(\"{\"),\n  catch: (error) => Effect.logError(error)\n})\n",
+			"diagnostics": [{
+				"start": 46,
+				"end": 53,
+				"text": "The error channel contains an Effect (Effect<void, never, never>). Putting Effect computations in the failure channel is not intended; keep only failure types there. effect(effectInFailure)"
+			}, {
+				"start": 56,
+				"end": 144,
+				"text": "The error channel contains an Effect (Effect<void, never, never>). Putting Effect computations in the failure channel is not intended; keep only failure types there. effect(effectInFailure)"
+			}]
+		}
+	},
+	{
+		"name": "effectInVoidSuccess",
+		"group": "antipattern",
+		"description": "Detects nested Effects in void success channels that may cause unexecuted effects",
+		"defaultSeverity": "warning",
+		"fixable": false,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377020],
+		"preview": {
+			"sourceText": "import * as Effect from \"effect/Effect\"\n\nexport const preview: Effect.Effect<void> = Effect.succeed(\n  Effect.log(\"nested\")\n)\n",
+			"diagnostics": [{
+				"start": 54,
+				"end": 61,
+				"text": "There is a nested 'Effect<void, never, never>' in the 'void' success channel, beware that this could lead to nested Effect<Effect<...>> that won't be executed. effect(effectInVoidSuccess)"
+			}]
+		}
 	},
 	{
 		"name": "globalErrorInEffectCatch",
+		"group": "antipattern",
 		"description": "Warns when catch callbacks return global Error type instead of typed errors",
 		"defaultSeverity": "warning",
-		"codes": [377022]
+		"fixable": false,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377022],
+		"preview": {
+			"sourceText": "import { Effect } from \"effect\"\n\nexport const preview = Effect.tryPromise({\n  try: async () => 1,\n  catch: (error) => new Error(String(error))\n})\n",
+			"diagnostics": [{
+				"start": 56,
+				"end": 73,
+				"text": "The 'catch' callback in Effect.tryPromise returns global 'Error', which loses type safety as untagged errors merge together. Consider using a tagged error and optionally wrapping the original in a 'cause' property. effect(globalErrorInEffectCatch)"
+			}]
+		}
 	},
 	{
 		"name": "globalErrorInEffectFailure",
+		"group": "antipattern",
 		"description": "Warns when the global Error type is used in an Effect failure channel",
 		"defaultSeverity": "warning",
-		"codes": [377023]
-	},
-	{
-		"name": "instanceOfSchema",
-		"description": "Suggests using Schema.is instead of instanceof for Effect Schema types",
-		"defaultSeverity": "off",
-		"codes": [377042]
+		"fixable": false,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377023],
+		"preview": {
+			"sourceText": "import { Effect } from \"effect\"\n\nexport const preview = Effect.fail(new Error(\"boom\"))\n",
+			"diagnostics": [{
+				"start": 68,
+				"end": 85,
+				"text": "Global 'Error' loses type safety as untagged errors merge together in the Effect failure channel. Consider using a tagged error and optionally wrapping the original in a 'cause' property. effect(globalErrorInEffectFailure)"
+			}]
+		}
 	},
 	{
 		"name": "layerMergeAllWithDependencies",
+		"group": "antipattern",
 		"description": "Detects interdependencies in Layer.mergeAll calls where one layer provides a service that another layer requires",
 		"defaultSeverity": "warning",
-		"codes": [377035]
+		"fixable": true,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377035],
+		"preview": {
+			"sourceText": "import { Effect, Layer, ServiceMap } from \"effect\"\n\nclass A extends ServiceMap.Service<A>()(\"A\", { make: Effect.succeed({}) }) {\n  static Default = Layer.effect(this, this.make)\n}\nclass B extends ServiceMap.Service<B>()(\"B\", { make: Effect.as(A.asEffect(), {}) }) {\n  static Default = Layer.effect(this, this.make)\n}\nexport const preview = Layer.mergeAll(A.Default, B.Default)\n",
+			"diagnostics": [{
+				"start": 355,
+				"end": 364,
+				"text": "This layer provides A which is required by another layer in the same Layer.mergeAll call. Layer.mergeAll creates layers in parallel, so dependencies between layers will not be satisfied. Consider moving this layer into a Layer.provideMerge after the Layer.mergeAll. effect(layerMergeAllWithDependencies)"
+			}]
+		}
 	},
 	{
 		"name": "leakingRequirements",
+		"group": "antipattern",
 		"description": "Detects implementation services leaked in service methods",
 		"defaultSeverity": "suggestion",
-		"codes": [377041]
+		"fixable": false,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377041],
+		"preview": {
+			"sourceText": "import type { Effect } from \"effect\"\nimport { ServiceMap } from \"effect\"\n\nclass FileSystem extends ServiceMap.Service<FileSystem, {\n  write: (s: string) => Effect.Effect<void>\n}>()(\"FileSystem\") {}\n\nexport class Cache extends ServiceMap.Service<Cache, {\n  read: Effect.Effect<string, never, FileSystem>\n  save: () => Effect.Effect<void, never, FileSystem>\n}>()(\"Cache\") {}\n",
+			"diagnostics": [{
+				"start": 212,
+				"end": 217,
+				"text": "Methods of this Service require 'FileSystem' from every caller. This leaks implementation details — resolve these dependencies at Layer creation time. effect(leakingRequirements)"
+			}]
+		}
 	},
 	{
-		"name": "missedPipeableOpportunity",
-		"description": "Suggests using .pipe() for nested function calls",
-		"defaultSeverity": "off",
-		"codes": [377050]
+		"name": "multipleEffectProvide",
+		"group": "antipattern",
+		"description": "Warns against chaining Effect.provide calls which can cause service lifecycle issues",
+		"defaultSeverity": "warning",
+		"fixable": true,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377033],
+		"preview": {
+			"sourceText": "import { Effect, Layer, ServiceMap } from \"effect\"\n\nclass A extends ServiceMap.Service<A>()(\"A\", { make: Effect.succeed({}) }) {\n  static Default = Layer.effect(this, this.make)\n}\nclass B extends ServiceMap.Service<B>()(\"B\", { make: Effect.succeed({}) }) {\n  static Default = Layer.effect(this, this.make)\n}\nexport const preview = Effect.void.pipe(Effect.provide(A.Default), Effect.provide(B.Default))\n",
+			"diagnostics": [{
+				"start": 348,
+				"end": 373,
+				"text": "Avoid chaining Effect.provide calls, as this can lead to service lifecycle issues. Instead, merge layers and provide them in a single call. effect(multipleEffectProvide)"
+			}]
+		}
 	},
 	{
-		"name": "missingEffectContext",
-		"description": "Detects Effect values with unhandled context requirements",
-		"defaultSeverity": "error",
-		"codes": [377004]
+		"name": "returnEffectInGen",
+		"group": "antipattern",
+		"description": "Warns when returning an Effect in a generator causes nested Effect<Effect<...>>",
+		"defaultSeverity": "suggestion",
+		"fixable": true,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377014],
+		"preview": {
+			"sourceText": "import * as Effect from \"effect/Effect\"\n\nexport const preview = Effect.gen(function*() {\n  return Effect.succeed(1)\n})\n",
+			"diagnostics": [{
+				"start": 91,
+				"end": 97,
+				"text": "You are returning an Effect-able type inside a generator function, and will result in nested Effect<Effect<...>>.\nMaybe you wanted to return yield* instead?\nNested Effect-able types may be intended if you plan to later manually flatten or unwrap this Effect, if so you can safely disable this diagnostic for this line through quickfixes. effect(returnEffectInGen)"
+			}]
+		}
 	},
 	{
-		"name": "missingEffectError",
-		"description": "Detects Effect values with unhandled error types",
-		"defaultSeverity": "error",
-		"codes": [377003]
+		"name": "runEffectInsideEffect",
+		"group": "antipattern",
+		"description": "Suggests using Runtime methods instead of Effect.run* inside Effect contexts",
+		"defaultSeverity": "suggestion",
+		"fixable": true,
+		"supportedEffect": ["v3"],
+		"codes": [377024, 377025],
+		"preview": {
+			"sourceText": "import { Effect } from \"effect\"\n\nexport const preview = Effect.gen(function*() {\n  const run = () => Effect.runSync(Effect.succeed(1))\n  return run()\n})\n",
+			"diagnostics": [{
+				"start": 101,
+				"end": 115,
+				"text": "Using Effect.runSync inside an Effect is not recommended. The same runtime should generally be used instead to run child effects.\nConsider extracting the Runtime by using for example Effect.runtime and then use Runtime.runSync with the extracted runtime instead. effect(runEffectInsideEffect)"
+			}]
+		}
 	},
 	{
-		"name": "missingEffectServiceDependency",
-		"description": "Checks that Effect.Service dependencies satisfy all required layer inputs",
-		"defaultSeverity": "off",
-		"codes": [377039, 377040]
+		"name": "schemaSyncInEffect",
+		"group": "antipattern",
+		"description": "Suggests using Effect-based Schema methods instead of sync methods inside Effect generators",
+		"defaultSeverity": "suggestion",
+		"fixable": false,
+		"supportedEffect": ["v3"],
+		"codes": [377037],
+		"preview": {
+			"sourceText": "import * as Effect from \"effect/Effect\"\nimport * as Schema from \"effect/Schema\"\n\nconst Person = Schema.Struct({ name: Schema.String, age: Schema.Number })\n\nexport const preview = Effect.gen(function*() {\n  const input = yield* Effect.succeed({ name: \"Ada\", age: 1 })\n  return Schema.decodeSync(Person)(input)\n})\n",
+			"diagnostics": [{
+				"start": 276,
+				"end": 293,
+				"text": "Using Schema.decodeSync inside an Effect generator is not recommended. Use Schema.decode instead to get properly typed error channel. effect(schemaSyncInEffect)"
+			}]
+		}
 	},
 	{
-		"name": "missingLayerContext",
-		"description": "Detects Layer values with unhandled context requirements",
-		"defaultSeverity": "error",
-		"codes": [377034]
+		"name": "scopeInLayerEffect",
+		"group": "antipattern",
+		"description": "Suggests using Layer.scoped instead of Layer.effect when Scope is in requirements",
+		"defaultSeverity": "warning",
+		"fixable": true,
+		"supportedEffect": ["v3"],
+		"codes": [377031],
+		"preview": {
+			"sourceText": "import * as Context from \"effect/Context\"\nimport * as Effect from \"effect/Effect\"\nimport * as Layer from \"effect/Layer\"\n\nclass Cache extends Context.Tag(\"Cache\")<Cache, { ok: true }>() {}\nexport const preview = Layer.effect(Cache, Effect.gen(function*() {\n  yield* Effect.addFinalizer(() => Effect.void)\n  return { ok: true as const }\n}))\n",
+			"diagnostics": [{
+				"start": 211,
+				"end": 338,
+				"text": "Seems like you are constructing a layer with a scope in the requirements.\nConsider using \"scoped\" instead to get rid of the scope in the requirements. effect(scopeInLayerEffect)"
+			}]
+		}
 	},
 	{
-		"name": "missingReturnYieldStar",
-		"description": "Suggests using return yield* for Effects that never succeed",
-		"defaultSeverity": "error",
-		"codes": [377006]
+		"name": "strictEffectProvide",
+		"group": "antipattern",
+		"description": "Warns when using Effect.provide with layers outside of application entry points",
+		"defaultSeverity": "off",
+		"fixable": false,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377032],
+		"preview": {
+			"sourceText": "import { Effect, Layer, ServiceMap } from \"effect\"\n\nclass Config extends ServiceMap.Service<Config>()(\"Config\", { make: Effect.succeed({}) }) {\n  static Default = Layer.effect(this, this.make)\n}\nexport const preview = Effect.void.pipe(Effect.provide(Config.Default))\n",
+			"diagnostics": [{
+				"start": 235,
+				"end": 265,
+				"text": "Effect.provide with a Layer should only be used at application entry points. If this is an entry point, you can safely disable this diagnostic. Otherwise, using Effect.provide may break scope lifetimes. Compose all layers at your entry point and provide them at once. effect(strictEffectProvide)"
+			}]
+		}
 	},
 	{
-		"name": "missingStarInYieldEffectGen",
-		"description": "Detects bare yield (without *) inside Effect generator scopes",
-		"defaultSeverity": "error",
-		"codes": [377007, 377008]
+		"name": "tryCatchInEffectGen",
+		"group": "antipattern",
+		"description": "Discourages try/catch in Effect generators in favor of Effect error handling",
+		"defaultSeverity": "suggestion",
+		"fixable": false,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377012],
+		"preview": {
+			"sourceText": "import * as Effect from \"effect/Effect\"\n\nexport const preview = Effect.gen(function*() {\n  try { return yield* Effect.succeed(1) }\n  catch { return 0 }\n})\n",
+			"diagnostics": [{
+				"start": 91,
+				"end": 151,
+				"text": "Avoid using try/catch inside Effect generators. Use Effect's error handling mechanisms instead (e.g. Effect.try, Effect.tryPromise, Effect.catch, Effect.catchTag). effect(tryCatchInEffectGen)"
+			}]
+		}
 	},
 	{
-		"name": "multipleEffectProvide",
-		"description": "Warns against chaining Effect.provide calls which can cause service lifecycle issues",
+		"name": "unknownInEffectCatch",
+		"group": "antipattern",
+		"description": "Warns when catch callbacks return unknown instead of typed errors",
 		"defaultSeverity": "warning",
-		"codes": [377033]
+		"fixable": false,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377021],
+		"preview": {
+			"sourceText": "import { Effect } from \"effect\"\n\nexport const preview = Effect.tryPromise({\n  try: async () => 1,\n  catch: (error) => error\n})\n",
+			"diagnostics": [{
+				"start": 56,
+				"end": 73,
+				"text": "The 'catch' callback in Effect.tryPromise returns 'unknown'. The catch callback should be used to provide typed errors.\nConsider wrapping unknown errors into Effect's Data.TaggedError for example, or narrow down the type to the specific error raised. effect(unknownInEffectCatch)"
+			}]
+		}
+	},
+	{
+		"name": "extendsNativeError",
+		"group": "effectNative",
+		"description": "Warns when a class directly extends the native Error class",
+		"defaultSeverity": "off",
+		"fixable": false,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377055],
+		"preview": {
+			"sourceText": "\nexport class PreviewError extends Error {}\n",
+			"diagnostics": [{
+				"start": 14,
+				"end": 26,
+				"text": "Avoid extending the native 'Error' class directly. Consider using a tagged error (e.g. Data.TaggedError) to maintain type safety in the Effect failure channel. effect(extendsNativeError)"
+			}]
+		}
+	},
+	{
+		"name": "instanceOfSchema",
+		"group": "effectNative",
+		"description": "Suggests using Schema.is instead of instanceof for Effect Schema types",
+		"defaultSeverity": "off",
+		"fixable": true,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377042],
+		"preview": {
+			"sourceText": "import { Schema } from \"effect\"\n\nclass User extends Schema.Class<User>(\"User\")({ name: Schema.String }) {}\ndeclare const value: unknown\nexport const preview = value instanceof User\n",
+			"diagnostics": [{
+				"start": 159,
+				"end": 180,
+				"text": "Consider using Schema.is instead of instanceof for Effect Schema types. effect(instanceOfSchema)"
+			}]
+		}
 	},
 	{
 		"name": "nodeBuiltinImport",
+		"group": "effectNative",
 		"description": "Warns when importing Node.js built-in modules that have Effect-native counterparts",
 		"defaultSeverity": "off",
-		"codes": [377057]
+		"fixable": false,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377057],
+		"preview": {
+			"sourceText": "import fs from \"node:fs\"\n\nexport const preview = fs.readFileSync\n",
+			"diagnostics": [{
+				"start": 15,
+				"end": 24,
+				"text": "Prefer using FileSystem from @effect/platform instead of the Node.js 'fs' module. effect(nodeBuiltinImport)"
+			}]
+		}
 	},
 	{
-		"name": "nonObjectEffectServiceType",
-		"description": "Ensures Effect.Service types are objects, not primitives",
-		"defaultSeverity": "error",
-		"codes": [377048]
+		"name": "preferSchemaOverJson",
+		"group": "effectNative",
+		"description": "Suggests using Effect Schema for JSON operations instead of JSON.parse/JSON.stringify",
+		"defaultSeverity": "suggestion",
+		"fixable": false,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377026],
+		"preview": {
+			"sourceText": "import { Effect } from \"effect\"\n\nexport const preview = Effect.gen(function*() {\n  const text = yield* Effect.succeed('{\"ok\":true}')\n  return JSON.parse(text)\n})\n",
+			"diagnostics": [{
+				"start": 142,
+				"end": 158,
+				"text": "Consider using Effect Schema for JSON operations instead of JSON.parse/JSON.stringify. effect(preferSchemaOverJson)"
+			}]
+		}
 	},
 	{
-		"name": "outdatedApi",
-		"description": "Detects usage of APIs that have been removed or renamed in Effect v4",
-		"defaultSeverity": "warning",
-		"codes": [377052, 377053]
+		"name": "catchAllToMapError",
+		"group": "style",
+		"description": "Suggests using Effect.mapError instead of Effect.catch + Effect.fail",
+		"defaultSeverity": "suggestion",
+		"fixable": true,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377010],
+		"preview": {
+			"sourceText": "import { Effect } from \"effect\"\n\nclass WrappedError {\n  constructor(readonly cause: unknown) {}\n}\n\nexport const preview = Effect.fail(\"boom\").pipe(\n  Effect.catch((cause) => Effect.fail(new WrappedError(cause)))\n)\n",
+			"diagnostics": [{
+				"start": 150,
+				"end": 162,
+				"text": "You can use Effect.mapError instead of Effect.catch + Effect.fail to transform the error type. effect(catchAllToMapError)"
+			}]
+		}
 	},
 	{
-		"name": "overriddenSchemaConstructor",
-		"description": "Prevents overriding constructors in Schema classes which breaks decoding behavior",
-		"defaultSeverity": "error",
-		"codes": [377044]
+		"name": "deterministicKeys",
+		"group": "style",
+		"description": "Enforces deterministic naming for service/tag/error identifiers based on class names",
+		"defaultSeverity": "off",
+		"fixable": true,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377049],
+		"preview": {
+			"sourceText": "import { ServiceMap } from \"effect\"\n\nexport class RenamedService\n  extends ServiceMap.Service<RenamedService, {}>()(\"CustomIdentifier\") {}\n",
+			"diagnostics": []
+		}
 	},
 	{
-		"name": "preferSchemaOverJson",
-		"description": "Suggests using Effect Schema for JSON operations instead of JSON.parse/JSON.stringify",
+		"name": "effectFnOpportunity",
+		"group": "style",
+		"description": "Suggests using Effect.fn for functions that return an Effect",
 		"defaultSeverity": "suggestion",
-		"codes": [377026]
+		"fixable": true,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377047],
+		"preview": {
+			"sourceText": "import * as Effect from \"effect/Effect\"\n\nexport const preview = () => Effect.gen(function*() {\n  return yield* Effect.succeed(1)\n})\n",
+			"diagnostics": [{
+				"start": 54,
+				"end": 61,
+				"text": "Can be rewritten as a reusable function: Effect.fn(function*() { ... }). effect(effectFnOpportunity)"
+			}]
+		}
 	},
 	{
-		"name": "redundantSchemaTagIdentifier",
-		"description": "Suggests removing redundant identifier argument when it equals the tag value in Schema.TaggedClass/TaggedError/TaggedRequest",
+		"name": "effectMapVoid",
+		"group": "style",
+		"description": "Suggests using Effect.asVoid instead of Effect.map(() => void 0), Effect.map(() => undefined), or Effect.map(() => {})",
 		"defaultSeverity": "suggestion",
-		"codes": [377045]
+		"fixable": true,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377018],
+		"preview": {
+			"sourceText": "import { Effect } from \"effect\"\n\nexport const preview = Effect.succeed(1).pipe(\n  Effect.map(() => undefined)\n)\n",
+			"diagnostics": [{
+				"start": 82,
+				"end": 92,
+				"text": "Effect.asVoid can be used instead to discard the success value. effect(effectMapVoid)"
+			}]
+		}
 	},
 	{
-		"name": "returnEffectInGen",
-		"description": "Warns when returning an Effect in a generator causes nested Effect<Effect<...>>",
+		"name": "effectSucceedWithVoid",
+		"group": "style",
+		"description": "Suggests using Effect.void instead of Effect.succeed(undefined) or Effect.succeed(void 0)",
 		"defaultSeverity": "suggestion",
-		"codes": [377014]
+		"fixable": true,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377016],
+		"preview": {
+			"sourceText": "import { Effect } from \"effect\"\n\nexport const preview = Effect.succeed(undefined)\n",
+			"diagnostics": [{
+				"start": 56,
+				"end": 81,
+				"text": "Effect.void can be used instead of Effect.succeed(undefined) or Effect.succeed(void 0). effect(effectSucceedWithVoid)"
+			}]
+		}
 	},
 	{
-		"name": "runEffectInsideEffect",
-		"description": "Suggests using Runtime methods instead of Effect.run* inside Effect contexts",
-		"defaultSeverity": "suggestion",
-		"codes": [377024, 377025]
+		"name": "missedPipeableOpportunity",
+		"group": "style",
+		"description": "Suggests using .pipe() for nested function calls",
+		"defaultSeverity": "off",
+		"fixable": true,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377050],
+		"preview": {
+			"sourceText": "import { identity, Schema } from \"effect\"\n\nconst User = Schema.Struct({ id: Schema.Number })\nexport const preview = identity(identity(Schema.decodeEffect(User)({ id: 1 })))\n",
+			"diagnostics": [{
+				"start": 116,
+				"end": 172,
+				"text": "Nested function calls can be converted to pipeable style for better readability; consider using Schema.decodeEffect(User)({ id: 1 }).pipe(...) instead. effect(missedPipeableOpportunity)"
+			}]
+		}
 	},
 	{
-		"name": "schemaStructWithTag",
-		"description": "Suggests using Schema.TaggedStruct instead of Schema.Struct with _tag field",
+		"name": "missingEffectServiceDependency",
+		"group": "style",
+		"description": "Checks that Effect.Service dependencies satisfy all required layer inputs",
+		"defaultSeverity": "off",
+		"fixable": false,
+		"supportedEffect": ["v3"],
+		"codes": [377039, 377040],
+		"preview": {
+			"sourceText": "import * as Effect from \"effect/Effect\"\n\nclass Db extends Effect.Service<Db>()(\"Db\", { succeed: { ok: true } }) {}\nexport class Repo extends Effect.Service<Repo>()(\"Repo\", {\n  effect: Effect.gen(function*() {\n    yield* Db\n    return { all: Effect.succeed([] as Array<number>) }\n  })\n}) {}\n",
+			"diagnostics": [{
+				"start": 128,
+				"end": 132,
+				"text": "Service 'Db' is required but not provided by dependencies. effect(missingEffectServiceDependency)"
+			}]
+		}
+	},
+	{
+		"name": "redundantSchemaTagIdentifier",
+		"group": "style",
+		"description": "Suggests removing redundant identifier argument when it equals the tag value in Schema.TaggedClass/TaggedError/TaggedRequest",
 		"defaultSeverity": "suggestion",
-		"codes": [377036]
+		"fixable": true,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377045],
+		"preview": {
+			"sourceText": "import * as Schema from \"effect/Schema\"\n\nexport class Preview\n  extends Schema.TaggedClass<Preview>(\"Preview\")(\"Preview\", {\n    value: Schema.String\n  }) {}\n",
+			"diagnostics": [{
+				"start": 100,
+				"end": 109,
+				"text": "Identifier 'Preview' is redundant since it equals the _tag value. effect(redundantSchemaTagIdentifier)"
+			}]
+		}
 	},
 	{
-		"name": "schemaSyncInEffect",
-		"description": "Suggests using Effect-based Schema methods instead of sync methods inside Effect generators",
+		"name": "schemaStructWithTag",
+		"group": "style",
+		"description": "Suggests using Schema.TaggedStruct instead of Schema.Struct with _tag field",
 		"defaultSeverity": "suggestion",
-		"codes": [377037]
+		"fixable": true,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377036],
+		"preview": {
+			"sourceText": "import * as Schema from \"effect/Schema\"\n\nexport const preview = Schema.Struct({\n  _tag: Schema.Literal(\"User\"),\n  name: Schema.String\n})\n",
+			"diagnostics": [{
+				"start": 64,
+				"end": 136,
+				"text": "Schema.Struct with a _tag field can be simplified to Schema.TaggedStruct to make the tag optional in the constructor. effect(schemaStructWithTag)"
+			}]
+		}
 	},
 	{
 		"name": "schemaUnionOfLiterals",
+		"group": "style",
 		"description": "Suggests combining multiple Schema.Literal calls in Schema.Union into a single Schema.Literal",
 		"defaultSeverity": "off",
-		"codes": [377038]
-	},
-	{
-		"name": "scopeInLayerEffect",
-		"description": "Suggests using Layer.scoped instead of Layer.effect when Scope is in requirements",
-		"defaultSeverity": "warning",
-		"codes": [377031]
+		"fixable": true,
+		"supportedEffect": ["v3"],
+		"codes": [377038],
+		"preview": {
+			"sourceText": "import * as Schema from \"effect/Schema\"\n\nexport const preview = Schema.Union(Schema.Literal(\"a\"), Schema.Literal(\"b\"))\n",
+			"diagnostics": [{
+				"start": 64,
+				"end": 118,
+				"text": "A Schema.Union of multiple Schema.Literal calls can be simplified to a single Schema.Literal call. effect(schemaUnionOfLiterals)"
+			}]
+		}
 	},
 	{
 		"name": "serviceNotAsClass",
+		"group": "style",
 		"description": "Warns when ServiceMap.Service is used as a variable instead of a class declaration",
 		"defaultSeverity": "off",
-		"codes": [377056]
+		"fixable": true,
+		"supportedEffect": ["v4"],
+		"codes": [377056],
+		"preview": {
+			"sourceText": "import { ServiceMap } from \"effect\"\n\nexport const Preview = ServiceMap.Service<{ port: number }>(\"Preview\")\n",
+			"diagnostics": [{
+				"start": 60,
+				"end": 107,
+				"text": "ServiceMap.Service should be used in a class declaration instead of as a variable. Use: class Preview extends ServiceMap.Service<Preview, { port: number }>()(\"Preview\") {} effect(serviceNotAsClass)"
+			}]
+		}
 	},
 	{
 		"name": "strictBooleanExpressions",
+		"group": "style",
 		"description": "Enforces boolean types in conditional expressions for type safety",
 		"defaultSeverity": "off",
-		"codes": [377029]
-	},
-	{
-		"name": "strictEffectProvide",
-		"description": "Warns when using Effect.provide with layers outside of application entry points",
-		"defaultSeverity": "off",
-		"codes": [377032]
-	},
-	{
-		"name": "tryCatchInEffectGen",
-		"description": "Discourages try/catch in Effect generators in favor of Effect error handling",
-		"defaultSeverity": "suggestion",
-		"codes": [377012]
-	},
-	{
-		"name": "unknownInEffectCatch",
-		"description": "Warns when catch callbacks return unknown instead of typed errors",
-		"defaultSeverity": "warning",
-		"codes": [377021]
+		"fixable": false,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377029],
+		"preview": {
+			"sourceText": "\ndeclare const value: string | undefined\nexport const preview = value ? 1 : 0\n",
+			"diagnostics": [{
+				"start": 64,
+				"end": 69,
+				"text": "Unexpected `string` type in condition, expected strictly a boolean instead. effect(strictBooleanExpressions)"
+			}, {
+				"start": 64,
+				"end": 69,
+				"text": "Unexpected `undefined` type in condition, expected strictly a boolean instead. effect(strictBooleanExpressions)"
+			}]
+		}
 	},
 	{
 		"name": "unnecessaryEffectGen",
+		"group": "style",
 		"description": "Suggests removing Effect.gen when it contains only a single return statement",
 		"defaultSeverity": "suggestion",
-		"codes": [377017]
+		"fixable": true,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377017],
+		"preview": {
+			"sourceText": "import * as Effect from \"effect/Effect\"\n\nexport const preview = Effect.gen(function*() {\n  return yield* Effect.succeed(1)\n})\n",
+			"diagnostics": [{
+				"start": 64,
+				"end": 125,
+				"text": "This Effect.gen contains a single return statement. effect(unnecessaryEffectGen)"
+			}]
+		}
 	},
 	{
 		"name": "unnecessaryFailYieldableError",
+		"group": "style",
 		"description": "Suggests yielding yieldable errors directly instead of wrapping with Effect.fail",
 		"defaultSeverity": "suggestion",
-		"codes": [377019]
+		"fixable": true,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377019],
+		"preview": {
+			"sourceText": "import * as Data from \"effect/Data\"\nimport * as Effect from \"effect/Effect\"\n\nclass Boom extends Data.TaggedError(\"Boom\")<{}> {}\nexport const preview = Effect.gen(function*() {\n  yield* Effect.fail(new Boom())\n})\n",
+			"diagnostics": [{
+				"start": 178,
+				"end": 183,
+				"text": "This Effect.fail call uses a yieldable error type as argument. You can yield* the error directly instead. effect(unnecessaryFailYieldableError)"
+			}]
+		}
 	},
 	{
 		"name": "unnecessaryPipe",
+		"group": "style",
 		"description": "Removes pipe calls with no arguments",
 		"defaultSeverity": "suggestion",
-		"codes": [377013]
+		"fixable": true,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377013],
+		"preview": {
+			"sourceText": "import { pipe } from \"effect/Function\"\n\nexport const preview = pipe(1)\n",
+			"diagnostics": [{
+				"start": 63,
+				"end": 70,
+				"text": "This pipe call contains no arguments. effect(unnecessaryPipe)"
+			}]
+		}
 	},
 	{
 		"name": "unnecessaryPipeChain",
+		"group": "style",
 		"description": "Simplifies chained pipe calls into a single pipe call",
 		"defaultSeverity": "suggestion",
-		"codes": [377015]
+		"fixable": true,
+		"supportedEffect": ["v3", "v4"],
+		"codes": [377015],
+		"preview": {
+			"sourceText": "import * as Effect from \"effect/Effect\"\n\nexport const preview = Effect.succeed(1).pipe(Effect.asVoid).pipe(Effect.as(\"done\"))\n",
+			"diagnostics": [{
+				"start": 64,
+				"end": 125,
+				"text": "Chained pipe calls can be simplified to a single pipe call. effect(unnecessaryPipeChain)"
+			}]
+		}
 	}
 ];
 
 //#endregion
 //#region src/setup/rule-info.ts
 function getAllRules() {
-	return rules_default;
+	return rules;
+}
+function getAllGroups() {
+	return groups;
 }
 function cycleSeverity(current, direction) {
 	const order = [
@@ -196759,187 +197385,349 @@ function getSeverityShortName(severity) {
 const RESET = "\x1B[0m";
 const BOLD = "\x1B[0;1m";
 const DIM = "\x1B[0;90m";
-const GREEN = "\x1B[0;32m";
-const WHITE = "\x1B[0;37m";
-const CYAN_BRIGHT = "\x1B[0;96m";
-const BG_BLACK_BRIGHT = "\x1B[0;100m";
-const BG_RED = "\x1B[41m";
-const BG_YELLOW = "\x1B[43m";
-const BG_BLUE = "\x1B[0;44m";
-const BG_CYAN = "\x1B[0;46m";
+const RED = "\x1B[0;31m";
+const YELLOW = "\x1B[0;33m";
+const BLUE = "\x1B[0;34m";
+const ITALIC = "\x1B[0;3m";
+const UNDERLINE = "\x1B[0;4m";
 const ansi = (text, code) => `${code}${text}${RESET}`;
 const ERASE_LINE = "\x1B[2K";
 const CURSOR_LEFT = "\r";
 const CURSOR_HIDE = "\x1B[?25l";
 const CURSOR_TO_0 = "\x1B[G";
 const BEEP = "\x07";
+const ANSI_ESCAPE_REGEX = new RegExp(String.raw`\u001b\[[0-?]*[ -/]*[@-~]`, "g");
+const stripAnsi = (text) => text.replace(ANSI_ESCAPE_REGEX, "");
+const visibleLength = (text) => stripAnsi(text).length;
 
 //#endregion
 //#region src/setup/rule-prompt.ts
-function eraseLines(count) {
-	let result = "";
-	for (let i = 0; i < count; i++) {
-		if (i > 0) result += "\x1B[1A";
-		result += ERASE_LINE;
-	}
-	if (count > 0) result += CURSOR_LEFT;
-	return result;
-}
+const diagnosticGroups = getAllGroups();
 const Action = taggedEnum();
-const NEWLINE_REGEX = /\r?\n/;
-function eraseText(text, columns) {
-	if (columns === 0) return ERASE_LINE + CURSOR_TO_0;
-	let rows = 0;
-	const lines = text.split(/\r?\n/);
-	for (const line of lines) rows += 1 + Math.floor(Math.max(line.length - 1, 0) / columns);
-	return eraseLines(rows);
+const SEARCH_ICON = "/";
+const MIN_PREVIEW_AND_MESSAGES_LINES = 18;
+function getControlsLegend(searchText) {
+	return `\u2190/\u2192 change rule  \u2191/\u2193 change severity  ${searchText.length === 0 ? `${SEARCH_ICON} type to search` : `${SEARCH_ICON} searching: ${searchText}`}`;
 }
-function entriesToDisplay(cursor, total, maxVisible) {
-	const max = maxVisible === void 0 ? total : maxVisible;
-	let startIndex = Math.min(total - max, cursor - Math.floor(max / 2));
-	if (startIndex < 0) startIndex = 0;
-	const endIndex = Math.min(startIndex + max, total);
+function getSeveritySymbol(severity) {
 	return {
-		startIndex,
-		endIndex
-	};
+		off: ".",
+		suggestion: "?",
+		message: "i",
+		warning: "!",
+		error: "x"
+	}[severity];
 }
-const figuresValue = {
-	arrowUp: "↑",
-	arrowDown: "↓",
-	tick: "✔",
-	pointerSmall: "›"
-};
 function getSeverityStyle(severity) {
 	return {
-		off: WHITE + BG_BLACK_BRIGHT,
-		suggestion: WHITE + BG_CYAN,
-		message: WHITE + BG_BLUE,
-		warning: WHITE + BG_YELLOW,
-		error: WHITE + BG_RED
+		off: DIM,
+		suggestion: DIM,
+		message: BLUE,
+		warning: YELLOW,
+		error: RED
 	}[severity];
 }
-function renderOutput(leadingSymbol, trailingSymbol, options) {
-	const annotateLine = (line) => ansi(line, BOLD);
-	const prefix = leadingSymbol + " ";
-	return match$6(options.message.split(NEWLINE_REGEX), {
-		onEmpty: () => `${prefix}${trailingSymbol}`,
-		onNonEmpty: (promptLines) => {
-			return `${prefix}${map$7(promptLines, (line) => annotateLine(line)).join("\n  ")} ${trailingSymbol} `;
+function renderEntry(entry, severity, isSelected) {
+	return `${ansi(getSeveritySymbol(severity), getSeverityStyle(severity))} ${isSelected ? ansi(entry.name, UNDERLINE) : entry.name}`;
+}
+function rowsForLength(length, columns) {
+	if (columns <= 0) return 1;
+	return Math.max(1, 1 + Math.floor(Math.max(length - 1, 0) / columns));
+}
+function eraseRenderedLines(lines, columns) {
+	let result = "";
+	for (let lineIndex = lines.length - 1; lineIndex >= 0; lineIndex--) {
+		const rows = rowsForLength(visibleLength(lines[lineIndex] ?? ""), columns);
+		for (let rowIndex = 0; rowIndex < rows; rowIndex++) {
+			result += ERASE_LINE;
+			if (!(lineIndex === 0 && rowIndex === rows - 1)) result += "\x1B[1A";
 		}
-	});
+	}
+	if (lines.length > 0) result += CURSOR_LEFT;
+	return result;
 }
-function renderRules(state, options, figs, columns) {
-	const toDisplay = entriesToDisplay(state.index, options.rules.length, options.maxPerPage);
-	const documents = [];
-	for (let index = toDisplay.startIndex; index < toDisplay.endIndex; index++) {
-		const rule = options.rules[index];
-		const isHighlighted = state.index === index;
-		const currentSeverity = state.severities[rule.name] ?? rule.defaultSeverity;
-		const hasChanged = currentSeverity !== rule.defaultSeverity;
-		let prefix = " ";
-		if (index === toDisplay.startIndex && toDisplay.startIndex > 0) prefix = figs.arrowUp;
-		else if (index === toDisplay.endIndex - 1 && toDisplay.endIndex < options.rules.length) prefix = figs.arrowDown;
-		const severityStr = ansi(` ${getSeverityShortName(currentSeverity).padEnd(MAX_SEVERITY_LENGTH, " ")} `, getSeverityStyle(currentSeverity));
-		const nameText = hasChanged ? `${rule.name}*` : rule.name;
-		const nameStr = isHighlighted ? ansi(nameText, CYAN_BRIGHT) : nameText;
-		const mainLine = `${prefix} ${severityStr} ${nameStr}`;
-		if (isHighlighted && rule.description) {
-			const indentWidth = 2 + (MAX_SEVERITY_LENGTH + 2) + 1;
-			const indent = " ".repeat(indentWidth);
-			const availableWidth = columns - indentWidth;
-			const truncatedDescription = availableWidth > 0 && rule.description.length > availableWidth ? rule.description.substring(0, availableWidth - 1) + "…" : rule.description;
-			documents.push(mainLine + "\n" + ansi(indent + truncatedDescription, DIM));
-		} else documents.push(mainLine);
+function wrapPaddedText(text, initialPadding, endPadding, columns) {
+	if (text.length === 0) return [initialPadding + endPadding];
+	const available = Math.max(columns - visibleLength(initialPadding) - visibleLength(endPadding), 1);
+	const lines = [];
+	let remaining = text;
+	while (remaining.length > 0) {
+		const chunk = remaining.slice(0, available);
+		lines.push(initialPadding + chunk + endPadding);
+		remaining = remaining.slice(chunk.length);
 	}
-	return documents.join("\n");
+	return lines;
 }
-function renderNextFrame(state, options) {
-	return gen(function* () {
-		const rulesStr = renderRules(state, options, figuresValue, yield* (yield* Terminal).columns);
-		const promptMsg = renderOutput(ansi("?", CYAN_BRIGHT), figuresValue.pointerSmall, options);
-		const helpText = ansi("Use ↑/↓ to navigate, ←/→ to change severity, Enter to finish", DIM);
-		return CURSOR_HIDE + promptMsg + "\n" + helpText + "\n" + rulesStr;
+function wrapListItemText(text, firstLinePadding, continuationPadding, endPadding, columns) {
+	if (text.length === 0) return [firstLinePadding + endPadding];
+	const firstAvailable = Math.max(columns - visibleLength(firstLinePadding) - visibleLength(endPadding), 1);
+	const continuationAvailable = Math.max(columns - visibleLength(continuationPadding) - visibleLength(endPadding), 1);
+	const lines = [];
+	let remaining = text;
+	let isFirstLine = true;
+	while (remaining.length > 0) {
+		const padding = isFirstLine ? firstLinePadding : continuationPadding;
+		const available = isFirstLine ? firstAvailable : continuationAvailable;
+		const chunk = remaining.slice(0, available);
+		lines.push(padding + chunk + endPadding);
+		remaining = remaining.slice(chunk.length);
+		isFirstLine = false;
+	}
+	return lines;
+}
+function renderPaddedLine(text, initialPadding, endPadding, columns) {
+	const available = Math.max(columns - visibleLength(initialPadding) - visibleLength(endPadding), 0);
+	const truncated = visibleLength(text) <= available ? text : text.slice(0, available);
+	const padding = Math.max(available - visibleLength(truncated), 0);
+	return initialPadding + truncated + " ".repeat(padding) + endPadding;
+}
+function mergeHighlightRanges(ranges) {
+	const sorted = ranges.filter((range) => range.end > range.start).slice().sort((a, b) => a.start - b.start);
+	const merged = [];
+	for (const range of sorted) {
+		const previous = merged[merged.length - 1];
+		if (!previous || range.start > previous.end) {
+			merged.push(range);
+			continue;
+		}
+		merged[merged.length - 1] = {
+			start: previous.start,
+			end: Math.max(previous.end, range.end)
+		};
+	}
+	return merged;
+}
+function stylePreviewLine(line, lineStart, ranges) {
+	if (line.length === 0) return "";
+	const lineEnd = lineStart + line.length;
+	let cursor = 0;
+	let rendered = "";
+	for (const range of ranges) {
+		const start = Math.max(range.start, lineStart);
+		const end = Math.min(range.end, lineEnd);
+		if (end <= start) continue;
+		const startIndex = start - lineStart;
+		const endIndex = end - lineStart;
+		if (cursor < startIndex) rendered += ansi(line.slice(cursor, startIndex), DIM);
+		rendered += ansi(line.slice(startIndex, endIndex), UNDERLINE);
+		cursor = endIndex;
+	}
+	if (cursor < line.length) rendered += ansi(line.slice(cursor), DIM);
+	return rendered;
+}
+function wrapSourceLine(line, lineStart, availableWidth) {
+	if (line.length === 0) return [{
+		text: "",
+		start: lineStart,
+		end: lineStart
+	}];
+	const width = Math.max(availableWidth, 1);
+	const wrapped = [];
+	let offset = 0;
+	while (offset < line.length) {
+		const text = line.slice(offset, offset + width);
+		wrapped.push({
+			text,
+			start: lineStart + offset,
+			end: lineStart + offset + text.length
+		});
+		offset += text.length;
+	}
+	return wrapped;
+}
+function wrapPreviewSourceText(sourceText, columns) {
+	const availableWidth = Math.max(columns - 2, 1);
+	const logicalLines = sourceText.split("\n");
+	const wrapped = [];
+	let offset = 0;
+	for (const line of logicalLines) {
+		for (const wrappedLine of wrapSourceLine(line, offset, availableWidth)) wrapped.push(wrappedLine);
+		offset += line.length + 1;
+	}
+	return wrapped;
+}
+function renderPreviewSourceText(sourceText, diagnostics, columns) {
+	const ranges = mergeHighlightRanges(diagnostics.map((diagnostic) => ({
+		start: diagnostic.start,
+		end: diagnostic.end
+	})));
+	return wrapPreviewSourceText(sourceText, columns).map((line) => {
+		return CURSOR_TO_0 + renderPaddedLine(stylePreviewLine(line.text, line.start, ranges), "  ", "", columns);
 	});
 }
-function renderSubmission(state, options) {
-	return gen(function* () {
-		const changedCount = Object.entries(state.severities).filter(([name, severity]) => {
-			const rule = options.rules.find((current) => current.name === name);
-			return rule && severity !== rule.defaultSeverity;
-		}).length;
-		const result = ansi(`${changedCount} rule${changedCount === 1 ? "" : "s"} configured`, WHITE);
-		return renderOutput(ansi(figuresValue.tick, GREEN), "", options) + " " + result + "\n";
+function renderPreviewMessages(diagnostics, columns) {
+	return Array.from(new Set(diagnostics.map((diagnostic) => diagnostic.text))).flatMap((message) => {
+		let isFirstBlock = true;
+		return message.split("\n").flatMap((line) => {
+			const wrappedLines = wrapListItemText(line, isFirstBlock ? "- " : "  ", "  ", "", columns);
+			isFirstBlock = false;
+			return wrappedLines.map((wrappedLine) => CURSOR_TO_0 + ansi(wrappedLine, DIM + ITALIC));
+		});
 	});
 }
-function processCursorUp(state, totalCount) {
-	const newIndex = state.index === 0 ? totalCount - 1 : state.index - 1;
-	return succeed(Action.NextFrame({ state: {
-		...state,
-		index: newIndex
-	} }));
+function renderDivider(columns, legendText) {
+	if (legendText === void 0) return ansi("─".repeat(Math.max(columns, 0)), DIM);
+	const legend = ` ${legendText} `;
+	const legendLength = visibleLength(legend);
+	if (columns <= legendLength) return ansi(legend.slice(0, Math.max(columns, 0)), DIM);
+	const remaining = columns - legendLength;
+	const left = "─".repeat(Math.floor(remaining / 2));
+	const right = "─".repeat(remaining - left.length);
+	return ansi(left + legend + right, DIM);
 }
-function processCursorDown(state, totalCount) {
-	const newIndex = (state.index + 1) % totalCount;
-	return succeed(Action.NextFrame({ state: {
-		...state,
-		index: newIndex
-	} }));
+function renderSelectedRuleDivider(selected, severities, columns) {
+	if (!selected) return renderDivider(columns);
+	const currentSeverity = severities[selected.name] ?? selected.defaultSeverity;
+	return renderDivider(columns, `${selected.name} (currently set as ${getSeverityShortName(currentSeverity)})`);
 }
-function processSeverityChange(state, options, direction) {
-	const rule = options.rules[state.index];
-	const newSeverity = cycleSeverity(state.severities[rule.name] ?? rule.defaultSeverity, direction);
-	return succeed(Action.NextFrame({ state: {
-		...state,
-		severities: {
-			...state.severities,
-			[rule.name]: newSeverity
-		}
-	} }));
+function matchesSearch(entry, searchText) {
+	if (searchText.length === 0) return true;
+	const normalized = searchText.toLowerCase();
+	return entry.name.toLowerCase().includes(normalized) || entry.description.toLowerCase().includes(normalized) || entry.previewSourceText.toLowerCase().includes(normalized);
+}
+function getFilteredEntries(entries, searchText) {
+	return entries.filter((entry) => matchesSearch(entry, searchText));
+}
+function normalizeStartIndex(length, startIndex) {
+	if (length <= 0) return 0;
+	return (startIndex % length + length) % length;
+}
+function isPrintableInput(input) {
+	const printablePattern = new RegExp(String.raw`^[^\u0000-\u001F\u007F]+$`, "u");
+	return !input.key.ctrl && !input.key.meta && input.input !== void 0 && input.input.length > 0 && printablePattern.test(input.input);
+}
+function buildVisibleEntries(entries, severities, startIndex, columns) {
+	if (entries.length === 0) return {
+		fullLine: renderPaddedLine(ansi("No matching rules", DIM), "  ", "  ", columns),
+		visibleRules: []
+	};
+	const itemColumns = Math.max(columns - 4, 0);
+	const separator = "  ";
+	const visibleEntries = [];
+	const visibleRules = [];
+	let currentLength = 0;
+	let seenCount = 0;
+	while (seenCount < entries.length) {
+		const rule = entries[(startIndex + seenCount) % entries.length];
+		const entry = renderEntry(rule, severities[rule.name] ?? rule.defaultSeverity, seenCount === 0);
+		const nextLength = visibleEntries.length === 0 ? visibleLength(entry) : currentLength + 2 + visibleLength(entry);
+		if (nextLength > itemColumns) break;
+		visibleEntries.push(entry);
+		visibleRules.push(rule);
+		currentLength = nextLength;
+		seenCount++;
+	}
+	const leftMarker = entries.length > 1 ? ansi("←", DIM) : " ";
+	const rightMarker = entries.length > 1 ? ansi("→", DIM) : " ";
+	return {
+		fullLine: renderPaddedLine(visibleEntries.join(separator), `${leftMarker} `, ` ${rightMarker}`, columns),
+		visibleRules
+	};
 }
-function handleProcess(options) {
+function buildGroupLine(selected, groups, columns) {
+	if (!selected) return renderPaddedLine("", "  ", "  ", columns);
+	const selectedIndex = groups.findIndex((group) => group.id === selected.group);
+	return renderPaddedLine(groups.map((_, index) => groups[(selectedIndex + index) % groups.length]).map((group, index) => {
+		const label = group.name.toUpperCase();
+		return index === 0 ? ansi(label, BOLD) : ansi(label, DIM);
+	}).join("  "), "  ", "  ", columns);
+}
+function buildFrame(entries, groups, searchText, severities, startIndex, columns) {
+	const visible = buildVisibleEntries(entries, severities, startIndex, columns);
+	const selected = visible.visibleRules[0];
+	const wrappedDescription = wrapPaddedText(selected?.description ?? "", "  ", "", columns);
+	const previewLines = renderPreviewSourceText(selected?.previewSourceText ?? "", selected?.previewDiagnostics ?? [], columns);
+	const previewMessages = renderPreviewMessages(selected?.previewDiagnostics ?? [], columns);
+	const previewSectionLines = [...previewLines, ...previewMessages];
+	const paddingLines = Array.from({ length: Math.max(MIN_PREVIEW_AND_MESSAGES_LINES - previewSectionLines.length, 0) }, () => "");
+	return [
+		CURSOR_HIDE + renderSelectedRuleDivider(selected, severities, columns),
+		...previewSectionLines,
+		...paddingLines,
+		CURSOR_TO_0 + renderDivider(columns),
+		CURSOR_TO_0 + buildGroupLine(selected, groups, columns),
+		CURSOR_TO_0 + visible.fullLine,
+		...wrappedDescription.map((line) => CURSOR_TO_0 + ansi(line, DIM)),
+		CURSOR_TO_0 + renderDivider(columns, getControlsLegend(searchText)),
+		""
+	];
+}
+function buildState(entries, groups, startIndex, searchText, severities) {
+	return gen(function* () {
+		const terminal = yield* Terminal;
+		const columns = Math.max(yield* terminal.columns, 1);
+		const filteredEntries = getFilteredEntries(entries, searchText);
+		const normalizedStartIndex = normalizeStartIndex(filteredEntries.length, startIndex);
+		return {
+			startIndex: normalizedStartIndex,
+			searchText,
+			severities,
+			renderedColumns: columns,
+			renderedLines: buildFrame(filteredEntries, groups, searchText, severities, normalizedStartIndex, columns)
+		};
+	});
+}
+function renderSubmission(state, entries) {
+	return succeed(CURSOR_TO_0 + JSON.stringify(Object.fromEntries(entries.flatMap((entry) => {
+		const severity = state.severities[entry.name];
+		return severity !== void 0 && severity !== entry.defaultSeverity ? [[entry.name, severity]] : [];
+	}))) + "\n");
+}
+function handleProcess(entries, groups) {
 	return (input, state) => {
-		const totalCount = options.rules.length;
+		const filteredEntries = getFilteredEntries(entries, state.searchText);
 		switch (input.key.name) {
-			case "k":
-			case "up": return processCursorUp(state, totalCount);
-			case "j":
-			case "down": return processCursorDown(state, totalCount);
-			case "left": return processSeverityChange(state, options, "left");
-			case "right": return processSeverityChange(state, options, "right");
+			case "backspace": return buildState(entries, groups, 0, state.searchText.slice(0, -1), state.severities).pipe(map$2((nextState) => Action.NextFrame({ state: nextState })));
+			case "left":
+				if (filteredEntries.length === 0) return succeed(Action.Beep());
+				return buildState(entries, groups, state.startIndex - 1, state.searchText, state.severities).pipe(map$2((nextState) => Action.NextFrame({ state: nextState })));
+			case "right":
+				if (filteredEntries.length === 0) return succeed(Action.Beep());
+				return buildState(entries, groups, state.startIndex + 1, state.searchText, state.severities).pipe(map$2((nextState) => Action.NextFrame({ state: nextState })));
+			case "up":
+			case "down":
+				if (filteredEntries.length === 0) return succeed(Action.Beep());
+				return buildState(entries, groups, state.startIndex, state.searchText, {
+					...state.severities,
+					[filteredEntries[state.startIndex].name]: cycleSeverity(state.severities[filteredEntries[state.startIndex].name] ?? filteredEntries[state.startIndex].defaultSeverity, input.key.name === "up" ? "left" : "right")
+				}).pipe(map$2((nextState) => Action.NextFrame({ state: nextState })));
 			case "enter":
-			case "return": return succeed(Action.Submit({ value: state.severities }));
-			default: return succeed(Action.Beep());
+			case "return": return succeed(Action.Submit({ value: Object.fromEntries(entries.flatMap((entry) => {
+				const severity = state.severities[entry.name];
+				return severity !== void 0 && severity !== entry.defaultSeverity ? [[entry.name, severity]] : [];
+			})) }));
+			default:
+				if (!isPrintableInput(input)) return succeed(Action.Beep());
+				return buildState(entries, groups, 0, state.searchText + input.input, state.severities).pipe(map$2((nextState) => Action.NextFrame({ state: nextState })));
 		}
 	};
 }
-function handleClear(options) {
-	return gen(function* () {
-		const columns = yield* (yield* Terminal).columns;
-		const visibleCount = Math.min(options.rules.length, options.maxPerPage);
-		return eraseText("\n".repeat(visibleCount + 2) + options.message, columns) + ERASE_LINE + CURSOR_LEFT;
-	});
-}
-function handleRender(options) {
-	return (state, action) => Action.$match(action, {
-		Beep: () => succeed(BEEP),
-		NextFrame: ({ state }) => renderNextFrame(state, options),
-		Submit: () => renderSubmission(state, options)
-	});
+function getPromptEntries(rules) {
+	return rules.map((rule) => ({
+		name: rule.name,
+		group: rule.group,
+		description: rule.description,
+		previewSourceText: rule.preview.sourceText,
+		previewDiagnostics: rule.preview.diagnostics,
+		defaultSeverity: rule.defaultSeverity
+	}));
 }
 function createRulePrompt(rules, initialSeverities) {
-	const options = {
-		message: "Configure Rule Severities",
-		rules,
-		maxPerPage: 10
-	};
-	return custom({
-		index: 0,
-		severities: initialSeverities
-	}, {
-		render: handleRender(options),
-		process: handleProcess(options),
-		clear: () => handleClear(options)
+	const entries = getPromptEntries(rules);
+	const groups = diagnosticGroups;
+	return custom(buildState(entries, groups, 0, "", initialSeverities), {
+		render: (state, action) => {
+			switch (action._tag) {
+				case "Beep": return succeed(BEEP);
+				case "NextFrame": return succeed(action.state.renderedLines.join("\n"));
+				case "Submit": return renderSubmission(state, entries);
+			}
+		},
+		process: handleProcess(entries, groups),
+		clear: (state) => gen(function* () {
+			const columns = yield* (yield* Terminal).columns;
+			return eraseRenderedLines(state.renderedLines, columns);
+		})
 	});
 }
 
@@ -196988,16 +197776,17 @@ const gatherTargetState = (assessment, context) => gen(function* () {
 		editors: []
 	};
 	const diagnosticSeverities = (yield* select({
-		message: "Would you like to customize the diagnostic severities?",
+		message: "Would you like to customize the diagnostics that the language service will provide?",
 		choices: [{
 			title: "Yes",
-			description: "Review the available rules and adjust their severities",
+			description: "Manually review and select which diagnostics to enable",
 			value: true,
 			selected: true
 		}, {
 			title: "No",
-			description: "Keep the default severities shipped by @effect/tsgo",
-			value: false
+			description: "Keep the defaults provided by the language service",
+			value: false,
+			selected: false
 		}]
 	})) ? some(yield* createRulePrompt(getAllRules(), getOrElse$1(assessment.tsconfig.currentDiagnosticSeverities, () => ({})))) : none$3();
 	const hasVscodeSettings = isSome(assessment.vscodeSettings);