@effect/language-service 0.22.1 → 0.22.3

package/index.js

@@ -729,6 +729,7 @@ var getOrElse = /* @__PURE__ */ dual(2, (self, onLeft) => isLeft2(self) ? onLeft
 
 // node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Order.js
 var make2 = (compare) => (self, that) => self === that ? 0 : compare(self, that);
+var string2 = /* @__PURE__ */ make2((self, that) => self < that ? -1 : 1);
 
 // node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Option.js
 var none2 = () => none;
@@ -1732,139 +1733,364 @@ var effectDataClasses = createCompletion({
   })
 });
 
-// src/completions/effectSchemaSelfInClasses.ts
-var effectSchemaSelfInClasses = createCompletion({
-  name: "effectSchemaSelfInClasses",
-  apply: fn("effectSchemaSelfInClasses")(function* (sourceFile, position) {
-    const ts = yield* service(TypeScriptApi);
-    const maybeInfos = yield* option(
-      parseDataForExtendsClassCompletion(sourceFile, position)
-    );
-    if (isNone2(maybeInfos)) return [];
-    const { accessedObject, className, replacementSpan } = maybeInfos.value;
-    const effectSchemaName = yield* option(
-      findImportedModuleIdentifierByPackageAndNameOrBarrel(
-        sourceFile,
-        "effect",
-        "Schema"
-      )
-    );
-    const schemaIdentifier = match(effectSchemaName, {
-      onNone: () => "Schema",
-      onSome: (_) => _.text
-    });
-    if (schemaIdentifier !== accessedObject.text) return [];
-    const name = className.text;
-    return [{
-      name: `Class<${name}>`,
-      kind: ts.ScriptElementKind.constElement,
-      insertText: `${schemaIdentifier}.Class<${name}>("${name}")({${"${0}"}}){}`,
-      replacementSpan,
-      isSnippet: true
-    }, {
-      name: `TaggedError<${name}>`,
-      kind: ts.ScriptElementKind.constElement,
-      insertText: `${schemaIdentifier}.TaggedError<${name}>("${name}")("${name}", {${"${0}"}}){}`,
-      replacementSpan,
-      isSnippet: true
-    }, {
-      name: `TaggedClass<${name}>`,
-      kind: ts.ScriptElementKind.constElement,
-      insertText: `${schemaIdentifier}.TaggedClass<${name}>("${name}")("${name}", {${"${0}"}}){}`,
-      replacementSpan,
-      isSnippet: true
-    }, {
-      name: `TaggedRequest<${name}>`,
-      kind: ts.ScriptElementKind.constElement,
-      insertText: `${schemaIdentifier}.TaggedRequest<${name}>("${name}")("${name}", {${"${0}"}}){}`,
-      replacementSpan,
-      isSnippet: true
-    }];
-  })
-});
+// src/diagnostics/duplicatePackage.ts
+var checkedPackagesCache = /* @__PURE__ */ new Map();
+var programResolvedCacheSize = /* @__PURE__ */ new Map();
+var duplicatePackage = createDiagnostic({
+  name: "duplicatePackage",
+  code: 6,
+  severity: "warning",
+  apply: fn("duplicatePackage.apply")(function* (sourceFile, report) {
+    const program = yield* service(TypeScriptProgram);
+    const options = yield* service(LanguageServicePluginOptions);
+    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.packageDirectory;
+      });
+      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]);
+        report({
+          node: sourceFile.statements[0],
+          messageText: `Package ${packageName} is referenced multiple times with different versions (${versions.join(", ")}) and may cause unexpected type errors.
+Cleanup your dependencies and your package lockfile to avoid multiple instances of this package and reload the project.
+If this is intended set the LSP config "allowedDuplicatedPackages" to ${JSON.stringify(options.allowedDuplicatedPackages.concat([packageName]))}.
 
-// src/completions/effectSelfInClasses.ts
-var effectSelfInClasses = createCompletion({
-  name: "effectSelfInClasses",
-  apply: fn("effectSelfInClasses")(function* (sourceFile, position) {
-    const ts = yield* service(TypeScriptApi);
-    const maybeInfos = yield* option(
-      parseDataForExtendsClassCompletion(sourceFile, position)
-    );
-    if (isNone2(maybeInfos)) return [];
-    const { accessedObject, className, replacementSpan } = maybeInfos.value;
-    const effectName = yield* option(
-      findImportedModuleIdentifierByPackageAndNameOrBarrel(
-        sourceFile,
-        "effect",
-        "Effect"
-      )
-    );
-    const effectIdentifier = match(effectName, {
-      onNone: () => "Effect",
-      onSome: (_) => _.text
-    });
-    if (effectIdentifier !== accessedObject.text) return [];
-    const name = className.text;
-    return [{
-      name: `Service<${name}>`,
-      kind: ts.ScriptElementKind.constElement,
-      insertText: `${effectIdentifier}.Service<${name}>()("${name}", {${"${0}"}}){}`,
-      replacementSpan,
-      isSnippet: true
-    }];
+${versions.map((version) => `- found ${version} at ${resolvedPackages[packageName][version]}`).join("\n")}`,
+          fixes: []
+        });
+      }
+    }
   })
 });
 
