@effect/language-service 0.20.0 → 0.21.0

package/transform.js

@@ -3,9 +3,9 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+var __export = (target, all2) => {
+  for (var name in all2)
+    __defProp(target, name, { get: all2[name], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -428,6 +428,7 @@ function compareBoth(self, that) {
   return structuralRegionState.enabled && structuralRegionState.tester ? structuralRegionState.tester(self, that) : false;
 }
 var isEqual = (u) => hasProperty(u, symbol2);
+var equivalence = () => equals;
 
 // node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Inspectable.js
 var NodeInspectSymbol = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
@@ -759,6 +760,20 @@ var sort = /* @__PURE__ */ dual(2, (self, O) => {
   out.sort(O);
   return out;
 });
+var containsWith = (isEquivalent) => dual(2, (self, a) => {
+  for (const i of self) {
+    if (isEquivalent(a, i)) {
+      return true;
+    }
+  }
+  return false;
+});
+var _equivalence = /* @__PURE__ */ equivalence();
+var intersectionWith = (isEquivalent) => {
+  const has = containsWith(isEquivalent);
+  return dual(2, (self, that) => fromIterable(self).filter((a) => has(that, a)));
+};
+var intersection = /* @__PURE__ */ intersectionWith(_equivalence);
 var empty = () => [];
 var map2 = /* @__PURE__ */ dual(2, (self, f) => self.map(f));
 var flatMap = /* @__PURE__ */ dual(2, (self, f) => {
@@ -837,7 +852,8 @@ function make2(run2) {
   return result;
 }
 var unsafeRun = (fa) => {
-  const result = fa.run(contextEmpty);
+  const program = provideService(internalNanoCache, {})(fa);
+  const result = program.run(contextEmpty);
   switch (result._tag) {
     case "Left":
       return left2(result.value);
@@ -873,14 +889,14 @@ var orElse2 = (f) => (fa) => make2((ctx) => {
   return result;
 });
 var service = (tag) => make2(
-  (ctx) => tag.key in ctx.value ? makeInternalSuccess(ctx.value[tag.key]) : makeInternalDefect(`Cannot find service ${tag.key}`)
+  (ctx) => tag.key in ctx.value ? ctx.value[tag.key] : makeInternalDefect(`Cannot find service ${tag.key}`)
 );
 var provideService = (tag, value) => (fa) => make2((ctx) => {
   return fa.run({
     ...ctx,
     value: {
       ...ctx.value,
-      [tag.key]: value
+      [tag.key]: makeInternalSuccess(value)
     }
   });
 });
@@ -921,6 +937,41 @@ var option = (fa) => make2((ctx) => {
       return result;
   }
 });
+var successUndefined = makeInternalSuccess(void 0);
+var void_ = make2(() => successUndefined);
+var ignore = (fa) => make2((ctx) => {
+  fa.run(ctx);
+  return successUndefined;
+});
+var all = (...args) => make2((ctx) => {
+  const results = [];
+  for (const arg of args) {
+    const result = arg.run(ctx);
+    if (result._tag !== "Right") return result;
+    results.push(result.value);
+  }
+  return makeInternalSuccess(results);
+});
+var internalNanoCache = Tag(
+  "@effect/language-service/internalNanoCache"
+);
+function cachedBy(fa, key, lookupKey) {
+  return (...args) => make2((ctx) => {
+    const cacheObj = ctx.value[internalNanoCache.key];
+    let cache = cacheObj[key];
+    if (!cache) {
+      cache = /* @__PURE__ */ new Map();
+      cacheObj[key] = cache;
+    }
+    const lookup = lookupKey(...args);
+    if (cache.has(lookup)) {
+      return cache.get(lookup);
+    }
+    const result = fa(...args).run(ctx);
+    cache.set(lookup, result);
+    return result;
+  });
+}
 
 // src/core/LanguageServicePluginOptions.ts
 var LanguageServicePluginOptions = Tag("PluginOptions");
@@ -929,6 +980,7 @@ function parse(config) {
     diagnostics: isObject(config) && hasProperty(config, "diagnostics") && isBoolean(config.diagnostics) ? config.diagnostics : true,
     quickinfo: isObject(config) && hasProperty(config, "quickinfo") && isBoolean(config.quickinfo) ? config.quickinfo : true,
     completions: isObject(config) && hasProperty(config, "completions") && isBoolean(config.completions) ? config.completions : true,
+    goto: isObject(config) && hasProperty(config, "goto") && isBoolean(config.goto) ? config.goto : true,
     allowedDuplicatedPackages: isObject(config) && hasProperty(config, "allowedDuplicatedPackages") && isArray(config.allowedDuplicatedPackages) && config.allowedDuplicatedPackages.every(isString) ? config.allowedDuplicatedPackages.map((_) => _.toLowerCase()) : []
   };
 }
@@ -1452,55 +1504,6 @@ var appendToUniqueTypesMap = fn(
   }
 );
 
-// src/diagnostics/duplicatePackage.ts
-var checkedPackagesCache = /* @__PURE__ */ new Map();
-var programResolvedCacheSize = /* @__PURE__ */ new Map();
-var duplicatePackage = createDiagnostic({
-  name: "duplicatePackage",
-  code: 6,
-  apply: fn("duplicatePackage.apply")(function* (sourceFile) {
-    const ts = yield* service(TypeScriptApi);
-    const program = yield* service(TypeScriptProgram);
-    const options = yield* service(LanguageServicePluginOptions);
-    const effectDiagnostics = [];
-    if (sourceFile.statements.length < 1) return [];
-    let resolvedPackages = checkedPackagesCache.get(sourceFile.fileName) || {};
-    const newResolvedModuleSize = hasProperty(program, "resolvedModules") && hasProperty(program.resolvedModules, "size") && isNumber(program.resolvedModules.size) ? program.resolvedModules.size : 0;
-    const oldResolvedSize = programResolvedCacheSize.get(sourceFile.fileName) || -1;
-    if (newResolvedModuleSize !== oldResolvedSize) {
-      const seenPackages = /* @__PURE__ */ new Set();
-      resolvedPackages = {};
-      program.getSourceFiles().map((_) => {
-        const packageInfo = parsePackageContentNameAndVersionFromScope(_);
-        if (!packageInfo) return;
-        const packageNameAndVersion = packageInfo.name + "@" + packageInfo.version;
-        if (seenPackages.has(packageNameAndVersion)) return;
-        seenPackages.add(packageNameAndVersion);
-        if (!(packageInfo.name === "effect" || packageInfo.hasEffectInPeerDependencies)) return;
-        if (options.allowedDuplicatedPackages.indexOf(packageInfo.name) > -1) return;
-        resolvedPackages[packageInfo.name] = resolvedPackages[packageInfo.name] || {};
-        resolvedPackages[packageInfo.name][packageInfo.version] = packageInfo.contents;
-      });
-      checkedPackagesCache.set(sourceFile.fileName, resolvedPackages);
-      programResolvedCacheSize.set(sourceFile.fileName, newResolvedModuleSize);
-    }
-    for (const packageName of Object.keys(resolvedPackages)) {
-      if (Object.keys(resolvedPackages[packageName]).length > 1) {
-        const versions = Object.keys(resolvedPackages[packageName]);
-        effectDiagnostics.push({
-          node: sourceFile.statements[0],
-          category: ts.DiagnosticCategory.Warning,
-          messageText: `Package ${packageName} is referenced multiple times with different versions (${versions.join(", ")}) and may cause unexpected type errors.
-Cleanup your dependencies and your package lockfile to avoid multiple instances of this package and reload the project.
-If this is intended set the LSP config "allowedDuplicatedPackages" to ${JSON.stringify(options.allowedDuplicatedPackages.concat([packageName]))}.`,
-          fixes: []
-        });
-      }
-    }
-    return effectDiagnostics;
-  })
-});
-
 // src/core/AST.ts
 function collectSelfAndAncestorNodesInRange(node, textRange) {
   return sync(() => {
@@ -1856,400 +1859,508 @@ var parsePipeCall = fn("AST.parsePipeCall")(
   }
 );
 
-// src/utils/TypeParser.ts
-var TypeParserIssue = class {
-  constructor(type, node, message) {
-    this.type = type;
-    this.node = node;
-    this.message = message;
-  }
+// src/core/TypeParser.ts
+var TypeParser = Tag("@effect/language-service/TypeParser");
+var TypeParserIssue = class _TypeParserIssue {
   _tag = "@effect/language-service/TypeParserIssue";
+  static issue = fail(new _TypeParserIssue());
 };
-function typeParserIssue(message, type, node) {
-  return fail(new TypeParserIssue(type, node, message));
-}
-function covariantTypeArgument(type) {
-  const signatures = type.getCallSignatures();
-  if (signatures.length !== 1) {
-    return typeParserIssue("Covariant type has no call signature", type);
-  }
-  return succeed(signatures[0].getReturnType());
-}
-function contravariantTypeArgument(type) {
-  const signatures = type.getCallSignatures();
-  if (signatures.length !== 1) {
-    return typeParserIssue("Contravariant type has no call signature", type);
-  }
-  return succeed(signatures[0].getTypeParameterAtPosition(0));
-}
-function invariantTypeArgument(type) {
-  const signatures = type.getCallSignatures();
-  if (signatures.length !== 1) {
-    return typeParserIssue("Invariant type has no call signature", type);
+function make3(ts, typeChecker) {
+  function typeParserIssue(_message, _type, _node) {
+    return TypeParserIssue.issue;
+  }
+  function covariantTypeArgument(type) {
+    const signatures = type.getCallSignatures();
+    if (signatures.length !== 1) {
+      return typeParserIssue("Covariant type has no call signature", type);
+    }
+    return succeed(signatures[0].getReturnType());
   }
-  return succeed(signatures[0].getReturnType());
-}
-var pipeableType = fn("TypeParser.pipeableType")(function* (type, atLocation) {
-  const typeChecker = yield* service(TypeCheckerApi);
-  const pipeSymbol = typeChecker.getPropertyOfType(type, "pipe");
-  if (!pipeSymbol) {
-    return yield* typeParserIssue("Type has no 'pipe' property", type, atLocation);
+  function contravariantTypeArgument(type) {
+    const signatures = type.getCallSignatures();
+    if (signatures.length !== 1) {
+      return typeParserIssue("Contravariant type has no call signature", type);
+    }
+    return succeed(signatures[0].getTypeParameterAtPosition(0));
   }
-  const pipeType = typeChecker.getTypeOfSymbolAtLocation(pipeSymbol, atLocation);
-  const signatures = pipeType.getCallSignatures();
-  if (signatures.length === 0) {
-    return yield* typeParserIssue("'pipe' property is not callable", type, atLocation);
+  function invariantTypeArgument(type) {
+    const signatures = type.getCallSignatures();
+    if (signatures.length !== 1) {
+      return typeParserIssue("Invariant type has no call signature", type);
+    }
+    return succeed(signatures[0].getReturnType());
   }
-  return type;
-});
-var varianceStructCovariantType = fn("TypeParser.varianceStructCovariantType")(
-  function* (type, atLocation, propertyName) {
-    const typeChecker = yield* service(TypeCheckerApi);
+  const pipeableType = cachedBy(
+    fn("TypeParser.pipeableType")(function* (type, atLocation) {
+      const pipeSymbol = typeChecker.getPropertyOfType(type, "pipe");
+      if (!pipeSymbol) {
+        return yield* typeParserIssue("Type has no 'pipe' property", type, atLocation);
+      }
+      const pipeType = typeChecker.getTypeOfSymbolAtLocation(pipeSymbol, atLocation);
+      const signatures = pipeType.getCallSignatures();
+      if (signatures.length === 0) {
+        return yield* typeParserIssue("'pipe' property is not callable", type, atLocation);
+      }
+      return type;
+    }),
+    "TypeParser.pipeableType",
+    (type) => type
+  );
+  const varianceStructCovariantType = (type, atLocation, propertyName) => {
     const propertySymbol = typeChecker.getPropertyOfType(type, propertyName);
     if (!propertySymbol) {
-      return yield* typeParserIssue(`Type has no '${propertyName}' property`, type, atLocation);
+      return typeParserIssue(`Type has no '${propertyName}' property`, type, atLocation);
     }
     const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
-    return yield* covariantTypeArgument(propertyType);
-  }
-);
-var varianceStructContravariantType = fn(
-  "TypeParser.varianceStructContravariantType"
-)(
-  function* (type, atLocation, propertyName) {
-    const typeChecker = yield* service(TypeCheckerApi);
+    return covariantTypeArgument(propertyType);
+  };
+  const varianceStructContravariantType = (type, atLocation, propertyName) => {
     const propertySymbol = typeChecker.getPropertyOfType(type, propertyName);
     if (!propertySymbol) {
-      return yield* typeParserIssue(`Type has no '${propertyName}' property`, type, atLocation);
+      return typeParserIssue(`Type has no '${propertyName}' property`, type, atLocation);
     }
     const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
-    return yield* contravariantTypeArgument(propertyType);
-  }
-);
-var varianceStructInvariantType = fn("TypeParser.varianceStructInvariantType")(
-  function* (type, atLocation, propertyName) {
-    const typeChecker = yield* service(TypeCheckerApi);
+    return contravariantTypeArgument(propertyType);
+  };
+  const varianceStructInvariantType = (type, atLocation, propertyName) => {
     const propertySymbol = typeChecker.getPropertyOfType(type, propertyName);
     if (!propertySymbol) {
-      return yield* typeParserIssue(`Type has no '${propertyName}' property`, type, atLocation);
+      return typeParserIssue(`Type has no '${propertyName}' property`, type, atLocation);
     }
     const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
-    return yield* invariantTypeArgument(propertyType);
-  }
-);
-var effectVarianceStruct = fn("TypeParser.effectVarianceStruct")(function* (type, atLocation) {
-  return {
-    A: yield* varianceStructCovariantType(type, atLocation, "_A"),
-    E: yield* varianceStructCovariantType(type, atLocation, "_E"),
-    R: yield* varianceStructCovariantType(type, atLocation, "_R")
+    return invariantTypeArgument(propertyType);
   };
-});
-var layerVarianceStruct = fn("TypeParser.layerVarianceStruct")(function* (type, atLocation) {
-  return {
-    ROut: yield* varianceStructContravariantType(type, atLocation, "_ROut"),
-    E: yield* varianceStructCovariantType(type, atLocation, "_E"),
-    RIn: yield* varianceStructCovariantType(type, atLocation, "_RIn")
-  };
-});
-var effectType = fn("TypeParser.effectType")(function* (type, atLocation) {
-  const ts = yield* service(TypeScriptApi);
-  const typeChecker = yield* service(TypeCheckerApi);
-  yield* pipeableType(type, atLocation);
-  const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
-    (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional)
+  const effectVarianceStruct = (type, atLocation) => map3(
+    all(
+      varianceStructCovariantType(type, atLocation, "_A"),
+      varianceStructCovariantType(type, atLocation, "_E"),
+      varianceStructCovariantType(type, atLocation, "_R")
+    ),
+    ([A, E, R]) => ({ A, E, R })
   );
-  propertiesSymbols.sort((a, b) => b.name.indexOf("EffectTypeId") - a.name.indexOf("EffectTypeId"));
-  for (const propertySymbol of propertiesSymbols) {
-    const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
-    const varianceArgs = yield* option(effectVarianceStruct(
-      propertyType,
-      atLocation
-    ));
-    if (isSome2(varianceArgs)) {
-      return varianceArgs.value;
-    }
-  }
-  return yield* typeParserIssue("Type has no effect variance struct", type, atLocation);
-});
-var layerType = fn("TypeParser.layerType")(function* (type, atLocation) {
-  const ts = yield* service(TypeScriptApi);
-  const typeChecker = yield* service(TypeCheckerApi);
-  yield* pipeableType(type, atLocation);
-  const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
-    (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional)
+  const layerVarianceStruct = (type, atLocation) => map3(
+    all(
+      varianceStructContravariantType(type, atLocation, "_ROut"),
+      varianceStructCovariantType(type, atLocation, "_E"),
+      varianceStructCovariantType(type, atLocation, "_RIn")
+    ),
+    ([ROut, E, RIn]) => ({ ROut, E, RIn })
   );
-  propertiesSymbols.sort((a, b) => b.name.indexOf("LayerTypeId") - a.name.indexOf("LayerTypeId"));
-  for (const propertySymbol of propertiesSymbols) {
-    const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
-    const varianceArgs = yield* option(layerVarianceStruct(
-      propertyType,
-      atLocation
-    ));
-    if (isSome2(varianceArgs)) {
-      return varianceArgs.value;
-    }
-  }
-  return yield* typeParserIssue("Type has no layer variance struct", type, atLocation);
-});
-var fiberType = fn("TypeParser.fiberType")(function* (type, atLocation) {
-  const typeChecker = yield* service(TypeCheckerApi);
-  const awaitSymbol = typeChecker.getPropertyOfType(type, "await");
-  const pollSymbol = typeChecker.getPropertyOfType(type, "poll");
-  if (!awaitSymbol || !pollSymbol) {
-    return yield* typeParserIssue(
-      "Type is not a fiber because it does not have 'await' or 'poll' property",
-      type,
-      atLocation
-    );
-  }
-  return yield* effectType(type, atLocation);
-});
-var effectSubtype = fn("TypeParser.effectSubtype")(function* (type, atLocation) {
-  const typeChecker = yield* service(TypeCheckerApi);
-  const tagSymbol = typeChecker.getPropertyOfType(type, "_tag");
-  const getSymbol = typeChecker.getPropertyOfType(type, "get");
-  if (!(tagSymbol || getSymbol)) {
-    return yield* typeParserIssue(
-      "Type is not a subtype of effect because it does not have '_tag' or 'get' property",
-      type,
-      atLocation
-    );
-  }
-  return yield* effectType(type, atLocation);
-});
-var importedEffectModule = fn("TypeParser.importedEffectModule")(function* (node) {
-  const ts = yield* service(TypeScriptApi);
-  const typeChecker = yield* service(TypeCheckerApi);
-  const type = typeChecker.getTypeAtLocation(node);
-  const propertySymbol = typeChecker.getPropertyOfType(type, "never");
-  if (!propertySymbol) {
-    return yield* typeParserIssue("Type has no 'never' property", type, node);
-  }
-  if (!ts.isExpression(node)) {
-    return yield* typeParserIssue("Node is not an expression", type, node);
-  }
-  const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, node);
-  yield* effectType(propertyType, node);
-  return node;
-});
-var effectGen = fn("TypeParser.effectGen")(function* (node) {
-  const ts = yield* service(TypeScriptApi);
-  if (!ts.isCallExpression(node)) {
-    return yield* typeParserIssue("Node is not a call expression", void 0, node);
-  }
-  if (node.arguments.length === 0) {
-    return yield* typeParserIssue("Node has no arguments", void 0, node);
-  }
-  const generatorFunction = node.arguments[0];
-  if (!ts.isFunctionExpression(generatorFunction)) {
-    return yield* typeParserIssue("Node is not a function expression", void 0, node);
-  }
-  if (generatorFunction.asteriskToken === void 0) {
-    return yield* typeParserIssue("Node is not a generator function", void 0, node);
-  }
-  if (!ts.isPropertyAccessExpression(node.expression)) {
-    return yield* typeParserIssue("Node is not a property access expression", void 0, node);
-  }
-  const propertyAccess = node.expression;
-  if (propertyAccess.name.text !== "gen") {
-    return yield* typeParserIssue("Call expression name is not 'gen'", void 0, node);
-  }
-  const effectModule = yield* importedEffectModule(propertyAccess.expression);
-  return {
-    node,
-    effectModule,
-    generatorFunction,
-    body: generatorFunction.body,
-    functionStar: generatorFunction.getFirstToken()
-  };
-});
-var effectFnUntracedGen = fn("TypeParser.effectFnUntracedGen")(
-  function* (node) {
-    const ts = yield* service(TypeScriptApi);
-    if (!ts.isCallExpression(node)) {
-      return yield* typeParserIssue("Node is not a call expression", void 0, node);
-    }
-    if (node.arguments.length === 0) {
-      return yield* typeParserIssue("Node has no arguments", void 0, node);
-    }
-    const generatorFunction = node.arguments[0];
-    if (!ts.isFunctionExpression(generatorFunction)) {
-      return yield* typeParserIssue("Node is not a function expression", void 0, node);
-    }
-    if (generatorFunction.asteriskToken === void 0) {
-      return yield* typeParserIssue(
-        "Node is not a generator function",
-        void 0,
-        node
+  const effectType = cachedBy(
+    fn("TypeParser.effectType")(function* (type, atLocation) {
+      yield* pipeableType(type, atLocation);
+      const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
+        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional)
       );
-    }
-    if (!ts.isPropertyAccessExpression(node.expression)) {
-      return yield* typeParserIssue(
-        "Node is not a property access expression",
-        void 0,
-        node
+      propertiesSymbols.sort((a, b) => b.name.indexOf("EffectTypeId") - a.name.indexOf("EffectTypeId"));
+      for (const propertySymbol of propertiesSymbols) {
+        const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
+        const varianceArgs = yield* option(effectVarianceStruct(
+          propertyType,
+          atLocation
+        ));
+        if (isSome2(varianceArgs)) {
+          return varianceArgs.value;
+        }
+      }
+      return yield* typeParserIssue("Type has no effect variance struct", type, atLocation);
+    }),
+    "TypeParser.effectType",
+    (type) => type
+  );
+  const layerType = cachedBy(
+    fn("TypeParser.layerType")(function* (type, atLocation) {
+      yield* pipeableType(type, atLocation);
+      const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
+        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional)
       );
-    }
-    const propertyAccess = node.expression;
-    if (propertyAccess.name.text !== "fnUntraced") {
+      propertiesSymbols.sort((a, b) => b.name.indexOf("LayerTypeId") - a.name.indexOf("LayerTypeId"));
+      for (const propertySymbol of propertiesSymbols) {
+        const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
+        const varianceArgs = yield* option(layerVarianceStruct(
+          propertyType,
+          atLocation
+        ));
+        if (isSome2(varianceArgs)) {
+          return varianceArgs.value;
+        }
+      }
+      return yield* typeParserIssue("Type has no layer variance struct", type, atLocation);
+    }),
+    "TypeParser.layerType",
+    (type) => type
+  );
+  const fiberType = cachedBy(
+    fn("TypeParser.fiberType")(function* (type, atLocation) {
+      const awaitSymbol = typeChecker.getPropertyOfType(type, "await");
+      const pollSymbol = typeChecker.getPropertyOfType(type, "poll");
+      if (!awaitSymbol || !pollSymbol) {
+        return yield* typeParserIssue(
+          "Type is not a fiber because it does not have 'await' or 'poll' property",
+          type,
+          atLocation
+        );
+      }
+      return yield* effectType(type, atLocation);
+    }),
+    "TypeParser.fiberType",
+    (type) => type
+  );
+  const effectSubtype = cachedBy(
+    fn("TypeParser.effectSubtype")(function* (type, atLocation) {
+      const tagSymbol = typeChecker.getPropertyOfType(type, "_tag");
+      const getSymbol = typeChecker.getPropertyOfType(type, "get");
+      if (!(tagSymbol || getSymbol)) {
+        return yield* typeParserIssue(
+          "Type is not a subtype of effect because it does not have '_tag' or 'get' property",
+          type,
+          atLocation
+        );
+      }
+      return yield* effectType(type, atLocation);
+    }),
+    "TypeParser.effectSubtype",
+    (type) => type
+  );
+  const importedEffectModule = cachedBy(
+    fn("TypeParser.importedEffectModule")(function* (node) {
+      const type = typeChecker.getTypeAtLocation(node);
+      const propertySymbol = typeChecker.getPropertyOfType(type, "never");
+      if (!propertySymbol) {
+        return yield* typeParserIssue("Type has no 'never' property", type, node);
+      }
+      if (!ts.isExpression(node)) {
+        return yield* typeParserIssue("Node is not an expression", type, node);
+      }
+      const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, node);
+      yield* effectType(propertyType, node);
+      return node;
+    }),
+    "TypeParser.importedEffectModule",
+    (node) => node
+  );
+  const effectGen = cachedBy(
+    fn("TypeParser.effectGen")(function* (node) {
+      if (!ts.isCallExpression(node)) {
+        return yield* typeParserIssue("Node is not a call expression", void 0, node);
+      }
+      if (node.arguments.length === 0) {
+        return yield* typeParserIssue("Node has no arguments", void 0, node);
+      }
+      const generatorFunction = node.arguments[0];
+      if (!ts.isFunctionExpression(generatorFunction)) {
+        return yield* typeParserIssue("Node is not a function expression", void 0, node);
+      }
+      if (generatorFunction.asteriskToken === void 0) {
+        return yield* typeParserIssue("Node is not a generator function", void 0, node);
+      }
+      if (!ts.isPropertyAccessExpression(node.expression)) {
+        return yield* typeParserIssue("Node is not a property access expression", void 0, node);
+      }
+      const propertyAccess = node.expression;
+      if (propertyAccess.name.text !== "gen") {
+        return yield* typeParserIssue("Call expression name is not 'gen'", void 0, node);
+      }
+      const effectModule = yield* importedEffectModule(propertyAccess.expression);
+      return {
+        node,
+        effectModule,
+        generatorFunction,
+        body: generatorFunction.body,
+        functionStar: generatorFunction.getFirstToken()
+      };
+    }),
+    "TypeParser.effectGen",
+    (node) => node
+  );
+  const effectFnUntracedGen = cachedBy(
+    fn("TypeParser.effectFnUntracedGen")(
+      function* (node) {
+        if (!ts.isCallExpression(node)) {
+          return yield* typeParserIssue("Node is not a call expression", void 0, node);
+        }
+        if (node.arguments.length === 0) {
+          return yield* typeParserIssue("Node has no arguments", void 0, node);
+        }
+        const generatorFunction = node.arguments[0];
+        if (!ts.isFunctionExpression(generatorFunction)) {
+          return yield* typeParserIssue("Node is not a function expression", void 0, node);
+        }
+        if (generatorFunction.asteriskToken === void 0) {
+          return yield* typeParserIssue(
+            "Node is not a generator function",
+            void 0,
+            node
+          );
+        }
+        if (!ts.isPropertyAccessExpression(node.expression)) {
+          return yield* typeParserIssue(
+            "Node is not a property access expression",
+            void 0,
+            node
+          );
+        }
+        const propertyAccess = node.expression;
+        if (propertyAccess.name.text !== "fnUntraced") {
+          return yield* typeParserIssue(
+            "Call expression name is not 'fnUntraced'",
+            void 0,
+            node
+          );
+        }
+        const effectModule = yield* importedEffectModule(propertyAccess.expression);
+        return {
+          node,
+          effectModule,
+          generatorFunction,
+          body: generatorFunction.body,
+          functionStar: generatorFunction.getFirstToken()
+        };
+      }
+    ),
+    "TypeParser.effectFnUntracedGen",
+    (node) => node
+  );
+  const effectFnGen = cachedBy(
+    fn("TypeParser.effectFnGen")(function* (node) {
+      if (!ts.isCallExpression(node)) {
+        return yield* typeParserIssue("Node is not a call expression", void 0, node);
+      }
+      if (node.arguments.length === 0) {
+        return yield* typeParserIssue("Node has no arguments", void 0, node);
+      }
+      const generatorFunction = node.arguments[0];
+      if (!ts.isFunctionExpression(generatorFunction)) {
+        return yield* typeParserIssue(
+          "Node is not a function expression",
+          void 0,
+          node
+        );
+      }
+      if (generatorFunction.asteriskToken === void 0) {
+        return yield* typeParserIssue(
+          "Node is not a generator function",
+          void 0,
+          node
+        );
+      }
+      const expressionToTest = ts.isCallExpression(node.expression) ? node.expression.expression : node.expression;
+      if (!ts.isPropertyAccessExpression(expressionToTest)) {
+        return yield* typeParserIssue(
+          "Node is not a property access expression",
+          void 0,
+          node
+        );
+      }
+      const propertyAccess = expressionToTest;
+      if (propertyAccess.name.text !== "fn") {
+        return yield* typeParserIssue(
+          "Call expression name is not 'fn'",
+          void 0,
+          node
+        );
+      }
+      const effectModule = yield* importedEffectModule(propertyAccess.expression);
+      return {
+        node,
+        generatorFunction,
+        effectModule,
+        body: generatorFunction.body,
+        functionStar: generatorFunction.getFirstToken()
+      };
+    }),
+    "TypeParser.effectFnGen",
+    (node) => node
+  );
+  const unnecessaryEffectGen2 = cachedBy(
+    fn("TypeParser.unnecessaryEffectGen")(function* (node) {
+      const { body } = yield* effectGen(node);
+      if (body.statements.length !== 1) {
+        return yield* typeParserIssue(
+          "Generator body should have a single statement",
+          void 0,
+          node
+        );
+      }
+      let explicitReturn = false;
+      let nodeToCheck = body.statements[0];
+      while (nodeToCheck) {
+        if (ts.isReturnStatement(nodeToCheck) && nodeToCheck.expression) {
+          nodeToCheck = nodeToCheck.expression;
+          explicitReturn = true;
+          continue;
+        }
+        if (ts.isExpressionStatement(nodeToCheck)) {
+          nodeToCheck = nodeToCheck.expression;
+          continue;
+        }
+        if (ts.isYieldExpression(nodeToCheck) && nodeToCheck.asteriskToken && nodeToCheck.expression) {
+          const yieldedExpression = nodeToCheck.expression;
+          const type = typeChecker.getTypeAtLocation(yieldedExpression);
+          const { A: successType } = yield* effectType(type, yieldedExpression);
+          let replacementNode = succeed(yieldedExpression);
+          if (!explicitReturn && !(successType.flags & ts.TypeFlags.VoidLike)) {
+            replacementNode = pipe(
+              gen(function* () {
+                const effectIdentifier = pipe(
+                  yield* option(
+                    findImportedModuleIdentifierByPackageAndNameOrBarrel(node.getSourceFile(), "effect", "Effect")
+                  ),
+                  match({
+                    onNone: () => "Effect",
+                    onSome: (_) => _.text
+                  })
+                );
+                return ts.factory.createCallExpression(
+                  ts.factory.createPropertyAccessExpression(
+                    ts.factory.createIdentifier(effectIdentifier),
+                    "asVoid"
+                  ),
+                  void 0,
+                  [
+                    yieldedExpression
+                  ]
+                );
+              }),
+              provideService(TypeScriptApi, ts)
+            );
+          }
+          return { node, body, yieldedExpression, replacementNode };
+        }
+        break;
+      }
       return yield* typeParserIssue(
-        "Call expression name is not 'fnUntraced'",
+        "Not an handled node",
         void 0,
         node
       );
-    }
-    const effectModule = yield* importedEffectModule(propertyAccess.expression);
-    return {
-      node,
-      effectModule,
-      generatorFunction,
-      body: generatorFunction.body,
-      functionStar: generatorFunction.getFirstToken()
-    };
-  }
-);
-var effectFnGen = fn("TypeParser.effectFnGen")(function* (node) {
-  const ts = yield* service(TypeScriptApi);
-  if (!ts.isCallExpression(node)) {
-    return yield* typeParserIssue("Node is not a call expression", void 0, node);
-  }
-  if (node.arguments.length === 0) {
-    return yield* typeParserIssue("Node has no arguments", void 0, node);
-  }
-  const generatorFunction = node.arguments[0];
-  if (!ts.isFunctionExpression(generatorFunction)) {
-    return yield* typeParserIssue(
-      "Node is not a function expression",
-      void 0,
-      node
-    );
-  }
-  if (generatorFunction.asteriskToken === void 0) {
-    return yield* typeParserIssue(
-      "Node is not a generator function",
-      void 0,
-      node
-    );
-  }
-  const expressionToTest = ts.isCallExpression(node.expression) ? node.expression.expression : node.expression;
-  if (!ts.isPropertyAccessExpression(expressionToTest)) {
-    return yield* typeParserIssue(
-      "Node is not a property access expression",
-      void 0,
-      node
-    );
-  }
-  const propertyAccess = expressionToTest;
-  if (propertyAccess.name.text !== "fn") {
-    return yield* typeParserIssue(
-      "Call expression name is not 'fn'",
-      void 0,
-      node
-    );
-  }
-  const effectModule = yield* importedEffectModule(propertyAccess.expression);
+    }),
+    "TypeParser.unnecessaryEffectGen",
+    (node) => node
+  );
+  const effectSchemaVarianceStruct = (type, atLocation) => map3(
+    all(
+      varianceStructInvariantType(type, atLocation, "_A"),
+      varianceStructInvariantType(type, atLocation, "_I"),
+      varianceStructCovariantType(type, atLocation, "_R")
+    ),
+    ([A, I, R]) => ({ A, I, R })
+  );
+  const effectSchemaType = cachedBy(
+    fn("TypeParser.effectSchemaType")(function* (type, atLocation) {
+      yield* pipeableType(type, atLocation);
+      const ast = typeChecker.getPropertyOfType(type, "ast");
+      if (!ast) return yield* typeParserIssue("Has no 'ast' property", type, atLocation);
+      const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
+        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional)
+      );
+      propertiesSymbols.sort((a, b) => b.name.indexOf("TypeId") - a.name.indexOf("TypeId"));
+      for (const propertySymbol of propertiesSymbols) {
+        const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
+        const varianceArgs = yield* option(effectSchemaVarianceStruct(
+          propertyType,
+          atLocation
+        ));
+        if (isSome2(varianceArgs)) {
+          return varianceArgs.value;
+        }
+      }
+      return yield* typeParserIssue("Type has no schema variance struct", type, atLocation);
+    }),
+    "TypeParser.effectSchemaType",
+    (type) => type
+  );
+  const contextTagVarianceStruct = (type, atLocation) => map3(
+    all(
+      varianceStructInvariantType(type, atLocation, "_Identifier"),
+      varianceStructInvariantType(type, atLocation, "_Service")
+    ),
+    ([Identifier, Service]) => ({ Identifier, Service })
+  );
+  const contextTag = cachedBy(
+    fn("TypeParser.contextTag")(function* (type, atLocation) {
+      yield* pipeableType(type, atLocation);
+      const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
+        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional)
+      );
+      propertiesSymbols.sort((a, b) => b.name.indexOf("TypeId") - a.name.indexOf("TypeId"));
+      for (const propertySymbol of propertiesSymbols) {
+        const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
+        const varianceArgs = yield* option(contextTagVarianceStruct(
+          propertyType,
+          atLocation
+        ));
+        if (isSome2(varianceArgs)) {
+          return varianceArgs.value;
+        }
+      }
+      return yield* typeParserIssue("Type has no tag variance struct", type, atLocation);
+    }),
+    "TypeParser.contextTag",
+    (type) => type
+  );
   return {
-    node,
-    generatorFunction,
-    effectModule,
-    body: generatorFunction.body,
-    functionStar: generatorFunction.getFirstToken()
+    effectType,
+    layerType,
+    fiberType,
+    effectSubtype,
+    importedEffectModule,
+    effectGen,
+    effectFnUntracedGen,
+    effectFnGen,
+    unnecessaryEffectGen: unnecessaryEffectGen2,
+    effectSchemaType,
+    contextTag
   };
-});
-var unnecessaryEffectGen = fn("TypeParser.unnecessaryEffectGen")(function* (node) {
-  const ts = yield* service(TypeScriptApi);
-  const typeChecker = yield* service(TypeCheckerApi);
-  const { body } = yield* effectGen(node);
-  if (body.statements.length !== 1) {
-    return yield* typeParserIssue(
-      "Generator body should have a single statement",
-      void 0,
-      node
-    );
-  }
-  let explicitReturn = false;
-  let nodeToCheck = body.statements[0];
-  while (nodeToCheck) {
-    if (ts.isReturnStatement(nodeToCheck) && nodeToCheck.expression) {
-      nodeToCheck = nodeToCheck.expression;
-      explicitReturn = true;
-      continue;
-    }
-    if (ts.isExpressionStatement(nodeToCheck)) {
-      nodeToCheck = nodeToCheck.expression;
-      continue;
+}
+
+// src/diagnostics/duplicatePackage.ts
+var checkedPackagesCache = /* @__PURE__ */ new Map();
+var programResolvedCacheSize = /* @__PURE__ */ new Map();
+var duplicatePackage = createDiagnostic({
+  name: "duplicatePackage",
+  code: 6,
+  apply: fn("duplicatePackage.apply")(function* (sourceFile) {
+    const ts = yield* service(TypeScriptApi);
+    const program = yield* service(TypeScriptProgram);
+    const options = yield* service(LanguageServicePluginOptions);
+    const effectDiagnostics = [];
+    if (sourceFile.statements.length < 1) return [];
+    let resolvedPackages = checkedPackagesCache.get(sourceFile.fileName) || {};
+    const newResolvedModuleSize = hasProperty(program, "resolvedModules") && hasProperty(program.resolvedModules, "size") && isNumber(program.resolvedModules.size) ? program.resolvedModules.size : 0;
+    const oldResolvedSize = programResolvedCacheSize.get(sourceFile.fileName) || -1;
+    if (newResolvedModuleSize !== oldResolvedSize) {
+      const seenPackages = /* @__PURE__ */ new Set();
+      resolvedPackages = {};
+      program.getSourceFiles().map((_) => {
+        const packageInfo = parsePackageContentNameAndVersionFromScope(_);
+        if (!packageInfo) return;
+        const packageNameAndVersion = packageInfo.name + "@" + packageInfo.version;
+        if (seenPackages.has(packageNameAndVersion)) return;
+        seenPackages.add(packageNameAndVersion);
+        if (!(packageInfo.name === "effect" || packageInfo.hasEffectInPeerDependencies)) return;
+        if (options.allowedDuplicatedPackages.indexOf(packageInfo.name) > -1) return;
+        resolvedPackages[packageInfo.name] = resolvedPackages[packageInfo.name] || {};
+        resolvedPackages[packageInfo.name][packageInfo.version] = packageInfo.contents;
+      });
+      checkedPackagesCache.set(sourceFile.fileName, resolvedPackages);
+      programResolvedCacheSize.set(sourceFile.fileName, newResolvedModuleSize);
     }
-    if (ts.isYieldExpression(nodeToCheck) && nodeToCheck.asteriskToken && nodeToCheck.expression) {
-      const yieldedExpression = nodeToCheck.expression;
-      const type = typeChecker.getTypeAtLocation(yieldedExpression);
-      const { A: successType } = yield* effectType(type, yieldedExpression);
-      let replacementNode = succeed(yieldedExpression);
-      if (!explicitReturn && !(successType.flags & ts.TypeFlags.VoidLike)) {
-        replacementNode = pipe(
-          gen(function* () {
-            const effectIdentifier = pipe(
-              yield* option(
-                findImportedModuleIdentifierByPackageAndNameOrBarrel(node.getSourceFile(), "effect", "Effect")
-              ),
-              match({
-                onNone: () => "Effect",
-                onSome: (_) => _.text
-              })
-            );
-            return ts.factory.createCallExpression(
-              ts.factory.createPropertyAccessExpression(
-                ts.factory.createIdentifier(effectIdentifier),
-                "asVoid"
-              ),
-              void 0,
-              [
-                yieldedExpression
-              ]
-            );
-          }),
-          provideService(TypeScriptApi, ts)
-        );
+    for (const packageName of Object.keys(resolvedPackages)) {
+      if (Object.keys(resolvedPackages[packageName]).length > 1) {
+        const versions = Object.keys(resolvedPackages[packageName]);
+        effectDiagnostics.push({
+          node: sourceFile.statements[0],
+          category: ts.DiagnosticCategory.Warning,
+          messageText: `Package ${packageName} is referenced multiple times with different versions (${versions.join(", ")}) and may cause unexpected type errors.
+Cleanup your dependencies and your package lockfile to avoid multiple instances of this package and reload the project.
+If this is intended set the LSP config "allowedDuplicatedPackages" to ${JSON.stringify(options.allowedDuplicatedPackages.concat([packageName]))}.`,
+          fixes: []
+        });
       }
-      return { node, body, yieldedExpression, replacementNode };
     }
-    break;
-  }
-  return yield* typeParserIssue(
-    "Not an handled node",
-    void 0,
-    node
-  );
-});
-var effectSchemaVarianceStruct = fn("TypeParser.effectSchemaVarianceStruct")(
-  function* (type, atLocation) {
-    return {
-      A: yield* varianceStructInvariantType(type, atLocation, "_A"),
-      I: yield* varianceStructInvariantType(type, atLocation, "_I"),
-      R: yield* varianceStructCovariantType(type, atLocation, "_R")
-    };
-  }
-);
-var effectSchemaType = fn("TypeParser.effectSchemaType")(function* (type, atLocation) {
-  const ts = yield* service(TypeScriptApi);
-  const typeChecker = yield* service(TypeCheckerApi);
-  yield* pipeableType(type, atLocation);
-  const ast = typeChecker.getPropertyOfType(type, "ast");
-  if (!ast) return yield* typeParserIssue("Has no 'ast' property", type, atLocation);
-  const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
-    (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional)
-  );
-  propertiesSymbols.sort((a, b) => b.name.indexOf("TypeId") - a.name.indexOf("TypeId"));
-  for (const propertySymbol of propertiesSymbols) {
-    const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
-    const varianceArgs = yield* option(effectSchemaVarianceStruct(
-      propertyType,
-      atLocation
-    ));
-    if (isSome2(varianceArgs)) {
-      return varianceArgs.value;
-    }
-  }
-  return yield* typeParserIssue("Type has no schema variance struct", type, atLocation);
+    return effectDiagnostics;
+  })
 });
 
 // src/diagnostics/floatingEffect.ts
@@ -2259,6 +2370,7 @@ var floatingEffect = createDiagnostic({
   apply: fn("floatingEffect.apply")(function* (sourceFile) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
     function isFloatingExpression(node) {
       if (!ts.isExpressionStatement(node)) return false;
       if (!(ts.isBlock(node.parent) || ts.isSourceFile(node.parent))) return false;
@@ -2278,11 +2390,11 @@ var floatingEffect = createDiagnostic({
       ts.forEachChild(node, appendNodeToVisit);
       if (!isFloatingExpression(node)) continue;
       const type = typeChecker.getTypeAtLocation(node.expression);
-      const effect = yield* option(effectType(type, node.expression));
+      const effect = yield* option(typeParser.effectType(type, node.expression));
       if (isSome2(effect)) {
         const allowedFloatingEffects = yield* pipe(
-          fiberType(type, node.expression),
-          orElse2(() => effectSubtype(type, node.expression)),
+          typeParser.fiberType(type, node.expression),
+          orElse2(() => typeParser.effectSubtype(type, node.expression)),
           option
         );
         if (isNone2(allowedFloatingEffects)) {
@@ -2299,6 +2411,112 @@ var floatingEffect = createDiagnostic({
   })
 });
 
+// src/diagnostics/leakingRequirements.ts
+var leakingRequirements = createDiagnostic({
+  name: "leakingRequirements",
+  code: 8,
+  apply: fn("leakingRequirements.apply")(function* (sourceFile) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
+    const typeOrder = yield* deterministicTypeOrder;
+    const effectDiagnostics = [];
+    const parseLeakedRequirements = cachedBy(
+      fn("leakingServices.checkServiceLeaking")(
+        function* (service2, atLocation) {
+          const properties = typeChecker.getPropertiesOfType(service2);
+          if (properties.length < 1) return [];
+          const memory = /* @__PURE__ */ new Map();
+          let sharedRequirementsKeys = void 0;
+          let effectMembers = 0;
+          for (const property of properties) {
+            const servicePropertyType = typeChecker.getTypeOfSymbolAtLocation(property, atLocation);
+            let effectContextType = void 0;
+            yield* pipe(
+              typeParser.effectType(servicePropertyType, atLocation),
+              map3((_) => effectContextType = _.R),
+              orElse2(() => {
+                const servicePropertyCallSignatures = servicePropertyType.getCallSignatures();
+                if (servicePropertyCallSignatures.length === 1) {
+                  return pipe(
+                    typeParser.effectType(servicePropertyCallSignatures[0].getReturnType(), atLocation),
+                    map3((_) => {
+                      effectContextType = _.R;
+                    })
+                  );
+                }
+                return void_;
+              }),
+              ignore
+            );
+            if (effectContextType) {
+              effectMembers++;
+              const { allIndexes } = yield* appendToUniqueTypesMap(memory, effectContextType, true);
+              if (!sharedRequirementsKeys) {
+                sharedRequirementsKeys = allIndexes;
+              } else {
+                sharedRequirementsKeys = intersection(sharedRequirementsKeys, allIndexes);
+                if (sharedRequirementsKeys.length === 0) return [];
+              }
+            }
+          }
+          if (sharedRequirementsKeys && sharedRequirementsKeys.length > 0 && effectMembers >= 2) {
+            return sharedRequirementsKeys.map((key) => memory.get(key));
+          }
+          return [];
+        }
+      ),
+      "leakingServices.checkServiceLeaking",
+      (_, service2) => service2
+    );
+    function reportLeakingRequirements(node, requirements) {
+      if (requirements.length === 0) return;
+      effectDiagnostics.push({
+        node,
+        category: ts.DiagnosticCategory.Warning,
+        messageText: `This Service is leaking the ${requirements.map((_) => typeChecker.typeToString(_)).join(" | ")} requirement`,
+        fixes: []
+      });
+    }
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      const typesToCheck = [];
+      if (ts.isCallExpression(node)) {
+        typesToCheck.push([typeChecker.getTypeAtLocation(node), node]);
+      } else if (ts.isClassDeclaration(node) && node.name) {
+        const classSym = typeChecker.getSymbolAtLocation(node.name);
+        if (classSym) {
+          const type = typeChecker.getTypeOfSymbol(classSym);
+          typesToCheck.push([type, node.name]);
+        }
+      } else {
+        ts.forEachChild(node, appendNodeToVisit);
+        continue;
+      }
+      for (const [type, reportAt] of typesToCheck) {
+        yield* pipe(
+          typeParser.contextTag(type, node),
+          flatMap2(
+            ({ Service }) => pipe(
+              parseLeakedRequirements(Service, node),
+              map3((requirements) => reportLeakingRequirements(reportAt, sort(requirements, typeOrder)))
+            )
+          ),
+          orElse2(() => sync(() => ts.forEachChild(node, appendNodeToVisit))),
+          ignore
+        );
+      }
+    }
+    return effectDiagnostics;
+  })
+});
+
 // src/diagnostics/missingEffectContext.ts
 var missingEffectContext = createDiagnostic({
   name: "missingEffectContext",
@@ -2306,15 +2524,16 @@ var missingEffectContext = createDiagnostic({
   apply: fn("missingEffectContext.apply")(function* (sourceFile) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
     const typeOrder = yield* deterministicTypeOrder;
     const checkForMissingContextTypes = fn(
       "missingEffectContext.apply.checkForMissingContextTypes"
     )(function* (node, expectedType, valueNode, realType) {
-      const expectedEffect = yield* effectType(
+      const expectedEffect = yield* typeParser.effectType(
         expectedType,
         node
       );
-      const realEffect = yield* effectType(
+      const realEffect = yield* typeParser.effectType(
         realType,
         valueNode
       );
@@ -2358,14 +2577,15 @@ var missingEffectError = createDiagnostic({
   apply: fn("missingEffectError.apply")(function* (sourceFile) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
     const typeOrder = yield* deterministicTypeOrder;
     const checkForMissingErrorTypes = fn("missingEffectError.apply.checkForMissingErrorTypes")(
       function* (node, expectedType, valueNode, realType) {
-        const expectedEffect = yield* effectType(
+        const expectedEffect = yield* typeParser.effectType(
           expectedType,
           node
         );
-        const realEffect = yield* effectType(
+        const realEffect = yield* typeParser.effectType(
           realType,
           valueNode
         );
@@ -2410,6 +2630,7 @@ var missingReturnYieldStar = createDiagnostic({
   apply: fn("missingReturnYieldStar.apply")(function* (sourceFile) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
     const effectDiagnostics = [];
     const brokenYields = /* @__PURE__ */ new Set();
     const nodeToVisit = [];
@@ -2423,7 +2644,7 @@ var missingReturnYieldStar = createDiagnostic({
       ts.forEachChild(node, appendNodeToVisit);
       if (ts.isYieldExpression(node) && node.expression && node.asteriskToken) {
         const type = typeChecker.getTypeAtLocation(node.expression);
-        const maybeEffect = yield* option(effectType(type, node.expression));
+        const maybeEffect = yield* option(typeParser.effectType(type, node.expression));
         if (isSome2(maybeEffect) && maybeEffect.value.A.flags & ts.TypeFlags.Never) {
           const generatorFunctionOrReturnStatement = ts.findAncestor(
             node,
@@ -2433,9 +2654,9 @@ var missingReturnYieldStar = createDiagnostic({
             if (generatorFunctionOrReturnStatement && generatorFunctionOrReturnStatement.parent) {
               const effectGenNode = generatorFunctionOrReturnStatement.parent;
               const effectGenLike = yield* pipe(
-                effectGen(effectGenNode),
-                orElse2(() => effectFnUntracedGen(effectGenNode)),
-                orElse2(() => effectFnGen(effectGenNode)),
+                typeParser.effectGen(effectGenNode),
+                orElse2(() => typeParser.effectFnUntracedGen(effectGenNode)),
+                orElse2(() => typeParser.effectFnGen(effectGenNode)),
                 option
               );
               if (isSome2(effectGenLike)) {
@@ -2478,6 +2699,7 @@ var missingStarInYieldEffectGen = createDiagnostic({
   code: 4,
   apply: fn("missingStarInYieldEffectGen.apply")(function* (sourceFile) {
     const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
     const effectDiagnostics = [];
     const brokenGenerators = /* @__PURE__ */ new Set();
     const brokenYields = /* @__PURE__ */ new Set();
@@ -2497,18 +2719,18 @@ var missingStarInYieldEffectGen = createDiagnostic({
         );
         if (functionStarNode && functionStarNode.parent) {
           const effectGenNode = functionStarNode.parent;
-          const effectGenLike = yield* pipe(
-            effectGen(effectGenNode),
-            orElse2(() => effectFnUntracedGen(effectGenNode)),
-            orElse2(() => effectFnGen(effectGenNode)),
-            option
+          yield* pipe(
+            typeParser.effectGen(effectGenNode),
+            orElse2(() => typeParser.effectFnUntracedGen(effectGenNode)),
+            orElse2(() => typeParser.effectFnGen(effectGenNode)),
+            map3(({ functionStar }) => {
+              if (functionStar) {
+                brokenGenerators.add(functionStar);
+              }
+              brokenYields.add(node);
+            }),
+            ignore
           );
-          if (isSome2(effectGenLike)) {
-            if (effectGenLike.value.functionStar) {
-              brokenGenerators.add(effectGenLike.value.functionStar);
-            }
-            brokenYields.add(node);
-          }
         }
       }
     }
@@ -2548,11 +2770,12 @@ var missingStarInYieldEffectGen = createDiagnostic({
 });
 
 // src/diagnostics/unnecessaryEffectGen.ts
-var unnecessaryEffectGen2 = createDiagnostic({
+var unnecessaryEffectGen = createDiagnostic({
   name: "unnecessaryEffectGen",
   code: 5,
   apply: fn("unnecessaryEffectGen.apply")(function* (sourceFile) {
     const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
     const effectDiagnostics = [];
     const unnecessaryGenerators = /* @__PURE__ */ new Map();
     const nodeToVisit = [];
@@ -2564,9 +2787,12 @@ var unnecessaryEffectGen2 = createDiagnostic({
     while (nodeToVisit.length > 0) {
       const node = nodeToVisit.shift();
       ts.forEachChild(node, appendNodeToVisit);
-      const maybeNode = yield* option(unnecessaryEffectGen(node));
-      if (isSome2(maybeNode)) {
-        unnecessaryGenerators.set(node, maybeNode.value.replacementNode);
+      if (ts.isCallExpression(node)) {
+        yield* pipe(
+          typeParser.unnecessaryEffectGen(node),
+          map3(({ replacementNode }) => unnecessaryGenerators.set(node, replacementNode)),
+          ignore
+        );
       }
     }
     unnecessaryGenerators.forEach(
@@ -2597,8 +2823,9 @@ var diagnostics = [
   missingEffectError,
   floatingEffect,
   missingStarInYieldEffectGen,
-  unnecessaryEffectGen2,
-  missingReturnYieldStar
+  unnecessaryEffectGen,
+  missingReturnYieldStar,
+  leakingRequirements
 ];
 
 // src/transform.ts
@@ -2610,6 +2837,7 @@ function transform_default(program, pluginConfig, { addDiagnostic, ts: tsInstanc
         provideService(TypeScriptApi, tsInstance),
         provideService(TypeScriptProgram, program),
         provideService(TypeCheckerApi, program.getTypeChecker()),
+        provideService(TypeParser, make3(tsInstance, program.getTypeChecker())),
         provideService(
           TypeCheckerApiCache,
           makeTypeCheckerApiCache()