@effect/language-service 0.22.0 → 0.22.2

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;
@@ -832,29 +833,11 @@ var dedupeWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => {
 });
 
 // src/core/Nano.ts
-var NanoInternalSuccessProto = {
-  _tag: "Right"
-};
 function makeInternalSuccess(value) {
-  const result = Object.create(NanoInternalSuccessProto);
-  result.value = value;
-  return result;
-}
-var NanoInternalFailureProto = {
-  _tag: "Left"
-};
-function makeInternalFailure(value) {
-  const result = Object.create(NanoInternalFailureProto);
-  result.value = value;
-  return result;
+  return { _tag: "Right", value };
 }
-var NanoInternalDefectProto = {
-  _tag: "Defect"
-};
 function makeInternalDefect(value) {
-  const result = Object.create(NanoInternalDefectProto);
-  result.value = value;
-  return result;
+  return { _tag: "Defect", value };
 }
 var NanoDefectException = class {
   constructor(message) {
@@ -869,17 +852,14 @@ var NanoTag = class {
 };
 var Tag = (identifier) => new NanoTag(identifier);
 var contextEmpty = { value: {} };
-var Proto = {
-  run: () => {
-  },
-  [Symbol.iterator]() {
-    return new SingleShotGen(new YieldWrap(this));
-  }
-};
 function make3(run2) {
-  const result = Object.create(Proto);
-  result.run = run2;
-  return result;
+  const nano = {
+    run: run2,
+    [Symbol.iterator]() {
+      return new SingleShotGen(new YieldWrap(this));
+    }
+  };
+  return nano;
 }
 var unsafeRun = (fa) => {
   const program = provideService(internalNanoCache, {})(fa);
@@ -900,9 +880,33 @@ var run = (fa) => {
     return left2(new NanoDefectException(e));
   }
 };
-var succeed = (value) => make3(() => makeInternalSuccess(value));
-var fail = (value) => make3(() => makeInternalFailure(value));
-var sync = (value) => make3(() => makeInternalSuccess(value()));
+var succeed = (value) => {
+  const nano = {
+    run: () => ({ _tag: "Right", value }),
+    [Symbol.iterator]() {
+      return new SingleShotGen(new YieldWrap(this));
+    }
+  };
+  return nano;
+};
+var fail = (value) => {
+  const nano = {
+    run: () => ({ _tag: "Left", value }),
+    [Symbol.iterator]() {
+      return new SingleShotGen(new YieldWrap(this));
+    }
+  };
+  return nano;
+};
+var sync = (value) => {
+  const nano = {
+    run: () => ({ _tag: "Right", value: value() }),
+    [Symbol.iterator]() {
+      return new SingleShotGen(new YieldWrap(this));
+    }
+  };
+  return nano;
+};
 var flatMap2 = dual(2, (fa, f) => make3((ctx) => {
   const result = fa.run(ctx);
   if (result._tag !== "Right") return result;
@@ -995,8 +999,9 @@ function cachedBy(fa, key, lookupKey) {
       cacheObj[key] = cache;
     }
     const lookup = lookupKey(...args);
-    if (cache.has(lookup)) {
-      return cache.get(lookup);
+    const cached2 = cache.get(lookup);
+    if (cached2 !== void 0) {
+      return cached2;
     }
     const result = fa(...args).run(ctx);
     cache.set(lookup, result);
@@ -1728,122 +1733,347 @@ 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(
+  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/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) {
@@ -2297,641 +2527,14 @@ function make4(ts, typeChecker) {
   };
 }
 
-// src/completions/fnFunctionStar.ts
-var fnFunctionStar = createCompletion({
-  name: "fnFunctionStar",
-  apply: fn("fnFunctionStar")(function* (sourceFile, position) {
+// src/diagnostics/floatingEffect.ts
+var floatingEffect = createDiagnostic({
+  name: "floatingEffect",
+  code: 3,
+  severity: "error",
+  apply: fn("floatingEffect.apply")(function* (sourceFile, report) {
     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
-              }
-            ]
-          };
-        }
-      }
-    }
-    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: []
-        });
-      }
-    }
-  })
-});
-
-// src/diagnostics/floatingEffect.ts
-var floatingEffect = createDiagnostic({
-  name: "floatingEffect",
-  code: 3,
-  severity: "error",
-  apply: fn("floatingEffect.apply")(function* (sourceFile, report) {
-    const ts = yield* service(TypeScriptApi);
-    const typeChecker = yield* service(TypeCheckerApi);
+    const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
     function isFloatingExpression(node) {
       if (!ts.isExpressionStatement(node)) return false;
@@ -3259,22 +2862,24 @@ var missingEffectContext = createDiagnostic({
     const sortTypes = sort(typeOrder);
     const entries = yield* expectedAndRealType(sourceFile);
     for (const [node, expectedType, valueNode, realType] of entries) {
-      const missingContext = yield* pipe(
-        checkForMissingContextTypes(
-          node,
-          expectedType,
-          valueNode,
-          realType
-        ),
-        orElse2(() => succeed([]))
-      );
-      if (missingContext.length > 0) {
-        report(
-          {
+      if (expectedType !== realType) {
+        yield* pipe(
+          checkForMissingContextTypes(
             node,
-            messageText: `Missing '${sortTypes(missingContext).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect context.`,
-            fixes: []
-          }
+            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
         );
       }
     }
@@ -3305,36 +2910,284 @@ var missingEffectError = createDiagnostic({
     const sortTypes = sort(typeOrder);
     const entries = yield* expectedAndRealType(sourceFile);
     for (const [node, expectedType, valueNode, realType] of entries) {
-      const missingContext = yield* pipe(
-        checkForMissingErrorTypes(
+      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 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);
+      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,
-          expectedType,
-          valueNode,
-          realType
-        ),
-        orElse2(() => succeed([]))
-      );
-      if (missingContext.length > 0) {
-        report(
-          {
+          (_) => 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
+          );
+        }
+      }
+    }
+    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,
-            messageText: `Missing '${sortTypes(missingContext).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect errors.`,
-            fixes: []
+            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
+      });
+    });
+  })
+});
+
+// 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
+            );
           }
+        }
+      }
+    }
+  })
+});
+
+// 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);
+                })
+              }]
+            })
+          ),
+          ignore
         );
       }
     }
   })
 });
 
