@effect/language-service 0.83.1 → 0.84.0

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.0",
   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) {
@@ -35020,6 +35044,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 +35285,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 +36529,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 +37924,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;
@@ -38058,9 +38341,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 +39184,7 @@ var diagnostics = [
   unnecessaryPipe,
   genericEffectServices,
   globalFetch,
+  globalFetchInEffect,
   returnEffectInGen,
   tryCatchInEffectGen,
   importFromBarrel,
@@ -38933,7 +39216,15 @@ var diagnostics = [
   preferSchemaOverJson,
   extendsNativeError,
   serviceNotAsClass,
-  nodeBuiltinImport
+  nodeBuiltinImport,
+  globalDate,
+  globalDateInEffect,
+  globalConsole,
+  globalConsoleInEffect,
+  globalRandom,
+  globalRandomInEffect,
+  globalTimers,
+  globalTimersInEffect
 ];
 
 // src/metadata.json
@@ -38967,9 +39258,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"
       }
     }
   ],
@@ -39702,10 +40002,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 +40107,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",