@effect/language-service 0.80.0 → 0.82.0

package/cli.js

@@ -25719,7 +25719,7 @@ var runWith2 = (command, config) => {
 // package.json
 var package_default = {
   name: "@effect/language-service",
-  version: "0.80.0",
+  version: "0.82.0",
   publishConfig: {
     access: "public",
     directory: "dist"
@@ -31800,6 +31800,7 @@ var anyUnknownInErrorContext = createDiagnostic({
   name: "anyUnknownInErrorContext",
   code: 28,
   description: "Detects 'any' or 'unknown' types in Effect error or requirements channels",
+  group: "correctness",
   severity: "off",
   fixable: false,
   supportedEffect: ["v3", "v4"],
@@ -31905,6 +31906,7 @@ var catchAllToMapError = createDiagnostic({
   name: "catchAllToMapError",
   code: 39,
   description: "Suggests using Effect.mapError instead of Effect.catchAll when the callback only wraps the error with Effect.fail",
+  group: "style",
   severity: "suggestion",
   fixable: true,
   supportedEffect: ["v3", "v4"],
@@ -32004,6 +32006,7 @@ var catchUnfailableEffect = createDiagnostic({
   name: "catchUnfailableEffect",
   code: 2,
   description: "Warns when using error handling on Effects that never fail (error type is 'never')",
+  group: "antipattern",
   severity: "suggestion",
   fixable: false,
   supportedEffect: ["v3", "v4"],
@@ -32055,6 +32058,7 @@ var classSelfMismatch = createDiagnostic({
   name: "classSelfMismatch",
   code: 20,
   description: "Ensures Self type parameter matches the class name in Service/Tag/Schema classes",
+  group: "correctness",
   severity: "error",
   fixable: true,
   supportedEffect: ["v3", "v4"],
@@ -32072,6 +32076,7 @@ var classSelfMismatch = createDiagnostic({
       if (ts.isClassDeclaration(node) && node.name && node.heritageClauses) {
         const result3 = yield* pipe(
           typeParser.extendsEffectService(node),
+          orElse5(() => typeParser.extendsServiceMapService(node)),
           orElse5(() => typeParser.extendsContextTag(node)),
           orElse5(() => typeParser.extendsEffectTag(node)),
           orElse5(() => typeParser.extendsSchemaClass(node)),
@@ -32195,6 +32200,7 @@ var deterministicKeys = createDiagnostic({
   name: "deterministicKeys",
   code: 25,
   description: "Enforces deterministic naming for service/tag/error identifiers based on class names",
+  group: "style",
   severity: "off",
   fixable: true,
   supportedEffect: ["v3", "v4"],
@@ -32314,6 +32320,7 @@ var duplicatePackage = createDiagnostic({
   name: "duplicatePackage",
   code: 6,
   description: "Detects when multiple versions of the same Effect package are loaded",
+  group: "correctness",
   severity: "warning",
   fixable: false,
   supportedEffect: ["v3", "v4"],
@@ -32345,6 +32352,7 @@ var effectFnIife = createDiagnostic({
   name: "effectFnIife",
   code: 46,
   description: "Effect.fn or Effect.fnUntraced is called as an IIFE (Immediately Invoked Function Expression). Use Effect.gen instead.",
+  group: "antipattern",
   severity: "warning",
   fixable: true,
   supportedEffect: ["v3", "v4"],
@@ -32444,11 +32452,95 @@ var effectFnIife = createDiagnostic({
   })
 });
 
+// src/diagnostics/effectFnImplicitAny.ts
+var getParameterName = (typescript, name) => {
+  if (typescript.isIdentifier(name)) {
+    return typescript.idText(name);
+  }
+  return "parameter";
+};
+var hasOuterContextualFunctionType = (typescript, typeChecker, node) => {
+  const contextualType = typeChecker.getContextualType(node);
+  if (!contextualType) {
+    return false;
+  }
+  return typeChecker.getSignaturesOfType(contextualType, typescript.SignatureKind.Call).length > 0;
+};
+var effectFnImplicitAny = createDiagnostic({
+  name: "effectFnImplicitAny",
+  code: 54,
+  description: "Mirrors noImplicitAny for unannotated Effect.fn and Effect.fnUntraced callback parameters when no outer contextual function type exists",
+  group: "correctness",
+  severity: "error",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
+  apply: fn3("effectFnImplicitAny.apply")(function* (sourceFile, report) {
+    const ts = yield* service2(TypeScriptApi);
+    const program = yield* service2(TypeScriptProgram);
+    const typeChecker = yield* service2(TypeCheckerApi);
+    const typeParser = yield* service2(TypeParser);
+    const noImplicitAny = program.getCompilerOptions().noImplicitAny ?? program.getCompilerOptions().strict ?? false;
+    if (!noImplicitAny) {
+      return;
+    }
+    const nodeToVisit = [sourceFile];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.pop();
+      ts.forEachChild(node, appendNodeToVisit);
+      const parsed = yield* pipe(
+        typeParser.effectFn(node),
+        map12((result3) => ({
+          call: result3.node,
+          fn: result3.regularFunction
+        })),
+        orElse5(
+          () => pipe(
+            typeParser.effectFnGen(node),
+            map12((result3) => ({
+              call: result3.node,
+              fn: result3.generatorFunction
+            }))
+          )
+        ),
+        orElse5(
+          () => pipe(
+            typeParser.effectFnUntracedGen(node),
+            map12((result3) => ({
+              call: result3.node,
+              fn: result3.generatorFunction
+            }))
+          )
+        ),
+        orUndefined
+      );
+      if (!parsed || hasOuterContextualFunctionType(ts, typeChecker, parsed.call)) {
+        continue;
+      }
+      for (const parameter of parsed.fn.parameters) {
+        if (parameter.type || parameter.initializer) {
+          continue;
+        }
+        const parameterName = getParameterName(ts, parameter.name);
+        report({
+          location: parameter.name,
+          messageText: `Parameter '${parameterName}' implicitly has an 'any' type in Effect.fn/Effect.fnUntraced. Add an explicit type annotation or provide a contextual function type.`,
+          fixes: []
+        });
+      }
+    }
+  })
+});
+
 // src/diagnostics/effectFnOpportunity.ts
 var effectFnOpportunity = createDiagnostic({
   name: "effectFnOpportunity",
   code: 41,
   description: "Suggests using Effect.fn for functions that returns an Effect",
+  group: "style",
   severity: "suggestion",
   fixable: true,
   supportedEffect: ["v3", "v4"],
@@ -33043,6 +33135,7 @@ var effectGenUsesAdapter = createDiagnostic({
   name: "effectGenUsesAdapter",
   code: 23,
   description: "Warns when using the deprecated adapter parameter in Effect.gen",
+  group: "antipattern",
   severity: "warning",
   fixable: false,
   supportedEffect: ["v3", "v4"],
@@ -33083,6 +33176,7 @@ var effectInFailure = createDiagnostic({
   name: "effectInFailure",
   code: 49,
   description: "Warns when an Effect is used inside an Effect failure channel",
+  group: "antipattern",
   severity: "warning",
   fixable: false,
   supportedEffect: ["v3", "v4"],
@@ -33149,6 +33243,7 @@ var effectInVoidSuccess = createDiagnostic({
   name: "effectInVoidSuccess",
   code: 14,
   description: "Detects nested Effects in void success channels that may cause unexecuted effects",
+  group: "antipattern",
   severity: "warning",
   fixable: false,
   supportedEffect: ["v3", "v4"],
@@ -33200,6 +33295,7 @@ var effectMapVoid = createDiagnostic({
   name: "effectMapVoid",
   code: 40,
   description: "Suggests using Effect.asVoid instead of Effect.map(() => void 0), Effect.map(() => undefined), or Effect.map(() => {})",
+  group: "style",
   severity: "suggestion",
   fixable: true,
   supportedEffect: ["v3", "v4"],
@@ -33266,6 +33362,7 @@ var effectSucceedWithVoid = createDiagnostic({
   name: "effectSucceedWithVoid",
   code: 47,
   description: "Suggests using Effect.void instead of Effect.succeed(undefined) or Effect.succeed(void 0)",
+  group: "style",
   severity: "suggestion",
   fixable: true,
   supportedEffect: ["v3", "v4"],
@@ -33319,6 +33416,7 @@ var extendsNativeError = createDiagnostic({
   name: "extendsNativeError",
   code: 50,
   description: "Warns when a class directly extends the native Error class",
+  group: "effectNative",
   severity: "off",
   fixable: false,
   supportedEffect: ["v3", "v4"],
@@ -33371,6 +33469,7 @@ var floatingEffect = createDiagnostic({
   name: "floatingEffect",
   code: 3,
   description: "Ensures Effects are yielded or assigned to variables, not left floating",
+  group: "correctness",
   severity: "error",
   fixable: false,
   supportedEffect: ["v3", "v4"],
@@ -33424,6 +33523,7 @@ var genericEffectServices = createDiagnostic({
   name: "genericEffectServices",
   code: 10,
   description: "Prevents services with type parameters that cannot be discriminated at runtime",
+  group: "correctness",
   severity: "warning",
   fixable: false,
   supportedEffect: ["v3", "v4"],
@@ -33473,6 +33573,7 @@ var globalErrorInEffectCatch = createDiagnostic({
   name: "globalErrorInEffectCatch",
   code: 36,
   description: "Warns when catch callbacks return global Error type instead of typed errors",
+  group: "antipattern",
   severity: "warning",
   fixable: false,
   supportedEffect: ["v3", "v4"],
@@ -33535,6 +33636,7 @@ var globalErrorInEffectFailure = createDiagnostic({
   name: "globalErrorInEffectFailure",
   code: 35,
   description: "Warns when the global Error type is used in an Effect failure channel",
+  group: "antipattern",
   severity: "warning",
   fixable: false,
   supportedEffect: ["v3", "v4"],
@@ -33585,11 +33687,54 @@ var globalErrorInEffectFailure = createDiagnostic({
   })
 });
 
+// src/diagnostics/globalFetch.ts
+var globalFetch = createDiagnostic({
+  name: "globalFetch",
+  code: 53,
+  description: "Warns when using the global fetch function instead of the Effect HTTP client",
+  group: "effectNative",
+  severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
+  apply: fn3("globalFetch.apply")(function* (sourceFile, report) {
+    const ts = yield* service2(TypeScriptApi);
+    const typeChecker = yield* service2(TypeCheckerApi);
+    const typeParser = yield* service2(TypeParser);
+    const fetchSymbol = typeChecker.resolveName("fetch", void 0, ts.SymbolFlags.Value, false);
+    if (!fetchSymbol) return;
+    const effectVersion = typeParser.supportedEffect();
+    const packageName = effectVersion === "v3" ? "@effect/platform" : "effect/unstable/http";
+    const messageText = `Prefer using HttpClient from ${packageName} instead of the global 'fetch' function.`;
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      if (ts.isCallExpression(node)) {
+        const symbol4 = typeChecker.getSymbolAtLocation(node.expression);
+        const resolvedSymbol = symbol4 && symbol4.flags & ts.SymbolFlags.Alias ? typeChecker.getAliasedSymbol(symbol4) : symbol4;
+        if (resolvedSymbol === fetchSymbol) {
+          report({
+            location: node.expression,
+            messageText,
+            fixes: []
+          });
+        }
+      }
+      ts.forEachChild(node, appendNodeToVisit);
+    }
+  })
+});
+
 // src/diagnostics/importFromBarrel.ts
 var importFromBarrel = createDiagnostic({
   name: "importFromBarrel",
   code: 12,
   description: "Suggests importing from specific module paths instead of barrel exports",
+  group: "style",
   severity: "off",
   fixable: true,
   supportedEffect: ["v3", "v4"],
@@ -33732,6 +33877,7 @@ var instanceOfSchema = createDiagnostic({
   name: "instanceOfSchema",
   code: 45,
   description: "Suggests using Schema.is instead of instanceof for Effect Schema types",
+  group: "effectNative",
   severity: "off",
   fixable: true,
   supportedEffect: ["v3", "v4"],
@@ -33797,6 +33943,7 @@ var layerMergeAllWithDependencies = createDiagnostic({
   name: "layerMergeAllWithDependencies",
   code: 37,
   description: "Detects interdependencies in Layer.mergeAll calls where one layer provides a service that another layer requires",
+  group: "antipattern",
   severity: "warning",
   fixable: true,
   supportedEffect: ["v3", "v4"],
@@ -33912,6 +34059,7 @@ var leakingRequirements = createDiagnostic({
   name: "leakingRequirements",
   code: 8,
   description: "Detects implementation services leaked in service methods",
+  group: "antipattern",
   severity: "suggestion",
   fixable: false,
   supportedEffect: ["v3", "v4"],
@@ -33921,6 +34069,24 @@ var leakingRequirements = createDiagnostic({
     const typeCheckerUtils = yield* service2(TypeCheckerUtils);
     const typeParser = yield* service2(TypeParser);
     const tsUtils = yield* service2(TypeScriptUtils);
+    const isExpectedLeakingServiceSuppressed = (leakedServiceName, startNode) => {
+      const sourceFile2 = tsUtils.getSourceFileOfNode(startNode);
+      if (!sourceFile2) return false;
+      return !!ts.findAncestor(startNode, (current) => {
+        const ranges = ts.getLeadingCommentRanges(sourceFile2.text, current.pos) ?? [];
+        const isSuppressed = ranges.some((range2) => {
+          const commentText = sourceFile2.text.slice(range2.pos, range2.end);
+          return commentText.split("\n").filter((line) => line.includes("@effect-expect-leaking")).some((line) => {
+            const markerIndex = line.indexOf("@effect-expect-leaking");
+            return markerIndex !== -1 && line.slice(markerIndex + "@effect-expect-leaking".length).includes(leakedServiceName);
+          });
+        });
+        if (isSuppressed) {
+          return true;
+        }
+        return ts.isClassDeclaration(current) || ts.isVariableStatement(current) || ts.isExpressionStatement(current) || ts.isStatement(current) ? "quit" : false;
+      });
+    };
     const parseLeakedRequirements = cachedBy(
       fn3("leakingServices.checkServiceLeaking")(
         function* (service3, atLocation) {
@@ -34002,8 +34168,12 @@ var leakingRequirements = createDiagnostic({
       (_, service3) => service3
     );
     function reportLeakingRequirements(node, requirements) {
-      if (requirements.length === 0) return;
-      const requirementsStr = requirements.map((_) => typeChecker.typeToString(_)).join(" | ");
+      const filteredRequirements = requirements.filter(
+        (requirement) => !isExpectedLeakingServiceSuppressed(typeChecker.typeToString(requirement), node)
+      );
+      if (filteredRequirements.length === 0) return;
+      const requirementsStr = filteredRequirements.map((_) => typeChecker.typeToString(_)).join(" | ");
+      const firstStr = typeChecker.typeToString(filteredRequirements[0]);
       report({
         location: node,
         messageText: `Methods of this Service require \`${requirementsStr}\` from every caller.
@@ -34012,7 +34182,7 @@ This leaks implementation details into the service's public type \u2014 callers
 
 Resolve these dependencies at Layer creation and provide them to each method, so the service's type reflects its purpose, not its implementation.
 
-To suppress this diagnostic for specific dependency types that are intentionally passed through (e.g., HttpServerRequest), add \`@effect-leakable-service\` JSDoc to their interface declarations (e.g., the \`${typeChecker.typeToString(requirements[0])}\` interface), not to this service.
+To suppress this diagnostic for specific dependency types that are intentionally passed through (e.g., HttpServerRequest), add \`@effect-leakable-service\` JSDoc to their interface declarations (e.g., the \`${firstStr}\` interface), or to this service by adding a \`@effect-expect-leaking ${firstStr}\` JSDoc.
 
 More info and examples at https://effect.website/docs/requirements-management/layers/#avoiding-requirement-leakage`,
         fixes: []
@@ -34068,6 +34238,7 @@ var missedPipeableOpportunity = createDiagnostic({
   name: "missedPipeableOpportunity",
   code: 26,
   description: "Enforces the use of pipeable style for nested function calls",
+  group: "style",
   severity: "off",
   fixable: true,
   supportedEffect: ["v3", "v4"],
@@ -34250,6 +34421,7 @@ var missingEffectContext = createDiagnostic({
   name: "missingEffectContext",
   code: 1,
   description: "Reports missing service requirements in Effect context channel",
+  group: "correctness",
   severity: "error",
   fixable: false,
   supportedEffect: ["v3", "v4"],
@@ -34301,6 +34473,7 @@ var missingEffectError = createDiagnostic({
   name: "missingEffectError",
   code: 1,
   description: "Reports missing error types in Effect error channel",
+  group: "correctness",
   severity: "error",
   fixable: true,
   supportedEffect: ["v3", "v4"],
@@ -34444,6 +34617,7 @@ var missingEffectServiceDependency = createDiagnostic({
   name: "missingEffectServiceDependency",
   code: 22,
   description: "Checks that Effect.Service dependencies satisfy all required layer inputs",
+  group: "style",
   severity: "off",
   fixable: false,
   supportedEffect: ["v3"],
@@ -34540,6 +34714,7 @@ var missingLayerContext = createDiagnostic({
   name: "missingLayerContext",
   code: 38,
   description: "Reports missing service requirements in Layer context channel",
+  group: "correctness",
   severity: "error",
   fixable: false,
   supportedEffect: ["v3", "v4"],
@@ -34591,6 +34766,7 @@ var missingReturnYieldStar = createDiagnostic({
   name: "missingReturnYieldStar",
   code: 7,
   description: "Suggests using 'return yield*' for Effects with never success for better type narrowing",
+  group: "correctness",
   severity: "error",
   fixable: true,
   supportedEffect: ["v3", "v4"],
@@ -34643,6 +34819,7 @@ var missingStarInYieldEffectGen = createDiagnostic({
   name: "missingStarInYieldEffectGen",
   code: 4,
   description: "Enforces using 'yield*' instead of 'yield' when yielding Effects in generators",
+  group: "correctness",
   severity: "error",
   fixable: true,
   supportedEffect: ["v3", "v4"],
@@ -34720,6 +34897,7 @@ var multipleEffectProvide = createDiagnostic({
   name: "multipleEffectProvide",
   code: 18,
   description: "Warns against chaining Effect.provide calls which can cause service lifecycle issues",
+  group: "antipattern",
   severity: "warning",
   fixable: true,
   supportedEffect: ["v3", "v4"],
@@ -34822,7 +35000,11 @@ var moduleAlternativesV3 = /* @__PURE__ */ new Map([
   ["path/win32", { alternative: "Path", module: "path", package: "@effect/platform" }],
   ["node:path/win32", { alternative: "Path", module: "path", package: "@effect/platform" }],
   ["child_process", { alternative: "CommandExecutor", module: "child_process", package: "@effect/platform" }],
-  ["node:child_process", { alternative: "CommandExecutor", module: "child_process", package: "@effect/platform" }]
+  ["node:child_process", { alternative: "CommandExecutor", module: "child_process", package: "@effect/platform" }],
+  ["http", { alternative: "HttpClient", module: "http", package: "@effect/platform" }],
+  ["node:http", { alternative: "HttpClient", module: "http", package: "@effect/platform" }],
+  ["https", { alternative: "HttpClient", module: "https", package: "@effect/platform" }],
+  ["node:https", { alternative: "HttpClient", module: "https", package: "@effect/platform" }]
 ]);
 var moduleAlternativesV4 = /* @__PURE__ */ new Map([
   ["fs", { alternative: "FileSystem", module: "fs", package: "effect" }],
@@ -34836,12 +35018,17 @@ var moduleAlternativesV4 = /* @__PURE__ */ new Map([
   ["path/win32", { alternative: "Path", module: "path", package: "effect" }],
   ["node:path/win32", { alternative: "Path", module: "path", package: "effect" }],
   ["child_process", { alternative: "ChildProcess", module: "child_process", package: "effect" }],
-  ["node:child_process", { alternative: "ChildProcess", module: "child_process", package: "effect" }]
+  ["node:child_process", { alternative: "ChildProcess", module: "child_process", package: "effect" }],
+  ["http", { alternative: "HttpClient", module: "http", package: "effect/unstable/http" }],
+  ["node:http", { alternative: "HttpClient", module: "http", package: "effect/unstable/http" }],
+  ["https", { alternative: "HttpClient", module: "https", package: "effect/unstable/http" }],
+  ["node:https", { alternative: "HttpClient", module: "https", package: "effect/unstable/http" }]
 ]);
 var nodeBuiltinImport = createDiagnostic({
   name: "nodeBuiltinImport",
   code: 52,
   description: "Warns when importing Node.js built-in modules that have Effect-native counterparts",
+  group: "effectNative",
   severity: "off",
   fixable: false,
   supportedEffect: ["v3", "v4"],
@@ -34885,6 +35072,7 @@ var nonObjectEffectServiceType = createDiagnostic({
   name: "nonObjectEffectServiceType",
   code: 24,
   description: "Ensures Effect.Service types are objects, not primitives",
+  group: "correctness",
   severity: "error",
   fixable: false,
   supportedEffect: ["v3"],
@@ -35669,6 +35857,7 @@ var outdatedApi = createDiagnostic({
   name: "outdatedApi",
   code: 48,
   description: "Detects usage of APIs that have been removed or renamed in Effect v4",
+  group: "correctness",
   severity: "warning",
   fixable: false,
   supportedEffect: ["v4"],
@@ -35738,6 +35927,7 @@ var outdatedEffectCodegen = createDiagnostic({
   name: "outdatedEffectCodegen",
   code: 19,
   description: "Detects when generated code is outdated and needs to be regenerated",
+  group: "correctness",
   severity: "warning",
   fixable: true,
   supportedEffect: ["v3", "v4"],
@@ -35786,6 +35976,7 @@ var overriddenSchemaConstructor = createDiagnostic({
   name: "overriddenSchemaConstructor",
   code: 30,
   description: "Prevents overriding constructors in Schema classes which breaks decoding behavior",
+  group: "correctness",
   severity: "error",
   fixable: true,
   supportedEffect: ["v3", "v4"],
@@ -35925,6 +36116,7 @@ var preferSchemaOverJson = createDiagnostic({
   name: "preferSchemaOverJson",
   code: 44,
   description: "Suggests using Effect Schema for JSON operations instead of JSON.parse/JSON.stringify which may throw",
+  group: "effectNative",
   severity: "suggestion",
   fixable: false,
   supportedEffect: ["v3", "v4"],
@@ -36037,6 +36229,7 @@ var redundantSchemaTagIdentifier = createDiagnostic({
   name: "redundantSchemaTagIdentifier",
   code: 42,
   description: "Suggests removing redundant identifier argument when it equals the tag value in Schema.TaggedClass/TaggedError/TaggedRequest",
+  group: "style",
   severity: "suggestion",
   fixable: true,
   supportedEffect: ["v3", "v4"],
@@ -36089,6 +36282,7 @@ var returnEffectInGen = createDiagnostic({
   name: "returnEffectInGen",
   code: 11,
   description: "Warns when returning an Effect in a generator causes nested Effect<Effect<...>>",
+  group: "antipattern",
   severity: "suggestion",
   fixable: true,
   supportedEffect: ["v3", "v4"],
@@ -36160,6 +36354,7 @@ var runEffectInsideEffect = createDiagnostic({
   name: "runEffectInsideEffect",
   code: 32,
   description: "Suggests using Runtime methods instead of Effect.run* inside Effect contexts",
+  group: "antipattern",
   severity: "suggestion",
   fixable: true,
   supportedEffect: ["v3"],
@@ -36286,6 +36481,7 @@ var schemaStructWithTag = createDiagnostic({
   name: "schemaStructWithTag",
   code: 34,
   description: "Suggests using Schema.TaggedStruct instead of Schema.Struct with _tag field",
+  group: "style",
   severity: "suggestion",
   fixable: true,
   supportedEffect: ["v3", "v4"],
@@ -36380,9 +36576,10 @@ var schemaSyncInEffect = createDiagnostic({
   name: "schemaSyncInEffect",
   code: 43,
   description: "Suggests using Effect-based Schema methods instead of sync methods inside Effect generators",
+  group: "antipattern",
   severity: "suggestion",
   fixable: false,
-  supportedEffect: ["v3", "v4"],
+  supportedEffect: ["v3"],
   apply: fn3("schemaSyncInEffect.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
@@ -36431,6 +36628,7 @@ var schemaUnionOfLiterals = createDiagnostic({
   name: "schemaUnionOfLiterals",
   code: 33,
   description: "Simplifies Schema.Union of multiple Schema.Literal calls into single Schema.Literal",
+  group: "style",
   severity: "off",
   fixable: true,
   supportedEffect: ["v3"],
@@ -36508,6 +36706,7 @@ var scopeInLayerEffect = createDiagnostic({
   name: "scopeInLayerEffect",
   code: 13,
   description: "Suggests using Layer.scoped instead of Layer.effect when Scope is in requirements",
+  group: "antipattern",
   severity: "warning",
   fixable: true,
   supportedEffect: ["v3"],
@@ -36605,6 +36804,7 @@ var serviceNotAsClass = createDiagnostic({
   name: "serviceNotAsClass",
   code: 51,
   description: "Warns when ServiceMap.Service is used as a variable instead of a class declaration",
+  group: "style",
   severity: "off",
   fixable: true,
   supportedEffect: ["v4"],
@@ -36682,6 +36882,7 @@ var strictBooleanExpressions = createDiagnostic({
   name: "strictBooleanExpressions",
   code: 17,
   description: "Enforces boolean types in conditional expressions for type safety",
+  group: "style",
   severity: "off",
   fixable: false,
   supportedEffect: ["v3", "v4"],
@@ -36755,6 +36956,7 @@ var strictEffectProvide = createDiagnostic({
   name: "strictEffectProvide",
   code: 27,
   description: "Warns when using Effect.provide with layers outside of application entry points",
+  group: "antipattern",
   severity: "off",
   fixable: false,
   supportedEffect: ["v3", "v4"],
@@ -36808,6 +37010,7 @@ var tryCatchInEffectGen = createDiagnostic({
   name: "tryCatchInEffectGen",
   code: 15,
   description: "Discourages try/catch in Effect generators in favor of Effect error handling",
+  group: "antipattern",
   severity: "suggestion",
   fixable: false,
   supportedEffect: ["v3", "v4"],
@@ -36867,6 +37070,7 @@ var unknownInEffectCatch = createDiagnostic({
   name: "unknownInEffectCatch",
   code: 31,
   description: "Warns when catch callbacks return unknown instead of typed errors",
+  group: "antipattern",
   severity: "warning",
   fixable: false,
   supportedEffect: ["v3", "v4"],
@@ -36930,6 +37134,7 @@ var unnecessaryEffectGen = createDiagnostic({
   name: "unnecessaryEffectGen",
   code: 5,
   description: "Suggests removing Effect.gen when it contains only a single return statement",
+  group: "style",
   severity: "suggestion",
   fixable: true,
   supportedEffect: ["v3", "v4"],
@@ -36976,6 +37181,7 @@ var unnecessaryFailYieldableError = createDiagnostic({
   name: "unnecessaryFailYieldableError",
   code: 29,
   description: "Suggests yielding yieldable errors directly instead of wrapping with Effect.fail",
+  group: "style",
   severity: "suggestion",
   fixable: true,
   supportedEffect: ["v3", "v4"],
@@ -37037,6 +37243,7 @@ var unnecessaryPipe = createDiagnostic({
   name: "unnecessaryPipe",
   code: 9,
   description: "Removes pipe calls with no arguments",
+  group: "style",
   severity: "suggestion",
   fixable: true,
   supportedEffect: ["v3", "v4"],
@@ -37085,6 +37292,7 @@ var unnecessaryPipeChain = createDiagnostic({
   name: "unnecessaryPipeChain",
   code: 16,
   description: "Simplifies chained pipe calls into a single pipe call",
+  group: "style",
   severity: "suggestion",
   fixable: true,
   supportedEffect: ["v3", "v4"],
@@ -37162,6 +37370,7 @@ var unsupportedServiceAccessors = createDiagnostic({
   name: "unsupportedServiceAccessors",
   code: 21,
   description: "Warns about service accessors that need codegen due to generic/complex signatures",
+  group: "correctness",
   severity: "warning",
   fixable: true,
   supportedEffect: ["v3", "v4"],
@@ -37225,6 +37434,7 @@ var diagnostics = [
   catchUnfailableEffect,
   classSelfMismatch,
   duplicatePackage,
+  effectFnImplicitAny,
   effectGenUsesAdapter,
   missingEffectContext,
   missingEffectError,
@@ -37239,6 +37449,7 @@ var diagnostics = [
   leakingRequirements,
   unnecessaryPipe,
   genericEffectServices,
+  globalFetch,
   returnEffectInGen,
   tryCatchInEffectGen,
   importFromBarrel,
@@ -37307,6 +37518,8 @@ var formatDiagnosticForJson = (diagnostic, tsInstance) => {
   const diagnosticName = Object.values(diagnostics).find((_) => _.code === diagnostic.code)?.name ?? `effect(${diagnostic.code})`;
   return {
     file: diagnostic.file.fileName,
+    start: diagnostic.start,
+    length: diagnostic.length ?? 0,
     line: line + 1,
     column: character + 1,
     endLine: endLine + 1,
@@ -38201,13 +38414,6 @@ var GREEN = "\x1B[0;32m";
 var YELLOW = "\x1B[0;33m";
 var BLUE = "\x1B[0;34m";
 var CYAN = "\x1B[0;36m";
-var WHITE = "\x1B[0;37m";
-var CYAN_BRIGHT = "\x1B[0;96m";
-var BG_BLACK_BRIGHT = "\x1B[0;100m";
-var BG_RED = "\x1B[41m";
-var BG_YELLOW = "\x1B[43m";
-var BG_BLUE = "\x1B[0;44m";
-var BG_CYAN = "\x1B[0;46m";
 var ansi = (text2, code) => `${code}${text2}${RESET}`;
 var ERASE_LINE = "\x1B[2K";
 var CURSOR_LEFT = "\r";
@@ -38215,6 +38421,11 @@ var CURSOR_HIDE = "\x1B[?25l";
 var CURSOR_SHOW = "\x1B[?25h";
 var CURSOR_TO_0 = "\x1B[G";
 var BEEP = "\x07";
+var ITALIC = "\x1B[0;3m";
+var UNDERLINE = "\x1B[0;4m";
+var ANSI_ESCAPE_REGEX = new RegExp(String.raw`\u001b\[[0-?]*[ -/]*[@-~]`, "g");
+var stripAnsi2 = (text2) => text2.replace(ANSI_ESCAPE_REGEX, "");
+var visibleLength = (text2) => stripAnsi2(text2).length;
 
 // src/cli/overview.ts
 var import_project_service3 = __toESM(require_dist3());
@@ -40178,9 +40389,100 @@ var computeTsConfigChanges = (current, target, lspVersion) => {
     if (!rootObj) {
       return emptyFileChangesResult();
     }
+    const buildPluginObject = (severities) => {
+      const nameProperty = ts.factory.createPropertyAssignment(
+        ts.factory.createStringLiteral("name"),
+        ts.factory.createStringLiteral("@effect/language-service")
+      );
+      return match(severities, {
+        onNone: () => {
+          return ts.factory.createObjectLiteralExpression([nameProperty], false);
+        },
+        onSome: (sevs) => {
+          const severityProperties = Object.entries(sevs).map(
+            ([name, severity]) => ts.factory.createPropertyAssignment(
+              ts.factory.createStringLiteral(name),
+              ts.factory.createStringLiteral(severity)
+            )
+          );
+          const diagnosticSeverityProperty = ts.factory.createPropertyAssignment(
+            ts.factory.createStringLiteral("diagnosticSeverity"),
+            ts.factory.createObjectLiteralExpression(severityProperties, true)
+          );
+          return ts.factory.createObjectLiteralExpression(
+            [nameProperty, diagnosticSeverityProperty],
+            true
+          );
+        }
+      });
+    };
+    const schemaPropertyAssignment = ts.factory.createPropertyAssignment(
+      ts.factory.createStringLiteral("$schema"),
+      ts.factory.createStringLiteral(TSCONFIG_SCHEMA_URL)
+    );
     const compilerOptionsProperty = findPropertyInObject(ts, rootObj, "compilerOptions");
     if (!compilerOptionsProperty) {
-      return emptyFileChangesResult();
+      if (isNone2(lspVersion)) {
+        return emptyFileChangesResult();
+      }
+      const textChanges2 = ts.textChanges;
+      const host2 = createMinimalHost(ts);
+      const formatOptions2 = { indentSize: 2, tabSize: 2 };
+      const formatContext2 = ts.formatting.getFormatContext(formatOptions2, host2);
+      const preferences2 = {};
+      const fileChanges2 = textChanges2.ChangeTracker.with(
+        { host: host2, formatContext: formatContext2, preferences: preferences2 },
+        (tracker) => {
+          const schemaProperty = findPropertyInObject(ts, rootObj, "$schema");
+          const shouldAddSchema = !schemaProperty;
+          const shouldUpdateSchema = !!schemaProperty && (!ts.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 @effect/language-service plugin");
+          const compilerOptionsAssignment = ts.factory.createPropertyAssignment(
+            ts.factory.createStringLiteral("compilerOptions"),
+            ts.factory.createObjectLiteralExpression([
+              ts.factory.createPropertyAssignment(
+                ts.factory.createStringLiteral("plugins"),
+                ts.factory.createArrayLiteralExpression([buildPluginObject(target.diagnosticSeverities)], true)
+              )
+            ], true)
+          );
+          const nextProperties = rootObj.properties.flatMap((property) => {
+            if (schemaProperty && property === schemaProperty) {
+              return [schemaPropertyAssignment];
+            }
+            return [property];
+          });
+          if (shouldAddSchema) {
+            nextProperties.push(schemaPropertyAssignment);
+          }
+          nextProperties.push(compilerOptionsAssignment);
+          tracker.replaceNode(
+            current.sourceFile,
+            rootObj,
+            ts.factory.createObjectLiteralExpression(nextProperties, true)
+          );
+        }
+      );
+      const fileChange2 = fileChanges2.find((fc) => fc.fileName === current.path);
+      const changes2 = fileChange2 ? fileChange2.textChanges : [];
+      if (changes2.length === 0) {
+        return { codeActions: [], messages };
+      }
+      return {
+        codeActions: [{
+          description: descriptions.join("; "),
+          changes: [{
+            fileName: current.path,
+            textChanges: changes2
+          }]
+        }],
+        messages
+      };
     }
     if (!ts.isObjectLiteralExpression(compilerOptionsProperty.initializer)) {
       return emptyFileChangesResult();
@@ -40196,10 +40498,6 @@ var computeTsConfigChanges = (current, target, lspVersion) => {
       (tracker) => {
         const schemaProperty = findPropertyInObject(ts, rootObj, "$schema");
         const pluginsProperty = findPropertyInObject(ts, compilerOptions, "plugins");
-        const schemaPropertyAssignment = ts.factory.createPropertyAssignment(
-          ts.factory.createStringLiteral("$schema"),
-          ts.factory.createStringLiteral(TSCONFIG_SCHEMA_URL)
-        );
         if (isNone2(lspVersion)) {
           if (schemaProperty) {
             descriptions.push("Remove $schema from tsconfig");
@@ -40229,33 +40527,6 @@ var computeTsConfigChanges = (current, target, lspVersion) => {
             descriptions.push("Update $schema in tsconfig");
             tracker.replaceNode(current.sourceFile, schemaProperty.initializer, schemaPropertyAssignment.initializer);
           }
-          const buildPluginObject = (severities) => {
-            const nameProperty = ts.factory.createPropertyAssignment(
-              ts.factory.createStringLiteral("name"),
-              ts.factory.createStringLiteral("@effect/language-service")
-            );
-            return match(severities, {
-              onNone: () => {
-                return ts.factory.createObjectLiteralExpression([nameProperty], false);
-              },
-              onSome: (sevs) => {
-                const severityProperties = Object.entries(sevs).map(
-                  ([name, severity]) => ts.factory.createPropertyAssignment(
-                    ts.factory.createStringLiteral(name),
-                    ts.factory.createStringLiteral(severity)
-                  )
-                );
-                const diagnosticSeverityProperty = ts.factory.createPropertyAssignment(
-                  ts.factory.createStringLiteral("diagnosticSeverity"),
-                  ts.factory.createObjectLiteralExpression(severityProperties, true)
-                );
-                return ts.factory.createObjectLiteralExpression(
-                  [nameProperty, diagnosticSeverityProperty],
-                  true
-                );
-              }
-            });
-          };
           const pluginObject = buildPluginObject(target.diagnosticSeverities);
           if (!pluginsProperty) {
             descriptions.push("Add plugins array with @effect/language-service plugin");
@@ -40468,244 +40739,1677 @@ var FileReadError = class extends TaggedError2("FileReadError") {
   }
 };
 
-// src/cli/setup/diagnostic-info.ts
-function getAllDiagnostics() {
-  return diagnostics.map((diagnostic) => ({
-    name: diagnostic.name,
-    code: diagnostic.code,
-    defaultSeverity: diagnostic.severity,
-    description: diagnostic.description
-  }));
-}
-function cycleSeverity(current, direction) {
-  const order = ["off", "suggestion", "message", "warning", "error"];
-  const currentIndex = order.indexOf(current);
-  if (direction === "right") {
-    return order[(currentIndex + 1) % order.length];
-  } else {
-    return order[(currentIndex - 1 + order.length) % order.length];
-  }
-}
-var shortNames = {
-  off: "off",
-  suggestion: "sugg",
-  message: "info",
-  warning: "warn",
-  error: "err"
-};
-var MAX_SEVERITY_LENGTH = Object.values(shortNames).reduce((max2, name) => Math.max(max2, name.length), 0);
-function getSeverityShortName(severity) {
-  return shortNames[severity] ?? "???";
-}
-
-// src/cli/setup/diagnostic-prompt.ts
-function eraseLines2(count) {
-  let result3 = "";
-  for (let i = 0; i < count; i++) {
-    if (i > 0) result3 += "\x1B[1A";
-    result3 += ERASE_LINE;
-  }
-  if (count > 0) result3 += CURSOR_LEFT;
-  return result3;
-}
-var Action2 = taggedEnum();
-var NEWLINE_REGEX = /\r?\n/;
-function eraseText2(text2, columns) {
-  if (columns === 0) {
-    return ERASE_LINE + CURSOR_TO_0;
-  }
-  let rows = 0;
-  const lines2 = text2.split(/\r?\n/);
-  for (const line of lines2) {
-    rows += 1 + Math.floor(Math.max(line.length - 1, 0) / columns);
-  }
-  return eraseLines2(rows);
-}
-function entriesToDisplay2(cursor, total, maxVisible) {
-  const max2 = maxVisible === void 0 ? total : maxVisible;
-  let startIndex = Math.min(total - max2, cursor - Math.floor(max2 / 2));
-  if (startIndex < 0) {
-    startIndex = 0;
-  }
-  const endIndex = Math.min(startIndex + max2, total);
-  return { startIndex, endIndex };
-}
-var defaultFigures2 = {
-  arrowUp: "\u2191",
-  arrowDown: "\u2193",
-  tick: "\u2714",
-  pointerSmall: "\u203A"
-};
-var figuresValue = defaultFigures2;
-function getSeverityStyle(severity) {
-  const styles = {
-    off: WHITE + BG_BLACK_BRIGHT,
-    suggestion: WHITE + BG_CYAN,
-    message: WHITE + BG_BLUE,
-    warning: WHITE + BG_YELLOW,
-    error: WHITE + BG_RED
-  };
-  return styles[severity];
-}
-function renderOutput(leadingSymbol, trailingSymbol, options) {
-  const annotateLine2 = (line) => ansi(line, BOLD);
-  const prefix = leadingSymbol + " ";
-  return match3(options.message.split(NEWLINE_REGEX), {
-    onEmpty: () => `${prefix}${trailingSymbol}`,
-    onNonEmpty: (promptLines) => {
-      const lines2 = map4(promptLines, (line) => annotateLine2(line));
-      return `${prefix}${lines2.join("\n  ")} ${trailingSymbol} `;
-    }
-  });
-}
-function renderDiagnostics(state, options, figs, columns) {
-  const diagnostics3 = options.diagnostics;
-  const toDisplay = entriesToDisplay2(state.index, diagnostics3.length, options.maxPerPage);
-  const documents = [];
-  for (let index = toDisplay.startIndex; index < toDisplay.endIndex; index++) {
-    const diagnostic = diagnostics3[index];
-    const isHighlighted = state.index === index;
-    const currentSeverity = state.severities[diagnostic.name] ?? diagnostic.defaultSeverity;
-    const hasChanged = currentSeverity !== diagnostic.defaultSeverity;
-    let prefix = " ";
-    if (index === toDisplay.startIndex && toDisplay.startIndex > 0) {
-      prefix = figs.arrowUp;
-    } else if (index === toDisplay.endIndex - 1 && toDisplay.endIndex < diagnostics3.length) {
-      prefix = figs.arrowDown;
-    }
-    const shortName = getSeverityShortName(currentSeverity);
-    const paddedSeverity = shortName.padEnd(MAX_SEVERITY_LENGTH, " ");
-    const severityStr = ansi(` ${paddedSeverity} `, getSeverityStyle(currentSeverity));
-    const nameText = hasChanged ? `${diagnostic.name}*` : diagnostic.name;
-    const nameStr = isHighlighted ? ansi(nameText, CYAN_BRIGHT) : nameText;
-    const mainLine = `${prefix} ${severityStr} ${nameStr}`;
-    if (isHighlighted && diagnostic.description) {
-      const indentWidth = 1 + 1 + (MAX_SEVERITY_LENGTH + 2) + 1;
-      const indent = " ".repeat(indentWidth);
-      const availableWidth = columns - indentWidth;
-      const truncatedDescription = availableWidth > 0 && diagnostic.description.length > availableWidth ? diagnostic.description.substring(0, availableWidth - 1) + "\u2026" : diagnostic.description;
-      const descriptionStr = ansi(indent + truncatedDescription, DIM);
-      documents.push(mainLine + "\n" + descriptionStr);
-    } else {
-      documents.push(mainLine);
-    }
-  }
-  return documents.join("\n");
-}
-function renderNextFrame(state, options) {
-  return gen2(function* () {
-    const terminal = yield* Terminal;
-    const columns = yield* terminal.columns;
-    const figs = figuresValue;
-    const diagnosticsStr = renderDiagnostics(state, options, figs, columns);
-    const leadingSymbol = ansi("?", CYAN_BRIGHT);
-    const trailingSymbol = figs.pointerSmall;
-    const promptMsg = renderOutput(leadingSymbol, trailingSymbol, options);
-    const helpText = ansi(
-      "Use \u2191/\u2193 to navigate, \u2190/\u2192 to change severity, Enter to finish",
-      DIM
-    );
-    return CURSOR_HIDE + promptMsg + "\n" + helpText + "\n" + diagnosticsStr;
-  });
-}
-function renderSubmission(state, options) {
-  return gen2(function* () {
-    const figs = figuresValue;
-    const changedCount = Object.entries(state.severities).filter(([name, severity]) => {
-      const diagnostic = options.diagnostics.find((d) => d.name === name);
-      return diagnostic && severity !== diagnostic.defaultSeverity;
-    }).length;
-    const result3 = ansi(
-      `${changedCount} diagnostic${changedCount === 1 ? "" : "s"} configured`,
-      WHITE
-    );
-    const leadingSymbol = ansi(figs.tick, GREEN);
-    const trailingSymbol = "";
-    const promptMsg = renderOutput(leadingSymbol, trailingSymbol, options);
-    return promptMsg + " " + result3 + "\n";
-  });
-}
-function processCursorUp(state, totalCount) {
-  const newIndex = state.index === 0 ? totalCount - 1 : state.index - 1;
-  return succeed6(Action2.NextFrame({ state: { ...state, index: newIndex } }));
-}
-function processCursorDown(state, totalCount) {
-  const newIndex = (state.index + 1) % totalCount;
-  return succeed6(Action2.NextFrame({ state: { ...state, index: newIndex } }));
-}
-function processSeverityChange(state, options, direction) {
-  const diagnostic = options.diagnostics[state.index];
-  const currentSeverity = state.severities[diagnostic.name] ?? diagnostic.defaultSeverity;
-  const newSeverity = cycleSeverity(currentSeverity, direction);
-  return succeed6(Action2.NextFrame({
-    state: {
-      ...state,
-      severities: { ...state.severities, [diagnostic.name]: newSeverity }
+// src/metadata.json
+var metadata_default = {
+  groups: [
+    {
+      id: "correctness",
+      name: "Correctness",
+      description: "Wrong, unsafe, or structurally invalid code patterns."
+    },
+    {
+      id: "antipattern",
+      name: "Anti-pattern",
+      description: "Discouraged patterns that often lead to bugs or confusing behavior."
+    },
+    {
+      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."
     }
-  }));
-}
-function handleProcess(options) {
-  return (input, state) => {
-    const totalCount = options.diagnostics.length;
-    switch (input.key.name) {
-      case "k":
-      case "up": {
-        return processCursorUp(state, totalCount);
-      }
-      case "j":
-      case "down": {
-        return processCursorDown(state, totalCount);
+  ],
+  rules: [
+    {
+      name: "anyUnknownInErrorContext",
+      group: "correctness",
+      description: "Detects 'any' or 'unknown' types in Effect error or requirements channels",
+      defaultSeverity: "off",
+      fixable: false,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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)"
+          }
+        ]
       }
-      case "left": {
-        return processSeverityChange(state, options, "left");
+    },
+    {
+      name: "classSelfMismatch",
+      group: "correctness",
+      description: "Ensures Self type parameter matches the class name in Service/Tag/Schema classes",
+      defaultSeverity: "error",
+      fixable: true,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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)"
+          }
+        ]
       }
-      case "right": {
-        return processSeverityChange(state, options, "right");
+    },
+    {
+      name: "duplicatePackage",
+      group: "correctness",
+      description: "Detects when multiple versions of the same Effect package are loaded",
+      defaultSeverity: "warning",
+      fixable: false,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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: []
       }
-      case "enter":
-      case "return": {
-        return succeed6(Action2.Submit({ value: state.severities }));
+    },
+    {
+      name: "effectFnImplicitAny",
+      group: "correctness",
+      description: "Mirrors noImplicitAny for unannotated Effect.fn and Effect.fnUntraced callback parameters when no outer contextual function type exists",
+      defaultSeverity: "error",
+      fixable: false,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      preview: {
+        sourceText: 'import * as Effect from "effect/Effect"\n\nexport const preview = Effect.fn("preview")((input) => Effect.succeed(input))\n',
+        diagnostics: [
+          {
+            start: 86,
+            end: 91,
+            text: "Parameter 'input' implicitly has an 'any' type in Effect.fn/Effect.fnUntraced. Add an explicit type annotation or provide a contextual function type.    effect(effectFnImplicitAny)"
+          }
+        ]
       }
-      default: {
-        return succeed6(Action2.Beep());
+    },
+    {
+      name: "floatingEffect",
+      group: "correctness",
+      description: "Ensures Effects are yielded or assigned to variables, not left floating",
+      defaultSeverity: "error",
+      fixable: false,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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",
+      fixable: false,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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: "missingEffectContext",
+      group: "correctness",
+      description: "Reports missing service requirements in Effect context channel",
+      defaultSeverity: "error",
+      fixable: false,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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 'Db' in the expected Effect context.    effect(missingEffectContext)"
+          }
+        ]
+      }
+    },
+    {
+      name: "missingEffectError",
+      group: "correctness",
+      description: "Reports missing error types in Effect error channel",
+      defaultSeverity: "error",
+      fixable: true,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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 'Boom' in the expected Effect errors.    effect(missingEffectError)"
+          }
+        ]
+      }
+    },
+    {
+      name: "missingLayerContext",
+      group: "correctness",
+      description: "Reports missing service requirements in Layer context channel",
+      defaultSeverity: "error",
+      fixable: false,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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: "missingReturnYieldStar",
+      group: "correctness",
+      description: "Suggests using 'return yield*' for Effects with never success for better type narrowing",
+      defaultSeverity: "error",
+      fixable: true,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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: 147,
+            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: "Enforces using 'yield*' instead of 'yield' when yielding Effects in generators",
+      defaultSeverity: "error",
+      fixable: true,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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: 75,
+            end: 83,
+            text: "Seems like you used yield instead of yield* inside this Effect.gen.    effect(missingStarInYieldEffectGen)"
+          },
+          {
+            start: 105,
+            end: 128,
+            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"
+      ],
+      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. \nConsider 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",
+      fixable: false,
+      supportedEffect: [
+        "v4"
+      ],
+      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, clone and consult the github.com/effect-ts/effect-smol repository 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.    effect(outdatedApi)"
+          }
+        ]
+      }
+    },
+    {
+      name: "outdatedEffectCodegen",
+      group: "correctness",
+      description: "Detects when generated code is outdated and needs to be regenerated",
+      defaultSeverity: "warning",
+      fixable: true,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      preview: {
+        sourceText: 'import * as Effect from "effect/Effect"\n\n// @effect-codegens accessors:stale-preview\nexport class Preview extends Effect.Service<Preview>()("Preview", {\n  accessors: true,\n  effect: Effect.succeed({ value: Effect.succeed(1) })\n}) {}\n',
+        diagnostics: [
+          {
+            start: 61,
+            end: 76,
+            text: "Codegen accessors result is outdated    effect(outdatedEffectCodegen)"
+          }
+        ]
+      }
+    },
+    {
+      name: "overriddenSchemaConstructor",
+      group: "correctness",
+      description: "Prevents overriding constructors in Schema classes which breaks decoding behavior",
+      defaultSeverity: "error",
+      fixable: true,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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: 185,
+            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: "unsupportedServiceAccessors",
+      group: "correctness",
+      description: "Warns about service accessors that need codegen due to generic/complex signatures",
+      defaultSeverity: "warning",
+      fixable: true,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      preview: {
+        sourceText: 'import * as Effect from "effect/Effect"\n\nexport class Preview extends Effect.Service<Preview>()("Preview", {\n  accessors: true,\n  effect: Effect.succeed({ get: <A>(value: A) => Effect.succeed(value) })\n}) {}\n',
+        diagnostics: [
+          {
+            start: 54,
+            end: 61,
+            text: "Even if accessors are enabled, accessors for 'get' won't be available because the signature have generic type parameters or multiple call signatures.    effect(unsupportedServiceAccessors)"
+          }
+        ]
+      }
+    },
+    {
+      name: "catchUnfailableEffect",
+      group: "antipattern",
+      description: "Warns when using error handling on Effects that never fail (error type is 'never')",
+      defaultSeverity: "suggestion",
+      fixable: false,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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: "effectFnIife",
+      group: "antipattern",
+      description: "Effect.fn or Effect.fnUntraced is called as an IIFE (Immediately Invoked Function Expression). Use Effect.gen instead.",
+      defaultSeverity: "warning",
+      fixable: true,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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 mantain tracing spans.    effect(effectFnIife)`
+          }
+        ]
+      }
+    },
+    {
+      name: "effectGenUsesAdapter",
+      group: "antipattern",
+      description: "Warns when using the deprecated adapter parameter in Effect.gen",
+      defaultSeverity: "warning",
+      fixable: false,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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: "effectInFailure",
+      group: "antipattern",
+      description: "Warns when an Effect is used inside an Effect failure channel",
+      defaultSeverity: "warning",
+      fixable: false,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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"
+      ],
+      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",
+      fixable: false,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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",
+      fixable: false,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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",
+      fixable: true,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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",
+      fixable: false,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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.\n\nThis leaks implementation details into the service's public type \u2014 callers shouldn't need to know *how* the service works internally, only *what* it provides.\n\nResolve these dependencies at Layer creation and provide them to each method, so the service's type reflects its purpose, not its implementation.\n\nTo suppress this diagnostic for specific dependency types that are intentionally passed through (e.g., HttpServerRequest), add `@effect-leakable-service` JSDoc to their interface declarations (e.g., the `FileSystem` interface), or to this service by adding a `@effect-expect-leaking FileSystem` JSDoc.\n\nMore info and examples at https://effect.website/docs/requirements-management/layers/#avoiding-requirement-leakage    effect(leakingRequirements)"
+          }
+        ]
+      }
+    },
+    {
+      name: "multipleEffectProvide",
+      group: "antipattern",
+      description: "Warns against chaining Effect.provide calls which can cause service lifecycle issues",
+      defaultSeverity: "warning",
+      fixable: true,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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: "returnEffectInGen",
+      group: "antipattern",
+      description: "Warns when returning an Effect in a generator causes nested Effect<Effect<...>>",
+      defaultSeverity: "suggestion",
+      fixable: true,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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: 115,
+            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: "runEffectInsideEffect",
+      group: "antipattern",
+      description: "Suggests using Runtime methods instead of Effect.run* inside Effect contexts",
+      defaultSeverity: "suggestion",
+      fixable: true,
+      supportedEffect: [
+        "v3"
+      ],
+      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: "schemaSyncInEffect",
+      group: "antipattern",
+      description: "Suggests using Effect-based Schema methods instead of sync methods inside Effect generators",
+      defaultSeverity: "suggestion",
+      fixable: false,
+      supportedEffect: [
+        "v3"
+      ],
+      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: "scopeInLayerEffect",
+      group: "antipattern",
+      description: "Suggests using Layer.scoped instead of Layer.effect when Scope is in requirements",
+      defaultSeverity: "warning",
+      fixable: true,
+      supportedEffect: [
+        "v3"
+      ],
+      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: "strictEffectProvide",
+      group: "antipattern",
+      description: "Warns when using Effect.provide with layers outside of application entry points",
+      defaultSeverity: "off",
+      fixable: false,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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: "tryCatchInEffectGen",
+      group: "antipattern",
+      description: "Discourages try/catch in Effect generators in favor of Effect error handling",
+      defaultSeverity: "suggestion",
+      fixable: false,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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: "unknownInEffectCatch",
+      group: "antipattern",
+      description: "Warns when catch callbacks return unknown instead of typed errors",
+      defaultSeverity: "warning",
+      fixable: false,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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"
+      ],
+      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: "globalFetch",
+      group: "effectNative",
+      description: "Warns when using the global fetch function instead of the Effect HTTP client",
+      defaultSeverity: "off",
+      fixable: false,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      preview: {
+        sourceText: '\nexport const preview = fetch("https://example.com")\n',
+        diagnostics: [
+          {
+            start: 24,
+            end: 29,
+            text: "Prefer using HttpClient from @effect/platform instead of the global 'fetch' function.    effect(globalFetch)"
+          }
+        ]
+      }
+    },
+    {
+      name: "instanceOfSchema",
+      group: "effectNative",
+      description: "Suggests using Schema.is instead of instanceof for Effect Schema types",
+      defaultSeverity: "off",
+      fixable: true,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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",
+      fixable: false,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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: "preferSchemaOverJson",
+      group: "effectNative",
+      description: "Suggests using Effect Schema for JSON operations instead of JSON.parse/JSON.stringify which may throw",
+      defaultSeverity: "suggestion",
+      fixable: false,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      preview: {
+        sourceText: `import { Effect } from "effect"
+
+export const preview = Effect.gen(function*() {
+  const text = yield* Effect.succeed('{"ok":true}')
+  return JSON.parse(text)
+})
+`,
+        diagnostics: [
+          {
+            start: 142,
+            end: 158,
+            text: "Consider using Effect Schema for JSON operations instead of JSON.parse/JSON.stringify    effect(preferSchemaOverJson)"
+          }
+        ]
+      }
+    },
+    {
+      name: "catchAllToMapError",
+      group: "style",
+      description: "Suggests using Effect.mapError instead of Effect.catchAll when the callback only wraps the error with Effect.fail",
+      defaultSeverity: "suggestion",
+      fixable: true,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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: "deterministicKeys",
+      group: "style",
+      description: "Enforces deterministic naming for service/tag/error identifiers based on class names",
+      defaultSeverity: "off",
+      fixable: true,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      preview: {
+        sourceText: 'import { ServiceMap } from "effect"\n\nexport class RenamedService\n  extends ServiceMap.Service<RenamedService, {}>()("CustomIdentifier") {}\n',
+        diagnostics: [
+          {
+            start: 116,
+            end: 134,
+            text: "Key should be '@effect/harness-effect-v4/examples/diagnostics/deterministicKeys_preview/RenamedService'    effect(deterministicKeys)"
+          }
+        ]
+      }
+    },
+    {
+      name: "effectFnOpportunity",
+      group: "style",
+      description: "Suggests using Effect.fn for functions that returns an Effect",
+      defaultSeverity: "suggestion",
+      fixable: true,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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: "effectMapVoid",
+      group: "style",
+      description: "Suggests using Effect.asVoid instead of Effect.map(() => void 0), Effect.map(() => undefined), or Effect.map(() => {})",
+      defaultSeverity: "suggestion",
+      fixable: true,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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: "effectSucceedWithVoid",
+      group: "style",
+      description: "Suggests using Effect.void instead of Effect.succeed(undefined) or Effect.succeed(void 0)",
+      defaultSeverity: "suggestion",
+      fixable: true,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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: "importFromBarrel",
+      group: "style",
+      description: "Suggests importing from specific module paths instead of barrel exports",
+      defaultSeverity: "off",
+      fixable: true,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      preview: {
+        sourceText: 'import { Effect } from "effect"\n\nexport const preview = Effect.void\n',
+        diagnostics: [
+          {
+            start: 9,
+            end: 15,
+            text: "Importing from barrel module effect is not allowed.    effect(importFromBarrel)"
+          }
+        ]
+      }
+    },
+    {
+      name: "missedPipeableOpportunity",
+      group: "style",
+      description: "Enforces the use of pipeable style for nested function calls",
+      defaultSeverity: "off",
+      fixable: true,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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: "missingEffectServiceDependency",
+      group: "style",
+      description: "Checks that Effect.Service dependencies satisfy all required layer inputs",
+      defaultSeverity: "off",
+      fixable: false,
+      supportedEffect: [
+        "v3"
+      ],
+      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",
+      fixable: true,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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: "schemaStructWithTag",
+      group: "style",
+      description: "Suggests using Schema.TaggedStruct instead of Schema.Struct with _tag field",
+      defaultSeverity: "suggestion",
+      fixable: true,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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: "Simplifies Schema.Union of multiple Schema.Literal calls into single Schema.Literal",
+      defaultSeverity: "off",
+      fixable: true,
+      supportedEffect: [
+        "v3"
+      ],
+      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",
+      fixable: true,
+      supportedEffect: [
+        "v4"
+      ],
+      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",
+      fixable: false,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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",
+      fixable: true,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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",
+      fixable: true,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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: 208,
+            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",
+      fixable: true,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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",
+      fixable: true,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      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)"
+          }
+        ]
+      }
+    }
+  ]
+};
+
+// src/cli/setup/diagnostic-info.ts
+var diagnosticMetadata = metadata_default;
+function getDiagnosticGroups() {
+  return diagnosticMetadata.groups;
 }
-function handleClear(options) {
+function getDiagnosticMetadataRules() {
+  return diagnosticMetadata.rules;
+}
+function getAllDiagnostics() {
+  const diagnosticsByName = new Map(diagnostics.map((diagnostic) => [diagnostic.name, diagnostic]));
+  return getDiagnosticMetadataRules().flatMap((metadataRule) => {
+    const diagnostic = diagnosticsByName.get(metadataRule.name);
+    if (!diagnostic) {
+      return [];
+    }
+    return [{
+      name: diagnostic.name,
+      code: diagnostic.code,
+      group: metadataRule.group,
+      defaultSeverity: diagnostic.severity,
+      description: metadataRule.description,
+      preview: metadataRule.preview
+    }];
+  });
+}
+function cycleSeverity(current, direction) {
+  const order = ["off", "suggestion", "message", "warning", "error"];
+  const currentIndex = order.indexOf(current);
+  if (direction === "right") {
+    return order[(currentIndex + 1) % order.length];
+  } else {
+    return order[(currentIndex - 1 + order.length) % order.length];
+  }
+}
+var shortNames = {
+  off: "off",
+  suggestion: "sugg",
+  message: "info",
+  warning: "warn",
+  error: "err"
+};
+var MAX_SEVERITY_LENGTH = Object.values(shortNames).reduce((max2, name) => Math.max(max2, name.length), 0);
+function getSeverityShortName(severity) {
+  return shortNames[severity] ?? "???";
+}
+
+// src/cli/setup/diagnostic-prompt.ts
+var diagnosticGroups = getDiagnosticGroups();
+var Action2 = taggedEnum();
+var SEARCH_ICON = "/";
+var MIN_PREVIEW_AND_MESSAGES_LINES = 18;
+function getControlsLegend(searchText) {
+  const searchLegend = searchText.length === 0 ? `${SEARCH_ICON} type to search` : `${SEARCH_ICON} searching: ${searchText}`;
+  return `\u2190/\u2192 change rule  \u2191/\u2193 change severity  ${searchLegend}`;
+}
+function getSeveritySymbol(severity) {
+  const symbols = {
+    off: ".",
+    suggestion: "?",
+    message: "i",
+    warning: "!",
+    error: "x"
+  };
+  return symbols[severity];
+}
+function getSeverityStyle(severity) {
+  const styles = {
+    off: DIM,
+    suggestion: DIM,
+    message: BLUE,
+    warning: YELLOW,
+    error: RED
+  };
+  return styles[severity];
+}
+function renderEntry(entry, severity, isSelected) {
+  const symbol4 = ansi(getSeveritySymbol(severity), getSeverityStyle(severity));
+  const name = isSelected ? ansi(entry.name, UNDERLINE) : entry.name;
+  return `${symbol4} ${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(lines2, columns) {
+  let result3 = "";
+  for (let lineIndex = lines2.length - 1; lineIndex >= 0; lineIndex--) {
+    const rows = rowsForLength(visibleLength(lines2[lineIndex] ?? ""), columns);
+    for (let rowIndex = 0; rowIndex < rows; rowIndex++) {
+      result3 += ERASE_LINE;
+      if (!(lineIndex === 0 && rowIndex === rows - 1)) {
+        result3 += "\x1B[1A";
+      }
+    }
+  }
+  if (lines2.length > 0) {
+    result3 += CURSOR_LEFT;
+  }
+  return result3;
+}
+function wrapPaddedText(text2, initialPadding, endPadding, columns) {
+  if (text2.length === 0) {
+    return [initialPadding + endPadding];
+  }
+  const available = Math.max(columns - visibleLength(initialPadding) - visibleLength(endPadding), 1);
+  const lines2 = [];
+  let remaining = text2;
+  while (remaining.length > 0) {
+    const chunk = remaining.slice(0, available);
+    lines2.push(initialPadding + chunk + endPadding);
+    remaining = remaining.slice(chunk.length);
+  }
+  return lines2;
+}
+function wrapListItemText(text2, firstLinePadding, continuationPadding, endPadding, columns) {
+  if (text2.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 lines2 = [];
+  let remaining = text2;
+  let isFirstLine = true;
+  while (remaining.length > 0) {
+    const padding = isFirstLine ? firstLinePadding : continuationPadding;
+    const available = isFirstLine ? firstAvailable : continuationAvailable;
+    const chunk = remaining.slice(0, available);
+    lines2.push(padding + chunk + endPadding);
+    remaining = remaining.slice(chunk.length);
+    isFirstLine = false;
+  }
+  return lines2;
+}
+function renderPaddedLine(text2, initialPadding, endPadding, columns) {
+  const available = Math.max(columns - visibleLength(initialPadding) - visibleLength(endPadding), 0);
+  const truncated = visibleLength(text2) <= available ? text2 : text2.slice(0, available);
+  const padding = Math.max(available - visibleLength(truncated), 0);
+  return initialPadding + truncated + " ".repeat(padding) + endPadding;
+}
+function mergeHighlightRanges(ranges) {
+  const sorted = ranges.filter((range2) => range2.end > range2.start).slice().sort((a, b) => a.start - b.start);
+  const merged = [];
+  for (const range2 of sorted) {
+    const previous = merged[merged.length - 1];
+    if (!previous || range2.start > previous.end) {
+      merged.push(range2);
+      continue;
+    }
+    merged[merged.length - 1] = {
+      start: previous.start,
+      end: Math.max(previous.end, range2.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 range2 of ranges) {
+    const start = Math.max(range2.start, lineStart);
+    const end = Math.min(range2.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 text2 = line.slice(offset, offset + width);
+    wrapped.push({
+      text: text2,
+      start: lineStart + offset,
+      end: lineStart + offset + text2.length
+    });
+    offset += text2.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, diagnostics3, columns) {
+  const ranges = mergeHighlightRanges(diagnostics3.map((diagnostic) => ({
+    start: diagnostic.start,
+    end: diagnostic.end
+  })));
+  return wrapPreviewSourceText(sourceText, columns).map((line) => {
+    const rendered = stylePreviewLine(line.text, line.start, ranges);
+    return CURSOR_TO_0 + renderPaddedLine(rendered, "  ", "", columns);
+  });
+}
+function renderPreviewMessages(diagnostics3, columns) {
+  const messages = Array.from(new Set(diagnostics3.map((diagnostic) => diagnostic.text)));
+  return messages.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 renderDivider(columns, legendText) {
+  if (legendText === void 0) {
+    return ansi("\u2500".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 = "\u2500".repeat(Math.floor(remaining / 2));
+  const right = "\u2500".repeat(remaining - left.length);
+  return ansi(left + legend + right, DIM);
+}
+function renderSelectedRuleDivider(selected, severities, columns) {
+  if (!selected) {
+    return renderDivider(columns);
+  }
+  const currentSeverity = severities[selected.name] ?? selected.defaultSeverity;
+  const text2 = `${selected.name} (currently set as ${getSeverityShortName(currentSeverity)})`;
+  return renderDivider(columns, text2);
+}
+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(entries2, searchText) {
+  return entries2.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(entries2, severities, startIndex, columns) {
+  if (entries2.length === 0) {
+    return {
+      fullLine: renderPaddedLine(ansi("No matching rules", DIM), "  ", "  ", columns),
+      visibleRules: []
+    };
+  }
+  const reservedColumns = 4;
+  const itemColumns = Math.max(columns - reservedColumns, 0);
+  const separator = "  ";
+  const visibleEntries = [];
+  const visibleRules = [];
+  let currentLength = 0;
+  let seenCount = 0;
+  while (seenCount < entries2.length) {
+    const index = (startIndex + seenCount) % entries2.length;
+    const rule = entries2[index];
+    const currentSeverity = severities[rule.name] ?? rule.defaultSeverity;
+    const entry = renderEntry(rule, currentSeverity, seenCount === 0);
+    const nextLength = visibleEntries.length === 0 ? visibleLength(entry) : currentLength + separator.length + visibleLength(entry);
+    if (nextLength > itemColumns) {
+      break;
+    }
+    visibleEntries.push(entry);
+    visibleRules.push(rule);
+    currentLength = nextLength;
+    seenCount++;
+  }
+  const leftMarker = entries2.length > 1 ? ansi("\u2190", DIM) : " ";
+  const rightMarker = entries2.length > 1 ? ansi("\u2192", DIM) : " ";
+  return {
+    fullLine: renderPaddedLine(visibleEntries.join(separator), `${leftMarker} `, ` ${rightMarker}`, columns),
+    visibleRules
+  };
+}
+function buildGroupLine(selected, columns) {
+  if (!selected) {
+    return renderPaddedLine("", "  ", "  ", columns);
+  }
+  const selectedIndex = diagnosticGroups.findIndex((group) => group.id === selected.group);
+  const rotatedGroups = diagnosticGroups.map(
+    (_, index) => diagnosticGroups[(selectedIndex + index) % diagnosticGroups.length]
+  );
+  const content = rotatedGroups.map((group, index) => {
+    const label = group.name.toUpperCase();
+    return index === 0 ? ansi(label, BOLD) : ansi(label, DIM);
+  }).join("  ");
+  return renderPaddedLine(content, "  ", "  ", columns);
+}
+function buildFrame(entries2, searchText, severities, startIndex, columns) {
+  const visible = buildVisibleEntries(entries2, 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, columns),
+    CURSOR_TO_0 + visible.fullLine,
+    ...wrappedDescription.map((line) => CURSOR_TO_0 + ansi(line, DIM)),
+    CURSOR_TO_0 + renderDivider(columns, getControlsLegend(searchText)),
+    ""
+  ];
+}
+function buildState(entries2, startIndex, searchText, severities) {
   return gen2(function* () {
     const terminal = yield* Terminal;
-    const columns = yield* terminal.columns;
-    const clearPrompt = ERASE_LINE + CURSOR_LEFT;
-    const visibleCount = Math.min(options.diagnostics.length, options.maxPerPage);
-    const text2 = "\n".repeat(visibleCount + 2) + options.message;
-    const clearOutput = eraseText2(text2, columns);
-    return clearOutput + clearPrompt;
+    const columns = Math.max(yield* terminal.columns, 1);
+    const filteredEntries = getFilteredEntries(entries2, searchText);
+    const normalizedStartIndex = normalizeStartIndex(filteredEntries.length, startIndex);
+    const renderedLines = buildFrame(filteredEntries, searchText, severities, normalizedStartIndex, columns);
+    return {
+      startIndex: normalizedStartIndex,
+      searchText,
+      severities,
+      renderedColumns: columns,
+      renderedLines
+    };
   });
 }
-function handleRender(options) {
-  return (state, action2) => {
-    return Action2.$match(action2, {
-      Beep: () => succeed6(BEEP),
-      NextFrame: ({ state: state2 }) => renderNextFrame(state2, options),
-      Submit: () => renderSubmission(state, options)
-    });
+function renderSubmission(state, entries2) {
+  return succeed6(
+    CURSOR_TO_0 + JSON.stringify(
+      Object.fromEntries(
+        entries2.flatMap((entry) => {
+          const severity = state.severities[entry.name];
+          return severity !== void 0 && severity !== entry.defaultSeverity ? [[entry.name, severity]] : [];
+        })
+      )
+    ) + "\n"
+  );
+}
+function handleProcess(entries2) {
+  return (input, state) => {
+    const filteredEntries = getFilteredEntries(entries2, state.searchText);
+    switch (input.key.name) {
+      case "backspace":
+        return buildState(entries2, 0, state.searchText.slice(0, -1), state.severities).pipe(
+          map6((nextState) => Action2.NextFrame({ state: nextState }))
+        );
+      case "left":
+        if (filteredEntries.length === 0) return succeed6(Action2.Beep());
+        return buildState(entries2, state.startIndex - 1, state.searchText, state.severities).pipe(
+          map6((nextState) => Action2.NextFrame({ state: nextState }))
+        );
+      case "right":
+        if (filteredEntries.length === 0) return succeed6(Action2.Beep());
+        return buildState(entries2, state.startIndex + 1, state.searchText, state.severities).pipe(
+          map6((nextState) => Action2.NextFrame({ state: nextState }))
+        );
+      case "up":
+      case "down":
+        if (filteredEntries.length === 0) return succeed6(Action2.Beep());
+        return buildState(entries2, 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(map6((nextState) => Action2.NextFrame({ state: nextState })));
+      case "enter":
+      case "return":
+        return succeed6(Action2.Submit({
+          value: Object.fromEntries(
+            entries2.flatMap((entry) => {
+              const severity = state.severities[entry.name];
+              return severity !== void 0 && severity !== entry.defaultSeverity ? [[entry.name, severity]] : [];
+            })
+          )
+        }));
+      default:
+        if (!isPrintableInput(input)) return succeed6(Action2.Beep());
+        return buildState(entries2, 0, state.searchText + input.input, state.severities).pipe(
+          map6((nextState) => Action2.NextFrame({ state: nextState }))
+        );
+    }
   };
 }
+function getPromptEntries(diagnostics3) {
+  const diagnosticsByName = new Map(diagnostics3.map((diagnostic) => [diagnostic.name, diagnostic]));
+  return diagnostics3.flatMap((rule) => {
+    const diagnostic = diagnosticsByName.get(rule.name);
+    if (!diagnostic) {
+      return [];
+    }
+    return [{
+      name: rule.name,
+      group: diagnostic.group,
+      description: diagnostic.description,
+      previewSourceText: diagnostic.preview.sourceText,
+      previewDiagnostics: diagnostic.preview.diagnostics,
+      defaultSeverity: diagnostic.defaultSeverity
+    }];
+  });
+}
 function createDiagnosticPrompt(diagnostics3, initialSeverities) {
-  const options = {
-    message: "Configure Diagnostic Severities",
-    diagnostics: diagnostics3,
-    maxPerPage: 10
-  };
-  const initialState = {
-    index: 0,
-    severities: initialSeverities
-  };
-  return custom(initialState, {
-    render: handleRender(options),
-    process: handleProcess(options),
-    clear: () => handleClear(options)
+  const entries2 = getPromptEntries(diagnostics3);
+  return custom(buildState(entries2, 0, "", initialSeverities), {
+    render: (state, action2) => {
+      switch (action2._tag) {
+        case "Beep":
+          return succeed6(BEEP);
+        case "NextFrame":
+          return succeed6(action2.state.renderedLines.join("\n"));
+        case "Submit":
+          return renderSubmission(state, entries2);
+      }
+    },
+    process: handleProcess(entries2),
+    clear: (state) => gen2(function* () {
+      const terminal = yield* Terminal;
+      const columns = yield* terminal.columns;
+      return eraseRenderedLines(state.renderedLines, columns);
+    })
   });
 }