-// src/diagnostics/missingReturnYieldStar.ts
-var missingReturnYieldStar = createDiagnostic({
-  name: "missingReturnYieldStar",
-  code: 7,
-  severity: "error",
-  apply: fn("missingReturnYieldStar.apply")(function* (sourceFile, report) {
+// 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 typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
     const nodeToVisit = [];
     const appendNodeToVisit = (node) => {
@@ -3345,295 +3198,485 @@ var missingReturnYieldStar = createDiagnostic({
     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",
+      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 changeTracker = yield* service(ChangeTracker);
-                    changeTracker.replaceNode(
-                      sourceFile,
-                      node,
-                      ts.factory.createReturnStatement(
-                        node
-                      )
+                    const textChanges = yield* service(
+                      ChangeTracker
                     );
+                    textChanges.replaceNode(sourceFile, node, subject);
                   })
-                }] : [];
-                report({
-                  node,
-                  messageText: `Yielded Effect never succeeds, so it is best to use a 'return yield*' instead.`,
-                  fixes: fix
-                });
-              }
+                }]
+              });
             }
-          }
+          }),
+          ignore
+        );
+      }
+    }
+  })
+});
+
+// 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/diagnostics/missingStarInYieldEffectGen.ts
-var missingStarInYieldEffectGen = createDiagnostic({
-  name: "missingStarInYieldEffectGen",
-  code: 4,
-  severity: "error",
-  apply: fn("missingStarInYieldEffectGen.apply")(function* (sourceFile, report) {
+// src/completions/genFunctionStar.ts
+var genFunctionStar = createCompletion({
+  name: "genFunctionStar",
+  apply: fn("genFunctionStar")(function* (sourceFile, position) {
     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);
-              }
-              brokenYields.add(node);
-            }),
-            ignore
-          );
-        }
-      }
-    }
-    brokenGenerators.forEach(
-      (node) => report({
-        node,
-        messageText: `Seems like you used yield instead of yield* inside this Effect.gen.`,
-        fixes: []
-      })
+    const typeChecker = yield* service(TypeCheckerApi);
+    const maybeInfos = yield* option(
+      parseAccessedExpressionForCompletion(sourceFile, position)
     );
-    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
-      });
-    });
+    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/returnEffectInGen.ts
-var returnEffectInGen = createDiagnostic({
-  name: "returnEffectInGen",
-  code: 11,
-  severity: "suggestion",
-  apply: fn("returnEffectInGen.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.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
-            );
+    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,
+  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();
+  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]
+  };
 });
-
-// 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);
-                })
-              }]
-            })
-          ),
-          ignore
-        );
-      }
+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;
+        })
+      };
     }
-  })
-});
-
-// src/diagnostics/unnecessaryPipe.ts
-var unnecessaryPipe = createDiagnostic({
-  name: "unnecessaryPipe",
-  code: 9,
-  severity: "suggestion",
-  apply: fn("unnecessaryPipe.apply")(function* (sourceFile, report) {
+    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 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.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);
-                  })
-                }]
-              });
+    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) + "."
+                );
+              }
             }
-          }),
-          ignore
-        );
+          );
+          return {
+            ...applicableCompletionEntryDetails,
+            codeActions: [
+              {
+                description: "Import * as " + data.effectNamespaceName + " from " + data.effectUnbarreledModulePath,
+                changes
+              }
+            ]
+          };
+        }
       }
     }
-  })
-});
-
-// src/diagnostics.ts
-var diagnostics = [
-  duplicatePackage,
-  missingEffectContext,
-  missingEffectError,
-  floatingEffect,
-  missingStarInYieldEffectGen,
-  unnecessaryEffectGen,
-  missingReturnYieldStar,
-  leakingRequirements,
-  unnecessaryPipe,
-  genericEffectServices,
-  returnEffectInGen,
-  importFromBarrel
-];
+    return applicableCompletionEntryDetails;
+  }
+);
 
 // src/goto/effectRpcDefinition.ts
 function effectRpcDefinition(applicableGotoDefinition, sourceFile, position) {