@effect/language-service 0.84.2 → 0.85.0

package/transform.js

@@ -24,7 +24,7 @@ __export(transform_exports, {
 });
 module.exports = __toCommonJS(transform_exports);
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.38/node_modules/effect/dist/Pipeable.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.43/node_modules/effect/dist/Pipeable.js
 var pipeArguments = (self, args3) => {
   switch (args3.length) {
     case 0:
@@ -57,7 +57,7 @@ var pipeArguments = (self, args3) => {
   }
 };
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.38/node_modules/effect/dist/Function.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.43/node_modules/effect/dist/Function.js
 var dual = function(arity, body) {
   if (typeof arity === "function") {
     return function() {
@@ -105,7 +105,7 @@ function pipe(a, ...args3) {
   return pipeArguments(a, args3);
 }
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.38/node_modules/effect/dist/internal/equal.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.43/node_modules/effect/dist/internal/equal.js
 var getAllObjectKeys = (obj) => {
   const keys2 = new Set(Reflect.ownKeys(obj));
   if (obj.constructor === Object) return keys2;
@@ -128,7 +128,7 @@ var getAllObjectKeys = (obj) => {
 };
 var byReferenceInstances = /* @__PURE__ */ new WeakSet();
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.38/node_modules/effect/dist/Predicate.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.43/node_modules/effect/dist/Predicate.js
 function isString(input) {
   return typeof input === "string";
 }
@@ -149,7 +149,7 @@ function isObjectKeyword(input) {
 }
 var hasProperty = /* @__PURE__ */ dual(2, (self, property) => isObjectKeyword(self) && property in self);
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.38/node_modules/effect/dist/Hash.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.43/node_modules/effect/dist/Hash.js
 var symbol = "~effect/interfaces/Hash";
 var hash = (self) => {
   switch (typeof self) {
@@ -268,7 +268,7 @@ function withVisitedTracking(obj, fn2) {
   return result;
 }
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.38/node_modules/effect/dist/Equal.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.43/node_modules/effect/dist/Equal.js
 var symbol2 = "~effect/interfaces/Equal";
 function equals() {
   if (arguments.length === 1) {
@@ -430,10 +430,10 @@ var compareSets = /* @__PURE__ */ makeCompareSet(compareBoth);
 var isEqual = (u) => hasProperty(u, symbol2);
 var asEquivalence = () => equals;
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.38/node_modules/effect/dist/internal/array.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.43/node_modules/effect/dist/internal/array.js
 var isArrayNonEmpty = (self) => self.length > 0;
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.38/node_modules/effect/dist/Redactable.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.43/node_modules/effect/dist/Redactable.js
 var symbolRedactable = /* @__PURE__ */ Symbol.for("~effect/Inspectable/redactable");
 var isRedactable = (u) => hasProperty(u, symbolRedactable);
 function redact(u) {
@@ -452,7 +452,7 @@ var emptyServiceMap = {
   }
 };
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.38/node_modules/effect/dist/Formatter.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.43/node_modules/effect/dist/Formatter.js
 function format(input, options) {
   const space = options?.space ?? 0;
   const seen = /* @__PURE__ */ new WeakSet();
@@ -531,7 +531,7 @@ function safeToString(input) {
   }
 }
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.38/node_modules/effect/dist/Inspectable.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.43/node_modules/effect/dist/Inspectable.js
 var NodeInspectSymbol = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
 var toJson = (input) => {
   try {
@@ -575,7 +575,7 @@ var Class = class {
   }
 };
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.38/node_modules/effect/dist/Utils.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.43/node_modules/effect/dist/Utils.js
 var SingleShotGen = class _SingleShotGen {
   called = false;
   self;
@@ -618,7 +618,7 @@ var forced = {
 var isNotOptimizedAway = /* @__PURE__ */ standard[InternalTypeId](() => new Error().stack)?.includes(InternalTypeId) === true;
 var internalCall = isNotOptimizedAway ? standard[InternalTypeId] : forced[InternalTypeId];
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.38/node_modules/effect/dist/internal/core.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.43/node_modules/effect/dist/internal/core.js
 var EffectTypeId = `~effect/Effect`;
 var ExitTypeId = `~effect/Exit`;
 var effectVariance = {
@@ -965,7 +965,7 @@ var DoneVoid = {
   value: void 0
 };
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.38/node_modules/effect/dist/internal/option.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.43/node_modules/effect/dist/internal/option.js
 var TypeId = "~effect/data/Option";
 var CommonProto = {
   [TypeId]: {
@@ -1036,7 +1036,7 @@ var some = (value) => {
   return a;
 };
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.38/node_modules/effect/dist/internal/result.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.43/node_modules/effect/dist/internal/result.js
 var TypeId2 = "~effect/data/Result";
 var CommonProto2 = {
   [TypeId2]: {
@@ -1107,13 +1107,13 @@ var succeed = (success) => {
   return a;
 };
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.38/node_modules/effect/dist/Order.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.43/node_modules/effect/dist/Order.js
 function make(compare) {
   return (self, that) => self === that ? 0 : compare(self, that);
 }
 var String2 = /* @__PURE__ */ make((self, that) => self < that ? -1 : 1);
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.38/node_modules/effect/dist/Option.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.43/node_modules/effect/dist/Option.js
 var none2 = () => none;
 var some2 = some;
 var isNone2 = isNone;
@@ -1123,7 +1123,7 @@ var orElse = /* @__PURE__ */ dual(2, (self, that) => isNone2(self) ? that() : se
 var fromNullishOr = (a) => a == null ? none2() : some2(a);
 var getOrUndefined = /* @__PURE__ */ getOrElse(constUndefined);
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.38/node_modules/effect/dist/Result.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.43/node_modules/effect/dist/Result.js
 var succeed2 = succeed;
 var fail2 = fail;
 var isFailure2 = isFailure;
@@ -1131,7 +1131,7 @@ var isSuccess2 = isSuccess;
 var map = /* @__PURE__ */ dual(2, (self, f) => isSuccess2(self) ? succeed2(f(self.success)) : fail2(self.failure));
 var getOrElse2 = /* @__PURE__ */ dual(2, (self, onFailure) => isFailure2(self) ? onFailure(self.failure) : self.success);
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.38/node_modules/effect/dist/Record.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.43/node_modules/effect/dist/Record.js
 var map2 = /* @__PURE__ */ dual(2, (self, f) => {
   const out = {
     ...self
@@ -1143,7 +1143,7 @@ var map2 = /* @__PURE__ */ dual(2, (self, f) => {
 });
 var keys = (self) => Object.keys(self);
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.38/node_modules/effect/dist/Array.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.43/node_modules/effect/dist/Array.js
 var Array2 = globalThis.Array;
 var fromIterable = (collection) => Array2.isArray(collection) ? collection : Array2.from(collection);
 var append = /* @__PURE__ */ dual(2, (self, last) => [...self, last]);
@@ -3477,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"),
@@ -3523,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);
@@ -4094,33 +4117,33 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     ),
     ([Identifier, Service]) => ({ Identifier, Service })
   );
-  const serviceVarianceStruct = (type, atLocation) => map4(
-    all(
-      varianceStructInvariantType(type, atLocation, "_Identifier"),
-      varianceStructInvariantType(type, atLocation, "_Service")
-    ),
-    ([Identifier, Service]) => ({ Identifier, Service })
-  );
   const serviceType = cachedBy(
     fn("TypeParser.serviceType")(function* (type, atLocation) {
+      if (supportedEffect() !== "v4") return yield* typeParserIssue("v4 only");
       yield* pipeableType(type, atLocation);
-      const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
-        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration
-      );
-      if (propertiesSymbols.length === 0) {
-        return yield* typeParserIssue("Type has no tag variance struct", type, atLocation);
+      const typeIdSymbol = typeChecker.getPropertyOfType(type, "~effect/ServiceMap/Service");
+      if (!typeIdSymbol) {
+        return yield* typeParserIssue("Type has no service key type id", type, atLocation);
       }
-      propertiesSymbols.sort((a, b) => ts.symbolName(b).indexOf("TypeId") - ts.symbolName(a).indexOf("TypeId"));
-      return yield* firstSuccessOf(propertiesSymbols.map((propertySymbol) => {
-        const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
-        return serviceVarianceStruct(propertyType, atLocation);
-      }));
+      const identifierSymbol = typeChecker.getPropertyOfType(type, "Identifier");
+      if (!identifierSymbol) {
+        return yield* typeParserIssue("Type has no 'Identifier' property", type, atLocation);
+      }
+      const serviceSymbol = typeChecker.getPropertyOfType(type, "Service");
+      if (!serviceSymbol) {
+        return yield* typeParserIssue("Type has no 'Service' property", type, atLocation);
+      }
+      return {
+        Identifier: typeChecker.getTypeOfSymbolAtLocation(identifierSymbol, atLocation),
+        Service: typeChecker.getTypeOfSymbolAtLocation(serviceSymbol, atLocation)
+      };
     }),
     "TypeParser.serviceType",
     (type) => type
   );
   const contextTag = cachedBy(
     fn("TypeParser.contextTag")(function* (type, atLocation) {
+      if (supportedEffect() !== "v3") return yield* typeParserIssue("v3 only");
       yield* pipeableType(type, atLocation);
       const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
         (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration
@@ -4261,6 +4284,19 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     "TypeParser.promiseLike",
     (type) => type
   );
+  const promiseType = cachedBy(
+    function(type, atLocation) {
+      const promiseSymbol = typeChecker.resolveName("Promise", void 0, ts.SymbolFlags.Type, false);
+      if (!promiseSymbol) return typeParserIssue("global Promise type not found", type, atLocation);
+      const globalPromiseType = typeChecker.getDeclaredTypeOfSymbol(promiseSymbol);
+      if (type === globalPromiseType || "target" in type && type.target === globalPromiseType || typeChecker.isTypeAssignableTo(type, globalPromiseType)) {
+        return succeed3(type);
+      }
+      return typeParserIssue("type is not a Promise", type, atLocation);
+    },
+    "TypeParser.promiseType",
+    (type) => type
+  );
   const extendsSchemaClass = cachedBy(
     fn("TypeParser.extendsSchemaClass")(function* (atLocation) {
       if (!atLocation.name) {
@@ -5258,6 +5294,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     isServiceMapTypeSourceFile,
     isNodeReferenceToServiceMapModuleApi,
     effectType,
+    streamType,
     strictEffectType,
     layerType,
     fiberType,
@@ -5279,6 +5316,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     singleArgCall,
     scopeType,
     promiseLike,
+    promiseType,
     extendsEffectTag,
     extendsEffectService,
     extendsServiceMapService,
@@ -5407,6 +5445,37 @@ var anyUnknownInErrorContext = createDiagnostic({
   })
 });
 
+// src/diagnostics/asyncFunction.ts
+var asyncFunction = createDiagnostic({
+  name: "asyncFunction",
+  code: 69,
+  description: "Warns when declaring async functions and suggests using Effect values and Effect.gen for async control flow",
+  group: "effectNative",
+  severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
+  apply: fn("asyncFunction.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const hasAsyncModifier = (node) => ts.getModifiers(node)?.some((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword) === true;
+    const visit = (node) => {
+      if (!ts.isFunctionDeclaration(node) && !ts.isFunctionExpression(node) && !ts.isArrowFunction(node) && !ts.isMethodDeclaration(node)) {
+        ts.forEachChild(node, visit);
+        return void 0;
+      }
+      if (hasAsyncModifier(node)) {
+        report({
+          location: node,
+          messageText: "This code declares an async function, consider representing this async control flow with Effect values and `Effect.gen`.",
+          fixes: []
+        });
+      }
+      ts.forEachChild(node, visit);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, visit);
+  })
+});
+
 // src/diagnostics/catchAllToMapError.ts
 var catchAllToMapError = createDiagnostic({
   name: "catchAllToMapError",
@@ -5485,7 +5554,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",
@@ -5549,7 +5618,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: []
             });
           }
@@ -5612,7 +5681,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}'`,
@@ -5635,6 +5704,59 @@ var classSelfMismatch = createDiagnostic({
   })
 });
 
+// src/diagnostics/cryptoRandomUUIDInEffect.ts
+var makeCryptoRandomUUIDApply = (checkInEffect) => fn(`cryptoRandomUUID${checkInEffect ? "InEffect" : ""}.apply`)(function* (sourceFile, report) {
+  const ts = yield* service(TypeScriptApi);
+  const typeChecker = yield* service(TypeCheckerApi);
+  const typeCheckerUtils = yield* service(TypeCheckerUtils);
+  const typeParser = yield* service(TypeParser);
+  const cryptoSymbol = typeChecker.resolveName("crypto", void 0, ts.SymbolFlags.Value, false);
+  if (!cryptoSymbol) return;
+  const nodeToVisit = [];
+  const appendNodeToVisit = (node) => {
+    nodeToVisit.push(node);
+    return void 0;
+  };
+  ts.forEachChild(sourceFile, appendNodeToVisit);
+  while (nodeToVisit.length > 0) {
+    const node = nodeToVisit.shift();
+    ts.forEachChild(node, appendNodeToVisit);
+    if (!ts.isCallExpression(node) || !ts.isPropertyAccessExpression(node.expression) || ts.idText(node.expression.name) !== "randomUUID") continue;
+    const symbol3 = typeChecker.getSymbolAtLocation(node.expression.expression);
+    if (!symbol3) continue;
+    if (typeCheckerUtils.resolveToGlobalSymbol(symbol3) !== cryptoSymbol) continue;
+    const { inEffect } = yield* typeParser.findEnclosingScopes(node);
+    if (inEffect !== checkInEffect) continue;
+    report({
+      location: node,
+      messageText: checkInEffect ? "This Effect code uses `crypto.randomUUID()`, prefer the Effect `Random` module instead because it uses Effect-injected randomness rather than the `crypto` module behind the scenes." : "This code uses `crypto.randomUUID()`, prefer the Effect `Random` module instead because it uses Effect-injected randomness rather than the `crypto` module behind the scenes.",
+      fixes: []
+    });
+  }
+});
+var cryptoRandomUUIDInEffect = createDiagnostic({
+  name: "cryptoRandomUUIDInEffect",
+  code: 67,
+  description: "Warns when using crypto.randomUUID() inside Effect generators instead of the Effect Random module, which uses Effect-injected randomness rather than the crypto module behind the scenes",
+  group: "effectNative",
+  severity: "off",
+  fixable: false,
+  supportedEffect: ["v4"],
+  apply: makeCryptoRandomUUIDApply(true)
+});
+
+// src/diagnostics/cryptoRandomUUID.ts
+var cryptoRandomUUID = createDiagnostic({
+  name: "cryptoRandomUUID",
+  code: 66,
+  description: "Warns when using crypto.randomUUID() outside Effect generators instead of the Effect Random module, which uses Effect-injected randomness rather than the crypto module behind the scenes",
+  group: "effectNative",
+  severity: "off",
+  fixable: false,
+  supportedEffect: ["v4"],
+  apply: makeCryptoRandomUUIDApply(false)
+});
+
 // src/core/KeyBuilder.ts
 var makeKeyBuilder = fn("KeyBuilder")(
   function* (sourceFile) {
@@ -5802,7 +5924,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}'`,
@@ -5841,9 +5963,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: []
@@ -5853,6 +5974,40 @@ ${versions.map((version) => `- found ${version} at ${resolvedPackages[packageNam
   })
 });
 
+// src/diagnostics/effectDoNotation.ts
+var effectDoNotation = createDiagnostic({
+  name: "effectDoNotation",
+  code: 73,
+  description: "Suggests using Effect.gen or Effect.fn instead of the Effect.Do notation helpers",
+  group: "style",
+  severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
+  apply: fn("effectDoNotation.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      const isReference = yield* orUndefined(typeParser.isNodeReferenceToEffectModuleApi("Do")(node));
+      if (isReference) {
+        report({
+          location: node,
+          messageText: "This uses the Effect do emulation. `Effect.gen` or `Effect.fn` achieve the same result with native JS scopes.",
+          fixes: []
+        });
+        continue;
+      }
+      ts.forEachChild(node, appendNodeToVisit);
+    }
+  })
+});
+
 // src/diagnostics/effectFnIife.ts
 var effectFnIife = createDiagnostic({
   name: "effectFnIife",
@@ -5951,7 +6106,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
       });
     }
@@ -6036,7 +6191,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: []
         });
       }
@@ -6632,7 +6787,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
       });
     }
@@ -6799,6 +6954,43 @@ var effectInVoidSuccess = createDiagnostic({
   })
 });
 
+// src/diagnostics/effectMapFlatten.ts
+var effectMapFlatten = createDiagnostic({
+  name: "effectMapFlatten",
+  code: 74,
+  description: "Suggests using Effect.flatMap instead of Effect.map followed by Effect.flatten in piping flows",
+  group: "style",
+  severity: "suggestion",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
+  apply: fn("effectMapFlatten.apply")(function* (sourceFile, report) {
+    const typeParser = yield* service(TypeParser);
+    const flows = yield* typeParser.pipingFlows(false)(sourceFile);
+    for (const flow2 of flows) {
+      for (let index = 0; index < flow2.transformations.length - 1; index++) {
+        const mapTransformation = flow2.transformations[index];
+        const flattenTransformation = flow2.transformations[index + 1];
+        if (!mapTransformation || !flattenTransformation || !mapTransformation?.args || flattenTransformation?.args || mapTransformation.kind !== "pipe" && mapTransformation.kind !== "pipeable" || flattenTransformation.kind !== mapTransformation.kind) {
+          continue;
+        }
+        const isMapCall = yield* orUndefined(
+          typeParser.isNodeReferenceToEffectModuleApi("map")(mapTransformation.callee)
+        );
+        const isFlattenCall = yield* orUndefined(
+          typeParser.isNodeReferenceToEffectModuleApi("flatten")(flattenTransformation.callee)
+        );
+        if (isMapCall && isFlattenCall) {
+          report({
+            location: flattenTransformation.callee,
+            messageText: "`Effect.map` + `Effect.flatten` is the same as `Effect.flatMap` that expresses the same steps more directly.",
+            fixes: []
+          });
+        }
+      }
+    }
+  })
+});
+
 // src/diagnostics/effectMapVoid.ts
 var effectMapVoid = createDiagnostic({
   name: "effectMapVoid",
@@ -6844,7 +7036,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",
@@ -6899,7 +7091,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",
@@ -6961,7 +7153,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: []
               });
             }
@@ -7006,7 +7198,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),
@@ -7015,10 +7212,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: []
           });
         }
@@ -7062,6 +7258,7 @@ var genericEffectServices = createDiagnostic({
       for (const [type, reportAt] of typesToCheck) {
         yield* pipe(
           typeParser.contextTag(type, node),
+          orElse2(() => typeParser.serviceType(type, node)),
           map4(() => {
             report({
               location: reportAt,
@@ -7113,7 +7310,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: []
     });
   }
@@ -7162,10 +7359,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);
@@ -7248,7 +7445,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: []
                     });
                   }
@@ -7328,7 +7525,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);
@@ -7401,7 +7598,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: []
     });
   }
@@ -7432,12 +7629,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) {
@@ -7679,7 +7876,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",
@@ -7825,6 +8022,55 @@ var layerMergeAllWithDependencies = createDiagnostic({
   })
 });
 
+// src/diagnostics/lazyPromiseInEffectSync.ts
+var lazyPromiseInEffectSync = createDiagnostic({
+  name: "lazyPromiseInEffectSync",
+  code: 70,
+  description: "Warns when Effect.sync lazily returns a Promise instead of using an async Effect constructor",
+  group: "antipattern",
+  severity: "warning",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
+  apply: fn("lazyPromiseInEffectSync.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
+    const typeParser = yield* service(TypeParser);
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts.forEachChild(node, appendNodeToVisit);
+      if (!ts.isCallExpression(node)) continue;
+      const isSyncCall = yield* orUndefined(
+        typeParser.isNodeReferenceToEffectModuleApi("sync")(node.expression)
+      );
+      if (!isSyncCall) continue;
+      const lazyArg = node.arguments[0];
+      if (!lazyArg) continue;
+      const lazyArgType = typeCheckerUtils.getTypeAtLocation(lazyArg);
+      if (!lazyArgType) continue;
+      const entries = typeCheckerUtils.unrollUnionMembers(lazyArgType).flatMap(
+        (member) => typeChecker.getSignaturesOfType(member, ts.SignatureKind.Call).map(
+          (signature) => typeParser.promiseType(typeChecker.getReturnTypeOfSignature(signature), lazyArg)
+        )
+      );
+      if (entries.length === 0) continue;
+      const promiseReturn = yield* orUndefined(firstSuccessOf(entries));
+      if (!promiseReturn) continue;
+      report({
+        location: lazyArg,
+        messageText: "This `Effect.sync` thunk returns a Promise. Use `Effect.promise` or `Effect.tryPromise` to represent async work.",
+        fixes: []
+      });
+    }
+  })
+});
+
 // src/diagnostics/leakingRequirements.ts
 var leakingRequirements = createDiagnostic({
   name: "leakingRequirements",
@@ -7949,7 +8195,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.
 
@@ -8146,7 +8392,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",
@@ -8227,7 +8473,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
@@ -8578,7 +8824,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
       });
     }
@@ -8634,7 +8880,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: []
       })
     );
@@ -8656,7 +8902,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
       });
     });
@@ -8724,7 +8970,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",
@@ -8758,6 +9004,74 @@ var multipleEffectProvide = createDiagnostic({
   })
 });
 
+// src/diagnostics/nestedEffectGenYield.ts
+var nestedEffectGenYield = createDiagnostic({
+  name: "nestedEffectGenYield",
+  code: 71,
+  description: "Warns when yielding a nested bare Effect.gen inside an existing Effect generator context",
+  group: "style",
+  severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
+  apply: fn("nestedEffectGenYield.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts.forEachChild(node, appendNodeToVisit);
+      if (!ts.isYieldExpression(node) || !node.asteriskToken || !node.expression) continue;
+      const { inEffect } = yield* typeParser.findEnclosingScopes(node);
+      if (!inEffect) continue;
+      const bareNestedEffectGen = yield* orUndefined(typeParser.effectGen(node.expression));
+      if (!bareNestedEffectGen) continue;
+      report({
+        location: node.expression,
+        messageText: "This `yield*` is applied to a nested `Effect.gen(...)` that can be inlined in the parent Effect generator context.",
+        fixes: []
+      });
+    }
+  })
+});
+
+// src/diagnostics/newPromise.ts
+var newPromise = createDiagnostic({
+  name: "newPromise",
+  code: 68,
+  description: "Warns when constructing promises with new Promise instead of using Effect APIs",
+  group: "effectNative",
+  severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
+  apply: fn("newPromise.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
+    const promiseSymbol = typeChecker.resolveName("Promise", void 0, ts.SymbolFlags.Value, false);
+    if (!promiseSymbol) return;
+    const visit = (node) => {
+      if (ts.isNewExpression(node)) {
+        const symbol3 = typeChecker.getSymbolAtLocation(node.expression);
+        if (symbol3 && typeCheckerUtils.resolveToGlobalSymbol(symbol3) === promiseSymbol) {
+          report({
+            location: node,
+            messageText: "This code constructs `new Promise(...)`, prefer Effect APIs such as `Effect.async`, `Effect.promise`, or `Effect.tryPromise` instead of manual Promise construction.",
+            fixes: []
+          });
+        }
+      }
+      ts.forEachChild(node, visit);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, visit);
+  })
+});
+
 // src/diagnostics/nodeBuiltinImport.ts
 var moduleAlternativesV3 = /* @__PURE__ */ new Map([
   ["fs", { alternative: "FileSystem", module: "fs", package: "@effect/platform" }],
@@ -8814,7 +9128,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: []
           });
         }
@@ -8827,7 +9141,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: []
               });
             }
@@ -8881,7 +9195,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") {
@@ -9101,6 +9415,14 @@ var effectModuleMigrationDb = {
   "yieldNow": asUnchanged,
   "zip": asUnchanged,
   "zipWith": asUnchanged,
+  "annotateLogsScoped": asUnchanged,
+  "awaitAllChildren": asUnchanged,
+  "bind": asUnchanged,
+  "bindTo": asUnchanged,
+  "Do": asUnchanged,
+  "let": asUnchanged,
+  "partition": asUnchanged,
+  "validate": asUnchanged,
   // Renamed APIs (v3 name → v4 name)
   "catchAll": asRenamedSameBehaviour("catch"),
   "catchAllCause": asRenamedSameBehaviour("catchCause"),
@@ -9120,14 +9442,6 @@ var effectModuleMigrationDb = {
   "serviceOptional": asRenamedSameBehaviour("serviceOption"),
   "tapErrorCause": asRenamedSameBehaviour("tapCause"),
   // Removed APIs
-  "annotateLogsScoped": asUnchanged,
-  "awaitAllChildren": asUnchanged,
-  "bind": asUnchanged,
-  "bindTo": asUnchanged,
-  "Do": asUnchanged,
-  "let": asUnchanged,
-  "partition": asUnchanged,
-  "validate": asUnchanged,
   "catchSomeDefect": asRemoved(
     "Use Effect.catchDefect or Effect.matchCause to handle specific defects."
   ),
@@ -9643,7 +9957,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: []
       });
     }
@@ -9686,7 +10000,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: []
       });
     }
@@ -10931,7 +11245,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",
@@ -11053,7 +11367,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: []
         });
       }
@@ -11061,6 +11375,63 @@ var preferSchemaOverJson = createDiagnostic({
   })
 });
 
+// src/diagnostics/processEnvInEffect.ts
+var isEnvPropertyAccess = (tsApi, node) => tsApi.isPropertyAccessExpression(node) && tsApi.idText(node.name) === "env";
+var isProcessEnvMemberAccess = (tsApi, node) => (tsApi.isPropertyAccessExpression(node) || tsApi.isElementAccessExpression(node)) && isEnvPropertyAccess(tsApi, node.expression);
+var makeProcessEnvApply = (checkInEffect) => fn(`processEnv${checkInEffect ? "InEffect" : ""}.apply`)(function* (sourceFile, report) {
+  const ts = yield* service(TypeScriptApi);
+  const typeChecker = yield* service(TypeCheckerApi);
+  const typeCheckerUtils = yield* service(TypeCheckerUtils);
+  const typeParser = yield* service(TypeParser);
+  const processSymbol = typeChecker.resolveName("process", void 0, ts.SymbolFlags.Value, false);
+  if (!processSymbol) return;
+  const nodeToVisit = [];
+  const appendNodeToVisit = (node) => {
+    nodeToVisit.push(node);
+    return void 0;
+  };
+  ts.forEachChild(sourceFile, appendNodeToVisit);
+  while (nodeToVisit.length > 0) {
+    const node = nodeToVisit.shift();
+    ts.forEachChild(node, appendNodeToVisit);
+    if (!isProcessEnvMemberAccess(ts, node)) continue;
+    const processNode = node.expression.expression;
+    if (!ts.isIdentifier(processNode) || ts.idText(processNode) !== "process") continue;
+    const symbol3 = typeChecker.getSymbolAtLocation(processNode);
+    if (!symbol3) continue;
+    if (typeCheckerUtils.resolveToGlobalSymbol(symbol3) !== processSymbol) continue;
+    const { inEffect } = yield* typeParser.findEnclosingScopes(node);
+    if (inEffect !== checkInEffect) continue;
+    report({
+      location: node,
+      messageText: checkInEffect ? "This Effect code reads from `process.env`, environment configuration in Effect code is represented through `Config` from Effect." : "This code reads from `process.env`, environment configuration is represented through `Config` from Effect.",
+      fixes: []
+    });
+  }
+});
+var processEnvInEffect = createDiagnostic({
+  name: "processEnvInEffect",
+  code: 65,
+  description: "Warns when reading process.env inside Effect generators instead of using Effect Config",
+  group: "effectNative",
+  severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
+  apply: makeProcessEnvApply(true)
+});
+
+// src/diagnostics/processEnv.ts
+var processEnv = createDiagnostic({
+  name: "processEnv",
+  code: 64,
+  description: "Warns when reading process.env outside Effect generators instead of using Effect Config",
+  group: "effectNative",
+  severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
+  apply: makeProcessEnvApply(false)
+});
+
 // src/diagnostics/redundantSchemaTagIdentifier.ts
 var redundantSchemaTagIdentifier = createDiagnostic({
   name: "redundantSchemaTagIdentifier",
@@ -11171,9 +11542,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
                 });
               }),
@@ -11328,9 +11697,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,
@@ -11343,7 +11710,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: []
           });
         }
@@ -11398,7 +11765,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",
@@ -11491,7 +11858,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: []
       });
     }
@@ -11551,7 +11918,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",
@@ -11614,8 +11981,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",
@@ -11715,7 +12081,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`,
@@ -11928,7 +12294,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: []
               });
             }),
@@ -11989,8 +12355,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: []
                     });
                   }
@@ -12004,6 +12369,56 @@ Consider wrapping unknown errors into Effect's Data.TaggedError for example, or
   })
 });
 
+// src/diagnostics/unnecessaryArrowBlock.ts
+var unnecessaryArrowBlock = createDiagnostic({
+  name: "unnecessaryArrowBlock",
+  code: 72,
+  description: "Suggests using a concise arrow body when the block only returns an expression",
+  group: "style",
+  severity: "off",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
+  apply: fn("unnecessaryArrowBlock.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts.forEachChild(node, appendNodeToVisit);
+      if (!ts.isArrowFunction(node) || !ts.isBlock(node.body)) continue;
+      if (node.body.statements.length !== 1) continue;
+      const [statement] = node.body.statements;
+      if (!ts.isReturnStatement(statement) || !statement.expression) continue;
+      const returnedExpression = statement.expression;
+      report({
+        location: node.body,
+        messageText: "This arrow function block only returns an expression and can use a concise body.",
+        fixes: [{
+          fixName: "unnecessaryArrowBlock_fix",
+          description: "Use a concise arrow body",
+          apply: gen(function* () {
+            const changeTracker = yield* service(ChangeTracker);
+            const replacementNode = ts.factory.updateArrowFunction(
+              node,
+              node.modifiers,
+              node.typeParameters,
+              node.parameters,
+              node.type,
+              node.equalsGreaterThanToken,
+              ts.factory.createParenthesizedExpression(returnedExpression)
+            );
+            changeTracker.replaceNode(sourceFile, node, replacementNode);
+          })
+        }]
+      });
+    }
+  })
+});
+
 // src/diagnostics/unnecessaryEffectGen.ts
 var unnecessaryEffectGen = createDiagnostic({
   name: "unnecessaryEffectGen",
@@ -12087,7 +12502,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*",
@@ -12192,7 +12607,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",
@@ -12304,12 +12719,17 @@ var unsupportedServiceAccessors = createDiagnostic({
 var diagnostics = [
   outdatedApi,
   anyUnknownInErrorContext,
+  asyncFunction,
   instanceOfSchema,
   catchAllToMapError,
   catchUnfailableEffect,
   classSelfMismatch,
+  cryptoRandomUUID,
+  cryptoRandomUUIDInEffect,
   duplicatePackage,
+  effectDoNotation,
   effectFnImplicitAny,
+  effectMapFlatten,
   effectGenUsesAdapter,
   missingEffectContext,
   missingEffectError,
@@ -12318,6 +12738,8 @@ var diagnostics = [
   floatingEffect,
   effectInFailure,
   missingStarInYieldEffectGen,
+  newPromise,
+  lazyPromiseInEffectSync,
   unnecessaryEffectGen,
   unnecessaryFailYieldableError,
   missingReturnYieldStar,
@@ -12326,6 +12748,8 @@ var diagnostics = [
   genericEffectServices,
   globalFetch,
   globalFetchInEffect,
+  processEnv,
+  processEnvInEffect,
   returnEffectInGen,
   tryCatchInEffectGen,
   importFromBarrel,
@@ -12343,6 +12767,8 @@ var diagnostics = [
   strictEffectProvide,
   unknownInEffectCatch,
   runEffectInsideEffect,
+  nestedEffectGenYield,
+  unnecessaryArrowBlock,
   schemaUnionOfLiterals,
   schemaStructWithTag,
   globalErrorInEffectCatch,