-// 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 make4(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);
+// src/core/TypeCheckerApi.ts
+var TypeCheckerApi = Tag("TypeChecker");
+var TypeCheckerApiCache = Tag("TypeCheckerApiCache");
+function makeTypeCheckerApiCache() {
+  return {
+    expectedAndRealType: /* @__PURE__ */ new WeakMap()
+  };
+}
+var deterministicTypeOrder = gen(function* () {
+  const typeChecker = yield* service(TypeCheckerApi);
+  return make2((a, b) => {
+    const aName = typeChecker.typeToString(a);
+    const bName = typeChecker.typeToString(b);
+    if (aName < bName) return -1;
+    if (aName > bName) return 1;
+    return 0;
+  });
+});
+var getMissingTypeEntriesInTargetType = fn(
+  "TypeCheckerApi.getMissingTypeEntriesInTargetType"
+)(
+  function* (realType, expectedType) {
+    if (realType === expectedType) return [];
+    const typeChecker = yield* service(TypeCheckerApi);
+    const result = [];
+    let toTest = [realType];
+    while (toTest.length > 0) {
+      const type = toTest.pop();
+      if (!type) return result;
+      if (type.isUnion()) {
+        toTest = toTest.concat(type.types);
+      } else {
+        const assignable = typeChecker.isTypeAssignableTo(type, expectedType);
+        if (!assignable) {
+          result.push(type);
+        }
+      }
     }
-    return succeed(signatures[0].getReturnType());
+    return result;
   }
-  function contravariantTypeArgument(type) {
-    const signatures = type.getCallSignatures();
-    if (signatures.length !== 1) {
-      return typeParserIssue("Contravariant type has no call signature", type);
+);
+var CannotFindAncestorConvertibleDeclarationError = class {
+  constructor(node) {
+    this.node = node;
+  }
+  _tag = "@effect/language-service/CannotFindAncestorConvertibleDeclarationError";
+};
+var getAncestorConvertibleDeclaration = fn(
+  "TypeCheckerApi.getAncestorConvertibleDeclaration"
+)(function* (node) {
+  const ts = yield* service(TypeScriptApi);
+  let current = node;
+  while (current) {
+    if (ts.isFunctionDeclaration(current) || ts.isFunctionExpression(current) || ts.isArrowFunction(current) || ts.isMethodDeclaration(current)) {
+      return current;
     }
-    return succeed(signatures[0].getTypeParameterAtPosition(0));
+    current = current.parent;
   }
-  function invariantTypeArgument(type) {
-    const signatures = type.getCallSignatures();
-    if (signatures.length !== 1) {
-      return typeParserIssue("Invariant type has no call signature", type);
+  return yield* fail(new CannotFindAncestorConvertibleDeclarationError(node));
+});
+var CannotInferReturnTypeFromEmptyBody = class {
+  constructor(declaration) {
+    this.declaration = declaration;
+  }
+  _tag = "@effect/language-service/CannotInferReturnTypeFromEmptyBody";
+};
+var CannotInferReturnType = class {
+  constructor(declaration) {
+    this.declaration = declaration;
+  }
+  _tag = "@effect/language-service/CannotInferReturnType";
+};
+var getInferredReturnType = fn("TypeCheckerApi.getInferredReturnType")(function* (declaration) {
+  const typeChecker = yield* service(TypeCheckerApi);
+  if (!declaration.body) {
+    return yield* fail(
+      new CannotInferReturnTypeFromEmptyBody(declaration)
+    );
+  }
+  let returnType;
+  if (typeChecker.isImplementationOfOverload(declaration)) {
+    const signatures = typeChecker.getTypeAtLocation(declaration).getCallSignatures();
+    if (signatures.length > 1) {
+      returnType = typeChecker.getUnionType(
+        signatures.map((s) => s.getReturnType()).filter((_) => !!_)
+      );
     }
-    return succeed(signatures[0].getReturnType());
   }
-  const pipeableType = cachedBy(
-    function(type, atLocation) {
-      const pipeSymbol = typeChecker.getPropertyOfType(type, "pipe");
-      if (!pipeSymbol) {
-        return typeParserIssue("Type has no 'pipe' property", type, atLocation);
-      }
-      const pipeType = typeChecker.getTypeOfSymbolAtLocation(pipeSymbol, atLocation);
-      const signatures = pipeType.getCallSignatures();
-      if (signatures.length === 0) {
-        return typeParserIssue("'pipe' property is not callable", type, atLocation);
+  if (!returnType) {
+    const signature = typeChecker.getSignatureFromDeclaration(declaration);
+    if (signature) {
+      const typePredicate = typeChecker.getTypePredicateOfSignature(signature);
+      if (typePredicate && typePredicate.type) {
+        return typePredicate.type;
+      } else {
+        returnType = typeChecker.getReturnTypeOfSignature(signature);
       }
-      return succeed(type);
-    },
-    "TypeParser.pipeableType",
-    (type) => type
-  );
-  const varianceStructCovariantType = (type, atLocation, propertyName) => {
-    const propertySymbol = typeChecker.getPropertyOfType(type, propertyName);
+    }
+  }
+  if (!returnType) {
+    return yield* fail(
+      new CannotInferReturnType(declaration)
+    );
+  }
+  return returnType;
+});
+var expectedAndRealType = fn("TypeCheckerApi.expectedAndRealType")(function* (sourceFile) {
+  const cache = yield* service(TypeCheckerApiCache);
+  const resultCached = cache.expectedAndRealType.get(sourceFile);
+  if (resultCached) return resultCached;
+  const typeChecker = yield* service(TypeCheckerApi);
+  const ts = yield* service(TypeScriptApi);
+  const result = [];
+  const nodeToVisit = [sourceFile];
+  const appendNodeToVisit = (node) => {
+    nodeToVisit.push(node);
+    return void 0;
+  };
+  while (nodeToVisit.length > 0) {
+    const node = nodeToVisit.shift();
+    if (ts.isVariableDeclaration(node) && node.initializer) {
+      const expectedType = typeChecker.getTypeAtLocation(node.name);
+      const realType = typeChecker.getTypeAtLocation(node.initializer);
+      result.push([node.name, expectedType, node.initializer, realType]);
+      appendNodeToVisit(node.initializer);
+      continue;
+    } else if (ts.isCallExpression(node)) {
+      const resolvedSignature = typeChecker.getResolvedSignature(node);
+      if (resolvedSignature) {
+        resolvedSignature.getParameters().map((parameter, index) => {
+          const expectedType = typeChecker.getTypeOfSymbolAtLocation(parameter, node);
+          const realType = typeChecker.getTypeAtLocation(node.arguments[index]);
+          result.push([
+            node.arguments[index],
+            expectedType,
+            node.arguments[index],
+            realType
+          ]);
+        });
+      }
+      ts.forEachChild(node, appendNodeToVisit);
+      continue;
+    } else if (ts.isIdentifier(node) || ts.isStringLiteral(node) || ts.isNumericLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+      const parent = node.parent;
+      if (ts.isObjectLiteralElement(parent)) {
+        if (ts.isObjectLiteralExpression(parent.parent) && parent.name === node) {
+          const type = typeChecker.getContextualType(parent.parent);
+          if (type) {
+            const symbol3 = typeChecker.getPropertyOfType(type, node.text);
+            if (symbol3) {
+              const expectedType = typeChecker.getTypeOfSymbolAtLocation(symbol3, node);
+              const realType = typeChecker.getTypeAtLocation(node);
+              result.push([node, expectedType, node, realType]);
+            }
+          }
+        }
+      }
+      ts.forEachChild(node, appendNodeToVisit);
+      continue;
+    } else if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+      const expectedType = typeChecker.getTypeAtLocation(node.left);
+      const realType = typeChecker.getTypeAtLocation(node.right);
+      result.push([node.left, expectedType, node.right, realType]);
+      appendNodeToVisit(node.right);
+      continue;
+    } else if (ts.isReturnStatement(node) && node.expression) {
+      const parentDeclaration = yield* option(getAncestorConvertibleDeclaration(node));
+      if (isSome2(parentDeclaration)) {
+        const expectedType = yield* option(getInferredReturnType(parentDeclaration.value));
+        const realType = typeChecker.getTypeAtLocation(node.expression);
+        if (isSome2(expectedType)) {
+          result.push([node, expectedType.value, node, realType]);
+        }
+      }
+      ts.forEachChild(node, appendNodeToVisit);
+      continue;
+    } else if (ts.isArrowFunction(node) && (node.typeParameters || []).length === 0 && ts.isExpression(node.body)) {
+      const body = node.body;
+      const expectedType = typeChecker.getContextualType(body);
+      const realType = typeChecker.getTypeAtLocation(body);
+      if (expectedType) {
+        result.push([body, expectedType, body, realType]);
+      }
+      ts.forEachChild(body, appendNodeToVisit);
+      continue;
+    } else if (ts.isArrowFunction(node) && (node.typeParameters || []).length > 0 && ts.isExpression(node.body)) {
+      const body = node.body;
+      const expectedType = yield* option(getInferredReturnType(node));
+      const realType = typeChecker.getTypeAtLocation(body);
+      if (isSome2(expectedType)) {
+        result.push([body, expectedType.value, body, realType]);
+      }
+      ts.forEachChild(body, appendNodeToVisit);
+      continue;
+    } else if (ts.isSatisfiesExpression(node)) {
+      const expectedType = typeChecker.getTypeAtLocation(node.type);
+      const realType = typeChecker.getTypeAtLocation(node.expression);
+      result.push([node.expression, expectedType, node.expression, realType]);
+      appendNodeToVisit(node.expression);
+      continue;
+    }
+    ts.forEachChild(node, appendNodeToVisit);
+  }
+  cache.expectedAndRealType.set(sourceFile, result);
+  return result;
+});
+var appendToUniqueTypesMap = fn(
+  "TypeCheckerApi.appendToUniqueTypesMap"
+)(
+  function* (memory, initialType, excludeNever) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const newIndexes = /* @__PURE__ */ new Set();
+    const knownIndexes = /* @__PURE__ */ new Set();
+    let toTest = [initialType];
+    while (toTest.length > 0) {
+      const type = toTest.pop();
+      if (!type) break;
+      if (excludeNever && type.flags & ts.TypeFlags.Never) {
+        continue;
+      }
+      if (type.isUnion()) {
+        toTest = toTest.concat(type.types);
+      } else {
+        const foundMatch = [];
+        for (const [typeId, knownType] of memory.entries()) {
+          const areSame = typeChecker.isTypeAssignableTo(knownType, type) && typeChecker.isTypeAssignableTo(type, knownType);
+          if (areSame) {
+            foundMatch.push(typeId);
+            break;
+          }
+        }
+        if (foundMatch.length === 0) {
+          const newId = "t" + (memory.size + 1);
+          memory.set(newId, type);
+          newIndexes.add(newId);
+        } else {
+          knownIndexes.add(foundMatch[0]);
+        }
+      }
+    }
+    return {
+      newIndexes,
+      knownIndexes,
+      allIndexes: pipe(
+        fromIterable(newIndexes),
+        appendAll(fromIterable(knownIndexes))
+      )
+    };
+  }
+);
+function makeResolveExternalModuleName(typeChecker) {
+  if (!(hasProperty(typeChecker, "resolveExternalModuleName") && isFunction(typeChecker.resolveExternalModuleName))) {
+    return;
+  }
+  const _internal = typeChecker.resolveExternalModuleName;
+  return (moduleSpecifier) => {
+    return _internal(moduleSpecifier);
+  };
+}
+
+// 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 make4(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());
+  }
+  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);
+    }
+    return succeed(signatures[0].getReturnType());
+  }
+  const pipeableType = cachedBy(
+    function(type, atLocation) {
+      const pipeSymbol = typeChecker.getPropertyOfType(type, "pipe");
+      if (!pipeSymbol) {
+        return typeParserIssue("Type has no 'pipe' property", type, atLocation);
+      }
+      const pipeType = typeChecker.getTypeOfSymbolAtLocation(pipeSymbol, atLocation);
+      const signatures = pipeType.getCallSignatures();
+      if (signatures.length === 0) {
+        return typeParserIssue("'pipe' property is not callable", type, atLocation);
+      }
+      return succeed(type);
+    },
+    "TypeParser.pipeableType",
+    (type) => type
+  );
+  const varianceStructCovariantType = (type, atLocation, propertyName) => {
+    const propertySymbol = typeChecker.getPropertyOfType(type, propertyName);
     if (!propertySymbol) {
       return typeParserIssue(`Type has no '${propertyName}' property`, type, atLocation);
     }
@@ -2247,686 +2473,59 @@ function make4(ts, typeChecker) {
       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
-  );
-  const pipeCall = cachedBy(
-    function(node) {
-      if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.name) && node.expression.name.text === "pipe") {
-        return succeed({ node, subject: node.expression.expression, args: Array.from(node.arguments) });
-      }
-      if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "pipe" && node.arguments.length > 0) {
-        const [subject, ...args] = node.arguments;
-        return succeed({ node, subject, args });
-      }
-      return typeParserIssue("Node is not a pipe call", void 0, node);
-    },
-    "TypeParser.pipeCall",
-    (node) => node
-  );
-  return {
-    effectType,
-    strictEffectType,
-    layerType,
-    fiberType,
-    effectSubtype,
-    importedEffectModule,
-    effectGen,
-    effectFnUntracedGen,
-    effectFnGen,
-    unnecessaryEffectGen: unnecessaryEffectGen2,
-    effectSchemaType,
-    contextTag,
-    pipeCall
-  };
-}
-
-// src/completions/fnFunctionStar.ts
-var fnFunctionStar = createCompletion({
-  name: "fnFunctionStar",
-  apply: fn("fnFunctionStar")(function* (sourceFile, position) {
-    const ts = yield* service(TypeScriptApi);
-    const typeParser = yield* service(TypeParser);
-    const maybeInfos = yield* option(
-      parseAccessedExpressionForCompletion(sourceFile, position)
-    );
-    if (isNone2(maybeInfos)) return [];
-    const { accessedObject } = maybeInfos.value;
-    const isEffectModule = yield* option(typeParser.importedEffectModule(accessedObject));
-    if (isNone2(isEffectModule)) return [];
-    const span = ts.createTextSpan(
-      accessedObject.end + 1,
-      Math.max(0, position - accessedObject.end - 1)
-    );
-    const maybeFnName = pipe(
-      yield* getAncestorNodesInRange(sourceFile, toTextRange(accessedObject.pos)),
-      filter(ts.isVariableDeclaration),
-      map3((_) => _.name && ts.isIdentifier(_.name) ? _.name.text : ""),
-      filter((_) => _.length > 0),
-      head,
-      map2((name) => [
-        {
-          name: `fn("${name}")`,
-          kind: ts.ScriptElementKind.constElement,
-          insertText: `fn("${name}")(function*(${"${1}"}){${"${0}"}})`,
-          replacementSpan: span,
-          isSnippet: true
-        }
-      ]),
-      getOrElse2(() => [])
-    );
-    return maybeFnName.concat([{
-      name: `fn(function*(){})`,
-      kind: ts.ScriptElementKind.constElement,
-      insertText: `fn(function*(${"${1}"}){${"${0}"}})`,
-      replacementSpan: span,
-      isSnippet: true
-    }, {
-      name: `fnUntraced(function*(){})`,
-      kind: ts.ScriptElementKind.constElement,
-      insertText: `fnUntraced(function*(${"${1}"}){${"${0}"}})`,
-      replacementSpan: span,
-      isSnippet: true
-    }]);
-  })
-});
-
-// src/core/TypeCheckerApi.ts
-var TypeCheckerApi = Tag("TypeChecker");
-var TypeCheckerApiCache = Tag("TypeCheckerApiCache");
-function makeTypeCheckerApiCache() {
-  return {
-    expectedAndRealType: /* @__PURE__ */ new WeakMap()
-  };
-}
-var deterministicTypeOrder = gen(function* () {
-  const typeChecker = yield* service(TypeCheckerApi);
-  return make2((a, b) => {
-    const aName = typeChecker.typeToString(a);
-    const bName = typeChecker.typeToString(b);
-    if (aName < bName) return -1;
-    if (aName > bName) return 1;
-    return 0;
-  });
-});
-var getMissingTypeEntriesInTargetType = fn(
-  "TypeCheckerApi.getMissingTypeEntriesInTargetType"
-)(
-  function* (realType, expectedType) {
-    if (realType === expectedType) return [];
-    const typeChecker = yield* service(TypeCheckerApi);
-    const result = [];
-    let toTest = [realType];
-    while (toTest.length > 0) {
-      const type = toTest.pop();
-      if (!type) return result;
-      if (type.isUnion()) {
-        toTest = toTest.concat(type.types);
-      } else {
-        const assignable = typeChecker.isTypeAssignableTo(type, expectedType);
-        if (!assignable) {
-          result.push(type);
-        }
-      }
-    }
-    return result;
-  }
-);
-var CannotFindAncestorConvertibleDeclarationError = class {
-  constructor(node) {
-    this.node = node;
-  }
-  _tag = "@effect/language-service/CannotFindAncestorConvertibleDeclarationError";
-};
-var getAncestorConvertibleDeclaration = fn(
-  "TypeCheckerApi.getAncestorConvertibleDeclaration"
-)(function* (node) {
-  const ts = yield* service(TypeScriptApi);
-  let current = node;
-  while (current) {
-    if (ts.isFunctionDeclaration(current) || ts.isFunctionExpression(current) || ts.isArrowFunction(current) || ts.isMethodDeclaration(current)) {
-      return current;
-    }
-    current = current.parent;
-  }
-  return yield* fail(new CannotFindAncestorConvertibleDeclarationError(node));
-});
-var CannotInferReturnTypeFromEmptyBody = class {
-  constructor(declaration) {
-    this.declaration = declaration;
-  }
-  _tag = "@effect/language-service/CannotInferReturnTypeFromEmptyBody";
-};
-var CannotInferReturnType = class {
-  constructor(declaration) {
-    this.declaration = declaration;
-  }
-  _tag = "@effect/language-service/CannotInferReturnType";
-};
-var getInferredReturnType = fn("TypeCheckerApi.getInferredReturnType")(function* (declaration) {
-  const typeChecker = yield* service(TypeCheckerApi);
-  if (!declaration.body) {
-    return yield* fail(
-      new CannotInferReturnTypeFromEmptyBody(declaration)
-    );
-  }
-  let returnType;
-  if (typeChecker.isImplementationOfOverload(declaration)) {
-    const signatures = typeChecker.getTypeAtLocation(declaration).getCallSignatures();
-    if (signatures.length > 1) {
-      returnType = typeChecker.getUnionType(
-        signatures.map((s) => s.getReturnType()).filter((_) => !!_)
-      );
-    }
-  }
-  if (!returnType) {
-    const signature = typeChecker.getSignatureFromDeclaration(declaration);
-    if (signature) {
-      const typePredicate = typeChecker.getTypePredicateOfSignature(signature);
-      if (typePredicate && typePredicate.type) {
-        return typePredicate.type;
-      } else {
-        returnType = typeChecker.getReturnTypeOfSignature(signature);
-      }
-    }
-  }
-  if (!returnType) {
-    return yield* fail(
-      new CannotInferReturnType(declaration)
-    );
-  }
-  return returnType;
-});
-var expectedAndRealType = fn("TypeCheckerApi.expectedAndRealType")(function* (sourceFile) {
-  const cache = yield* service(TypeCheckerApiCache);
-  const resultCached = cache.expectedAndRealType.get(sourceFile);
-  if (resultCached) return resultCached;
-  const typeChecker = yield* service(TypeCheckerApi);
-  const ts = yield* service(TypeScriptApi);
-  const result = [];
-  const nodeToVisit = [sourceFile];
-  const appendNodeToVisit = (node) => {
-    nodeToVisit.push(node);
-    return void 0;
-  };
-  while (nodeToVisit.length > 0) {
-    const node = nodeToVisit.shift();
-    if (ts.isVariableDeclaration(node) && node.initializer) {
-      const expectedType = typeChecker.getTypeAtLocation(node.name);
-      const realType = typeChecker.getTypeAtLocation(node.initializer);
-      result.push([node.name, expectedType, node.initializer, realType]);
-      appendNodeToVisit(node.initializer);
-      continue;
-    } else if (ts.isCallExpression(node)) {
-      const resolvedSignature = typeChecker.getResolvedSignature(node);
-      if (resolvedSignature) {
-        resolvedSignature.getParameters().map((parameter, index) => {
-          const expectedType = typeChecker.getTypeOfSymbolAtLocation(parameter, node);
-          const realType = typeChecker.getTypeAtLocation(node.arguments[index]);
-          result.push([
-            node.arguments[index],
-            expectedType,
-            node.arguments[index],
-            realType
-          ]);
-        });
-      }
-      ts.forEachChild(node, appendNodeToVisit);
-      continue;
-    } else if (ts.isIdentifier(node) || ts.isStringLiteral(node) || ts.isNumericLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
-      const parent = node.parent;
-      if (ts.isObjectLiteralElement(parent)) {
-        if (ts.isObjectLiteralExpression(parent.parent) && parent.name === node) {
-          const type = typeChecker.getContextualType(parent.parent);
-          if (type) {
-            const symbol3 = typeChecker.getPropertyOfType(type, node.text);
-            if (symbol3) {
-              const expectedType = typeChecker.getTypeOfSymbolAtLocation(symbol3, node);
-              const realType = typeChecker.getTypeAtLocation(node);
-              result.push([node, expectedType, node, realType]);
-            }
-          }
-        }
-      }
-      ts.forEachChild(node, appendNodeToVisit);
-      continue;
-    } else if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
-      const expectedType = typeChecker.getTypeAtLocation(node.left);
-      const realType = typeChecker.getTypeAtLocation(node.right);
-      result.push([node.left, expectedType, node.right, realType]);
-      appendNodeToVisit(node.right);
-      continue;
-    } else if (ts.isReturnStatement(node) && node.expression) {
-      const parentDeclaration = yield* option(getAncestorConvertibleDeclaration(node));
-      if (isSome2(parentDeclaration)) {
-        const expectedType = yield* option(getInferredReturnType(parentDeclaration.value));
-        const realType = typeChecker.getTypeAtLocation(node.expression);
-        if (isSome2(expectedType)) {
-          result.push([node, expectedType.value, node, realType]);
-        }
-      }
-      ts.forEachChild(node, appendNodeToVisit);
-      continue;
-    } else if (ts.isArrowFunction(node) && (node.typeParameters || []).length === 0 && ts.isExpression(node.body)) {
-      const body = node.body;
-      const expectedType = typeChecker.getContextualType(body);
-      const realType = typeChecker.getTypeAtLocation(body);
-      if (expectedType) {
-        result.push([body, expectedType, body, realType]);
-      }
-      ts.forEachChild(body, appendNodeToVisit);
-      continue;
-    } else if (ts.isArrowFunction(node) && (node.typeParameters || []).length > 0 && ts.isExpression(node.body)) {
-      const body = node.body;
-      const expectedType = yield* option(getInferredReturnType(node));
-      const realType = typeChecker.getTypeAtLocation(body);
-      if (isSome2(expectedType)) {
-        result.push([body, expectedType.value, body, realType]);
-      }
-      ts.forEachChild(body, appendNodeToVisit);
-      continue;
-    } else if (ts.isSatisfiesExpression(node)) {
-      const expectedType = typeChecker.getTypeAtLocation(node.type);
-      const realType = typeChecker.getTypeAtLocation(node.expression);
-      result.push([node.expression, expectedType, node.expression, realType]);
-      appendNodeToVisit(node.expression);
-      continue;
-    }
-    ts.forEachChild(node, appendNodeToVisit);
-  }
-  cache.expectedAndRealType.set(sourceFile, result);
-  return result;
-});
-var appendToUniqueTypesMap = fn(
-  "TypeCheckerApi.appendToUniqueTypesMap"
-)(
-  function* (memory, initialType, excludeNever) {
-    const ts = yield* service(TypeScriptApi);
-    const typeChecker = yield* service(TypeCheckerApi);
-    const newIndexes = /* @__PURE__ */ new Set();
-    const knownIndexes = /* @__PURE__ */ new Set();
-    let toTest = [initialType];
-    while (toTest.length > 0) {
-      const type = toTest.pop();
-      if (!type) break;
-      if (excludeNever && type.flags & ts.TypeFlags.Never) {
-        continue;
-      }
-      if (type.isUnion()) {
-        toTest = toTest.concat(type.types);
-      } else {
-        const foundMatch = [];
-        for (const [typeId, knownType] of memory.entries()) {
-          const areSame = typeChecker.isTypeAssignableTo(knownType, type) && typeChecker.isTypeAssignableTo(type, knownType);
-          if (areSame) {
-            foundMatch.push(typeId);
-            break;
-          }
-        }
-        if (foundMatch.length === 0) {
-          const newId = "t" + (memory.size + 1);
-          memory.set(newId, type);
-          newIndexes.add(newId);
-        } else {
-          knownIndexes.add(foundMatch[0]);
-        }
-      }
-    }
-    return {
-      newIndexes,
-      knownIndexes,
-      allIndexes: pipe(
-        fromIterable(newIndexes),
-        appendAll(fromIterable(knownIndexes))
-      )
-    };
-  }
-);
-function makeResolveExternalModuleName(typeChecker) {
-  if (!(hasProperty(typeChecker, "resolveExternalModuleName") && isFunction(typeChecker.resolveExternalModuleName))) {
-    return;
-  }
-  const _internal = typeChecker.resolveExternalModuleName;
-  return (moduleSpecifier) => {
-    return _internal(moduleSpecifier);
-  };
-}
-
-// src/completions/genFunctionStar.ts
-var genFunctionStar = createCompletion({
-  name: "genFunctionStar",
-  apply: fn("genFunctionStar")(function* (sourceFile, position) {
-    const ts = yield* service(TypeScriptApi);
-    const typeChecker = yield* service(TypeCheckerApi);
-    const maybeInfos = yield* option(
-      parseAccessedExpressionForCompletion(sourceFile, position)
-    );
-    if (isNone2(maybeInfos)) return [];
-    const { accessedObject } = maybeInfos.value;
-    const type = typeChecker.getTypeAtLocation(accessedObject);
-    const genMemberSymbol = type.getProperty("gen");
-    if (!genMemberSymbol) return [];
-    const genType = typeChecker.getTypeOfSymbolAtLocation(genMemberSymbol, accessedObject);
-    if (genType.getCallSignatures().length === 0) return [];
-    const span = ts.createTextSpan(
-      accessedObject.end + 1,
-      Math.max(0, position - accessedObject.end - 1)
-    );
-    return [{
-      name: `gen(function*(){})`,
-      kind: ts.ScriptElementKind.constElement,
-      insertText: `gen(function*(){${"${0}"}})`,
-      replacementSpan: span,
-      isSnippet: true
-    }];
-  })
-});
-
-// src/completions/rpcMakeClasses.ts
-var rpcMakeClasses = createCompletion({
-  name: "rpcMakeClasses",
-  apply: fn("rpcMakeClasses")(function* (sourceFile, position) {
-    const ts = yield* service(TypeScriptApi);
-    const maybeInfos = yield* option(
-      parseDataForExtendsClassCompletion(sourceFile, position)
-    );
-    if (isNone2(maybeInfos)) return [];
-    const { accessedObject, className, replacementSpan } = maybeInfos.value;
-    const rpcName = yield* option(
-      findImportedModuleIdentifierByPackageAndNameOrBarrel(
-        sourceFile,
-        "@effect/rpc",
-        "Rpc"
-      )
-    );
-    const rpcIdentifier = match(rpcName, {
-      onNone: () => "Rpc",
-      onSome: (_) => _.text
-    });
-    if (rpcIdentifier !== accessedObject.text) return [];
-    const name = className.text;
-    return [{
-      name: `make("${name}")`,
-      kind: ts.ScriptElementKind.constElement,
-      insertText: `${rpcIdentifier}.make("${name}", {${"${0}"}}) {}`,
-      replacementSpan,
-      isSnippet: true
-    }];
-  })
-});
-
-// src/completions.ts
-var completions = [
-  effectSchemaSelfInClasses,
-  effectSelfInClasses,
-  contextSelfInClasses,
-  rpcMakeClasses,
-  genFunctionStar,
-  fnFunctionStar,
-  effectDataClasses
-];
-
-// src/completions/middlewareNamespaceImports.ts
-var importablePackagesMetadataCache = /* @__PURE__ */ new Map();
-var makeImportablePackagesMetadata = fn("makeImportablePackagesMetadata")(function* (sourceFile) {
-  const ts = yield* service(TypeScriptApi);
-  const program = yield* service(TypeScriptProgram);
-  const languageServicePluginOptions = yield* service(LanguageServicePluginOptions);
-  const host = program;
-  const namespaceByFileName = /* @__PURE__ */ new Map();
-  const excludedByFileName = /* @__PURE__ */ new Map();
-  const unbarreledModulePathByFileName = /* @__PURE__ */ new Map();
-  for (const packageName of languageServicePluginOptions.namespaceImportPackages) {
-    const barrelModule = ts.resolveModuleName(packageName, sourceFile.fileName, program.getCompilerOptions(), host);
-    if (barrelModule.resolvedModule) {
-      const barrelPath = barrelModule.resolvedModule.resolvedFileName;
-      const barrelSource = program.getSourceFile(barrelPath) || ts.createSourceFile(barrelPath, host.readFile(barrelPath) || "", sourceFile.languageVersion, true);
-      if (barrelSource) {
-        for (const statement of barrelSource.statements) {
-          if (ts.isExportDeclaration(statement)) {
-            const exportClause = statement.exportClause;
-            const moduleSpecifier = statement.moduleSpecifier;
-            if (moduleSpecifier && ts.isStringLiteral(moduleSpecifier)) {
-              const unbarreledModulePathResolved = ts.resolveModuleName(
-                moduleSpecifier.text,
-                barrelSource.fileName,
-                program.getCompilerOptions(),
-                host
-              );
-              if (unbarreledModulePathResolved.resolvedModule) {
-                const unbarreledModulePath = unbarreledModulePathResolved.resolvedModule.resolvedFileName;
-                if (exportClause && ts.isNamespaceExport(exportClause) && ts.isIdentifier(exportClause.name)) {
-                  namespaceByFileName.set(unbarreledModulePath, exportClause.name.text);
-                  const existingUnbarreledModulePath = unbarreledModulePathByFileName.get(barrelSource.fileName) || [];
-                  existingUnbarreledModulePath.push([exportClause.name.text, unbarreledModulePath]);
-                  unbarreledModulePathByFileName.set(barrelSource.fileName, existingUnbarreledModulePath);
-                }
-                if (exportClause && ts.isNamedExports(exportClause)) {
-                  for (const element of exportClause.elements) {
-                    if (!ts.isIdentifier(element.name)) continue;
-                    const methodName = element.name.text;
-                    const excludedMethods = excludedByFileName.get(methodName) || [];
-                    excludedMethods.push(unbarreledModulePath);
-                    excludedByFileName.set(methodName, excludedMethods);
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  return {
-    getImportNamespaceByFileName: (fileName) => namespaceByFileName.get(fileName),
-    isExcludedFromNamespaceImport: (fileName, exportName) => (excludedByFileName.get(exportName) || []).includes(fileName),
-    getUnbarreledModulePath: (fileName, exportName) => unbarreledModulePathByFileName.get(fileName)?.find(([name]) => name === exportName)?.[1]
-  };
-});
-var appendEffectCompletionEntryData = fn("collectNamespaceImports")(
-  function* (sourceFile, applicableCompletions) {
-    const languageServicePluginOptions = yield* service(LanguageServicePluginOptions);
-    if (languageServicePluginOptions.namespaceImportPackages.length === 0) return applicableCompletions;
-    const packagesMetadata = importablePackagesMetadataCache.get(sourceFile.fileName) || (yield* makeImportablePackagesMetadata(sourceFile));
-    importablePackagesMetadataCache.set(sourceFile.fileName, packagesMetadata);
-    if (applicableCompletions) {
-      return {
-        ...applicableCompletions,
-        entries: applicableCompletions.entries.map((entry) => {
-          if (entry.data && entry.data.fileName && !entry.insertText && !entry.filterText && entry.data.exportName && entry.data.moduleSpecifier) {
-            const isExcluded = packagesMetadata.isExcludedFromNamespaceImport(
-              entry.data.fileName,
-              entry.data.exportName
-            );
-            if (isExcluded) return entry;
-            const unbarreledModulePath = packagesMetadata.getUnbarreledModulePath(
-              entry.data.fileName,
-              entry.data.exportName
-            );
-            const namespaceName = packagesMetadata.getImportNamespaceByFileName(
-              unbarreledModulePath || entry.data.fileName
-            );
-            if (namespaceName) {
-              return {
-                ...entry,
-                // insertText: unbarreledModulePath ? namespaceName : namespaceName + "." + entry.name,
-                // filterText: entry.name,
-                data: {
-                  ...entry.data,
-                  effectNamespaceName: namespaceName,
-                  effectUnbarreledModulePath: unbarreledModulePath || "",
-                  effectReplaceSpan: entry.replacementSpan || applicableCompletions.optionalReplacementSpan
-                }
-              };
-            }
-          }
-          return entry;
-        })
-      };
-    }
-    return applicableCompletions;
-  }
-);
-var postprocessCompletionEntryDetails = fn("postprocessCompletionEntryDetails")(
-  function* (sourceFile, data, applicableCompletionEntryDetails, formatOptions, preferences, languageServiceHost) {
-    const languageServicePluginOptions = yield* service(LanguageServicePluginOptions);
-    if (languageServicePluginOptions.namespaceImportPackages.length === 0) return applicableCompletionEntryDetails;
-    const ts = yield* service(TypeScriptApi);
-    const program = yield* service(TypeScriptProgram);
-    const getModuleSpecifier = makeGetModuleSpecifier(ts);
-    if (!getModuleSpecifier) return applicableCompletionEntryDetails;
-    if (!applicableCompletionEntryDetails) return applicableCompletionEntryDetails;
-    if (!data) return applicableCompletionEntryDetails;
-    if (!("effectNamespaceName" in data && "effectUnbarreledModulePath" in data && "effectReplaceSpan" in data)) {
-      return applicableCompletionEntryDetails;
-    }
-    const effectReplaceSpan = data.effectReplaceSpan;
-    const codeActions = applicableCompletionEntryDetails.codeActions;
-    if (codeActions && codeActions.length === 1) {
-      const action = codeActions[0];
-      if (action.changes.length === 1) {
-        const fileTextChanges = action.changes[0];
-        if (fileTextChanges.fileName === sourceFile.fileName && fileTextChanges.textChanges.length === 1) {
-          const change = fileTextChanges.textChanges[0];
-          let hasImportActions = false;
-          if (change.newText.trim().toLowerCase().startsWith("import") && change.newText.indexOf(data.exportName) > -1) {
-            hasImportActions = true;
-          }
-          if (!hasImportActions && change.newText.indexOf(data.exportName) > -1) {
-            const ancestorNodes = yield* getAncestorNodesInRange(sourceFile, {
-              pos: change.span.start,
-              end: change.span.start
-            });
-            const importNodes = ancestorNodes.filter((node) => ts.isImportDeclaration(node));
-            hasImportActions = importNodes.length > 0;
-          }
-          if (!hasImportActions) return applicableCompletionEntryDetails;
-          const formatContext = ts.formatting.getFormatContext(
-            formatOptions || {},
-            languageServiceHost
-          );
-          const changes = ts.textChanges.ChangeTracker.with(
-            {
-              formatContext,
-              host: languageServiceHost,
-              preferences: preferences || {}
-            },
-            (changeTracker) => {
-              const isBarrelRedirect = String(data.effectUnbarreledModulePath).length > 0;
-              const moduleSpecifier = isBarrelRedirect ? getModuleSpecifier(
-                program.getCompilerOptions(),
-                sourceFile,
-                sourceFile.fileName,
-                String(data.effectUnbarreledModulePath),
-                program
-              ) : String(data.moduleSpecifier);
-              ts.insertImports(
-                changeTracker,
-                sourceFile,
-                ts.factory.createImportDeclaration(
-                  void 0,
-                  ts.factory.createImportClause(
-                    false,
-                    void 0,
-                    ts.factory.createNamespaceImport(ts.factory.createIdentifier(String(data.effectNamespaceName)))
-                  ),
-                  ts.factory.createStringLiteral(moduleSpecifier)
-                ),
-                true,
-                preferences || {}
-              );
-              if (!isBarrelRedirect) {
-                changeTracker.insertText(
-                  sourceFile,
-                  effectReplaceSpan.start,
-                  String(data.effectNamespaceName) + "."
-                );
-              }
-            }
-          );
-          return {
-            ...applicableCompletionEntryDetails,
-            codeActions: [
-              {
-                description: "Import * as " + data.effectNamespaceName + " from " + data.effectUnbarreledModulePath,
-                changes
-              }
-            ]
-          };
+  );
+  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 applicableCompletionEntryDetails;
-  }
-);
-
-// src/diagnostics/duplicatePackage.ts
-var checkedPackagesCache = /* @__PURE__ */ new Map();
-var programResolvedCacheSize = /* @__PURE__ */ new Map();
-var duplicatePackage = createDiagnostic({
-  name: "duplicatePackage",
-  code: 6,
-  severity: "warning",
-  apply: fn("duplicatePackage.apply")(function* (sourceFile, report) {
-    const program = yield* service(TypeScriptProgram);
-    const options = yield* service(LanguageServicePluginOptions);
-    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.packageDirectory;
-      });
-      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]);
-        report({
-          node: sourceFile.statements[0],
-          messageText: `Package ${packageName} is referenced multiple times with different versions (${versions.join(", ")}) and may cause unexpected type errors.
-Cleanup your dependencies and your package lockfile to avoid multiple instances of this package and reload the project.
-If this is intended set the LSP config "allowedDuplicatedPackages" to ${JSON.stringify(options.allowedDuplicatedPackages.concat([packageName]))}.
-
-${versions.map((version) => `- found ${version} at ${resolvedPackages[packageName][version]}`).join("\n")}`,
-          fixes: []
-        });
+      return yield* typeParserIssue("Type has no tag variance struct", type, atLocation);
+    }),
+    "TypeParser.contextTag",
+    (type) => type
+  );
+  const pipeCall = cachedBy(
+    function(node) {
+      if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.name) && node.expression.name.text === "pipe") {
+        return succeed({ node, subject: node.expression.expression, args: Array.from(node.arguments) });
       }
-    }
-  })
-});
+      if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "pipe" && node.arguments.length > 0) {
+        const [subject, ...args] = node.arguments;
+        return succeed({ node, subject, args });
+      }
+      return typeParserIssue("Node is not a pipe call", void 0, node);
+    },
+    "TypeParser.pipeCall",
+    (node) => node
+  );
+  return {
+    effectType,
+    strictEffectType,
+    layerType,
+    fiberType,
+    effectSubtype,
+    importedEffectModule,
+    effectGen,
+    effectFnUntracedGen,
+    effectFnGen,
+    unnecessaryEffectGen: unnecessaryEffectGen2,
+    effectSchemaType,
+    contextTag,
+    pipeCall
+  };
+}
 
 // src/diagnostics/floatingEffect.ts
 var floatingEffect = createDiagnostic({
@@ -2981,8 +2580,226 @@ var genericEffectServices = createDiagnostic({
   severity: "warning",
   apply: fn("genericEffectServices.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
-    const typeParser = yield* service(TypeParser);
+    const typeParser = yield* service(TypeParser);
+    const typeChecker = yield* service(TypeCheckerApi);
+    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.isClassDeclaration(node) && node.name && node.typeParameters && node.heritageClauses) {
+        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),
+          map4(() => {
+            report({
+              node: reportAt,
+              messageText: `Effect Services with type parameters are not supported because they cannot be properly discriminated at runtime, which may cause unexpected behavior.`,
+              fixes: []
+            });
+          }),
+          orElse2(() => sync(() => ts.forEachChild(node, appendNodeToVisit))),
+          ignore
+        );
+      }
+    }
+  })
+});
+
+// src/diagnostics/importFromBarrel.ts
+var importFromBarrel = createDiagnostic({
+  name: "importFromBarrel",
+  code: 12,
+  severity: "off",
+  apply: fn("importFromBarrel.apply")(function* (sourceFile, report) {
+    const languageServicePluginOptions = yield* service(LanguageServicePluginOptions);
+    if (languageServicePluginOptions.namespaceImportPackages.length === 0) return;
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const program = yield* service(TypeScriptProgram);
+    const isImportedFromBarrelExport = (element, languageServicePluginOptions2) => {
+      const getModuleSpecifier = makeGetModuleSpecifier(ts);
+      const resolveExternalModuleName = makeResolveExternalModuleName(typeChecker);
+      if (!(getModuleSpecifier && resolveExternalModuleName)) return;
+      const importDeclaration = ts.findAncestor(element, (node) => ts.isImportDeclaration(node));
+      if (!importDeclaration) return;
+      if (!ts.isStringLiteral(importDeclaration.moduleSpecifier)) return;
+      const importClause = importDeclaration.importClause;
+      if (!importClause) return;
+      const namedBindings = importClause.namedBindings;
+      if (!namedBindings) return;
+      if (!ts.isNamedImports(namedBindings)) return;
+      const barrelModuleName = importDeclaration.moduleSpecifier.text;
+      if (languageServicePluginOptions2.namespaceImportPackages.indexOf(barrelModuleName.toLowerCase()) === -1) return;
+      const moduleSymbol = resolveExternalModuleName(importDeclaration.moduleSpecifier);
+      if (!moduleSymbol) return;
+      if (!moduleSymbol.exports) return;
+      const sourceFile2 = importDeclaration.getSourceFile();
+      const nodeForSymbol = element.propertyName || element.name;
+      if (!ts.isIdentifier(nodeForSymbol)) return;
+      const importedName = nodeForSymbol.text;
+      const reexportedSymbol = moduleSymbol.exports.get(ts.escapeLeadingUnderscores(importedName));
+      if (!reexportedSymbol) return;
+      if (!(reexportedSymbol.declarations && reexportedSymbol.declarations.length === 1)) return;
+      const namespaceExport = reexportedSymbol.declarations[0];
+      if (!ts.isNamespaceExport(namespaceExport)) return;
+      const exportDeclaration = namespaceExport.parent;
+      if (!ts.isExportDeclaration(exportDeclaration)) return;
+      if (!exportDeclaration.moduleSpecifier) return;
+      const originalModuleSymbol = resolveExternalModuleName(exportDeclaration.moduleSpecifier);
+      if (!originalModuleSymbol) return;
+      if (!originalModuleSymbol.valueDeclaration) return;
+      const originalSourceFile = originalModuleSymbol.valueDeclaration.getSourceFile();
+      const unbarrelledFileName = getModuleSpecifier(
+        program.getCompilerOptions(),
+        sourceFile2,
+        sourceFile2.fileName,
+        originalSourceFile.fileName,
+        program
+      );
+      if (unbarrelledFileName.toLowerCase().indexOf(barrelModuleName.toLowerCase() + "/") === -1) return;
+      return { unbarrelledFileName, importedName, barrelModuleName, importClause, namedBindings, importDeclaration };
+    };
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      const parent = node.parent;
+      if (!(ts.isImportSpecifier(node) && ts.isNamedImports(parent))) {
+        ts.forEachChild(node, appendNodeToVisit);
+        continue;
+      }
+      const result = isImportedFromBarrelExport(node, languageServicePluginOptions);
+      if (!result) continue;
+      const { barrelModuleName, importClause, importDeclaration, importedName, namedBindings, unbarrelledFileName } = result;
+      report({
+        node,
+        messageText: `Importing from barrel module ${barrelModuleName} is not allowed.`,
+        fixes: [
+          {
+            fixName: "replaceWithUnbarrelledImport",
+            description: `Import * as ${importedName} from ${unbarrelledFileName}`,
+            apply: gen(function* () {
+              const changeTracker = yield* service(ChangeTracker);
+              const newImport = ts.factory.createImportDeclaration(
+                void 0,
+                ts.factory.createImportClause(
+                  importClause.isTypeOnly || node.isTypeOnly,
+                  void 0,
+                  ts.factory.createNamespaceImport(ts.factory.createIdentifier(importedName))
+                ),
+                ts.factory.createStringLiteral(unbarrelledFileName)
+              );
+              if (namedBindings.elements.length === 1) {
+                changeTracker.replaceNode(
+                  sourceFile,
+                  importDeclaration,
+                  newImport
+                );
+              } else {
+                changeTracker.insertNodeAfter(sourceFile, importDeclaration, newImport);
+                changeTracker.replaceNode(
+                  sourceFile,
+                  namedBindings,
+                  ts.factory.updateNamedImports(
+                    namedBindings,
+                    namedBindings.elements.filter((e) => e !== node)
+                  )
+                );
+              }
+            })
+          }
+        ]
+      });
+    }
+  })
+});
+
+// src/diagnostics/leakingRequirements.ts
+var leakingRequirements = createDiagnostic({
+  name: "leakingRequirements",
+  code: 8,
+  severity: "suggestion",
+  apply: fn("leakingRequirements.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
+    const typeOrder = yield* deterministicTypeOrder;
+    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),
+              map4((_) => effectContextType = _.R),
+              orElse2(() => {
+                const servicePropertyCallSignatures = servicePropertyType.getCallSignatures();
+                if (servicePropertyCallSignatures.length === 1) {
+                  return pipe(
+                    typeParser.effectType(servicePropertyCallSignatures[0].getReturnType(), atLocation),
+                    map4((_) => {
+                      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;
+      report({
+        node,
+        messageText: `This Service is leaking the ${requirements.map((_) => typeChecker.typeToString(_)).join(" | ")} requirement.
+If these requirements cannot be cached and are expected to be provided per method invocation (e.g. HttpServerRequest), you can safely disable this diagnostic for this line through quickfixes.
+More info at https://effect.website/docs/requirements-management/layers/#avoiding-requirement-leakage`,
+        fixes: []
+      });
+    }
     const nodeToVisit = [];
     const appendNodeToVisit = (node) => {
       nodeToVisit.push(node);
@@ -2992,7 +2809,9 @@ var genericEffectServices = createDiagnostic({
     while (nodeToVisit.length > 0) {
       const node = nodeToVisit.shift();
       const typesToCheck = [];
-      if (ts.isClassDeclaration(node) && node.name && node.typeParameters && node.heritageClauses) {
+      if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.name) && node.expression.name.text === "GenericTag") {
+        typesToCheck.push([typeChecker.getTypeAtLocation(node), node]);
+      } else if (ts.isClassDeclaration(node) && node.name && node.heritageClauses) {
         const classSym = typeChecker.getSymbolAtLocation(node.name);
         if (classSym) {
           const type = typeChecker.getTypeOfSymbol(classSym);
@@ -3005,13 +2824,12 @@ var genericEffectServices = createDiagnostic({
       for (const [type, reportAt] of typesToCheck) {
         yield* pipe(
           typeParser.contextTag(type, node),
-          map4(() => {
-            report({
-              node: reportAt,
-              messageText: `Effect Services with type parameters are not supported because they cannot be properly discriminated at runtime, which may cause unexpected behavior.`,
-              fixes: []
-            });
-          }),
+          flatMap2(
+            ({ Service }) => pipe(
+              parseLeakedRequirements(Service, node),
+              map4((requirements) => reportLeakingRequirements(reportAt, sort(requirements, typeOrder)))
+            )
+          ),
           orElse2(() => sync(() => ts.forEachChild(node, appendNodeToVisit))),
           ignore
         );
@@ -3020,60 +2838,176 @@ var genericEffectServices = createDiagnostic({
   })
 });
 
-// src/diagnostics/importFromBarrel.ts
-var importFromBarrel = createDiagnostic({
-  name: "importFromBarrel",
-  code: 12,
-  severity: "off",
-  apply: fn("importFromBarrel.apply")(function* (sourceFile, report) {
-    const languageServicePluginOptions = yield* service(LanguageServicePluginOptions);
-    if (languageServicePluginOptions.namespaceImportPackages.length === 0) return;
+// src/diagnostics/missingEffectContext.ts
+var missingEffectContext = createDiagnostic({
+  name: "missingEffectContext",
+  code: 1,
+  severity: "error",
+  apply: fn("missingEffectContext.apply")(function* (sourceFile, report) {
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
+    const typeOrder = yield* deterministicTypeOrder;
+    const checkForMissingContextTypes = (node, expectedType, valueNode, realType) => pipe(
+      all(
+        typeParser.effectType(expectedType, node),
+        typeParser.effectType(realType, valueNode)
+      ),
+      flatMap2(
+        ([expectedEffect, realEffect]) => getMissingTypeEntriesInTargetType(
+          realEffect.R,
+          expectedEffect.R
+        )
+      )
+    );
+    const sortTypes = sort(typeOrder);
+    const entries = yield* expectedAndRealType(sourceFile);
+    for (const [node, expectedType, valueNode, realType] of entries) {
+      if (expectedType !== realType) {
+        yield* pipe(
+          checkForMissingContextTypes(
+            node,
+            expectedType,
+            valueNode,
+            realType
+          ),
+          map4(
+            (missingTypes) => missingTypes.length > 0 ? report(
+              {
+                node,
+                messageText: `Missing '${sortTypes(missingTypes).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect context.`,
+                fixes: []
+              }
+            ) : void 0
+          ),
+          ignore
+        );
+      }
+    }
+  })
+});
+
+// src/diagnostics/missingEffectError.ts
+var missingEffectError = createDiagnostic({
+  name: "missingEffectError",
+  code: 1,
+  severity: "error",
+  apply: fn("missingEffectError.apply")(function* (sourceFile, report) {
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
+    const typeOrder = yield* deterministicTypeOrder;
+    const checkForMissingErrorTypes = (node, expectedType, valueNode, realType) => pipe(
+      all(
+        typeParser.effectType(expectedType, node),
+        typeParser.effectType(realType, valueNode)
+      ),
+      flatMap2(
+        ([expectedEffect, realEffect]) => getMissingTypeEntriesInTargetType(
+          realEffect.E,
+          expectedEffect.E
+        )
+      )
+    );
+    const sortTypes = sort(typeOrder);
+    const entries = yield* expectedAndRealType(sourceFile);
+    for (const [node, expectedType, valueNode, realType] of entries) {
+      if (expectedType !== realType) {
+        yield* pipe(
+          checkForMissingErrorTypes(
+            node,
+            expectedType,
+            valueNode,
+            realType
+          ),
+          map4(
+            (missingTypes) => missingTypes.length > 0 ? report(
+              {
+                node,
+                messageText: `Missing '${sortTypes(missingTypes).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect errors.`,
+                fixes: []
+              }
+            ) : void 0
+          ),
+          ignore
+        );
+      }
+    }
+  })
+});
+
+// src/diagnostics/missingReturnYieldStar.ts
+var missingReturnYieldStar = createDiagnostic({
+  name: "missingReturnYieldStar",
+  code: 7,
+  severity: "error",
+  apply: fn("missingReturnYieldStar.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
-    const program = yield* service(TypeScriptProgram);
-    const isImportedFromBarrelExport = (element, languageServicePluginOptions2) => {
-      const getModuleSpecifier = makeGetModuleSpecifier(ts);
-      const resolveExternalModuleName = makeResolveExternalModuleName(typeChecker);
-      if (!(getModuleSpecifier && resolveExternalModuleName)) return;
-      const importDeclaration = ts.findAncestor(element, (node) => ts.isImportDeclaration(node));
-      if (!importDeclaration) return;
-      if (!ts.isStringLiteral(importDeclaration.moduleSpecifier)) return;
-      const importClause = importDeclaration.importClause;
-      if (!importClause) return;
-      const namedBindings = importClause.namedBindings;
-      if (!namedBindings) return;
-      if (!ts.isNamedImports(namedBindings)) return;
-      const barrelModuleName = importDeclaration.moduleSpecifier.text;
-      if (languageServicePluginOptions2.namespaceImportPackages.indexOf(barrelModuleName.toLowerCase()) === -1) return;
-      const moduleSymbol = resolveExternalModuleName(importDeclaration.moduleSpecifier);
-      if (!moduleSymbol) return;
-      if (!moduleSymbol.exports) return;
-      const sourceFile2 = importDeclaration.getSourceFile();
-      const nodeForSymbol = element.propertyName || element.name;
-      if (!ts.isIdentifier(nodeForSymbol)) return;
-      const importedName = nodeForSymbol.text;
-      const reexportedSymbol = moduleSymbol.exports.get(ts.escapeLeadingUnderscores(importedName));
-      if (!reexportedSymbol) return;
-      if (!(reexportedSymbol.declarations && reexportedSymbol.declarations.length === 1)) return;
-      const namespaceExport = reexportedSymbol.declarations[0];
-      if (!ts.isNamespaceExport(namespaceExport)) return;
-      const exportDeclaration = namespaceExport.parent;
-      if (!ts.isExportDeclaration(exportDeclaration)) return;
-      if (!exportDeclaration.moduleSpecifier) return;
-      const originalModuleSymbol = resolveExternalModuleName(exportDeclaration.moduleSpecifier);
-      if (!originalModuleSymbol) return;
-      if (!originalModuleSymbol.valueDeclaration) return;
-      const originalSourceFile = originalModuleSymbol.valueDeclaration.getSourceFile();
-      const unbarrelledFileName = getModuleSpecifier(
-        program.getCompilerOptions(),
-        sourceFile2,
-        sourceFile2.fileName,
-        originalSourceFile.fileName,
-        program
-      );
-      if (unbarrelledFileName.toLowerCase().indexOf(barrelModuleName.toLowerCase() + "/") === -1) return;
-      return { unbarrelledFileName, importedName, barrelModuleName, importClause, namedBindings, importDeclaration };
+    const typeParser = yield* service(TypeParser);
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
     };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts.forEachChild(node, appendNodeToVisit);
+      if (ts.isYieldExpression(node) && node.expression && node.asteriskToken) {
+        const type = typeChecker.getTypeAtLocation(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,
+            (_) => ts.isFunctionExpression(_) || ts.isFunctionDeclaration(_) || ts.isMethodDeclaration(_) || ts.isReturnStatement(_)
+          );
+          if (generatorFunctionOrReturnStatement && !ts.isReturnStatement(generatorFunctionOrReturnStatement)) {
+            if (generatorFunctionOrReturnStatement && generatorFunctionOrReturnStatement.parent) {
+              const effectGenNode = generatorFunctionOrReturnStatement.parent;
+              const effectGenLike = yield* pipe(
+                typeParser.effectGen(effectGenNode),
+                orElse2(() => typeParser.effectFnUntracedGen(effectGenNode)),
+                orElse2(() => typeParser.effectFnGen(effectGenNode)),
+                option
+              );
+              if (isSome2(effectGenLike)) {
+                const fix = node.expression ? [{
+                  fixName: "missingReturnYieldStar_fix",
+                  description: "Add return statement",
+                  apply: gen(function* () {
+                    const changeTracker = yield* service(ChangeTracker);
+                    changeTracker.replaceNode(
+                      sourceFile,
+                      node,
+                      ts.factory.createReturnStatement(
+                        node
+                      )
+                    );
+                  })
+                }] : [];
+                report({
+                  node,
+                  messageText: `Yielded Effect never succeeds, so it is best to use a 'return yield*' instead.`,
+                  fixes: fix
+                });
+              }
+            }
+          }
+        }
+      }
+    }
+  })
+});
+
+// src/diagnostics/missingStarInYieldEffectGen.ts
+var missingStarInYieldEffectGen = createDiagnostic({
+  name: "missingStarInYieldEffectGen",
+  code: 4,
+  severity: "error",
+  apply: fn("missingStarInYieldEffectGen.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
+    const brokenGenerators = /* @__PURE__ */ new Set();
+    const brokenYields = /* @__PURE__ */ new Set();
     const nodeToVisit = [];
     const appendNodeToVisit = (node) => {
       nodeToVisit.push(node);
@@ -3082,125 +3016,136 @@ var importFromBarrel = createDiagnostic({
     ts.forEachChild(sourceFile, appendNodeToVisit);
     while (nodeToVisit.length > 0) {
       const node = nodeToVisit.shift();
-      const parent = node.parent;
-      if (!(ts.isImportSpecifier(node) && ts.isNamedImports(parent))) {
-        ts.forEachChild(node, appendNodeToVisit);
-        continue;
+      ts.forEachChild(node, appendNodeToVisit);
+      if (ts.isYieldExpression(node) && node.expression && node.asteriskToken === void 0) {
+        const functionStarNode = ts.findAncestor(
+          node,
+          (_) => ts.isFunctionExpression(_) || ts.isFunctionDeclaration(_) || ts.isMethodDeclaration(_)
+        );
+        if (functionStarNode && functionStarNode.parent) {
+          const effectGenNode = functionStarNode.parent;
+          yield* pipe(
+            typeParser.effectGen(effectGenNode),
+            orElse2(() => typeParser.effectFnUntracedGen(effectGenNode)),
+            orElse2(() => typeParser.effectFnGen(effectGenNode)),
+            map4(({ functionStar }) => {
+              if (functionStar) {
+                brokenGenerators.add(functionStar);
+              }
+              brokenYields.add(node);
+            }),
+            ignore
+          );
+        }
       }
-      const result = isImportedFromBarrelExport(node, languageServicePluginOptions);
-      if (!result) continue;
-      const { barrelModuleName, importClause, importDeclaration, importedName, namedBindings, unbarrelledFileName } = result;
+    }
+    brokenGenerators.forEach(
+      (node) => report({
+        node,
+        messageText: `Seems like you used yield instead of yield* inside this Effect.gen.`,
+        fixes: []
+      })
+    );
+    brokenYields.forEach((node) => {
+      const fix = node.expression ? [{
+        fixName: "missingStarInYieldEffectGen_fix",
+        description: "Replace yield with yield*",
+        apply: gen(function* () {
+          const changeTracker = yield* service(ChangeTracker);
+          changeTracker.replaceNode(
+            sourceFile,
+            node,
+            ts.factory.createYieldExpression(
+              ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+              node.expression
+            )
+          );
+        })
+      }] : [];
       report({
         node,
-        messageText: `Importing from barrel module ${barrelModuleName} is not allowed.`,
-        fixes: [
-          {
-            fixName: "replaceWithUnbarrelledImport",
-            description: `Import * as ${importedName} from ${unbarrelledFileName}`,
-            apply: gen(function* () {
-              const changeTracker = yield* service(ChangeTracker);
-              const newImport = ts.factory.createImportDeclaration(
-                void 0,
-                ts.factory.createImportClause(
-                  importClause.isTypeOnly || node.isTypeOnly,
-                  void 0,
-                  ts.factory.createNamespaceImport(ts.factory.createIdentifier(importedName))
-                ),
-                ts.factory.createStringLiteral(unbarrelledFileName)
-              );
-              if (namedBindings.elements.length === 1) {
-                changeTracker.replaceNode(
-                  sourceFile,
-                  importDeclaration,
-                  newImport
-                );
-              } else {
-                changeTracker.insertNodeAfter(sourceFile, importDeclaration, newImport);
-                changeTracker.replaceNode(
-                  sourceFile,
-                  namedBindings,
-                  ts.factory.updateNamedImports(
-                    namedBindings,
-                    namedBindings.elements.filter((e) => e !== node)
-                  )
-                );
-              }
-            })
-          }
-        ]
+        messageText: `When yielding Effects inside Effect.gen, you should use yield* instead of yield.`,
+        fixes: fix
       });
-    }
+    });
   })
 });
 
-// src/diagnostics/leakingRequirements.ts
-var leakingRequirements = createDiagnostic({
-  name: "leakingRequirements",
-  code: 8,
+// src/diagnostics/returnEffectInGen.ts
+var returnEffectInGen = createDiagnostic({
+  name: "returnEffectInGen",
+  code: 11,
   severity: "suggestion",
-  apply: fn("leakingRequirements.apply")(function* (sourceFile, report) {
+  apply: fn("returnEffectInGen.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
-    const typeOrder = yield* deterministicTypeOrder;
-    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;
+    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.isReturnStatement(node) && node.expression) {
+        if (ts.isYieldExpression(node.expression)) continue;
+        const generatorOrRegularFunction = ts.findAncestor(
+          node,
+          (_) => ts.isFunctionExpression(_) || ts.isFunctionDeclaration(_) || ts.isMethodDeclaration(_) || ts.isArrowFunction(_) || ts.isGetAccessor(_)
+        );
+        if (!(generatorOrRegularFunction && "asteriskToken" in generatorOrRegularFunction && generatorOrRegularFunction.asteriskToken)) continue;
+        const type = typeChecker.getTypeAtLocation(node.expression);
+        const maybeEffect = yield* option(typeParser.strictEffectType(type, node.expression));
+        if (isSome2(maybeEffect)) {
+          if (generatorOrRegularFunction && generatorOrRegularFunction.parent) {
+            const effectGenNode = generatorOrRegularFunction.parent;
             yield* pipe(
-              typeParser.effectType(servicePropertyType, atLocation),
-              map4((_) => effectContextType = _.R),
-              orElse2(() => {
-                const servicePropertyCallSignatures = servicePropertyType.getCallSignatures();
-                if (servicePropertyCallSignatures.length === 1) {
-                  return pipe(
-                    typeParser.effectType(servicePropertyCallSignatures[0].getReturnType(), atLocation),
-                    map4((_) => {
-                      effectContextType = _.R;
-                    })
-                  );
-                }
-                return void_;
+              typeParser.effectGen(effectGenNode),
+              orElse2(() => typeParser.effectFnUntracedGen(effectGenNode)),
+              orElse2(() => typeParser.effectFnGen(effectGenNode)),
+              map4(() => {
+                const fix = node.expression ? [{
+                  fixName: "returnEffectInGen_fix",
+                  description: "Add yield* statement",
+                  apply: gen(function* () {
+                    const changeTracker = yield* service(ChangeTracker);
+                    changeTracker.replaceNode(
+                      sourceFile,
+                      node.expression,
+                      ts.factory.createYieldExpression(
+                        ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+                        node.expression
+                      )
+                    );
+                  })
+                }] : [];
+                report({
+                  node,
+                  messageText: `You are returning an Effect-able type inside a generator function, and will result in nested Effect<Effect<...>>.
+Maybe you wanted to return yield* instead?
+Nested Effect-able types may be intended if you plan to later manually flatten or unwrap this Effect, if so you can safely disable this diagnostic for this line through quickfixes.`,
+                  fixes: fix
+                });
               }),
               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;
-      report({
-        node,
-        messageText: `This Service is leaking the ${requirements.map((_) => typeChecker.typeToString(_)).join(" | ")} requirement.
-If these requirements cannot be cached and are expected to be provided per method invocation (e.g. HttpServerRequest), you can safely disable this diagnostic for this line through quickfixes.
-More info at https://effect.website/docs/requirements-management/layers/#avoiding-requirement-leakage`,
-        fixes: []
-      });
+      }
     }
+  })
+});
+
+// src/diagnostics/unnecessaryEffectGen.ts
+var unnecessaryEffectGen = createDiagnostic({
+  name: "unnecessaryEffectGen",
+  code: 5,
+  severity: "suggestion",
+  apply: fn("unnecessaryEffectGen.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
     const nodeToVisit = [];
     const appendNodeToVisit = (node) => {
       nodeToVisit.push(node);
@@ -3209,29 +3154,26 @@ More info at https://effect.website/docs/requirements-management/layers/#avoidin
     ts.forEachChild(sourceFile, appendNodeToVisit);
     while (nodeToVisit.length > 0) {
       const node = nodeToVisit.shift();
-      const typesToCheck = [];
-      if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.name) && node.expression.name.text === "GenericTag") {
-        typesToCheck.push([typeChecker.getTypeAtLocation(node), node]);
-      } else if (ts.isClassDeclaration(node) && node.name && node.heritageClauses) {
-        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) {
+      ts.forEachChild(node, appendNodeToVisit);
+      if (ts.isCallExpression(node)) {
         yield* pipe(
-          typeParser.contextTag(type, node),
-          flatMap2(
-            ({ Service }) => pipe(
-              parseLeakedRequirements(Service, node),
-              map4((requirements) => reportLeakingRequirements(reportAt, sort(requirements, typeOrder)))
-            )
+          typeParser.unnecessaryEffectGen(node),
+          map4(
+            ({ replacementNode }) => report({
+              node,
+              messageText: `This Effect.gen contains a single return statement.`,
+              fixes: [{
+                fixName: "unnecessaryEffectGen_fix",
+                description: "Remove the Effect.gen, and keep the body",
+                apply: gen(function* () {
+                  const textChanges = yield* service(
+                    ChangeTracker
+                  );
+                  textChanges.replaceNode(sourceFile, node, yield* replacementNode);
+                })
+              }]
+            })
           ),
-          orElse2(() => sync(() => ts.forEachChild(node, appendNodeToVisit))),
           ignore
         );
       }
@@ -3239,47 +3181,44 @@ More info at https://effect.website/docs/requirements-management/layers/#avoidin
   })
 });
 
-// src/diagnostics/missingEffectContext.ts
-var missingEffectContext = createDiagnostic({
-  name: "missingEffectContext",
-  code: 1,
-  severity: "error",
-  apply: fn("missingEffectContext.apply")(function* (sourceFile, report) {
-    const typeChecker = yield* service(TypeCheckerApi);
+// src/diagnostics/unnecessaryPipe.ts
+var unnecessaryPipe = createDiagnostic({
+  name: "unnecessaryPipe",
+  code: 9,
+  severity: "suggestion",
+  apply: fn("unnecessaryPipe.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
-    const typeOrder = yield* deterministicTypeOrder;
-    const checkForMissingContextTypes = (node, expectedType, valueNode, realType) => pipe(
-      all(
-        typeParser.effectType(expectedType, node),
-        typeParser.effectType(realType, valueNode)
-      ),
-      flatMap2(
-        ([expectedEffect, realEffect]) => getMissingTypeEntriesInTargetType(
-          realEffect.R,
-          expectedEffect.R
-        )
-      )
-    );
-    const sortTypes = sort(typeOrder);
-    const entries = yield* expectedAndRealType(sourceFile);
-    for (const [node, expectedType, valueNode, realType] of entries) {
-      if (expectedType !== realType) {
+    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)) {
         yield* pipe(
-          checkForMissingContextTypes(
-            node,
-            expectedType,
-            valueNode,
-            realType
-          ),
-          map4(
-            (missingTypes) => missingTypes.length > 0 ? report(
-              {
+          typeParser.pipeCall(node),
+          map4(({ args, subject }) => {
+            if (args.length === 0) {
+              report({
                 node,
-                messageText: `Missing '${sortTypes(missingTypes).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect context.`,
-                fixes: []
-              }
-            ) : void 0
-          ),
+                messageText: `This pipe call contains no arguments.`,
+                fixes: [{
+                  fixName: "unnecessaryPipe_fix",
+                  description: "Remove the pipe call",
+                  apply: gen(function* () {
+                    const textChanges = yield* service(
+                      ChangeTracker
+                    );
+                    textChanges.replaceNode(sourceFile, node, subject);
+                  })
+                }]
+              });
+            }
+          }),
           ignore
         );
       }
@@ -3287,361 +3226,468 @@ var missingEffectContext = createDiagnostic({
   })
 });
 
-// src/diagnostics/missingEffectError.ts
-var missingEffectError = createDiagnostic({
-  name: "missingEffectError",
-  code: 1,
-  severity: "error",
-  apply: fn("missingEffectError.apply")(function* (sourceFile, report) {
+// src/diagnostics.ts
+var diagnostics = [
+  duplicatePackage,
+  missingEffectContext,
+  missingEffectError,
+  floatingEffect,
+  missingStarInYieldEffectGen,
+  unnecessaryEffectGen,
+  missingReturnYieldStar,
+  leakingRequirements,
+  unnecessaryPipe,
+  genericEffectServices,
+  returnEffectInGen,
+  importFromBarrel
+];
+
+// src/completions/effectDiagnosticsComment.ts
+var effectDiagnosticsComment = createCompletion({
+  name: "effectDiagnosticsComment",
+  apply: fn("effectDiagnosticsComment")(function* (sourceFile, position) {
+    const ts = yield* service(TypeScriptApi);
+    const sourceText = sourceFile.text;
+    const match2 = /(\/\/|\/\*(?:\*?))\s*(@)\s*$/id.exec(sourceText.substring(0, position));
+    if (match2 && match2.indices) {
+      const lastIndex = match2.indices[2][0];
+      const replacementSpan = {
+        start: lastIndex,
+        length: Math.max(0, position - lastIndex)
+      };
+      const allDiagnostics = sort(Object.values(diagnostics).map((diagnostic) => diagnostic.name), string2).join(",");
+      const disableSnippet = "${1|" + allDiagnostics + "|}:${2|off,warning,error,message,suggestion|}$0";
+      return [{
+        name: `@effect-diagnostics`,
+        kind: ts.ScriptElementKind.string,
+        insertText: "@effect-diagnostics " + disableSnippet,
+        isSnippet: true,
+        replacementSpan
+      }, {
+        name: `@effect-diagnostics-next-line`,
+        kind: ts.ScriptElementKind.string,
+        insertText: "@effect-diagnostics-next-line " + disableSnippet,
+        isSnippet: true,
+        replacementSpan
+      }];
+    }
+    return [];
+  })
+});
+
+// src/completions/effectSchemaSelfInClasses.ts
+var effectSchemaSelfInClasses = createCompletion({
+  name: "effectSchemaSelfInClasses",
+  apply: fn("effectSchemaSelfInClasses")(function* (sourceFile, position) {
+    const ts = yield* service(TypeScriptApi);
+    const maybeInfos = yield* option(
+      parseDataForExtendsClassCompletion(sourceFile, position)
+    );
+    if (isNone2(maybeInfos)) return [];
+    const { accessedObject, className, replacementSpan } = maybeInfos.value;
+    const effectSchemaName = yield* option(
+      findImportedModuleIdentifierByPackageAndNameOrBarrel(
+        sourceFile,
+        "effect",
+        "Schema"
+      )
+    );
+    const schemaIdentifier = match(effectSchemaName, {
+      onNone: () => "Schema",
+      onSome: (_) => _.text
+    });
+    if (schemaIdentifier !== accessedObject.text) return [];
+    const name = className.text;
+    return [{
+      name: `Class<${name}>`,
+      kind: ts.ScriptElementKind.constElement,
+      insertText: `${schemaIdentifier}.Class<${name}>("${name}")({${"${0}"}}){}`,
+      replacementSpan,
+      isSnippet: true
+    }, {
+      name: `TaggedError<${name}>`,
+      kind: ts.ScriptElementKind.constElement,
+      insertText: `${schemaIdentifier}.TaggedError<${name}>("${name}")("${name}", {${"${0}"}}){}`,
+      replacementSpan,
+      isSnippet: true
+    }, {
+      name: `TaggedClass<${name}>`,
+      kind: ts.ScriptElementKind.constElement,
+      insertText: `${schemaIdentifier}.TaggedClass<${name}>("${name}")("${name}", {${"${0}"}}){}`,
+      replacementSpan,
+      isSnippet: true
+    }, {
+      name: `TaggedRequest<${name}>`,
+      kind: ts.ScriptElementKind.constElement,
+      insertText: `${schemaIdentifier}.TaggedRequest<${name}>("${name}")("${name}", {${"${0}"}}){}`,
+      replacementSpan,
+      isSnippet: true
+    }];
+  })
+});
+
+// src/completions/effectSelfInClasses.ts
+var effectSelfInClasses = createCompletion({
+  name: "effectSelfInClasses",
+  apply: fn("effectSelfInClasses")(function* (sourceFile, position) {
+    const ts = yield* service(TypeScriptApi);
+    const maybeInfos = yield* option(
+      parseDataForExtendsClassCompletion(sourceFile, position)
+    );
+    if (isNone2(maybeInfos)) return [];
+    const { accessedObject, className, replacementSpan } = maybeInfos.value;
+    const effectName = yield* option(
+      findImportedModuleIdentifierByPackageAndNameOrBarrel(
+        sourceFile,
+        "effect",
+        "Effect"
+      )
+    );
+    const effectIdentifier = match(effectName, {
+      onNone: () => "Effect",
+      onSome: (_) => _.text
+    });
+    if (effectIdentifier !== accessedObject.text) return [];
+    const name = className.text;
+    return [{
+      name: `Service<${name}>`,
+      kind: ts.ScriptElementKind.constElement,
+      insertText: `${effectIdentifier}.Service<${name}>()("${name}", {${"${0}"}}){}`,
+      replacementSpan,
+      isSnippet: true
+    }];
+  })
+});
+
+// src/completions/fnFunctionStar.ts
+var fnFunctionStar = createCompletion({
+  name: "fnFunctionStar",
+  apply: fn("fnFunctionStar")(function* (sourceFile, position) {
+    const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
+    const maybeInfos = yield* option(
+      parseAccessedExpressionForCompletion(sourceFile, position)
+    );
+    if (isNone2(maybeInfos)) return [];
+    const { accessedObject } = maybeInfos.value;
+    const isEffectModule = yield* option(typeParser.importedEffectModule(accessedObject));
+    if (isNone2(isEffectModule)) return [];
+    const span = ts.createTextSpan(
+      accessedObject.end + 1,
+      Math.max(0, position - accessedObject.end - 1)
+    );
+    const maybeFnName = pipe(
+      yield* getAncestorNodesInRange(sourceFile, toTextRange(accessedObject.pos)),
+      filter(ts.isVariableDeclaration),
+      map3((_) => _.name && ts.isIdentifier(_.name) ? _.name.text : ""),
+      filter((_) => _.length > 0),
+      head,
+      map2((name) => [
+        {
+          name: `fn("${name}")`,
+          kind: ts.ScriptElementKind.constElement,
+          insertText: `fn("${name}")(function*(${"${1}"}){${"${0}"}})`,
+          replacementSpan: span,
+          isSnippet: true
+        }
+      ]),
+      getOrElse2(() => [])
+    );
+    return maybeFnName.concat([{
+      name: `fn(function*(){})`,
+      kind: ts.ScriptElementKind.constElement,
+      insertText: `fn(function*(${"${1}"}){${"${0}"}})`,
+      replacementSpan: span,
+      isSnippet: true
+    }, {
+      name: `fnUntraced(function*(){})`,
+      kind: ts.ScriptElementKind.constElement,
+      insertText: `fnUntraced(function*(${"${1}"}){${"${0}"}})`,
+      replacementSpan: span,
+      isSnippet: true
+    }]);
+  })
+});
+
+// src/completions/genFunctionStar.ts
+var genFunctionStar = createCompletion({
+  name: "genFunctionStar",
+  apply: fn("genFunctionStar")(function* (sourceFile, position) {
+    const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
-    const typeParser = yield* service(TypeParser);
-    const typeOrder = yield* deterministicTypeOrder;
-    const checkForMissingErrorTypes = (node, expectedType, valueNode, realType) => pipe(
-      all(
-        typeParser.effectType(expectedType, node),
-        typeParser.effectType(realType, valueNode)
-      ),
-      flatMap2(
-        ([expectedEffect, realEffect]) => getMissingTypeEntriesInTargetType(
-          realEffect.E,
-          expectedEffect.E
-        )
-      )
+    const maybeInfos = yield* option(
+      parseAccessedExpressionForCompletion(sourceFile, position)
     );
-    const sortTypes = sort(typeOrder);
-    const entries = yield* expectedAndRealType(sourceFile);
-    for (const [node, expectedType, valueNode, realType] of entries) {
-      if (expectedType !== realType) {
-        yield* pipe(
-          checkForMissingErrorTypes(
-            node,
-            expectedType,
-            valueNode,
-            realType
-          ),
-          map4(
-            (missingTypes) => missingTypes.length > 0 ? report(
-              {
-                node,
-                messageText: `Missing '${sortTypes(missingTypes).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect errors.`,
-                fixes: []
-              }
-            ) : void 0
-          ),
-          ignore
-        );
-      }
-    }
+    if (isNone2(maybeInfos)) return [];
+    const { accessedObject } = maybeInfos.value;
+    const type = typeChecker.getTypeAtLocation(accessedObject);
+    const genMemberSymbol = type.getProperty("gen");
+    if (!genMemberSymbol) return [];
+    const genType = typeChecker.getTypeOfSymbolAtLocation(genMemberSymbol, accessedObject);
+    if (genType.getCallSignatures().length === 0) return [];
+    const span = ts.createTextSpan(
+      accessedObject.end + 1,
+      Math.max(0, position - accessedObject.end - 1)
+    );
+    return [{
+      name: `gen(function*(){})`,
+      kind: ts.ScriptElementKind.constElement,
+      insertText: `gen(function*(){${"${0}"}})`,
+      replacementSpan: span,
+      isSnippet: true
+    }];
   })
 });
 
-// src/diagnostics/missingReturnYieldStar.ts
-var missingReturnYieldStar = createDiagnostic({
-  name: "missingReturnYieldStar",
-  code: 7,
-  severity: "error",
-  apply: fn("missingReturnYieldStar.apply")(function* (sourceFile, report) {
+// src/completions/rpcMakeClasses.ts
+var rpcMakeClasses = createCompletion({
+  name: "rpcMakeClasses",
+  apply: fn("rpcMakeClasses")(function* (sourceFile, position) {
     const ts = yield* service(TypeScriptApi);
-    const typeChecker = yield* service(TypeCheckerApi);
-    const typeParser = yield* service(TypeParser);
-    const nodeToVisit = [];
-    const appendNodeToVisit = (node) => {
-      nodeToVisit.push(node);
-      return void 0;
-    };
-    ts.forEachChild(sourceFile, appendNodeToVisit);
-    while (nodeToVisit.length > 0) {
-      const node = nodeToVisit.shift();
-      ts.forEachChild(node, appendNodeToVisit);
-      if (ts.isYieldExpression(node) && node.expression && node.asteriskToken) {
-        const type = typeChecker.getTypeAtLocation(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,
-            (_) => ts.isFunctionExpression(_) || ts.isFunctionDeclaration(_) || ts.isMethodDeclaration(_) || ts.isReturnStatement(_)
-          );
-          if (generatorFunctionOrReturnStatement && !ts.isReturnStatement(generatorFunctionOrReturnStatement)) {
-            if (generatorFunctionOrReturnStatement && generatorFunctionOrReturnStatement.parent) {
-              const effectGenNode = generatorFunctionOrReturnStatement.parent;
-              const effectGenLike = yield* pipe(
-                typeParser.effectGen(effectGenNode),
-                orElse2(() => typeParser.effectFnUntracedGen(effectGenNode)),
-                orElse2(() => typeParser.effectFnGen(effectGenNode)),
-                option
-              );
-              if (isSome2(effectGenLike)) {
-                const fix = node.expression ? [{
-                  fixName: "missingReturnYieldStar_fix",
-                  description: "Add return statement",
-                  apply: gen(function* () {
-                    const changeTracker = yield* service(ChangeTracker);
-                    changeTracker.replaceNode(
-                      sourceFile,
-                      node,
-                      ts.factory.createReturnStatement(
-                        node
-                      )
-                    );
-                  })
-                }] : [];
-                report({
-                  node,
-                  messageText: `Yielded Effect never succeeds, so it is best to use a 'return yield*' instead.`,
-                  fixes: fix
-                });
-              }
-            }
-          }
-        }
-      }
-    }
+    const maybeInfos = yield* option(
+      parseDataForExtendsClassCompletion(sourceFile, position)
+    );
+    if (isNone2(maybeInfos)) return [];
+    const { accessedObject, className, replacementSpan } = maybeInfos.value;
+    const rpcName = yield* option(
+      findImportedModuleIdentifierByPackageAndNameOrBarrel(
+        sourceFile,
+        "@effect/rpc",
+        "Rpc"
+      )
+    );
+    const rpcIdentifier = match(rpcName, {
+      onNone: () => "Rpc",
+      onSome: (_) => _.text
+    });
+    if (rpcIdentifier !== accessedObject.text) return [];
+    const name = className.text;
+    return [{
+      name: `make("${name}")`,
+      kind: ts.ScriptElementKind.constElement,
+      insertText: `${rpcIdentifier}.make("${name}", {${"${0}"}}) {}`,
+      replacementSpan,
+      isSnippet: true
+    }];
   })
 });
 
-// src/diagnostics/missingStarInYieldEffectGen.ts
-var missingStarInYieldEffectGen = createDiagnostic({
-  name: "missingStarInYieldEffectGen",
-  code: 4,
-  severity: "error",
-  apply: fn("missingStarInYieldEffectGen.apply")(function* (sourceFile, report) {
-    const ts = yield* service(TypeScriptApi);
-    const typeParser = yield* service(TypeParser);
-    const brokenGenerators = /* @__PURE__ */ new Set();
-    const brokenYields = /* @__PURE__ */ new Set();
-    const nodeToVisit = [];
-    const appendNodeToVisit = (node) => {
-      nodeToVisit.push(node);
-      return void 0;
-    };
-    ts.forEachChild(sourceFile, appendNodeToVisit);
-    while (nodeToVisit.length > 0) {
-      const node = nodeToVisit.shift();
-      ts.forEachChild(node, appendNodeToVisit);
-      if (ts.isYieldExpression(node) && node.expression && node.asteriskToken === void 0) {
-        const functionStarNode = ts.findAncestor(
-          node,
-          (_) => ts.isFunctionExpression(_) || ts.isFunctionDeclaration(_) || ts.isMethodDeclaration(_)
-        );
-        if (functionStarNode && functionStarNode.parent) {
-          const effectGenNode = functionStarNode.parent;
-          yield* pipe(
-            typeParser.effectGen(effectGenNode),
-            orElse2(() => typeParser.effectFnUntracedGen(effectGenNode)),
-            orElse2(() => typeParser.effectFnGen(effectGenNode)),
-            map4(({ functionStar }) => {
-              if (functionStar) {
-                brokenGenerators.add(functionStar);
+// src/completions.ts
+var completions = [
+  effectSchemaSelfInClasses,
+  effectSelfInClasses,
+  contextSelfInClasses,
+  rpcMakeClasses,
+  genFunctionStar,
+  fnFunctionStar,
+  effectDataClasses,
+  effectDiagnosticsComment
+];
+
+// src/completions/middlewareNamespaceImports.ts
+var importablePackagesMetadataCache = /* @__PURE__ */ new Map();
+var makeImportablePackagesMetadata = fn("makeImportablePackagesMetadata")(function* (sourceFile) {
+  const ts = yield* service(TypeScriptApi);
+  const program = yield* service(TypeScriptProgram);
+  const languageServicePluginOptions = yield* service(LanguageServicePluginOptions);
+  const host = program;
+  const namespaceByFileName = /* @__PURE__ */ new Map();
+  const excludedByFileName = /* @__PURE__ */ new Map();
+  const unbarreledModulePathByFileName = /* @__PURE__ */ new Map();
+  const barreledModulePathByFileName = /* @__PURE__ */ new Map();
+  for (const packageName of languageServicePluginOptions.namespaceImportPackages) {
+    const barrelModule = ts.resolveModuleName(packageName, sourceFile.fileName, program.getCompilerOptions(), host);
+    if (barrelModule.resolvedModule) {
+      const barrelPath = barrelModule.resolvedModule.resolvedFileName;
+      const barrelSource = program.getSourceFile(barrelPath) || ts.createSourceFile(barrelPath, host.readFile(barrelPath) || "", sourceFile.languageVersion, true);
+      if (barrelSource) {
+        for (const statement of barrelSource.statements) {
+          if (ts.isExportDeclaration(statement)) {
+            const exportClause = statement.exportClause;
+            const moduleSpecifier = statement.moduleSpecifier;
+            if (moduleSpecifier && ts.isStringLiteral(moduleSpecifier)) {
+              const unbarreledModulePathResolved = ts.resolveModuleName(
+                moduleSpecifier.text,
+                barrelSource.fileName,
+                program.getCompilerOptions(),
+                host
+              );
+              if (unbarreledModulePathResolved.resolvedModule) {
+                const unbarreledModulePath = unbarreledModulePathResolved.resolvedModule.resolvedFileName;
+                if (exportClause && ts.isNamespaceExport(exportClause) && ts.isIdentifier(exportClause.name)) {
+                  namespaceByFileName.set(unbarreledModulePath, exportClause.name.text);
+                  const existingUnbarreledModulePath = unbarreledModulePathByFileName.get(barrelSource.fileName) || [];
+                  existingUnbarreledModulePath.push({
+                    fileName: unbarreledModulePath,
+                    exportName: exportClause.name.text
+                  });
+                  unbarreledModulePathByFileName.set(barrelSource.fileName, existingUnbarreledModulePath);
+                  barreledModulePathByFileName.set(unbarreledModulePath, {
+                    fileName: barrelSource.fileName,
+                    exportName: exportClause.name.text
+                  });
+                }
+                if (exportClause && ts.isNamedExports(exportClause)) {
+                  for (const element of exportClause.elements) {
+                    if (!ts.isIdentifier(element.name)) continue;
+                    const methodName = element.name.text;
+                    const excludedMethods = excludedByFileName.get(methodName) || [];
+                    excludedMethods.push(unbarreledModulePath);
+                    excludedByFileName.set(methodName, excludedMethods);
+                  }
+                }
               }
-              brokenYields.add(node);
-            }),
-            ignore
-          );
+            }
+          }
         }
       }
     }
-    brokenGenerators.forEach(
-      (node) => report({
-        node,
-        messageText: `Seems like you used yield instead of yield* inside this Effect.gen.`,
-        fixes: []
-      })
-    );
-    brokenYields.forEach((node) => {
-      const fix = node.expression ? [{
-        fixName: "missingStarInYieldEffectGen_fix",
-        description: "Replace yield with yield*",
-        apply: gen(function* () {
-          const changeTracker = yield* service(ChangeTracker);
-          changeTracker.replaceNode(
-            sourceFile,
-            node,
-            ts.factory.createYieldExpression(
-              ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
-              node.expression
-            )
-          );
-        })
-      }] : [];
-      report({
-        node,
-        messageText: `When yielding Effects inside Effect.gen, you should use yield* instead of yield.`,
-        fixes: fix
-      });
-    });
-  })
+  }
+  return {
+    getImportNamespaceByFileName: (fileName) => namespaceByFileName.get(fileName),
+    isExcludedFromNamespaceImport: (fileName, exportName) => (excludedByFileName.get(exportName) || []).includes(fileName),
+    getUnbarreledModulePath: (fileName, exportName) => unbarreledModulePathByFileName.get(fileName)?.find((_) => _.exportName === exportName)?.fileName,
+    getBarreledModulePath: (fileName) => barreledModulePathByFileName.get(fileName)
+  };
 });
-
-// src/diagnostics/returnEffectInGen.ts
-var returnEffectInGen = createDiagnostic({
-  name: "returnEffectInGen",
-  code: 11,
-  severity: "suggestion",
-  apply: fn("returnEffectInGen.apply")(function* (sourceFile, report) {
-    const ts = yield* service(TypeScriptApi);
-    const typeChecker = yield* service(TypeCheckerApi);
-    const typeParser = yield* service(TypeParser);
-    const nodeToVisit = [];
-    const appendNodeToVisit = (node) => {
-      nodeToVisit.push(node);
-      return void 0;
-    };
-    ts.forEachChild(sourceFile, appendNodeToVisit);
-    while (nodeToVisit.length > 0) {
-      const node = nodeToVisit.shift();
-      ts.forEachChild(node, appendNodeToVisit);
-      if (ts.isReturnStatement(node) && node.expression) {
-        if (ts.isYieldExpression(node.expression)) continue;
-        const generatorOrRegularFunction = ts.findAncestor(
-          node,
-          (_) => ts.isFunctionExpression(_) || ts.isFunctionDeclaration(_) || ts.isMethodDeclaration(_) || ts.isArrowFunction(_) || ts.isGetAccessor(_)
-        );
-        if (!(generatorOrRegularFunction && "asteriskToken" in generatorOrRegularFunction && generatorOrRegularFunction.asteriskToken)) continue;
-        const type = typeChecker.getTypeAtLocation(node.expression);
-        const maybeEffect = yield* option(typeParser.strictEffectType(type, node.expression));
-        if (isSome2(maybeEffect)) {
-          if (generatorOrRegularFunction && generatorOrRegularFunction.parent) {
-            const effectGenNode = generatorOrRegularFunction.parent;
-            yield* pipe(
-              typeParser.effectGen(effectGenNode),
-              orElse2(() => typeParser.effectFnUntracedGen(effectGenNode)),
-              orElse2(() => typeParser.effectFnGen(effectGenNode)),
-              map4(() => {
-                const fix = node.expression ? [{
-                  fixName: "returnEffectInGen_fix",
-                  description: "Add yield* statement",
-                  apply: gen(function* () {
-                    const changeTracker = yield* service(ChangeTracker);
-                    changeTracker.replaceNode(
-                      sourceFile,
-                      node.expression,
-                      ts.factory.createYieldExpression(
-                        ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
-                        node.expression
-                      )
-                    );
-                  })
-                }] : [];
-                report({
-                  node,
-                  messageText: `You are returning an Effect-able type inside a generator function, and will result in nested Effect<Effect<...>>.
-Maybe you wanted to return yield* instead?
-Nested Effect-able types may be intended if you plan to later manually flatten or unwrap this Effect, if so you can safely disable this diagnostic for this line through quickfixes.`,
-                  fixes: fix
-                });
-              }),
-              ignore
-            );
+var appendEffectCompletionEntryData = fn("appendEffectCompletionEntryData")(
+  function* (_sourceFile, applicableCompletions) {
+    const languageServicePluginOptions = yield* service(LanguageServicePluginOptions);
+    if (languageServicePluginOptions.namespaceImportPackages.length === 0) return applicableCompletions;
+    if (applicableCompletions) {
+      return {
+        ...applicableCompletions,
+        entries: applicableCompletions.entries.map(
+          (entry) => entry.data ? {
+            ...entry,
+            data: {
+              ...entry.data,
+              effectReplaceSpan: entry.replacementSpan || applicableCompletions.optionalReplacementSpan
+            }
+          } : entry
+        )
+      };
+    }
+    return applicableCompletions;
+  }
+);
+var postprocessCompletionEntryDetails = fn("postprocessCompletionEntryDetails")(
+  function* (sourceFile, data, applicableCompletionEntryDetails, formatOptions, preferences, languageServiceHost) {
+    const languageServicePluginOptions = yield* service(LanguageServicePluginOptions);
+    if (languageServicePluginOptions.namespaceImportPackages.length === 0) return applicableCompletionEntryDetails;
+    const isAutoImportOnlyCodeActions = fn("isAutoImportOnlyCodeActions")(
+      function* (codeActions, exportName2) {
+        if (!codeActions) return;
+        if (codeActions.length !== 1) return;
+        const action = codeActions[0];
+        const changes2 = action.changes;
+        if (changes2.length !== 1) return;
+        const fileTextChanges = action.changes[0];
+        if (fileTextChanges.fileName !== sourceFile.fileName) return;
+        const textChanges = fileTextChanges.textChanges;
+        if (textChanges.length !== 1) return;
+        const change = textChanges[0];
+        if (change.newText.trim().toLowerCase().startsWith("import") && change.newText.indexOf(exportName2) > -1) {
+          return {
+            type: "create"
+          };
+        }
+        if (change.newText.indexOf(exportName2) > -1) {
+          const ancestorNodes = yield* getAncestorNodesInRange(sourceFile, {
+            pos: change.span.start,
+            end: change.span.start
+          });
+          const importNodes = ancestorNodes.filter((node) => ts.isImportDeclaration(node));
+          if (importNodes.length > 0) {
+            return {
+              type: "update"
+            };
           }
         }
       }
-    }
-  })
-});
-
-// src/diagnostics/unnecessaryEffectGen.ts
-var unnecessaryEffectGen = createDiagnostic({
-  name: "unnecessaryEffectGen",
-  code: 5,
-  severity: "suggestion",
-  apply: fn("unnecessaryEffectGen.apply")(function* (sourceFile, report) {
+    );
     const ts = yield* service(TypeScriptApi);
-    const typeParser = yield* service(TypeParser);
-    const nodeToVisit = [];
-    const appendNodeToVisit = (node) => {
-      nodeToVisit.push(node);
-      return void 0;
-    };
-    ts.forEachChild(sourceFile, appendNodeToVisit);
-    while (nodeToVisit.length > 0) {
-      const node = nodeToVisit.shift();
-      ts.forEachChild(node, appendNodeToVisit);
-      if (ts.isCallExpression(node)) {
-        yield* pipe(
-          typeParser.unnecessaryEffectGen(node),
-          map4(
-            ({ replacementNode }) => report({
-              node,
-              messageText: `This Effect.gen contains a single return statement.`,
-              fixes: [{
-                fixName: "unnecessaryEffectGen_fix",
-                description: "Remove the Effect.gen, and keep the body",
-                apply: gen(function* () {
-                  const textChanges = yield* service(
-                    ChangeTracker
-                  );
-                  textChanges.replaceNode(sourceFile, node, yield* replacementNode);
-                })
-              }]
-            })
+    const program = yield* service(TypeScriptProgram);
+    const getModuleSpecifier = makeGetModuleSpecifier(ts);
+    if (!getModuleSpecifier) return applicableCompletionEntryDetails;
+    if (!applicableCompletionEntryDetails) return applicableCompletionEntryDetails;
+    if (!data) return applicableCompletionEntryDetails;
+    const { exportName, fileName, moduleSpecifier } = data;
+    if (!fileName) return applicableCompletionEntryDetails;
+    if (!exportName) return applicableCompletionEntryDetails;
+    if (!moduleSpecifier) return applicableCompletionEntryDetails;
+    if (!("effectReplaceSpan" in data)) return applicableCompletionEntryDetails;
+    const effectReplaceSpan = data.effectReplaceSpan;
+    const result = yield* isAutoImportOnlyCodeActions(applicableCompletionEntryDetails.codeActions, exportName);
+    if (!result) return applicableCompletionEntryDetails;
+    const packagesMetadata = importablePackagesMetadataCache.get(sourceFile.fileName) || (yield* makeImportablePackagesMetadata(sourceFile));
+    importablePackagesMetadataCache.set(sourceFile.fileName, packagesMetadata);
+    const formatContext = ts.formatting.getFormatContext(
+      formatOptions || {},
+      languageServiceHost
+    );
+    const isExcluded = packagesMetadata.isExcludedFromNamespaceImport(
+      fileName,
+      exportName
+    );
+    if (isExcluded) return applicableCompletionEntryDetails;
+    const effectUnbarreledModulePath = packagesMetadata.getUnbarreledModulePath(
+      fileName,
+      exportName
+    );
+    const effectNamespaceName = packagesMetadata.getImportNamespaceByFileName(
+      effectUnbarreledModulePath || fileName
+    );
+    if (!effectNamespaceName) return applicableCompletionEntryDetails;
+    const newModuleSpecifier = effectUnbarreledModulePath ? getModuleSpecifier(
+      program.getCompilerOptions(),
+      sourceFile,
+      sourceFile.fileName,
+      String(effectUnbarreledModulePath || fileName),
+      program
+    ) : moduleSpecifier;
+    const changes = ts.textChanges.ChangeTracker.with(
+      {
+        formatContext,
+        host: languageServiceHost,
+        preferences: preferences || {}
+      },
+      (changeTracker) => {
+        ts.insertImports(
+          changeTracker,
+          sourceFile,
+          ts.factory.createImportDeclaration(
+            void 0,
+            ts.factory.createImportClause(
+              false,
+              void 0,
+              ts.factory.createNamespaceImport(ts.factory.createIdentifier(effectNamespaceName))
+            ),
+            ts.factory.createStringLiteral(newModuleSpecifier)
           ),
-          ignore
+          true,
+          preferences || {}
         );
+        if (!effectUnbarreledModulePath) {
+          changeTracker.insertText(
+            sourceFile,
+            effectReplaceSpan.start,
+            effectNamespaceName + "."
+          );
+        }
       }
-    }
-  })
-});
-
-// src/diagnostics/unnecessaryPipe.ts
-var unnecessaryPipe = createDiagnostic({
-  name: "unnecessaryPipe",
-  code: 9,
-  severity: "suggestion",
-  apply: fn("unnecessaryPipe.apply")(function* (sourceFile, report) {
-    const ts = yield* service(TypeScriptApi);
-    const typeParser = yield* service(TypeParser);
-    const nodeToVisit = [];
-    const appendNodeToVisit = (node) => {
-      nodeToVisit.push(node);
-      return void 0;
+    );
+    return {
+      ...applicableCompletionEntryDetails,
+      codeActions: [
+        {
+          description: "Import * as " + effectNamespaceName + " from " + newModuleSpecifier,
+          changes
+        }
+      ]
     };
-    ts.forEachChild(sourceFile, appendNodeToVisit);
-    while (nodeToVisit.length > 0) {
-      const node = nodeToVisit.shift();
-      ts.forEachChild(node, appendNodeToVisit);
-      if (ts.isCallExpression(node)) {
-        yield* pipe(
-          typeParser.pipeCall(node),
-          map4(({ args, subject }) => {
-            if (args.length === 0) {
-              report({
-                node,
-                messageText: `This pipe call contains no arguments.`,
-                fixes: [{
-                  fixName: "unnecessaryPipe_fix",
-                  description: "Remove the pipe call",
-                  apply: gen(function* () {
-                    const textChanges = yield* service(
-                      ChangeTracker
-                    );
-                    textChanges.replaceNode(sourceFile, node, subject);
-                  })
-                }]
-              });
-            }
-          }),
-          ignore
-        );
-      }
-    }
-  })
-});
-
-// src/diagnostics.ts
-var diagnostics = [
-  duplicatePackage,
-  missingEffectContext,
-  missingEffectError,
-  floatingEffect,
-  missingStarInYieldEffectGen,
-  unnecessaryEffectGen,
-  missingReturnYieldStar,
-  leakingRequirements,
-  unnecessaryPipe,
-  genericEffectServices,
-  returnEffectInGen,
-  importFromBarrel
-];
+  }
+);
 
 // src/goto/effectRpcDefinition.ts
 function effectRpcDefinition(applicableGotoDefinition, sourceFile, position) {