@effect/language-service 0.84.1 → 0.84.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect/language-service",
-  "version": "0.84.1",
+  "version": "0.84.3",
   "description": "A Language-Service Plugin to Refactor and Diagnostic effect-ts projects",
   "main": "index.cjs",
   "bin": {

package/transform.js

@@ -3118,10 +3118,42 @@ function makeTypeCheckerUtils(ts, typeChecker, tsUtils) {
     if (node.parent && ts.isJsxOpeningElement(node.parent) && node.parent.tagName === node) return;
     if (node.parent && ts.isJsxClosingElement(node.parent) && node.parent.tagName === node) return;
     if (node.parent && ts.isJsxAttribute(node.parent) && node.parent.name === node) return;
+    if (isInsideTypeOnlyHeritageExpression(node)) return;
     if (ts.isExpression(node) || ts.isTypeNode(node)) {
       return typeChecker.getTypeAtLocation(node);
     }
   }
+  function isInsideTypeOnlyHeritageExpression(node) {
+    if (ts.isExpressionWithTypeArguments(node)) {
+      return isTypeOnlyHeritageClause(node.parent);
+    }
+    if (!ts.isIdentifier(node) && !ts.isPropertyAccessExpression(node)) {
+      return false;
+    }
+    for (let current = node.parent; current; current = current.parent) {
+      if (ts.isPropertyAccessExpression(current)) {
+        continue;
+      }
+      if (ts.isExpressionWithTypeArguments(current)) {
+        return isTypeOnlyHeritageClause(current.parent);
+      }
+      return false;
+    }
+    return false;
+  }
+  function isTypeOnlyHeritageClause(node) {
+    if (!node || !ts.isHeritageClause(node)) {
+      return false;
+    }
+    const container = node.parent;
+    if (!container) {
+      return false;
+    }
+    if (ts.isInterfaceDeclaration(container)) {
+      return true;
+    }
+    return ts.isClassLike(container) && node.token === ts.SyntaxKind.ImplementsKeyword;
+  }
   function resolveToGlobalSymbol(symbol3) {
     if (symbol3.flags & ts.SymbolFlags.Alias) {
       symbol3 = typeChecker.getAliasedSymbol(symbol3);
@@ -3445,6 +3477,14 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     ),
     ([A, E, R]) => ({ A, E, R })
   );
+  const streamVarianceStruct = (type, atLocation) => map4(
+    all(
+      varianceStructCovariantType(type, atLocation, "_A"),
+      varianceStructCovariantType(type, atLocation, "_E"),
+      varianceStructCovariantType(type, atLocation, "_R")
+    ),
+    ([A, E, R]) => ({ A, E, R })
+  );
   const layerVarianceStruct = (type, atLocation) => map4(
     all(
       varianceStructContravariantType(type, atLocation, "_ROut"),
@@ -3491,6 +3531,21 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     "TypeParser.strictEffectType",
     (type) => type
   );
+  const streamType = cachedBy(
+    fn("TypeParser.streamType")(function* (type, atLocation) {
+      if (supportedEffect() === "v3") {
+        return yield* effectType(type, atLocation);
+      }
+      const typeIdSymbol = typeChecker.getPropertyOfType(type, "~effect/Stream");
+      if (!typeIdSymbol) {
+        return yield* typeParserIssue("Type is not a stream", type, atLocation);
+      }
+      const typeIdType = typeChecker.getTypeOfSymbolAtLocation(typeIdSymbol, atLocation);
+      return yield* streamVarianceStruct(typeIdType, atLocation);
+    }),
+    "TypeParser.streamType",
+    (type) => type
+  );
   const isEffectTypeSourceFile = cachedBy(
     fn("TypeParser.isEffectTypeSourceFile")(function* (sourceFile) {
       const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
@@ -5226,6 +5281,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     isServiceMapTypeSourceFile,
     isNodeReferenceToServiceMapModuleApi,
     effectType,
+    streamType,
     strictEffectType,
     layerType,
     fiberType,
@@ -5453,7 +5509,7 @@ var catchAllToMapError = createDiagnostic({
         const { failArg, failCall } = failCallInfo;
         report({
           location: transformation.callee,
-          messageText: `You can use Effect.mapError instead of Effect.${catchAllName} + Effect.fail to transform the error type.`,
+          messageText: `\`Effect.mapError\` expresses the same error-type transformation more directly than \`Effect.${catchAllName}\` followed by \`Effect.fail\`.`,
           fixes: [{
             fixName: "catchAllToMapError_fix",
             description: "Replace with Effect.mapError",
@@ -5517,7 +5573,7 @@ var catchUnfailableEffect = createDiagnostic({
           if (E.flags & ts.TypeFlags.Never) {
             report({
               location: transformation.callee,
-              messageText: `Looks like the previous effect never fails, so probably this error handling will never be triggered.`,
+              messageText: "The previous Effect does not fail, so this error-handling branch will never run.",
               fixes: []
             });
           }
@@ -5580,7 +5636,7 @@ var classSelfMismatch = createDiagnostic({
           if (actualName !== expectedName) {
             report({
               location: selfTypeNode,
-              messageText: `Self type parameter should be '${expectedName}'`,
+              messageText: `The \`Self\` type parameter for this class should be \`${expectedName}\`.`,
               fixes: [{
                 fixName: "classSelfMismatch_fix",
                 description: `Replace '${actualName}' with '${expectedName}'`,
@@ -5770,7 +5826,7 @@ var deterministicKeys = createDiagnostic({
           if (actualIdentifier !== expectedKey) {
             report({
               location: keyStringLiteral,
-              messageText: `Key should be '${expectedKey}'`,
+              messageText: `This key does not match the deterministic key for this declaration. The expected key is \`${expectedKey}\`.`,
               fixes: [{
                 fixName: "deterministicKeys_fix",
                 description: `Replace '${actualIdentifier}' with '${expectedKey}'`,
@@ -5809,9 +5865,8 @@ var duplicatePackage = createDiagnostic({
         const versions = Object.keys(resolvedPackages[packageName]);
         report({
           location: sourceFile.statements[0],
-          messageText: `Package ${packageName} is referenced multiple times with different versions (${versions.join(", ")}) and may cause unexpected type errors.
-Cleanup your dependencies and your package lockfile to avoid multiple instances of this package and reload the project.
-If this is intended set the LSP config "allowedDuplicatedPackages" to ${JSON.stringify(options.allowedDuplicatedPackages.concat([packageName]))}.
+          messageText: `Multiple versions of package \`${packageName}\` were detected: ${versions.join(", ")}. Package duplication can change runtime identity and type equality across Effect modules.
+If this is intentional, set the LSP config \`allowedDuplicatedPackages\` to ${JSON.stringify(options.allowedDuplicatedPackages.concat([packageName]))}.
 
 ${versions.map((version) => `- found ${version} at ${resolvedPackages[packageName][version]}`).join("\n")}`,
           fixes: []
@@ -5919,7 +5974,7 @@ var effectFnIife = createDiagnostic({
       const traceExpressionText = traceExpression ? sourceFile.text.slice(traceExpression.pos, traceExpression.end) : void 0;
       report({
         location: node,
-        messageText: `${effectModuleName}.${kind} returns a reusable function that can take arguments, but here it's called immediately. Use Effect.gen instead${traceExpressionText ? ` with Effect.withSpan(${traceExpressionText}) piped in the end to mantain tracing spans` : ``}.`,
+        messageText: `\`${effectModuleName}.${kind}\` returns a reusable function that can take arguments, but it is invoked immediately here. \`Effect.gen\` represents the immediate-use form for this pattern${traceExpressionText ? ` with \`Effect.withSpan(${traceExpressionText})\` piped at the end to maintain tracing spans` : ``}.`,
         fixes
       });
     }
@@ -6004,7 +6059,7 @@ var effectFnImplicitAny = createDiagnostic({
         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.`,
+          messageText: `Parameter \`${parameterName}\` implicitly has type \`any\` in \`Effect.fn\`, \`Effect.fnUntraced\`, or \`Effect.fnUntracedEager\`. No parameter type is available from an explicit annotation or contextual function type.`,
           fixes: []
         });
       }
@@ -6600,7 +6655,7 @@ var effectFnOpportunity = createDiagnostic({
       const expectedSignature = generateExpectedSignature();
       report({
         location: nameIdentifier ?? targetNode,
-        messageText: `Can be rewritten as a reusable function: ${expectedSignature}`,
+        messageText: `This expression can be rewritten in the reusable function form \`${expectedSignature}\`.`,
         fixes
       });
     }
@@ -6812,7 +6867,7 @@ var effectMapVoid = createDiagnostic({
           if (isNone2(match2)) continue;
           report({
             location: node.expression,
-            messageText: "Effect.asVoid can be used instead to discard the success value",
+            messageText: "This expression discards the success value through mapping. `Effect.asVoid` represents that form directly.",
             fixes: [{
               fixName: "effectMapVoid_fix",
               description: "Replace with Effect.asVoid",
@@ -6867,7 +6922,7 @@ var effectSucceedWithVoid = createDiagnostic({
           if (!tsUtils.isVoidExpression(argument)) continue;
           report({
             location: node,
-            messageText: "Effect.void can be used instead of Effect.succeed(undefined) or Effect.succeed(void 0)",
+            messageText: "`Effect.void` represents the same outcome as `Effect.succeed(undefined)` or `Effect.succeed(void 0)`.",
             fixes: [{
               fixName: "effectSucceedWithVoid_fix",
               description: "Replace with Effect.void",
@@ -6929,7 +6984,7 @@ var extendsNativeError = createDiagnostic({
             if (isNativeError) {
               report({
                 location: node.name ?? typeExpression,
-                messageText: "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.",
+                messageText: "This class extends the native `Error` type directly. Untagged native errors lose distinction in the Effect failure channel.",
                 fixes: []
               });
             }
@@ -6974,7 +7029,12 @@ var floatingEffect = createDiagnostic({
       if (!isFloatingExpression(node)) continue;
       const type = typeCheckerUtils.getTypeAtLocation(node.expression);
       if (!type) continue;
-      const effect = yield* option(typeParser.effectType(type, node.expression));
+      const effect = yield* option(
+        pipe(
+          typeParser.effectType(type, node.expression),
+          orElse2(() => typeParser.streamType(type, node.expression))
+        )
+      );
       if (isSome2(effect)) {
         const allowedFloatingEffects = yield* pipe(
           typeParser.fiberType(type, node.expression),
@@ -6983,10 +7043,9 @@ var floatingEffect = createDiagnostic({
         );
         if (isNone2(allowedFloatingEffects)) {
           const isStrictEffect = yield* option(typeParser.strictEffectType(type, node.expression));
-          const name = isSome2(isStrictEffect) ? "Effect" : "Effect-able " + typeChecker.typeToString(type);
           report({
             location: node,
-            messageText: `${name} must be yielded or assigned to a variable.`,
+            messageText: isSome2(isStrictEffect) ? "This Effect value is neither yielded nor used in an assignment." : `This Effect-able \`${typeChecker.typeToString(type)}\` value is neither yielded nor assigned to a variable.`,
             fixes: []
           });
         }
@@ -7081,7 +7140,7 @@ var makeGlobalConsoleApply = (checkInEffect) => fn(`globalConsole${checkInEffect
     if (inEffect !== checkInEffect) continue;
     report({
       location: node,
-      messageText: checkInEffect ? `Prefer using ${alternative} instead of console.${method} inside Effect generators.` : `Prefer using ${alternative} instead of console.${method}.`,
+      messageText: checkInEffect ? `This Effect code uses \`console.${method}\`, logging in Effect code is represented through \`${alternative}\`.` : `This code uses \`console.${method}\`, the corresponding Effect logging API is \`${alternative}\`.`,
       fixes: []
     });
   }
@@ -7130,10 +7189,10 @@ var makeGlobalDateApply = (checkInEffect) => fn(`globalDate${checkInEffect ? "In
     let objectNode;
     if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.idText(node.expression.name) === "now") {
       objectNode = node.expression.expression;
-      messageText = checkInEffect ? "Prefer using Clock or DateTime from Effect instead of Date.now() inside Effect generators." : "Prefer using Clock or DateTime from Effect instead of Date.now().";
+      messageText = checkInEffect ? "This Effect code uses `Date.now()`, time access in Effect code is represented through `Clock` from Effect." : "This code uses `Date.now()`, time access is represented through `Clock` from Effect.";
     } else if (ts.isNewExpression(node)) {
       objectNode = node.expression;
-      messageText = checkInEffect ? "Prefer using DateTime from Effect instead of new Date() inside Effect generators." : "Prefer using DateTime from Effect instead of new Date().";
+      messageText = checkInEffect ? "This Effect code constructs `new Date()`, date values in Effect code are represented through `DateTime` from Effect." : "This code constructs `new Date()`, date values are represented through `DateTime` from Effect.";
     }
     if (!messageText || !objectNode) continue;
     const symbol3 = typeChecker.getSymbolAtLocation(objectNode);
@@ -7216,7 +7275,7 @@ var globalErrorInEffectCatch = createDiagnostic({
                     );
                     report({
                       location: node.expression,
-                      messageText: `The 'catch' callback in ${nodeText} 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.`,
+                      messageText: `The \`catch\` callback in \`${nodeText}\` returns the global \`Error\` type. Untagged errors merge together in the Effect error channel and lose type-level distinction; a tagged error preserves that distinction and can wrap the original error in a \`cause\` property.`,
                       fixes: []
                     });
                   }
@@ -7296,7 +7355,7 @@ var makeGlobalFetchApply = (checkInEffect) => fn(`globalFetch${checkInEffect ? "
   if (!fetchSymbol) return;
   const effectVersion = typeParser.supportedEffect();
   const packageName = effectVersion === "v3" ? "@effect/platform" : "effect/unstable/http";
-  const messageText = checkInEffect ? `Prefer using HttpClient from ${packageName} instead of the global 'fetch' function inside Effect generators.` : `Prefer using HttpClient from ${packageName} instead of the global 'fetch' function.`;
+  const messageText = checkInEffect ? `This Effect code calls the global \`fetch\` function, HTTP requests in Effect code are represented through \`HttpClient\` from \`${packageName}\`.` : `This code uses the global \`fetch\` function, HTTP requests are represented through \`HttpClient\` from \`${packageName}\`.`;
   const nodeToVisit = [];
   const appendNodeToVisit = (node) => {
     nodeToVisit.push(node);
@@ -7369,7 +7428,7 @@ var makeGlobalRandomApply = (checkInEffect) => fn(`globalRandom${checkInEffect ?
     if (inEffect !== checkInEffect) continue;
     report({
       location: node,
-      messageText: checkInEffect ? "Prefer using the Random service from Effect instead of Math.random() inside Effect generators." : "Prefer using the Random service from Effect instead of Math.random().",
+      messageText: checkInEffect ? "This Effect code uses `Math.random()`, randomness is represented through the Effect `Random` service." : "This code uses `Math.random()`, randomness is represented through the Effect `Random` service.",
       fixes: []
     });
   }
@@ -7400,12 +7459,12 @@ var globalRandom = createDiagnostic({
 // src/diagnostics/globalTimersInEffect.ts
 var timerAlternatives = {
   "setTimeout": {
-    inEffect: "Prefer using Effect.sleep or Schedule from Effect instead of setTimeout inside Effect generators.",
-    outsideEffect: "Prefer using Effect.sleep or Schedule from Effect instead of setTimeout."
+    inEffect: "This Effect code uses `setTimeout`, the corresponding timer API in this context is `Effect.sleep or Schedule` from Effect.",
+    outsideEffect: "This code uses `setTimeout`, the corresponding Effect timer API is `Effect.sleep or Schedule` from Effect."
   },
   "setInterval": {
-    inEffect: "Prefer using Schedule or Effect.repeat from Effect instead of setInterval inside Effect generators.",
-    outsideEffect: "Prefer using Schedule or Effect.repeat from Effect instead of setInterval."
+    inEffect: "This Effect code uses `setInterval`, the corresponding timer API in this context is `Schedule or Effect.repeat` from Effect.",
+    outsideEffect: "This code uses `setInterval`, the corresponding Effect timer API is `Schedule or Effect.repeat` from Effect."
   }
 };
 var makeGlobalTimersApply = (checkInEffect) => fn(`globalTimers${checkInEffect ? "InEffect" : ""}.apply`)(function* (sourceFile, report) {
@@ -7647,7 +7706,7 @@ var instanceOfSchema = createDiagnostic({
         if (isSchemaType._tag === "Some") {
           report({
             location: node,
-            messageText: "Consider using Schema.is instead of instanceof for Effect Schema types.",
+            messageText: "This code uses `instanceof` with an Effect Schema type. `Schema.is` is the schema-aware runtime check for this case.",
             fixes: [{
               fixName: "instanceOfSchema_fix",
               description: "Replace with Schema.is",
@@ -7917,7 +7976,7 @@ var leakingRequirements = createDiagnostic({
         location: node,
         messageText: `Methods of this Service require \`${requirementsStr}\` from every caller.
 
-This 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.
+The requirement becomes part of the public service surface instead of remaining internal to Layer implementation.
 
 Resolve these dependencies at Layer creation and provide them to each method, so the service's type reflects its purpose, not its implementation.
 
@@ -8114,7 +8173,7 @@ var missedPipeableOpportunity = createDiagnostic({
           ).trim() : "";
           report({
             location: flow2.node,
-            messageText: `Nested function calls can be converted to pipeable style for better readability; consider using ${subjectText}.pipe(...) instead.`,
+            messageText: `This nested call structure has a pipeable form. \`${subjectText}.pipe(...)\` represents the same call sequence in pipe style and may be easier to read.`,
             fixes: [{
               fixName: "missedPipeableOpportunity_fix",
               description: "Convert to pipe style",
@@ -8195,7 +8254,7 @@ var missingEffectContext = createDiagnostic({
             (missingTypes) => missingTypes.length > 0 ? report(
               {
                 location: node,
-                messageText: `Missing '${sortTypes(missingTypes).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect context.`,
+                messageText: `This Effect requires a service that is missing from the expected Effect context: \`${sortTypes(missingTypes).map((_) => typeChecker.typeToString(_)).join(" | ")}\`.`,
                 fixes: []
               }
             ) : void 0
@@ -8546,7 +8605,7 @@ var missingReturnYieldStar = createDiagnostic({
       }];
       report({
         location: unwrapped,
-        messageText: `It is recommended to use return yield* for Effects that never succeed to signal a definitive exit point for type narrowing and tooling support.`,
+        messageText: "This Effect never succeeds; using `return yield*` preserves a definitive generator exit point for type narrowing and tooling support.",
         fixes: fix
       });
     }
@@ -8602,7 +8661,7 @@ var missingStarInYieldEffectGen = createDiagnostic({
     brokenGenerators.forEach(
       (pos) => report({
         location: { pos, end: pos + "function".length },
-        messageText: `Seems like you used yield instead of yield* inside this Effect.gen.`,
+        messageText: "This uses `yield` for an `Effect` value. `yield*` is the Effect-aware form in this context.",
         fixes: []
       })
     );
@@ -8624,7 +8683,7 @@ var missingStarInYieldEffectGen = createDiagnostic({
       }] : [];
       report({
         location: node,
-        messageText: `When yielding Effects inside Effect.gen, you should use yield* instead of yield.`,
+        messageText: "This uses `yield` for an `Effect` value. `yield*` is the Effect-aware form in this context.",
         fixes: fix
       });
     });
@@ -8692,7 +8751,7 @@ var multipleEffectProvide = createDiagnostic({
         if (chunk.length < 2) continue;
         report({
           location: chunk[0].node,
-          messageText: "Avoid chaining Effect.provide calls, as this can lead to service lifecycle issues. Instead, merge layers and provide them in a single call.",
+          messageText: "This expression chains multiple `Effect.provide` calls. Providing Layers in multiple calls in a chain can break service lifecycle behavior compared with a single combined provide with merged layers.",
           fixes: [{
             fixName: "multipleEffectProvide_fix",
             description: "Combine into a single provide",
@@ -8782,7 +8841,7 @@ var nodeBuiltinImport = createDiagnostic({
         if (match2) {
           report({
             location: statement.moduleSpecifier,
-            messageText: `Prefer using ${match2.alternative} from ${match2.package} instead of the Node.js '${match2.module}' module.`,
+            messageText: `This module reference uses the \`${match2.module}\` module, the corresponding Effect API is \`${match2.alternative}\` from \`${match2.package}\`.`,
             fixes: []
           });
         }
@@ -8795,7 +8854,7 @@ var nodeBuiltinImport = createDiagnostic({
             if (match2) {
               report({
                 location: arg,
-                messageText: `Prefer using ${match2.alternative} from ${match2.package} instead of the Node.js '${match2.module}' module.`,
+                messageText: `This module reference uses the \`${match2.module}\` module, the corresponding Effect API is \`${match2.alternative}\` from \`${match2.package}\`.`,
                 fixes: []
               });
             }
@@ -8849,7 +8908,7 @@ var nonObjectEffectServiceType = createDiagnostic({
             const propertyValue = property.initializer;
             const errorToReport = {
               location: property.name,
-              messageText: "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.",
+              messageText: "`Effect.Service` is declared with a primitive service type. `Effect.Service` models object-shaped services; primitive values use `Context.Tag` or `Effect.Tag` directly.",
               fixes: []
             };
             if (propertyName === "succeed") {
@@ -9611,7 +9670,7 @@ var outdatedApi = createDiagnostic({
       hasReported = true;
       report({
         location: propertyAccess.name,
-        messageText: `${propertyName} is an Effect v3 API, but the project is using Effect v4.`,
+        messageText: `This project targets Effect v4, but this code uses the Effect v3 API \`${propertyName}\`. The referenced API belongs to the v3 surface rather than the configured v4 surface.`,
         fixes: []
       });
     }
@@ -9654,7 +9713,7 @@ var outdatedApi = createDiagnostic({
     if (hasReported) {
       report({
         location: { pos: 0, end: 0 },
-        messageText: "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.",
+        messageText: "This project targets Effect v4, but this code uses Effect v3 APIs. The referenced API belongs to the v3 surface rather than the configured v4 surface.",
         fixes: []
       });
     }
@@ -10899,7 +10958,7 @@ var overriddenSchemaConstructor = createDiagnostic({
               };
               report({
                 location: member,
-                messageText: "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.",
+                messageText: "This Schema subclass defines its own constructor. For Schema classes, constructor overrides break decoding behavior for the class shape. Custom construction can be expressed through a static `new` method instead.",
                 fixes: (member.body ? [fixAsStaticNew] : []).concat([{
                   fixName: "overriddenSchemaConstructor_fix",
                   description: "Remove the constructor override",
@@ -11021,7 +11080,7 @@ var preferSchemaOverJson = createDiagnostic({
       if (isSome2(match2)) {
         report({
           location: match2.value,
-          messageText: "Consider using Effect Schema for JSON operations instead of JSON.parse/JSON.stringify",
+          messageText: "This code uses `JSON.parse` or `JSON.stringify`. Effect Schema provides Effect-aware APIs for JSON parsing and stringifying.",
           fixes: []
         });
       }
@@ -11139,9 +11198,7 @@ var returnEffectInGen = createDiagnostic({
                 }] : [];
                 report({
                   location: node,
-                  messageText: `You are returning an Effect-able type inside a generator function, and will result in nested Effect<Effect<...>>.
-Maybe you wanted to return yield* instead?
-Nested 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.`,
+                  messageText: "This generator returns an Effect-able value directly, which produces a nested `Effect<Effect<...>>`. If the intended result is the inner Effect value, `return yield*` represents that form.",
                   fixes: fix
                 });
               }),
@@ -11296,9 +11353,7 @@ var runEffectInsideEffect = createDiagnostic({
             );
           });
           const v4MethodName = `${isEffectRunCall.value.methodName}With`;
-          const messageText = supportedEffect === "v4" ? `Using ${nodeText} inside an Effect is not recommended. The same services should generally be used instead to run child effects.
-Consider extracting the current services by using for example Effect.services and then use Effect.${v4MethodName} with the extracted services instead.` : `Using ${nodeText} inside an Effect is not recommended. The same runtime should generally be used instead to run child effects.
-Consider extracting the Runtime by using for example Effect.runtime and then use Runtime.${isEffectRunCall.value.methodName} with the extracted runtime instead.`;
+          const messageText = supportedEffect === "v4" ? `\`${nodeText}\` is called inside an Effect with a separate services invocation. In this context, child Effects run with the surrounding services, which can be accessed through \`Effect.services\` and \`Effect.${v4MethodName}\`.` : `\`${nodeText}\` is called inside an Effect with a separate runtime invocation. In this context, run child Effects with the surrounding runtime, which can be accessed through \`Effect.runtime\` and \`Runtime.${isEffectRunCall.value.methodName}\`.`;
           report({
             location: node.expression,
             messageText,
@@ -11311,7 +11366,7 @@ Consider extracting the Runtime by using for example Effect.runtime and then use
         } else {
           report({
             location: node.expression,
-            messageText: `Using ${nodeText} inside an Effect is not recommended. Effects inside generators can usually just be yielded.`,
+            messageText: `\`${nodeText}\` is called inside an existing Effect context. Here, the inner Effect can be used directly.`,
             fixes: []
           });
         }
@@ -11366,7 +11421,7 @@ var schemaStructWithTag = createDiagnostic({
                   const otherProperties = arg.properties.filter((prop) => prop !== tagProperty);
                   report({
                     location: node,
-                    messageText: "Schema.Struct with a _tag field can be simplified to Schema.TaggedStruct to make the tag optional in the constructor.",
+                    messageText: "This `Schema.Struct` includes a `_tag` field. `Schema.TaggedStruct` is the tagged-struct form for this pattern and makes the tag optional in the constructor.",
                     fixes: [{
                       fixName: "schemaStructWithTag_fix",
                       description: "Replace with Schema.TaggedStruct",
@@ -11459,7 +11514,7 @@ var schemaSyncInEffect = createDiagnostic({
       const effectMethodName = syncToEffectMethod[isSchemaSyncCall.value.methodName];
       report({
         location: node.expression,
-        messageText: `Using ${nodeText} inside an Effect generator is not recommended. Use Schema.${effectMethodName} instead to get properly typed error channel.`,
+        messageText: `\`${nodeText}\` is used inside an Effect generator. \`Schema.${effectMethodName}\` preserves the typed Effect error channel for this operation without throwing.`,
         fixes: []
       });
     }
@@ -11519,7 +11574,7 @@ var schemaUnionOfLiterals = createDiagnostic({
                 const schemaLiteralExpression = firstLiteralCall.expression;
                 report({
                   location: node,
-                  messageText: "A Schema.Union of multiple Schema.Literal calls can be simplified to a single Schema.Literal call.",
+                  messageText: "This `Schema.Union` contains multiple `Schema.Literal` members and can be simplified to a single `Schema.Literal` call.",
                   fixes: [{
                     fixName: "schemaUnionOfLiterals_fix",
                     description: "Replace with a single Schema.Literal call",
@@ -11582,8 +11637,7 @@ var scopeInLayerEffect = createDiagnostic({
         map4(
           () => report({
             location: node,
-            messageText: `Seems like you are constructing a layer with a scope in the requirements.
-Consider using "scoped" instead to get rid of the scope in the requirements.`,
+            messageText: "This layer construction leaves `Scope` in the requirement set. The scoped API removes `Scope` from the resulting requirements.",
             fixes: methodIdentifier ? [{
               fixName: "scopeInLayerEffect_scoped",
               description: "Use scoped for Layer creation",
@@ -11683,7 +11737,7 @@ var serviceNotAsClass = createDiagnostic({
       const shapeText = typeArgs.length > 0 ? typeArgs.map((t) => sourceFile.text.substring(ts.getTokenPosOfNode(t, sourceFile), t.end)).join(", ") : "Shape";
       report({
         location: callExpr,
-        messageText: `ServiceMap.Service should be used in a class declaration instead of as a variable. Use: class ${variableName} extends ServiceMap.Service<${variableName}, ${shapeText}>()("${argsText.replace(/['"]/g, "")}") {}`,
+        messageText: `\`ServiceMap.Service\` is assigned to a variable here, but this API is intended for a class declaration shape such as \`class ${variableName} extends ServiceMap.Service<${variableName}, ${shapeText}>()("${argsText.replace(/['"]/g, "")}") {}\`.`,
         fixes: [{
           fixName: "serviceNotAsClass",
           description: `Convert to class declaration`,
@@ -11896,7 +11950,7 @@ var tryCatchInEffectGen = createDiagnostic({
             map4(() => {
               report({
                 location: node,
-                messageText: `Avoid using try/catch inside Effect generators. Use Effect's error handling mechanisms instead (e.g. ${alternatives.join(", ")}).`,
+                messageText: `This Effect generator contains \`try/catch\`; in this context, error handling is expressed with Effect APIs such as ${alternatives.join(", ")}).`,
                 fixes: []
               });
             }),
@@ -11957,8 +12011,7 @@ var unknownInEffectCatch = createDiagnostic({
                     );
                     report({
                       location: node.expression,
-                      messageText: `The 'catch' callback in ${nodeText} returns 'unknown'. The catch callback should be used to provide typed errors.
-Consider wrapping unknown errors into Effect's Data.TaggedError for example, or narrow down the type to the specific error raised.`,
+                      messageText: `The \`catch\` callback in \`${nodeText}\` returns \`unknown\`, so the Effect error type stays untyped. A specific typed error preserves error-channel information, for example by narrowing the value or wrapping it in \`Data.TaggedError\`.`,
                       fixes: []
                     });
                   }
@@ -12055,7 +12108,7 @@ var unnecessaryFailYieldableError = createDiagnostic({
                 map4(
                   () => report({
                     location: node,
-                    messageText: `This Effect.fail call uses a yieldable error type as argument. You can yield* the error directly instead.`,
+                    messageText: "This `yield* Effect.fail(...)` passes a yieldable error value. `yield*` represents that value directly without wrapping it in `Effect.fail`.",
                     fixes: [{
                       fixName: "unnecessaryFailYieldableError_fix",
                       description: "Replace yield* Effect.fail with yield*",
@@ -12160,7 +12213,7 @@ var unnecessaryPipeChain = createDiagnostic({
           map4(({ innerCall, pipeCall }) => {
             report({
               location: node,
-              messageText: `Chained pipe calls can be simplified to a single pipe call`,
+              messageText: "This expression contains chained `pipe` calls that can be simplified to a single `pipe` call.",
               fixes: [{
                 fixName: "unnecessaryPipeChain_fix",
                 description: "Rewrite as single pipe call",