@effect/language-service 0.83.1 → 0.84.1

package/cli.js

@@ -25942,7 +25942,7 @@ var runWith2 = (command, config2) => {
 // package.json
 var package_default = {
   name: "@effect/language-service",
-  version: "0.83.1",
+  version: "0.84.1",
   publishConfig: {
     access: "public",
     directory: "dist"
@@ -28669,6 +28669,25 @@ function makeTypeCheckerUtils(ts, typeChecker, tsUtils) {
       return typeChecker.getTypeAtLocation(node);
     }
   }
+  function resolveToGlobalSymbol(symbol4) {
+    if (symbol4.flags & ts.SymbolFlags.Alias) {
+      symbol4 = typeChecker.getAliasedSymbol(symbol4);
+    }
+    let depth = 0;
+    while (depth < 2 && symbol4.valueDeclaration && ts.isVariableDeclaration(symbol4.valueDeclaration)) {
+      const initializer = symbol4.valueDeclaration.initializer;
+      if (!initializer) break;
+      let nextSymbol = typeChecker.getSymbolAtLocation(initializer);
+      if (!nextSymbol) break;
+      if (nextSymbol.flags & ts.SymbolFlags.Alias) {
+        nextSymbol = typeChecker.getAliasedSymbol(nextSymbol);
+      }
+      if (nextSymbol === symbol4) break;
+      symbol4 = nextSymbol;
+      depth++;
+    }
+    return symbol4;
+  }
   return {
     isUnion: isUnion2,
     isReadonlyArrayType,
@@ -28682,7 +28701,8 @@ function makeTypeCheckerUtils(ts, typeChecker, tsUtils) {
     expectedAndRealType,
     typeToSimplifiedTypeNode,
     isGlobalErrorType,
-    getTypeAtLocation
+    getTypeAtLocation,
+    resolveToGlobalSymbol
   };
 }
 
@@ -29370,7 +29390,11 @@ function make26(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
       }
       currentParent = nodeToCheck.parent;
     }
-    return { scopeNode, effectGen: effectGenResult };
+    return {
+      inEffect: effectGenResult !== void 0 && effectGenResult.body.statements.length > 0 && scopeNode === effectGenResult.generatorFunction,
+      scopeNode,
+      effectGen: effectGenResult
+    };
   });
   const effectFn = cachedBy(
     function(node) {
@@ -33911,12 +33935,14 @@ var getParameterName = (typescript, name) => {
   }
   return "parameter";
 };
-var hasOuterContextualFunctionType = (typescript, typeChecker, node) => {
+var hasOuterContextualFunctionType = (typescript, typeChecker, typeCheckerUtils, node) => {
   const contextualType = typeChecker.getContextualType(node);
   if (!contextualType) {
     return false;
   }
-  return typeChecker.getSignaturesOfType(contextualType, typescript.SignatureKind.Call).length > 0;
+  return typeCheckerUtils.unrollUnionMembers(contextualType).some(
+    (type) => typeChecker.getSignaturesOfType(type, typescript.SignatureKind.Call).length > 0
+  );
 };
 var effectFnImplicitAny = createDiagnostic({
   name: "effectFnImplicitAny",
@@ -33930,6 +33956,7 @@ var effectFnImplicitAny = createDiagnostic({
     const ts = yield* service2(TypeScriptApi);
     const program = yield* service2(TypeScriptProgram);
     const typeChecker = yield* service2(TypeCheckerApi);
+    const typeCheckerUtils = yield* service2(TypeCheckerUtils);
     const typeParser = yield* service2(TypeParser);
     const noImplicitAny = program.getCompilerOptions().noImplicitAny ?? program.getCompilerOptions().strict ?? false;
     if (!noImplicitAny) {
@@ -33969,7 +33996,7 @@ var effectFnImplicitAny = createDiagnostic({
         ),
         orUndefined
       );
-      if (!parsed || hasOuterContextualFunctionType(ts, typeChecker, parsed.call)) {
+      if (!parsed || hasOuterContextualFunctionType(ts, typeChecker, typeCheckerUtils, parsed.call)) {
         continue;
       }
       for (const parameter of parsed.fn.parameters) {
@@ -35020,6 +35047,128 @@ var genericEffectServices = createDiagnostic({
   })
 });
 
+// src/diagnostics/globalConsoleInEffect.ts
+var consoleMethodAlternatives = {
+  "log": "Effect.log or Logger",
+  "warn": "Effect.logWarning or Logger",
+  "error": "Effect.logError or Logger",
+  "info": "Effect.logInfo or Logger",
+  "debug": "Effect.logDebug or Logger",
+  "trace": "Effect.logTrace or Logger"
+};
+var makeGlobalConsoleApply = (checkInEffect) => fn3(`globalConsole${checkInEffect ? "InEffect" : ""}.apply`)(function* (sourceFile, report) {
+  const ts = yield* service2(TypeScriptApi);
+  const typeChecker = yield* service2(TypeCheckerApi);
+  const typeCheckerUtils = yield* service2(TypeCheckerUtils);
+  const typeParser = yield* service2(TypeParser);
+  const consoleSymbol = typeChecker.resolveName("console", void 0, ts.SymbolFlags.Value, false);
+  if (!consoleSymbol) 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)) continue;
+    const method = ts.idText(node.expression.name);
+    const alternative = consoleMethodAlternatives[method];
+    if (!alternative) continue;
+    const symbol4 = typeChecker.getSymbolAtLocation(node.expression.expression);
+    if (!symbol4) continue;
+    if (typeCheckerUtils.resolveToGlobalSymbol(symbol4) !== consoleSymbol) continue;
+    const { inEffect } = yield* typeParser.findEnclosingScopes(node);
+    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}.`,
+      fixes: []
+    });
+  }
+});
+var globalConsoleInEffect = createDiagnostic({
+  name: "globalConsoleInEffect",
+  code: 56,
+  description: "Warns when using console methods inside Effect generators instead of Effect.log/Logger",
+  group: "effectNative",
+  severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
+  apply: makeGlobalConsoleApply(true)
+});
+
+// src/diagnostics/globalConsole.ts
+var globalConsole = createDiagnostic({
+  name: "globalConsole",
+  code: 60,
+  description: "Warns when using console methods outside Effect generators instead of Effect.log/Logger",
+  group: "effectNative",
+  severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
+  apply: makeGlobalConsoleApply(false)
+});
+
+// src/diagnostics/globalDateInEffect.ts
+var makeGlobalDateApply = (checkInEffect) => fn3(`globalDate${checkInEffect ? "InEffect" : ""}.apply`)(function* (sourceFile, report) {
+  const ts = yield* service2(TypeScriptApi);
+  const typeChecker = yield* service2(TypeCheckerApi);
+  const typeCheckerUtils = yield* service2(TypeCheckerUtils);
+  const typeParser = yield* service2(TypeParser);
+  const dateSymbol = typeChecker.resolveName("Date", void 0, ts.SymbolFlags.Value, false);
+  if (!dateSymbol) 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);
+    let messageText;
+    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().";
+    } 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().";
+    }
+    if (!messageText || !objectNode) continue;
+    const symbol4 = typeChecker.getSymbolAtLocation(objectNode);
+    if (!symbol4) continue;
+    if (typeCheckerUtils.resolveToGlobalSymbol(symbol4) !== dateSymbol) continue;
+    const { inEffect } = yield* typeParser.findEnclosingScopes(node);
+    if (inEffect !== checkInEffect) continue;
+    report({ location: node, messageText, fixes: [] });
+  }
+});
+var globalDateInEffect = createDiagnostic({
+  name: "globalDateInEffect",
+  code: 55,
+  description: "Warns when using Date.now() or new Date() inside Effect generators instead of Clock/DateTime",
+  group: "effectNative",
+  severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
+  apply: makeGlobalDateApply(true)
+});
+
+// src/diagnostics/globalDate.ts
+var globalDate = createDiagnostic({
+  name: "globalDate",
+  code: 59,
+  description: "Warns when using Date.now() or new Date() outside Effect generators instead of Clock/DateTime",
+  group: "effectNative",
+  severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
+  apply: makeGlobalDateApply(false)
+});
+
 // src/diagnostics/globalErrorInEffectCatch.ts
 var globalErrorInEffectCatch = createDiagnostic({
   name: "globalErrorInEffectCatch",
@@ -35139,46 +35288,186 @@ var globalErrorInEffectFailure = createDiagnostic({
   })
 });
 
+// src/diagnostics/globalFetchInEffect.ts
+var makeGlobalFetchApply = (checkInEffect) => fn3(`globalFetch${checkInEffect ? "InEffect" : ""}.apply`)(function* (sourceFile, report) {
+  const ts = yield* service2(TypeScriptApi);
+  const typeChecker = yield* service2(TypeCheckerApi);
+  const typeCheckerUtils = yield* service2(TypeCheckerUtils);
+  const typeParser = yield* service2(TypeParser);
+  const fetchSymbol = typeChecker.resolveName("fetch", void 0, ts.SymbolFlags.Value, false);
+  if (!fetchSymbol) return;
+  const effectVersion = typeParser.supportedEffect();
+  const packageName = effectVersion === "v3" ? "@effect/platform" : "effect/unstable/http";
+  const messageText = 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 nodeToVisit = [];
+  const appendNodeToVisit = (node) => {
+    nodeToVisit.push(node);
+    return void 0;
+  };
+  ts.forEachChild(sourceFile, appendNodeToVisit);
+  while (nodeToVisit.length > 0) {
+    const node = nodeToVisit.shift();
+    if (ts.isCallExpression(node)) {
+      const symbol4 = typeChecker.getSymbolAtLocation(node.expression);
+      if (symbol4 && typeCheckerUtils.resolveToGlobalSymbol(symbol4) === fetchSymbol) {
+        const { inEffect } = yield* typeParser.findEnclosingScopes(node);
+        if (inEffect === checkInEffect) {
+          report({
+            location: node.expression,
+            messageText,
+            fixes: []
+          });
+        }
+      }
+    }
+    ts.forEachChild(node, appendNodeToVisit);
+  }
+});
+var globalFetchInEffect = createDiagnostic({
+  name: "globalFetchInEffect",
+  code: 63,
+  description: "Warns when using the global fetch function inside Effect generators instead of the Effect HTTP client",
+  group: "effectNative",
+  severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
+  apply: makeGlobalFetchApply(true)
+});
+
 // src/diagnostics/globalFetch.ts
 var globalFetch = createDiagnostic({
   name: "globalFetch",
   code: 53,
-  description: "Warns when using the global fetch function instead of the Effect HTTP client",
+  description: "Warns when using the global fetch function outside Effect generators instead of the Effect HTTP client",
   group: "effectNative",
   severity: "off",
   fixable: false,
   supportedEffect: ["v3", "v4"],
-  apply: fn3("globalFetch.apply")(function* (sourceFile, report) {
-    const ts = yield* service2(TypeScriptApi);
-    const typeChecker = yield* service2(TypeCheckerApi);
-    const typeParser = yield* service2(TypeParser);
-    const fetchSymbol = typeChecker.resolveName("fetch", void 0, ts.SymbolFlags.Value, false);
-    if (!fetchSymbol) return;
-    const effectVersion = typeParser.supportedEffect();
-    const packageName = effectVersion === "v3" ? "@effect/platform" : "effect/unstable/http";
-    const messageText = `Prefer using HttpClient from ${packageName} instead of the global 'fetch' function.`;
-    const nodeToVisit = [];
-    const appendNodeToVisit = (node) => {
-      nodeToVisit.push(node);
-      return void 0;
-    };
-    ts.forEachChild(sourceFile, appendNodeToVisit);
-    while (nodeToVisit.length > 0) {
-      const node = nodeToVisit.shift();
-      if (ts.isCallExpression(node)) {
-        const symbol4 = typeChecker.getSymbolAtLocation(node.expression);
-        const resolvedSymbol = symbol4 && symbol4.flags & ts.SymbolFlags.Alias ? typeChecker.getAliasedSymbol(symbol4) : symbol4;
-        if (resolvedSymbol === fetchSymbol) {
-          report({
-            location: node.expression,
-            messageText,
-            fixes: []
-          });
-        }
+  apply: makeGlobalFetchApply(false)
+});
+
+// src/diagnostics/globalRandomInEffect.ts
+var makeGlobalRandomApply = (checkInEffect) => fn3(`globalRandom${checkInEffect ? "InEffect" : ""}.apply`)(function* (sourceFile, report) {
+  const ts = yield* service2(TypeScriptApi);
+  const typeChecker = yield* service2(TypeCheckerApi);
+  const typeCheckerUtils = yield* service2(TypeCheckerUtils);
+  const typeParser = yield* service2(TypeParser);
+  const mathSymbol = typeChecker.resolveName("Math", void 0, ts.SymbolFlags.Value, false);
+  if (!mathSymbol) 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) !== "random") continue;
+    const symbol4 = typeChecker.getSymbolAtLocation(node.expression.expression);
+    if (!symbol4) continue;
+    if (typeCheckerUtils.resolveToGlobalSymbol(symbol4) !== mathSymbol) continue;
+    const { inEffect } = yield* typeParser.findEnclosingScopes(node);
+    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().",
+      fixes: []
+    });
+  }
+});
+var globalRandomInEffect = createDiagnostic({
+  name: "globalRandomInEffect",
+  code: 57,
+  description: "Warns when using Math.random() inside Effect generators instead of the Random service",
+  group: "effectNative",
+  severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
+  apply: makeGlobalRandomApply(true)
+});
+
+// src/diagnostics/globalRandom.ts
+var globalRandom = createDiagnostic({
+  name: "globalRandom",
+  code: 61,
+  description: "Warns when using Math.random() outside Effect generators instead of the Random service",
+  group: "effectNative",
+  severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
+  apply: makeGlobalRandomApply(false)
+});
+
+// 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."
+  },
+  "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."
+  }
+};
+var makeGlobalTimersApply = (checkInEffect) => fn3(`globalTimers${checkInEffect ? "InEffect" : ""}.apply`)(function* (sourceFile, report) {
+  const ts = yield* service2(TypeScriptApi);
+  const typeChecker = yield* service2(TypeCheckerApi);
+  const typeCheckerUtils = yield* service2(TypeCheckerUtils);
+  const typeParser = yield* service2(TypeParser);
+  const globalSymbols = /* @__PURE__ */ new Map();
+  for (const name of Object.keys(timerAlternatives)) {
+    const symbol4 = typeChecker.resolveName(name, void 0, ts.SymbolFlags.Value, false);
+    if (symbol4) globalSymbols.set(name, symbol4);
+  }
+  if (globalSymbols.size === 0) 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)) continue;
+    const symbol4 = typeChecker.getSymbolAtLocation(node.expression);
+    if (!symbol4) continue;
+    const resolvedSymbol = typeCheckerUtils.resolveToGlobalSymbol(symbol4);
+    let messageText;
+    for (const [name, symbol5] of globalSymbols) {
+      if (resolvedSymbol === symbol5) {
+        messageText = checkInEffect ? timerAlternatives[name].inEffect : timerAlternatives[name].outsideEffect;
+        break;
       }
-      ts.forEachChild(node, appendNodeToVisit);
     }
-  })
+    if (!messageText) continue;
+    const { inEffect } = yield* typeParser.findEnclosingScopes(node);
+    if (inEffect !== checkInEffect) continue;
+    report({ location: node, messageText, fixes: [] });
+  }
+});
+var globalTimersInEffect = createDiagnostic({
+  name: "globalTimersInEffect",
+  code: 58,
+  description: "Warns when using setTimeout/setInterval inside Effect generators instead of Effect.sleep/Schedule",
+  group: "effectNative",
+  severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
+  apply: makeGlobalTimersApply(true)
+});
+
+// src/diagnostics/globalTimers.ts
+var globalTimers = createDiagnostic({
+  name: "globalTimers",
+  code: 62,
+  description: "Warns when using setTimeout/setInterval outside Effect generators instead of Effect.sleep/Schedule",
+  group: "effectNative",
+  severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
+  apply: makeGlobalTimersApply(false)
 });
 
 // src/diagnostics/importFromBarrel.ts
@@ -36243,8 +36532,8 @@ var missingReturnYieldStar = createDiagnostic({
       if (!type) continue;
       const maybeEffect = yield* option4(typeParser.effectYieldableType(type, unwrapped.expression));
       if (!(isSome2(maybeEffect) && maybeEffect.value.A.flags & ts.TypeFlags.Never)) continue;
-      const { effectGen, scopeNode } = yield* typeParser.findEnclosingScopes(node);
-      if (!effectGen || scopeNode && scopeNode !== effectGen.generatorFunction) continue;
+      const { inEffect } = yield* typeParser.findEnclosingScopes(node);
+      if (!inEffect) continue;
       const fix = [{
         fixName: "missingReturnYieldStar_fix",
         description: "Add return statement",
@@ -37638,11 +37927,8 @@ var preferSchemaOverJson = createDiagnostic({
     });
     const jsonMethodInEffectGen = fn3("preferSchemaOverJson.jsonMethodInEffectGen")(
       function* (jsonCall) {
-        const { effectGen, scopeNode } = yield* typeParser.findEnclosingScopes(jsonCall);
-        if (!effectGen || effectGen.body.statements.length === 0) {
-          return yield* TypeParserIssue.issue;
-        }
-        if (scopeNode && scopeNode !== effectGen.generatorFunction) {
+        const { inEffect } = yield* typeParser.findEnclosingScopes(jsonCall);
+        if (!inEffect) {
           return yield* TypeParserIssue.issue;
         }
         return jsonCall;
@@ -37805,16 +38091,16 @@ Nested Effect-able types may be intended if you plan to later manually flatten o
 var runEffectInsideEffect = createDiagnostic({
   name: "runEffectInsideEffect",
   code: 32,
-  description: "Suggests using Runtime methods instead of Effect.run* inside Effect contexts",
+  description: "Suggests using Runtime or Effect.run*With methods instead of Effect.run* inside Effect contexts",
   group: "antipattern",
   severity: "suggestion",
   fixable: true,
-  supportedEffect: ["v3"],
+  supportedEffect: ["v3", "v4"],
   apply: fn3("runEffectInsideEffect.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
     const tsUtils = yield* service2(TypeScriptUtils);
-    if (typeParser.supportedEffect() === "v4") return;
+    const supportedEffect = typeParser.supportedEffect();
     const parseEffectMethod = (node, methodName) => pipe(
       typeParser.isNodeReferenceToEffectModuleApi(methodName)(node),
       map12(() => ({ node, methodName }))
@@ -37847,9 +38133,10 @@ var runEffectInsideEffect = createDiagnostic({
         if (scopeNode && scopeNode !== effectGen.generatorFunction) {
           const fixAddRuntime = gen3(function* () {
             const changeTracker = yield* service2(ChangeTracker);
-            const runtimeModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, "effect", "Runtime") || "Runtime";
             const effectModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, "effect", "Effect") || "Effect";
+            const runtimeModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, "effect", "Runtime") || "Runtime";
             let runtimeIdentifier = void 0;
+            let servicesIdentifier = void 0;
             for (const statement of effectGen.generatorFunction.body.statements) {
               if (ts.isVariableStatement(statement) && statement.declarationList.declarations.length === 1) {
                 const declaration = statement.declarationList.declarations[0];
@@ -37863,11 +38150,46 @@ var runEffectInsideEffect = createDiagnostic({
                     if (isSome2(maybeEffectRuntime) && ts.isIdentifier(declaration.name)) {
                       runtimeIdentifier = ts.idText(declaration.name);
                     }
+                    const maybeEffectServices = yield* pipe(
+                      typeParser.isNodeReferenceToEffectModuleApi("services")(yieldedExpression.expression),
+                      option4
+                    );
+                    if (isSome2(maybeEffectServices) && ts.isIdentifier(declaration.name)) {
+                      servicesIdentifier = ts.idText(declaration.name);
+                    }
                   }
                 }
               }
             }
-            if (!runtimeIdentifier) {
+            if (supportedEffect === "v4" && !servicesIdentifier) {
+              changeTracker.insertNodeAt(
+                sourceFile,
+                effectGen.body.statements[0].pos,
+                ts.factory.createVariableStatement(
+                  void 0,
+                  ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(
+                    "effectServices",
+                    void 0,
+                    void 0,
+                    ts.factory.createYieldExpression(
+                      ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+                      ts.factory.createCallExpression(
+                        ts.factory.createPropertyAccessExpression(
+                          ts.factory.createIdentifier(effectModuleIdentifier),
+                          "services"
+                        ),
+                        [ts.factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword)],
+                        []
+                      )
+                    )
+                  )], ts.NodeFlags.Const)
+                ),
+                {
+                  prefix: "\n",
+                  suffix: "\n"
+                }
+              );
+            } else if (supportedEffect === "v3" && !runtimeIdentifier) {
               changeTracker.insertNodeAt(
                 sourceFile,
                 effectGen.body.statements[0].pos,
@@ -37903,16 +38225,19 @@ var runEffectInsideEffect = createDiagnostic({
             changeTracker.insertText(
               sourceFile,
               node.arguments[0].pos,
-              `${runtimeModuleIdentifier}.${isEffectRunCall.value.methodName}(${runtimeIdentifier || "effectRuntime"}, `
+              supportedEffect === "v4" ? `${effectModuleIdentifier}.${isEffectRunCall.value.methodName}With(${servicesIdentifier || "effectServices"})(` : `${runtimeModuleIdentifier}.${isEffectRunCall.value.methodName}(${runtimeIdentifier || "effectRuntime"}, `
             );
           });
+          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.`;
           report({
             location: node.expression,
-            messageText: `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.`,
+            messageText,
             fixes: [{
               fixName: "runEffectInsideEffect_fix",
-              description: "Use a runtime to run the Effect",
+              description: supportedEffect === "v4" ? "Use the current services to run the Effect" : "Use a runtime to run the Effect",
               apply: fixAddRuntime
             }]
           });
@@ -38058,9 +38383,8 @@ var schemaSyncInEffect = createDiagnostic({
         option4
       );
       if (isNone2(isSchemaSyncCall)) continue;
-      const { effectGen, scopeNode } = yield* typeParser.findEnclosingScopes(node);
-      if (!effectGen || effectGen.body.statements.length === 0) continue;
-      if (scopeNode && scopeNode !== effectGen.generatorFunction) continue;
+      const { inEffect } = yield* typeParser.findEnclosingScopes(node);
+      if (!inEffect) continue;
       const nodeText = sourceFile.text.substring(
         ts.getTokenPosOfNode(node.expression, sourceFile),
         node.expression.end
@@ -38902,6 +39226,7 @@ var diagnostics = [
   unnecessaryPipe,
   genericEffectServices,
   globalFetch,
+  globalFetchInEffect,
   returnEffectInGen,
   tryCatchInEffectGen,
   importFromBarrel,
@@ -38933,7 +39258,15 @@ var diagnostics = [
   preferSchemaOverJson,
   extendsNativeError,
   serviceNotAsClass,
-  nodeBuiltinImport
+  nodeBuiltinImport,
+  globalDate,
+  globalDateInEffect,
+  globalConsole,
+  globalConsoleInEffect,
+  globalRandom,
+  globalRandomInEffect,
+  globalTimers,
+  globalTimersInEffect
 ];
 
 // src/metadata.json
@@ -38967,9 +39300,18 @@ var metadata_default = {
       diagnosticSeverity: {
         instanceOfSchema: "warning",
         globalFetch: "warning",
+        globalFetchInEffect: "warning",
         preferSchemaOverJson: "warning",
         extendsNativeError: "warning",
-        nodeBuiltinImport: "warning"
+        nodeBuiltinImport: "warning",
+        globalDate: "warning",
+        globalDateInEffect: "warning",
+        globalConsole: "warning",
+        globalConsoleInEffect: "warning",
+        globalRandom: "warning",
+        globalRandomInEffect: "warning",
+        globalTimers: "warning",
+        globalTimersInEffect: "warning"
       }
     }
   ],
@@ -39561,11 +39903,12 @@ var metadata_default = {
     {
       name: "runEffectInsideEffect",
       group: "antipattern",
-      description: "Suggests using Runtime methods instead of Effect.run* inside Effect contexts",
+      description: "Suggests using Runtime or Effect.run*With methods instead of Effect.run* inside Effect contexts",
       defaultSeverity: "suggestion",
       fixable: true,
       supportedEffect: [
-        "v3"
+        "v3",
+        "v4"
       ],
       preview: {
         sourceText: 'import { Effect } from "effect"\n\nexport const preview = Effect.gen(function*() {\n  const run = () => Effect.runSync(Effect.succeed(1))\n  return run()\n})\n',
@@ -39573,7 +39916,7 @@ var metadata_default = {
           {
             start: 101,
             end: 115,
-            text: "Using Effect.runSync inside an Effect is not recommended. The same runtime should generally be used instead to run child effects.\nConsider extracting the Runtime by using for example Effect.runtime and then use Runtime.runSync with the extracted runtime instead.    effect(runEffectInsideEffect)"
+            text: "Using Effect.runSync inside an Effect is not recommended. The same services should generally be used instead to run child effects.\nConsider extracting the current services by using for example Effect.services and then use Effect.runSyncWith with the extracted services instead.    effect(runEffectInsideEffect)"
           }
         ]
       }
@@ -39702,10 +40045,94 @@ var metadata_default = {
         ]
       }
     },
+    {
+      name: "globalConsole",
+      group: "effectNative",
+      description: "Warns when using console methods outside Effect generators instead of Effect.log/Logger",
+      defaultSeverity: "off",
+      fixable: false,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      preview: {
+        sourceText: '\nconsole.log("preview")\n',
+        diagnostics: [
+          {
+            start: 1,
+            end: 23,
+            text: "Prefer using Effect.log or Logger instead of console.log.    effect(globalConsole)"
+          }
+        ]
+      }
+    },
+    {
+      name: "globalConsoleInEffect",
+      group: "effectNative",
+      description: "Warns when using console methods inside Effect generators instead of Effect.log/Logger",
+      defaultSeverity: "off",
+      fixable: false,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      preview: {
+        sourceText: 'import { Effect } from "effect"\n\nexport const preview = Effect.gen(function*() {\n  console.log("hello")\n})\n',
+        diagnostics: [
+          {
+            start: 83,
+            end: 103,
+            text: "Prefer using Effect.log or Logger instead of console.log inside Effect generators.    effect(globalConsoleInEffect)"
+          }
+        ]
+      }
+    },
+    {
+      name: "globalDate",
+      group: "effectNative",
+      description: "Warns when using Date.now() or new Date() outside Effect generators instead of Clock/DateTime",
+      defaultSeverity: "off",
+      fixable: false,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      preview: {
+        sourceText: "\nexport const preview = Date.now()\n",
+        diagnostics: [
+          {
+            start: 24,
+            end: 34,
+            text: "Prefer using Clock or DateTime from Effect instead of Date.now().    effect(globalDate)"
+          }
+        ]
+      }
+    },
+    {
+      name: "globalDateInEffect",
+      group: "effectNative",
+      description: "Warns when using Date.now() or new Date() inside Effect generators instead of Clock/DateTime",
+      defaultSeverity: "off",
+      fixable: false,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      preview: {
+        sourceText: 'import { Effect } from "effect"\n\nexport const preview = Effect.gen(function*() {\n  const now = Date.now()\n  return now\n})\n',
+        diagnostics: [
+          {
+            start: 95,
+            end: 105,
+            text: "Prefer using Clock or DateTime from Effect instead of Date.now() inside Effect generators.    effect(globalDateInEffect)"
+          }
+        ]
+      }
+    },
     {
       name: "globalFetch",
       group: "effectNative",
-      description: "Warns when using the global fetch function instead of the Effect HTTP client",
+      description: "Warns when using the global fetch function outside Effect generators instead of the Effect HTTP client",
       defaultSeverity: "off",
       fixable: false,
       supportedEffect: [
@@ -39723,6 +40150,105 @@ var metadata_default = {
         ]
       }
     },
+    {
+      name: "globalFetchInEffect",
+      group: "effectNative",
+      description: "Warns when using the global fetch function inside Effect generators instead of the Effect HTTP client",
+      defaultSeverity: "off",
+      fixable: false,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      preview: {
+        sourceText: 'import { Effect } from "effect"\n\nexport const preview = Effect.gen(function*() {\n  return yield* Effect.promise(() => fetch("https://example.com"))\n})\n',
+        diagnostics: []
+      }
+    },
+    {
+      name: "globalRandom",
+      group: "effectNative",
+      description: "Warns when using Math.random() outside Effect generators instead of the Random service",
+      defaultSeverity: "off",
+      fixable: false,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      preview: {
+        sourceText: "\nexport const preview = Math.random()\n",
+        diagnostics: [
+          {
+            start: 24,
+            end: 37,
+            text: "Prefer using the Random service from Effect instead of Math.random().    effect(globalRandom)"
+          }
+        ]
+      }
+    },
+    {
+      name: "globalRandomInEffect",
+      group: "effectNative",
+      description: "Warns when using Math.random() inside Effect generators instead of the Random service",
+      defaultSeverity: "off",
+      fixable: false,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      preview: {
+        sourceText: 'import { Effect } from "effect"\n\nexport const preview = Effect.gen(function*() {\n  const r = Math.random()\n  return r\n})\n',
+        diagnostics: [
+          {
+            start: 93,
+            end: 106,
+            text: "Prefer using the Random service from Effect instead of Math.random() inside Effect generators.    effect(globalRandomInEffect)"
+          }
+        ]
+      }
+    },
+    {
+      name: "globalTimers",
+      group: "effectNative",
+      description: "Warns when using setTimeout/setInterval outside Effect generators instead of Effect.sleep/Schedule",
+      defaultSeverity: "off",
+      fixable: false,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      preview: {
+        sourceText: "\nsetTimeout(() => {}, 100)\n",
+        diagnostics: [
+          {
+            start: 1,
+            end: 26,
+            text: "Prefer using Effect.sleep or Schedule from Effect instead of setTimeout.    effect(globalTimers)"
+          }
+        ]
+      }
+    },
+    {
+      name: "globalTimersInEffect",
+      group: "effectNative",
+      description: "Warns when using setTimeout/setInterval inside Effect generators instead of Effect.sleep/Schedule",
+      defaultSeverity: "off",
+      fixable: false,
+      supportedEffect: [
+        "v3",
+        "v4"
+      ],
+      preview: {
+        sourceText: 'import { Effect } from "effect"\n\nexport const preview = Effect.gen(function*() {\n  setTimeout(() => {}, 100)\n})\n',
+        diagnostics: [
+          {
+            start: 83,
+            end: 108,
+            text: "Prefer using Effect.sleep or Schedule from Effect instead of setTimeout inside Effect generators.    effect(globalTimersInEffect)"
+          }
+        ]
+      }
+    },
     {
       name: "instanceOfSchema",
       group: "effectNative",