@effect/language-service 0.84.3 → 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]);
@@ -4117,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
@@ -4284,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) {
@@ -5303,6 +5316,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     singleArgCall,
     scopeType,
     promiseLike,
+    promiseType,
     extendsEffectTag,
     extendsEffectService,
     extendsServiceMapService,
@@ -5431,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",
@@ -5659,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) {
@@ -5876,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",
@@ -6822,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",
@@ -7089,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,
@@ -7852,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",
@@ -8785,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" }],
@@ -9128,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"),
@@ -9147,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."
   ),
@@ -11088,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",
@@ -12025,6 +12369,56 @@ var unknownInEffectCatch = createDiagnostic({
   })
 });
 
+// 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",
@@ -12325,12 +12719,17 @@ var unsupportedServiceAccessors = createDiagnostic({
 var diagnostics = [
   outdatedApi,
   anyUnknownInErrorContext,
+  asyncFunction,
   instanceOfSchema,
   catchAllToMapError,
   catchUnfailableEffect,
   classSelfMismatch,
+  cryptoRandomUUID,
+  cryptoRandomUUIDInEffect,
   duplicatePackage,
+  effectDoNotation,
   effectFnImplicitAny,
+  effectMapFlatten,
   effectGenUsesAdapter,
   missingEffectContext,
   missingEffectError,
@@ -12339,6 +12738,8 @@ var diagnostics = [
   floatingEffect,
   effectInFailure,
   missingStarInYieldEffectGen,
+  newPromise,
+  lazyPromiseInEffectSync,
   unnecessaryEffectGen,
   unnecessaryFailYieldableError,
   missingReturnYieldStar,
@@ -12347,6 +12748,8 @@ var diagnostics = [
   genericEffectServices,
   globalFetch,
   globalFetchInEffect,
+  processEnv,
+  processEnvInEffect,
   returnEffectInGen,
   tryCatchInEffectGen,
   importFromBarrel,
@@ -12364,6 +12767,8 @@ var diagnostics = [
   strictEffectProvide,
   unknownInEffectCatch,
   runEffectInsideEffect,
+  nestedEffectGenYield,
+  unnecessaryArrowBlock,
   schemaUnionOfLiterals,
   schemaStructWithTag,
   globalErrorInEffectCatch,