@effect/language-service 0.28.3 → 0.30.0

package/cli.js

@@ -16666,8 +16666,8 @@ var go = (ast, isDecoding) => {
       return (i, options3) => handleForbidden(flatMap10(mapError3(from(i, options3), (e) => new Transformation2(ast, i, isDecoding ? "Encoded" : "Type", e)), (a) => flatMap10(mapError3(transform3(a, options3 ?? defaultParseOption, ast, i), (e) => new Transformation2(ast, i, "Transformation", e)), (i2) => mapError3(to(i2, options3), (e) => new Transformation2(ast, i, isDecoding ? "Type" : "Encoded", e)))), ast, i, options3);
     }
     case "Declaration": {
-      const parse5 = isDecoding ? ast.decodeUnknown(...ast.typeParameters) : ast.encodeUnknown(...ast.typeParameters);
-      return (i, options3) => handleForbidden(parse5(i, options3 ?? defaultParseOption, ast), ast, i, options3);
+      const parse6 = isDecoding ? ast.decodeUnknown(...ast.typeParameters) : ast.encodeUnknown(...ast.typeParameters);
+      return (i, options3) => handleForbidden(parse6(i, options3 ?? defaultParseOption, ast), ast, i, options3);
     }
     case "Literal":
       return fromRefinement(ast, (u) => u === ast.literal);
@@ -24040,7 +24040,7 @@ var validateInternal = (self, value5, config2) => {
     }
   }
 };
-var attempt = (option5, typeName, parse5) => orElseFail2(option5, () => `${typeName} options do not have a default value`).pipe(flatMap9((value5) => orElseFail2(parse5(value5), () => `'${value5}' is not a ${typeName}`)));
+var attempt = (option5, typeName, parse6) => orElseFail2(option5, () => `${typeName} options do not have a default value`).pipe(flatMap9((value5) => orElseFail2(parse6(value5), () => `'${value5}' is not a ${typeName}`)));
 var validatePathExistence = (path2, shouldPathExist, pathExists) => {
   if (shouldPathExist === "no" && pathExists) {
     return fail7(`Path '${path2}' must not exist`);
@@ -26628,7 +26628,7 @@ var parseConfig = (config2) => {
   let argsIndex = 0;
   const options3 = [];
   let optionsIndex = 0;
-  function parse5(config3) {
+  function parse6(config3) {
     const tree = {};
     for (const key in config3) {
       tree[key] = parseValue(config3[key]);
@@ -26656,14 +26656,14 @@ var parseConfig = (config2) => {
     } else {
       return {
         _tag: "ParsedConfig",
-        tree: parse5(value5)
+        tree: parse6(value5)
       };
     }
   }
   return {
     args: args3,
     options: options3,
-    tree: parse5(config2)
+    tree: parse6(config2)
   };
 };
 var reconstructConfigTree = (tree, args3, options3) => {
@@ -28794,44 +28794,50 @@ function parse4(config2) {
 var TypeScriptApi = Tag4("TypeScriptApi");
 var TypeScriptProgram = Tag4("TypeScriptProgram");
 var ChangeTracker = Tag4("ChangeTracker");
-function parsePackageContentNameAndVersionFromScope(v) {
-  if (!isObject(v)) return;
-  if (!hasProperty(v, "packageJsonScope")) return;
-  if (!v.packageJsonScope) return;
-  const packageJsonScope = v.packageJsonScope;
-  if (!hasProperty(packageJsonScope, "contents")) return;
-  if (!hasProperty(packageJsonScope.contents, "packageJsonContent")) return;
-  const packageJsonContent = packageJsonScope.contents.packageJsonContent;
-  if (!hasProperty(packageJsonContent, "name")) return;
-  if (!hasProperty(packageJsonContent, "version")) return;
-  if (!hasProperty(packageJsonScope, "packageDirectory")) return;
-  if (!isString(packageJsonScope.packageDirectory)) return;
-  const { name, version } = packageJsonContent;
-  if (!isString(name)) return;
-  if (!isString(version)) return;
-  const hasEffectInPeerDependencies = hasProperty(packageJsonContent, "peerDependencies") && isObject(packageJsonContent.peerDependencies) && hasProperty(packageJsonContent.peerDependencies, "effect");
-  const referencedPackages = Object.keys({
-    ...hasProperty(packageJsonContent, "dependencies") && isObject(packageJsonContent.dependencies) ? packageJsonContent.dependencies : {},
-    ...hasProperty(packageJsonContent, "peerDependencies") && isObject(packageJsonContent.peerDependencies) ? packageJsonContent.peerDependencies : {},
-    ...hasProperty(packageJsonContent, "devDependencies") && isObject(packageJsonContent.devDependencies) ? packageJsonContent.devDependencies : {}
-  });
-  const exportsKeys = Object.keys(
-    hasProperty(packageJsonContent, "exports") && isObject(packageJsonContent.exports) ? packageJsonContent.exports : {}
-  );
-  return {
-    name: name.toLowerCase(),
-    version: version.toLowerCase(),
-    hasEffectInPeerDependencies,
-    contents: packageJsonContent,
-    packageDirectory: packageJsonScope.packageDirectory,
-    referencedPackages,
-    exportsKeys
-  };
-}
-var resolveModulePattern = fn("resolveModulePattern")(
-  function* (sourceFile, pattern2) {
+
+// src/core/TypeScriptUtils.ts
+var TypeScriptUtils = Tag4("TypeScriptUtils");
+var nanoLayer = (fa) => pipe(
+  service2(TypeScriptApi),
+  flatMap18((ts2) => pipe(fa, provideService7(TypeScriptUtils, makeTypeScriptUtils(ts2))))
+);
+function makeTypeScriptUtils(ts2) {
+  function parsePackageContentNameAndVersionFromScope(v) {
+    if (!isObject(v)) return;
+    if (!hasProperty(v, "packageJsonScope")) return;
+    if (!v.packageJsonScope) return;
+    const packageJsonScope = v.packageJsonScope;
+    if (!hasProperty(packageJsonScope, "contents")) return;
+    if (!hasProperty(packageJsonScope.contents, "packageJsonContent")) return;
+    const packageJsonContent = packageJsonScope.contents.packageJsonContent;
+    if (!hasProperty(packageJsonContent, "name")) return;
+    if (!hasProperty(packageJsonContent, "version")) return;
+    if (!hasProperty(packageJsonScope, "packageDirectory")) return;
+    if (!isString(packageJsonScope.packageDirectory)) return;
+    const { name, version } = packageJsonContent;
+    if (!isString(name)) return;
+    if (!isString(version)) return;
+    const hasEffectInPeerDependencies = hasProperty(packageJsonContent, "peerDependencies") && isObject(packageJsonContent.peerDependencies) && hasProperty(packageJsonContent.peerDependencies, "effect");
+    const referencedPackages = Object.keys({
+      ...hasProperty(packageJsonContent, "dependencies") && isObject(packageJsonContent.dependencies) ? packageJsonContent.dependencies : {},
+      ...hasProperty(packageJsonContent, "peerDependencies") && isObject(packageJsonContent.peerDependencies) ? packageJsonContent.peerDependencies : {},
+      ...hasProperty(packageJsonContent, "devDependencies") && isObject(packageJsonContent.devDependencies) ? packageJsonContent.devDependencies : {}
+    });
+    const exportsKeys = Object.keys(
+      hasProperty(packageJsonContent, "exports") && isObject(packageJsonContent.exports) ? packageJsonContent.exports : {}
+    );
+    return {
+      name: name.toLowerCase(),
+      version: version.toLowerCase(),
+      hasEffectInPeerDependencies,
+      contents: packageJsonContent,
+      packageDirectory: packageJsonScope.packageDirectory,
+      referencedPackages,
+      exportsKeys
+    };
+  }
+  function resolveModulePattern(sourceFile, pattern2) {
     if (pattern2.indexOf("*") === -1) return [pattern2.toLowerCase()];
-    const ts2 = yield* service2(TypeScriptApi);
     const packageJsonScope = parsePackageContentNameAndVersionFromScope(sourceFile);
     const referencedPackages = [];
     for (const statement of sourceFile.statements) {
@@ -28850,19 +28856,338 @@ var resolveModulePattern = fn("resolveModulePattern")(
       )
     );
   }
-);
-function makeGetModuleSpecifier(ts2) {
-  if (!(hasProperty(ts2, "moduleSpecifiers") && hasProperty(ts2.moduleSpecifiers, "getModuleSpecifier") && isFunction2(ts2.moduleSpecifiers.getModuleSpecifier))) return;
-  const _internal = ts2.moduleSpecifiers.getModuleSpecifier;
-  return (compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host, options3) => {
-    return _internal(
-      compilerOptions,
-      importingSourceFile,
-      importingSourceFileName,
-      toFileName,
-      host,
-      options3
+  function makeGetModuleSpecifier() {
+    if (!(hasProperty(ts2, "moduleSpecifiers") && hasProperty(ts2.moduleSpecifiers, "getModuleSpecifier") && isFunction2(ts2.moduleSpecifiers.getModuleSpecifier))) return;
+    const _internal = ts2.moduleSpecifiers.getModuleSpecifier;
+    return (compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host, options3) => {
+      return _internal(
+        compilerOptions,
+        importingSourceFile,
+        importingSourceFileName,
+        toFileName,
+        host,
+        options3
+      );
+    };
+  }
+  function findNodeWithLeadingCommentAtPosition(sourceFile, position) {
+    const sourceText = sourceFile.text;
+    let result;
+    function find3(node) {
+      const leading = ts2.getLeadingCommentRanges(sourceText, node.getFullStart());
+      if (leading) {
+        for (const commentRange of leading) {
+          if (commentRange.pos <= position && position < commentRange.end) {
+            result = { node, commentRange };
+            return;
+          }
+        }
+      }
+      if (node.getFullStart() <= position && position < node.getEnd()) {
+        node.forEachChild(find3);
+      }
+    }
+    find3(sourceFile);
+    return result;
+  }
+  function collectSelfAndAncestorNodesInRange(node, textRange) {
+    let result = empty2();
+    let parent = node;
+    while (parent) {
+      if (parent.end >= textRange.end) {
+        result = pipe(result, append(parent));
+      }
+      parent = parent.parent;
+    }
+    return result;
+  }
+  function findNodeAtPosition(sourceFile, position) {
+    function find3(node) {
+      if (position >= node.getStart() && position < node.getEnd()) {
+        return ts2.forEachChild(node, find3) || node;
+      }
+      return void 0;
+    }
+    return find3(sourceFile);
+  }
+  function findNodeAtPositionIncludingTrivia(sourceFile, position) {
+    function find3(node) {
+      if (position >= node.pos && position < node.end) {
+        return ts2.forEachChild(node, find3) || node;
+      }
+      return void 0;
+    }
+    return find3(sourceFile);
+  }
+  function getAncestorNodesInRange(sourceFile, textRange) {
+    const nodeAtPosition = findNodeAtPosition(sourceFile, textRange.pos);
+    if (!nodeAtPosition) return empty2();
+    return collectSelfAndAncestorNodesInRange(nodeAtPosition, textRange);
+  }
+  function getCommentAtPosition(sourceFile, pos) {
+    const token = findNodeAtPositionIncludingTrivia(sourceFile, pos);
+    if (token === void 0 || token.kind === ts2.SyntaxKind.JsxText || pos >= token.end - (ts2.tokenToString(token.kind) || "").length) {
+      return;
+    }
+    const startPos = token.pos === 0 ? (ts2.getShebang(sourceFile.text) || "").length : token.pos;
+    if (startPos === 0) return;
+    const result = ts2.forEachTrailingCommentRange(sourceFile.text, startPos, isCommentInRange, pos) || ts2.forEachLeadingCommentRange(sourceFile.text, startPos, isCommentInRange, pos);
+    return result;
+  }
+  function isCommentInRange(pos, end5, kind, _nl, at) {
+    return at >= pos && at < end5 ? { pos, end: end5, kind } : void 0;
+  }
+  function toTextRange(positionOrRange) {
+    return typeof positionOrRange === "number" ? { end: positionOrRange, pos: positionOrRange } : positionOrRange;
+  }
+  function isNodeInRange(textRange) {
+    return (node) => node.pos <= textRange.pos && node.end >= textRange.end;
+  }
+  function transformAsyncAwaitToEffectGen(node, effectModuleName, onAwait) {
+    function visitor(_) {
+      if (ts2.isAwaitExpression(_)) {
+        const expression = ts2.visitEachChild(_.expression, visitor, ts2.nullTransformationContext);
+        return ts2.factory.createYieldExpression(
+          ts2.factory.createToken(ts2.SyntaxKind.AsteriskToken),
+          onAwait(expression)
+        );
+      }
+      return ts2.visitEachChild(_, visitor, ts2.nullTransformationContext);
+    }
+    const generatorBody = visitor(node.body);
+    const effectGenCallExp = createEffectGenCallExpression(effectModuleName, generatorBody);
+    let currentFlags = ts2.getCombinedModifierFlags(node);
+    currentFlags &= ~ts2.ModifierFlags.Async;
+    const newModifiers = ts2.factory.createModifiersFromModifierFlags(currentFlags);
+    if (ts2.isArrowFunction(node)) {
+      return ts2.factory.createArrowFunction(
+        newModifiers,
+        node.typeParameters,
+        node.parameters,
+        void 0,
+        node.equalsGreaterThanToken,
+        effectGenCallExp
+      );
+    }
+    const newBody = ts2.factory.createBlock([
+      ts2.factory.createReturnStatement(effectGenCallExp)
+    ]);
+    if (ts2.isFunctionDeclaration(node)) {
+      return ts2.factory.createFunctionDeclaration(
+        newModifiers,
+        node.asteriskToken,
+        node.name,
+        node.typeParameters,
+        node.parameters,
+        void 0,
+        newBody
+      );
+    }
+    return ts2.factory.createFunctionExpression(
+      newModifiers,
+      node.asteriskToken,
+      node.name,
+      node.typeParameters,
+      node.parameters,
+      void 0,
+      newBody
+    );
+  }
+  function findImportedModuleIdentifier(sourceFile, test) {
+    for (const statement of sourceFile.statements) {
+      if (!ts2.isImportDeclaration(statement)) continue;
+      const importClause = statement.importClause;
+      if (!importClause) continue;
+      const namedBindings = importClause.namedBindings;
+      if (!namedBindings) continue;
+      if (ts2.isNamespaceImport(namedBindings)) {
+        if (test(namedBindings.name, statement.moduleSpecifier, none2())) {
+          return namedBindings.name.text;
+        }
+      } else if (ts2.isNamedImports(namedBindings)) {
+        for (const importSpecifier of namedBindings.elements) {
+          const importProperty = fromNullable(importSpecifier.propertyName).pipe(
+            orElse(() => some2(importSpecifier.name))
+          );
+          if (test(importSpecifier.name, statement.moduleSpecifier, importProperty)) {
+            return importSpecifier.name.text;
+          }
+        }
+      }
+    }
+  }
+  function findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, packageName, moduleName) {
+    return findImportedModuleIdentifier(
+      sourceFile,
+      (_, fromModule, importProperty) => {
+        if (isNone2(importProperty) && ts2.isStringLiteral(fromModule) && fromModule.text === packageName + "/" + moduleName) {
+          return true;
+        }
+        if (isSome2(importProperty) && ts2.isIdentifier(importProperty.value) && importProperty.value.text === moduleName && ts2.isStringLiteral(fromModule) && fromModule.text === packageName) {
+          return true;
+        }
+        return false;
+      }
+    );
+  }
+  function simplifyTypeNode(typeNode) {
+    function collectCallable(typeNode2) {
+      if (ts2.isParenthesizedTypeNode(typeNode2)) return collectCallable(typeNode2.type);
+      if (ts2.isFunctionTypeNode(typeNode2)) {
+        return some2([
+          ts2.factory.createCallSignature(typeNode2.typeParameters, typeNode2.parameters, typeNode2.type)
+        ]);
+      }
+      if (ts2.isTypeLiteralNode(typeNode2)) {
+        const allCallSignatures = typeNode2.members.every(ts2.isCallSignatureDeclaration);
+        if (allCallSignatures) {
+          return some2(typeNode2.members);
+        }
+      }
+      if (ts2.isIntersectionTypeNode(typeNode2)) {
+        const members = typeNode2.types.map((node) => collectCallable(node));
+        if (members.every(isSome2)) {
+          return some2(members.map((_) => isSome2(_) ? _.value : []).flat());
+        }
+      }
+      return none2();
+    }
+    const callSignatures = collectCallable(typeNode);
+    if (isSome2(callSignatures) && callSignatures.value.length > 1) {
+      return ts2.factory.createTypeLiteralNode(callSignatures.value);
+    }
+    return typeNode;
+  }
+  function tryPreserveDeclarationSemantics(nodeToReplace, node) {
+    if (!ts2.isExpression(node)) return node;
+    if (ts2.isFunctionDeclaration(nodeToReplace)) {
+      if (!nodeToReplace.name) return node;
+      return ts2.factory.createVariableStatement(
+        nodeToReplace.modifiers,
+        ts2.factory.createVariableDeclarationList(
+          [ts2.factory.createVariableDeclaration(
+            nodeToReplace.name,
+            void 0,
+            void 0,
+            node
+          )],
+          ts2.NodeFlags.Const
+        )
+      );
+    } else if (ts2.isMethodDeclaration(nodeToReplace)) {
+      return ts2.factory.createPropertyDeclaration(
+        nodeToReplace.modifiers,
+        nodeToReplace.name,
+        void 0,
+        void 0,
+        node
+      );
+    }
+    return node;
+  }
+  function parseAccessedExpressionForCompletion(sourceFile, position) {
+    const precedingToken = ts2.findPrecedingToken(position, sourceFile, void 0, true);
+    if (!precedingToken) return;
+    let accessedObject = precedingToken;
+    let replacementSpan = ts2.createTextSpan(position, 0);
+    let outerNode = precedingToken;
+    if (ts2.isIdentifier(precedingToken) && precedingToken.parent && ts2.isPropertyAccessExpression(precedingToken.parent)) {
+      replacementSpan = ts2.createTextSpan(
+        precedingToken.parent.getStart(sourceFile),
+        precedingToken.end - precedingToken.parent.getStart(sourceFile)
+      );
+      accessedObject = precedingToken.parent.expression;
+      outerNode = precedingToken.parent;
+    } else if (ts2.isToken(precedingToken) && precedingToken.kind === ts2.SyntaxKind.DotToken && ts2.isPropertyAccessExpression(precedingToken.parent)) {
+      replacementSpan = ts2.createTextSpan(
+        precedingToken.parent.getStart(sourceFile),
+        precedingToken.end - precedingToken.parent.getStart(sourceFile)
+      );
+      accessedObject = precedingToken.parent.expression;
+      outerNode = precedingToken.parent;
+    } else if (ts2.isIdentifier(precedingToken) && precedingToken.parent) {
+      replacementSpan = ts2.createTextSpan(
+        precedingToken.getStart(sourceFile),
+        precedingToken.end - precedingToken.getStart(sourceFile)
+      );
+      accessedObject = precedingToken;
+      outerNode = precedingToken;
+    } else {
+      return;
+    }
+    return { accessedObject, outerNode, replacementSpan };
+  }
+  function parseDataForExtendsClassCompletion(sourceFile, position) {
+    const maybeInfos = parseAccessedExpressionForCompletion(sourceFile, position);
+    if (!maybeInfos) return;
+    const { accessedObject, outerNode, replacementSpan } = maybeInfos;
+    if (!ts2.isIdentifier(accessedObject)) return;
+    let classDeclaration = outerNode.parent;
+    while (ts2.isExpressionWithTypeArguments(classDeclaration) || ts2.isHeritageClause(classDeclaration)) {
+      if (!classDeclaration.parent) break;
+      classDeclaration = classDeclaration.parent;
+    }
+    if (!ts2.isClassDeclaration(classDeclaration)) return;
+    if (!classDeclaration.name) return;
+    return {
+      accessedObject,
+      classDeclaration,
+      className: classDeclaration.name,
+      replacementSpan
+    };
+  }
+  function createEffectGenCallExpression(effectModuleIdentifierName, node) {
+    const generator = ts2.factory.createFunctionExpression(
+      void 0,
+      ts2.factory.createToken(ts2.SyntaxKind.AsteriskToken),
+      void 0,
+      [],
+      [],
+      void 0,
+      node
+      // NOTE(mattia): intended, to use same routine for both ConciseBody and Body
+    );
+    return ts2.factory.createCallExpression(
+      ts2.factory.createPropertyAccessExpression(
+        ts2.factory.createIdentifier(effectModuleIdentifierName),
+        "gen"
+      ),
+      void 0,
+      [generator]
+    );
+  }
+  function createEffectGenCallExpressionWithBlock(effectModuleIdentifierName, statement) {
+    return createEffectGenCallExpression(
+      effectModuleIdentifierName,
+      ts2.factory.createBlock(isArray(statement) ? statement : [statement], false)
+    );
+  }
+  function createReturnYieldStarStatement(expr) {
+    return ts2.factory.createReturnStatement(
+      ts2.factory.createYieldExpression(
+        ts2.factory.createToken(ts2.SyntaxKind.AsteriskToken),
+        expr
+      )
     );
+  }
+  return {
+    findNodeAtPositionIncludingTrivia,
+    parsePackageContentNameAndVersionFromScope,
+    resolveModulePattern,
+    findNodeWithLeadingCommentAtPosition,
+    getCommentAtPosition,
+    getAncestorNodesInRange,
+    toTextRange,
+    isNodeInRange,
+    transformAsyncAwaitToEffectGen,
+    findImportedModuleIdentifierByPackageAndNameOrBarrel,
+    simplifyTypeNode,
+    tryPreserveDeclarationSemantics,
+    parseDataForExtendsClassCompletion,
+    createEffectGenCallExpressionWithBlock,
+    createReturnYieldStarStatement,
+    makeGetModuleSpecifier,
+    parseAccessedExpressionForCompletion
   };
 }
 
@@ -28870,6 +29195,9 @@ function makeGetModuleSpecifier(ts2) {
 var RefactorNotApplicableError = class {
   _tag = "@effect/language-service/RefactorNotApplicableError";
 };
+function createRefactor(definition) {
+  return definition;
+}
 function createDiagnostic(definition) {
   return definition;
 }
@@ -28932,27 +29260,8 @@ var getCompletionsAtPosition = fn("LSP.getCompletionsAtPosition")(function* (com
 var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
   function* (sourceFile) {
     const ts2 = yield* service2(TypeScriptApi);
+    const tsUtils = yield* service2(TypeScriptUtils);
     const pluginOptions = yield* service2(LanguageServicePluginOptions);
-    function findNodeWithLeadingCommentAtPosition(position) {
-      const sourceText = sourceFile.text;
-      let result;
-      function find3(node) {
-        const leading = ts2.getLeadingCommentRanges(sourceText, node.getFullStart());
-        if (leading) {
-          for (const r of leading) {
-            if (r.pos <= position && position < r.end) {
-              result = node;
-              return;
-            }
-          }
-        }
-        if (node.getFullStart() <= position && position < node.getEnd()) {
-          node.forEachChild(find3);
-        }
-      }
-      find3(sourceFile);
-      return result;
-    }
     function findParentStatementForDisableNextLine(node) {
       let result;
       function find3(node2) {
@@ -28985,12 +29294,12 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
               if (ruleLevel === "skip-file") skippedRules.push(ruleName);
               const isOverrideNextLine = nextLineCaptureGroup && nextLineCaptureGroup.trim().toLowerCase() === "-next-line";
               if (isOverrideNextLine) {
-                const node = findNodeWithLeadingCommentAtPosition(match18.index);
-                if (node) {
+                const foundNode = tsUtils.findNodeWithLeadingCommentAtPosition(sourceFile, match18.index);
+                if (foundNode) {
                   lineOverrides[ruleName] = lineOverrides[ruleName] || [];
                   lineOverrides[ruleName].unshift({
-                    pos: node.getFullStart(),
-                    end: node.end,
+                    pos: foundNode.node.getFullStart(),
+                    end: foundNode.node.end,
                     level: ruleLevel
                   });
                 }
@@ -29012,7 +29321,7 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
       message: ts2.DiagnosticCategory.Message,
       suggestion: ts2.DiagnosticCategory.Suggestion
     };
-    const execute2 = fn("LSP.ruleExecutor")(function* (rule) {
+    const execute2 = (rule) => gen3(function* () {
       const diagnostics2 = [];
       const codeFixes = [];
       const ruleNameLowered = rule.name.toLowerCase();
@@ -29021,13 +29330,13 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
       if (defaultLevel === "off" && (lineOverrides[ruleNameLowered] || sectionOverrides[ruleNameLowered] || []).length === 0) {
         return { diagnostics: diagnostics2, codeFixes };
       }
-      const fixByDisableNextLine = (_) => ({
+      const fixByDisableNextLine = (node) => ({
         fixName: rule.name + "_skipNextLine",
         description: "Disable " + rule.name + " for this line",
         apply: flatMap18(
           service2(ChangeTracker),
-          (changeTracker) => sync11(() => {
-            const disableAtNode = findParentStatementForDisableNextLine(_.node);
+          (changeTracker) => gen3(function* () {
+            const disableAtNode = findParentStatementForDisableNextLine(node);
             const { line: line4 } = ts2.getLineAndCharacterOfPosition(sourceFile, disableAtNode.getStart());
             changeTracker.insertCommentBeforeLine(
               sourceFile,
@@ -29055,29 +29364,30 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
       };
       const applicableDiagnostics = [];
       yield* rule.apply(sourceFile, (entry) => {
+        const range3 = "getEnd" in entry.location ? { pos: entry.location.getStart(sourceFile), end: entry.location.getEnd() } : entry.location;
+        const node = "getEnd" in entry.location ? entry.location : tsUtils.findNodeAtPositionIncludingTrivia(sourceFile, entry.location.pos);
         applicableDiagnostics.push({
-          ...entry,
-          fixes: entry.fixes.concat([fixByDisableNextLine(entry), fixByDisableEntireFile])
+          range: range3,
+          messageText: entry.messageText,
+          fixes: entry.fixes.concat(node ? [fixByDisableNextLine(node)] : []).concat([fixByDisableEntireFile])
         });
       });
       for (const emitted of applicableDiagnostics.slice(0)) {
         let newLevel = defaultLevel;
         const lineOverride = (lineOverrides[ruleNameLowered] || []).find(
-          (_) => _.pos < emitted.node.getStart(sourceFile) && _.end >= emitted.node.getEnd()
+          (_) => _.pos < emitted.range.pos && _.end >= emitted.range.end
         );
         if (lineOverride) {
           newLevel = lineOverride.level;
         } else {
-          const sectionOverride = (sectionOverrides[ruleNameLowered] || []).find(
-            (_) => _.pos < emitted.node.getStart(sourceFile)
-          );
+          const sectionOverride = (sectionOverrides[ruleNameLowered] || []).find((_) => _.pos < emitted.range.pos);
           if (sectionOverride) newLevel = sectionOverride.level;
         }
         if (!(newLevel in levelToDiagnosticCategory)) continue;
         diagnostics2.push({
           file: sourceFile,
-          start: emitted.node.getStart(sourceFile),
-          length: emitted.node.getEnd() - emitted.node.getStart(sourceFile),
+          start: emitted.range.pos,
+          length: emitted.range.end - emitted.range.pos,
           messageText: emitted.messageText,
           category: levelToDiagnosticCategory[newLevel],
           code: rule.code,
@@ -29087,8 +29397,8 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
           codeFixes.push({
             ...fix,
             code: rule.code,
-            start: emitted.node.getStart(sourceFile),
-            end: emitted.node.getEnd()
+            start: emitted.range.pos,
+            end: emitted.range.end
           });
         }
       }
@@ -29097,15 +29407,85 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
     return { execute: execute2 };
   }
 );
+var cyrb53 = (str, seed = 0) => {
+  let h12 = 3735928559 ^ seed, h2 = 1103547991 ^ seed;
+  for (let i = 0, ch; i < str.length; i++) {
+    ch = str.charCodeAt(i);
+    h12 = Math.imul(h12 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h12 = Math.imul(h12 ^ h12 >>> 16, 2246822507);
+  h12 ^= Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507);
+  h2 ^= Math.imul(h12 ^ h12 >>> 13, 3266489909);
+  return (h2 >>> 0).toString(16).padStart(8, "0") + (h12 >>> 0).toString(16).padStart(8, "0");
+};
+var CodegenNotApplicableError = class {
+  constructor(cause2) {
+    this.cause = cause2;
+  }
+  _tag = "@effect/language-service/CodegenNotApplicableError";
+};
+function createCodegen(definition) {
+  return definition;
+}
+var getCodegensForSourceFile = fn("LSP.getApplicableCodegens")(function* (codegens2, sourceFile) {
+  const tsUtils = yield* service2(TypeScriptUtils);
+  const result = [];
+  const regex = /@effect-codegens((?:\s[a-zA-Z0-9]+(?::(?:[a-zA-Z0-9]+))?)+)+/gmid;
+  let match18;
+  while ((match18 = regex.exec(sourceFile.text)) !== null) {
+    const pos = match18.indices?.[0]?.[0];
+    if (!pos) continue;
+    const commentRange = tsUtils.getCommentAtPosition(sourceFile, pos);
+    if (!commentRange) continue;
+    const commentText = sourceFile.text.slice(pos, commentRange.end);
+    const codegenRegex = /(\s+)(\w+)(?::(\w+))?/gmi;
+    let codegenMatch;
+    while ((codegenMatch = codegenRegex.exec(commentText)) !== null) {
+      const whitespace = codegenMatch[1] || "";
+      const codegenName = codegenMatch[2] || "";
+      const codegenHash = codegenMatch[3] || "";
+      const range3 = {
+        pos: codegenMatch.index + pos + whitespace.length,
+        end: codegenMatch.index + pos + codegenMatch[0].length
+      };
+      const codegen = codegens2.find((codegen2) => codegen2.name === codegenName);
+      if (!codegen) continue;
+      result.push({ codegen, hash: codegenHash, range: range3 });
+    }
+  }
+  return result;
+});
+var getEditsForCodegen = fn("LSP.getEditsForCodegen")(function* (codegens2, sourceFile, textRange) {
+  const applicableCodegens = yield* getCodegensForSourceFile(codegens2, sourceFile);
+  const inRangeCodegens = applicableCodegens.filter(
+    (codegen2) => codegen2.range.pos <= textRange.pos && codegen2.range.end >= textRange.end
+  );
+  if (inRangeCodegens.length !== 1) {
+    return yield* fail18(new CodegenNotApplicableError("zero or multiple codegens in range"));
+  }
+  const { codegen, range: range3 } = inRangeCodegens[0];
+  const edit = yield* codegen.apply(sourceFile, range3);
+  const updateHashComment = pipe(
+    service2(ChangeTracker),
+    map33((changeTracker) => {
+      changeTracker.deleteRange(sourceFile, range3);
+      changeTracker.insertText(sourceFile, range3.pos, `${codegen.name}:${edit.hash}`);
+    })
+  );
+  return {
+    ...edit,
+    apply: pipe(
+      edit.apply,
+      flatMap18(() => updateHashComment)
+    ),
+    ignore: updateHashComment
+  };
+});
 
 // src/core/TypeCheckerApi.ts
 var TypeCheckerApi = Tag4("TypeChecker");
-var TypeCheckerApiCache = Tag4("TypeCheckerApiCache");
-function makeTypeCheckerApiCache() {
-  return {
-    expectedAndRealType: /* @__PURE__ */ new WeakMap()
-  };
-}
 var deterministicTypeOrder = gen3(function* () {
   const typeChecker = yield* service2(TypeCheckerApi);
   return make2((a, b) => {
@@ -29204,106 +29584,106 @@ var getInferredReturnType = fn("TypeCheckerApi.getInferredReturnType")(function*
   }
   return returnType;
 });
-var expectedAndRealType = fn("TypeCheckerApi.expectedAndRealType")(function* (sourceFile) {
-  const cache = yield* service2(TypeCheckerApiCache);
-  const resultCached = cache.expectedAndRealType.get(sourceFile);
-  if (resultCached) return resultCached;
-  const typeChecker = yield* service2(TypeCheckerApi);
-  const ts2 = yield* service2(TypeScriptApi);
-  const result = [];
-  const nodeToVisit = [sourceFile];
-  const appendNodeToVisit = (node) => {
-    nodeToVisit.push(node);
-    return void 0;
-  };
-  while (nodeToVisit.length > 0) {
-    const node = nodeToVisit.shift();
-    if (ts2.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 (ts2.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
-          ]);
-        });
-      }
-      ts2.forEachChild(node, appendNodeToVisit);
-      continue;
-    } else if (ts2.isIdentifier(node) || ts2.isStringLiteral(node) || ts2.isNumericLiteral(node) || ts2.isNoSubstitutionTemplateLiteral(node)) {
-      const parent = node.parent;
-      if (ts2.isObjectLiteralElement(parent)) {
-        if (ts2.isObjectLiteralExpression(parent.parent) && parent.name === node) {
-          const type2 = typeChecker.getContextualType(parent.parent);
-          if (type2) {
-            const symbol3 = typeChecker.getPropertyOfType(type2, node.text);
-            if (symbol3) {
-              const expectedType = typeChecker.getTypeOfSymbolAtLocation(symbol3, node);
-              const realType = typeChecker.getTypeAtLocation(node);
-              result.push([node, expectedType, node, realType]);
+var expectedAndRealType = cachedBy(
+  fn("TypeCheckerApi.expectedAndRealType")(function* (sourceFile) {
+    const typeChecker = yield* service2(TypeCheckerApi);
+    const ts2 = yield* service2(TypeScriptApi);
+    const result = [];
+    const nodeToVisit = [sourceFile];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      if (ts2.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 (ts2.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
+            ]);
+          });
+        }
+        ts2.forEachChild(node, appendNodeToVisit);
+        continue;
+      } else if (ts2.isIdentifier(node) || ts2.isStringLiteral(node) || ts2.isNumericLiteral(node) || ts2.isNoSubstitutionTemplateLiteral(node)) {
+        const parent = node.parent;
+        if (ts2.isObjectLiteralElement(parent)) {
+          if (ts2.isObjectLiteralExpression(parent.parent) && parent.name === node) {
+            const type2 = typeChecker.getContextualType(parent.parent);
+            if (type2) {
+              const symbol3 = typeChecker.getPropertyOfType(type2, node.text);
+              if (symbol3) {
+                const expectedType = typeChecker.getTypeOfSymbolAtLocation(symbol3, node);
+                const realType = typeChecker.getTypeAtLocation(node);
+                result.push([node, expectedType, node, realType]);
+              }
             }
           }
         }
-      }
-      ts2.forEachChild(node, appendNodeToVisit);
-      continue;
-    } else if (ts2.isBinaryExpression(node) && node.operatorToken.kind === ts2.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 (ts2.isReturnStatement(node) && node.expression) {
-      const parentDeclaration = yield* option4(getAncestorConvertibleDeclaration(node));
-      if (isSome2(parentDeclaration)) {
-        const expectedType = yield* option4(getInferredReturnType(parentDeclaration.value));
-        const realType = typeChecker.getTypeAtLocation(node.expression);
+        ts2.forEachChild(node, appendNodeToVisit);
+        continue;
+      } else if (ts2.isBinaryExpression(node) && node.operatorToken.kind === ts2.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 (ts2.isReturnStatement(node) && node.expression) {
+        const parentDeclaration = yield* option4(getAncestorConvertibleDeclaration(node));
+        if (isSome2(parentDeclaration)) {
+          const expectedType = yield* option4(getInferredReturnType(parentDeclaration.value));
+          const realType = typeChecker.getTypeAtLocation(node.expression);
+          if (isSome2(expectedType)) {
+            result.push([node, expectedType.value, node, realType]);
+          }
+        }
+        ts2.forEachChild(node, appendNodeToVisit);
+        continue;
+      } else if (ts2.isArrowFunction(node) && (node.typeParameters || []).length === 0 && ts2.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]);
+        }
+        ts2.forEachChild(body, appendNodeToVisit);
+        continue;
+      } else if (ts2.isArrowFunction(node) && (node.typeParameters || []).length > 0 && ts2.isExpression(node.body)) {
+        const body = node.body;
+        const expectedType = yield* option4(getInferredReturnType(node));
+        const realType = typeChecker.getTypeAtLocation(body);
         if (isSome2(expectedType)) {
-          result.push([node, expectedType.value, node, realType]);
+          result.push([body, expectedType.value, body, realType]);
         }
+        ts2.forEachChild(body, appendNodeToVisit);
+        continue;
+      } else if (ts2.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;
       }
       ts2.forEachChild(node, appendNodeToVisit);
-      continue;
-    } else if (ts2.isArrowFunction(node) && (node.typeParameters || []).length === 0 && ts2.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]);
-      }
-      ts2.forEachChild(body, appendNodeToVisit);
-      continue;
-    } else if (ts2.isArrowFunction(node) && (node.typeParameters || []).length > 0 && ts2.isExpression(node.body)) {
-      const body = node.body;
-      const expectedType = yield* option4(getInferredReturnType(node));
-      const realType = typeChecker.getTypeAtLocation(body);
-      if (isSome2(expectedType)) {
-        result.push([body, expectedType.value, body, realType]);
-      }
-      ts2.forEachChild(body, appendNodeToVisit);
-      continue;
-    } else if (ts2.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;
     }
-    ts2.forEachChild(node, appendNodeToVisit);
-  }
-  cache.expectedAndRealType.set(sourceFile, result);
-  return result;
-});
+    return result;
+  }),
+  "TypeCheckerApi.expectedAndRealType",
+  (sourceFile) => sourceFile
+);
 var unrollUnionMembers = (type2) => {
   const result = [];
   let toTest = [type2];
@@ -29371,350 +29751,17 @@ function makeResolveExternalModuleName(typeChecker) {
   };
 }
 
-// src/core/AST.ts
-function collectSelfAndAncestorNodesInRange(node, textRange) {
-  return sync11(() => {
-    let result = empty2();
-    let parent = node;
-    while (parent) {
-      if (parent.end >= textRange.end) {
-        result = pipe(result, append(parent));
-      }
-      parent = parent.parent;
-    }
-    return result;
-  });
-}
-var getAncestorNodesInRange = fn("AST.getAncestorNodesInRange")(function* (sourceFile, textRange) {
-  const nodeAtPosition = yield* option4(findNodeAtPosition(sourceFile, textRange.pos));
-  if (isNone2(nodeAtPosition)) return empty2();
-  return yield* collectSelfAndAncestorNodesInRange(nodeAtPosition.value, textRange);
-});
-var NodeNotFoundError = class {
-  _tag = "@effect/language-service/NodeNotFoundError";
-};
-var findNodeAtPosition = fn("AST.findNodeAtPosition")(function* (sourceFile, position) {
-  const ts2 = yield* service2(TypeScriptApi);
-  function find3(node) {
-    if (position >= node.getStart() && position < node.getEnd()) {
-      return ts2.forEachChild(node, find3) || node;
-    }
-    return void 0;
-  }
-  const result = find3(sourceFile);
-  if (!result) return yield* fail18(new NodeNotFoundError());
-  return result;
-});
-var getCommentAtPosition = fn("TypeScriptApi.getCommentAtPosition")(function* (sourceFile, pos) {
-  const ts2 = yield* service2(TypeScriptApi);
-  const token = yield* findNodeAtPosition(sourceFile, pos);
-  if (token === void 0 || token.kind === ts2.SyntaxKind.JsxText || pos >= token.end - (ts2.tokenToString(token.kind) || "").length) {
-    return yield* fail18(new NodeNotFoundError());
-  }
-  const startPos = token.pos === 0 ? (ts2.getShebang(sourceFile.text) || "").length : token.pos;
-  if (startPos === 0) return yield* fail18(new NodeNotFoundError());
-  const result = ts2.forEachTrailingCommentRange(sourceFile.text, startPos, isCommentInRange, pos) || ts2.forEachLeadingCommentRange(sourceFile.text, startPos, isCommentInRange, pos);
-  if (!result) return yield* fail18(new NodeNotFoundError());
-  return result;
-});
-function isCommentInRange(pos, end5, kind, _nl, at) {
-  return at >= pos && at < end5 ? { pos, end: end5, kind } : void 0;
-}
-var transformAsyncAwaitToEffectGen = fn("AST.transformAsyncAwaitToEffectGen")(
-  function* (node, effectModuleName, onAwait) {
-    const ts2 = yield* service2(TypeScriptApi);
-    function visitor(_) {
-      if (ts2.isAwaitExpression(_)) {
-        const expression = ts2.visitEachChild(_.expression, visitor, ts2.nullTransformationContext);
-        return ts2.factory.createYieldExpression(
-          ts2.factory.createToken(ts2.SyntaxKind.AsteriskToken),
-          onAwait(expression)
-        );
-      }
-      return ts2.visitEachChild(_, visitor, ts2.nullTransformationContext);
-    }
-    const generatorBody = visitor(node.body);
-    const effectGenCallExp = yield* createEffectGenCallExpression(effectModuleName, generatorBody);
-    let currentFlags = ts2.getCombinedModifierFlags(node);
-    currentFlags &= ~ts2.ModifierFlags.Async;
-    const newModifiers = ts2.factory.createModifiersFromModifierFlags(currentFlags);
-    if (ts2.isArrowFunction(node)) {
-      return ts2.factory.createArrowFunction(
-        newModifiers,
-        node.typeParameters,
-        node.parameters,
-        void 0,
-        node.equalsGreaterThanToken,
-        effectGenCallExp
-      );
-    }
-    const newBody = ts2.factory.createBlock([
-      ts2.factory.createReturnStatement(effectGenCallExp)
-    ]);
-    if (ts2.isFunctionDeclaration(node)) {
-      return ts2.factory.createFunctionDeclaration(
-        newModifiers,
-        node.asteriskToken,
-        node.name,
-        node.typeParameters,
-        node.parameters,
-        void 0,
-        newBody
-      );
-    }
-    return ts2.factory.createFunctionExpression(
-      newModifiers,
-      node.asteriskToken,
-      node.name,
-      node.typeParameters,
-      node.parameters,
-      void 0,
-      newBody
-    );
-  }
-);
-var addReturnTypeAnnotation = fn("AST.addReturnTypeAnnotation")(function* (sourceFile, declaration, typeNode) {
-  const ts2 = yield* service2(TypeScriptApi);
-  const changes2 = yield* service2(ChangeTracker);
-  const closeParen = ts2.findChildOfKind(declaration, ts2.SyntaxKind.CloseParenToken, sourceFile);
-  const needParens = ts2.isArrowFunction(declaration) && closeParen === void 0;
-  const endNode = needParens ? declaration.parameters[0] : closeParen;
-  if (endNode) {
-    if (needParens) {
-      changes2.insertNodeBefore(
-        sourceFile,
-        endNode,
-        ts2.factory.createToken(ts2.SyntaxKind.OpenParenToken)
-      );
-      changes2.insertNodeAfter(
-        sourceFile,
-        endNode,
-        ts2.factory.createToken(ts2.SyntaxKind.CloseParenToken)
-      );
-    }
-    changes2.insertNodeAt(sourceFile, endNode.end, typeNode, { prefix: ": " });
-  }
-});
-var removeReturnTypeAnnotation = fn("AST.removeReturnTypeAnnotation")(function* (sourceFile, declaration) {
-  const ts2 = yield* service2(TypeScriptApi);
-  const changes2 = yield* service2(ChangeTracker);
-  const closeParen = ts2.findChildOfKind(declaration, ts2.SyntaxKind.CloseParenToken, sourceFile);
-  const needParens = ts2.isArrowFunction(declaration) && closeParen === void 0;
-  const endNode = needParens ? declaration.parameters[0] : closeParen;
-  if (endNode && declaration.type) {
-    changes2.deleteRange(sourceFile, { pos: endNode.end, end: declaration.type.end });
-  }
-});
-var ImportModuleIdentifierNotFoundError = class {
-  _tag = "@effect/language-service/ImportModuleIdentifierNotFoundError";
-};
-var findImportedModuleIdentifier = fn("AST.findImportedModuleIdentifier")(
-  function* (sourceFile, test) {
-    const ts2 = yield* service2(TypeScriptApi);
-    for (const statement of sourceFile.statements) {
-      if (!ts2.isImportDeclaration(statement)) continue;
-      const importClause = statement.importClause;
-      if (!importClause) continue;
-      const namedBindings = importClause.namedBindings;
-      if (!namedBindings) continue;
-      if (ts2.isNamespaceImport(namedBindings)) {
-        if (yield* test(namedBindings.name, statement.moduleSpecifier, none2())) {
-          return namedBindings.name;
-        }
-      } else if (ts2.isNamedImports(namedBindings)) {
-        for (const importSpecifier of namedBindings.elements) {
-          const importProperty = fromNullable(importSpecifier.propertyName).pipe(
-            orElse(() => some2(importSpecifier.name))
-          );
-          if (yield* test(importSpecifier.name, statement.moduleSpecifier, importProperty)) {
-            return importSpecifier.name;
-          }
-        }
-      }
-    }
-    return yield* fail18(new ImportModuleIdentifierNotFoundError());
-  }
-);
-function findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, packageName, moduleName) {
-  return findImportedModuleIdentifier(
-    sourceFile,
-    fn(
-      "AST.findImportedModuleIdentifierByPackageAndNameOrBarrel.findImportedModuleIdentifier"
-    )(function* (_, fromModule, importProperty) {
-      const ts2 = yield* service2(TypeScriptApi);
-      if (isNone2(importProperty) && ts2.isStringLiteral(fromModule) && fromModule.text === packageName + "/" + moduleName) {
-        return true;
-      }
-      if (isSome2(importProperty) && ts2.isIdentifier(importProperty.value) && importProperty.value.text === moduleName && ts2.isStringLiteral(fromModule) && fromModule.text === packageName) {
-        return true;
-      }
-      return false;
-    })
-  );
-}
-var simplifyTypeNode = fn("AST.simplifyTypeNode")(function* (typeNode) {
-  const ts2 = yield* service2(TypeScriptApi);
-  function collectCallable(typeNode2) {
-    if (ts2.isParenthesizedTypeNode(typeNode2)) return collectCallable(typeNode2.type);
-    if (ts2.isFunctionTypeNode(typeNode2)) {
-      return some2([
-        ts2.factory.createCallSignature(typeNode2.typeParameters, typeNode2.parameters, typeNode2.type)
-      ]);
-    }
-    if (ts2.isTypeLiteralNode(typeNode2)) {
-      const allCallSignatures = typeNode2.members.every(ts2.isCallSignatureDeclaration);
-      if (allCallSignatures) {
-        return some2(typeNode2.members);
-      }
-    }
-    if (ts2.isIntersectionTypeNode(typeNode2)) {
-      const members = typeNode2.types.map((node) => collectCallable(node));
-      if (members.every(isSome2)) {
-        return some2(members.map((_) => isSome2(_) ? _.value : []).flat());
-      }
-    }
-    return none2();
-  }
-  const callSignatures = collectCallable(typeNode);
-  if (isSome2(callSignatures) && callSignatures.value.length > 1) {
-    return ts2.factory.createTypeLiteralNode(callSignatures.value);
-  }
-  return typeNode;
-});
-var tryPreserveDeclarationSemantics = fn("AST.tryPreserveDeclarationSemantics")(
-  function* (nodeToReplace, node) {
-    const ts2 = yield* service2(TypeScriptApi);
-    if (!ts2.isExpression(node)) return node;
-    if (ts2.isFunctionDeclaration(nodeToReplace)) {
-      if (!nodeToReplace.name) return node;
-      return ts2.factory.createVariableStatement(
-        nodeToReplace.modifiers,
-        ts2.factory.createVariableDeclarationList(
-          [ts2.factory.createVariableDeclaration(
-            nodeToReplace.name,
-            void 0,
-            void 0,
-            node
-          )],
-          ts2.NodeFlags.Const
-        )
-      );
-    } else if (ts2.isMethodDeclaration(nodeToReplace)) {
-      return ts2.factory.createPropertyDeclaration(
-        nodeToReplace.modifiers,
-        nodeToReplace.name,
-        void 0,
-        void 0,
-        node
-      );
-    }
-    return node;
-  }
-);
-var parseAccessedExpressionForCompletion = fn(
-  "AST.parseAccessedExpressionForCompletion"
-)(
-  function* (sourceFile, position) {
-    const ts2 = yield* service2(TypeScriptApi);
-    const precedingToken = ts2.findPrecedingToken(position, sourceFile, void 0, true);
-    if (!precedingToken) return yield* fail18(new NodeNotFoundError());
-    let accessedObject = precedingToken;
-    let replacementSpan = ts2.createTextSpan(position, 0);
-    let outerNode = precedingToken;
-    if (ts2.isIdentifier(precedingToken) && precedingToken.parent && ts2.isPropertyAccessExpression(precedingToken.parent)) {
-      replacementSpan = ts2.createTextSpan(
-        precedingToken.parent.getStart(sourceFile),
-        precedingToken.end - precedingToken.parent.getStart(sourceFile)
-      );
-      accessedObject = precedingToken.parent.expression;
-      outerNode = precedingToken.parent;
-    } else if (ts2.isToken(precedingToken) && precedingToken.kind === ts2.SyntaxKind.DotToken && ts2.isPropertyAccessExpression(precedingToken.parent)) {
-      replacementSpan = ts2.createTextSpan(
-        precedingToken.parent.getStart(sourceFile),
-        precedingToken.end - precedingToken.parent.getStart(sourceFile)
-      );
-      accessedObject = precedingToken.parent.expression;
-      outerNode = precedingToken.parent;
-    } else if (ts2.isIdentifier(precedingToken) && precedingToken.parent) {
-      replacementSpan = ts2.createTextSpan(
-        precedingToken.getStart(sourceFile),
-        precedingToken.end - precedingToken.getStart(sourceFile)
-      );
-      accessedObject = precedingToken;
-      outerNode = precedingToken;
-    } else {
-      return yield* fail18(new NodeNotFoundError());
-    }
-    return { accessedObject, outerNode, replacementSpan };
-  }
-);
-var parseDataForExtendsClassCompletion = fn(
-  "AST.parseDataForExtendsClassCompletion"
-)(function* (sourceFile, position) {
-  const ts2 = yield* service2(TypeScriptApi);
-  const { accessedObject, outerNode, replacementSpan } = yield* parseAccessedExpressionForCompletion(
-    sourceFile,
-    position
-  );
-  if (!ts2.isIdentifier(accessedObject)) return yield* fail18(new NodeNotFoundError());
-  let classDeclaration = outerNode.parent;
-  while (ts2.isExpressionWithTypeArguments(classDeclaration) || ts2.isHeritageClause(classDeclaration)) {
-    if (!classDeclaration.parent) break;
-    classDeclaration = classDeclaration.parent;
-  }
-  if (!ts2.isClassDeclaration(classDeclaration)) return yield* fail18(new NodeNotFoundError());
-  if (!classDeclaration.name) return yield* fail18(new NodeNotFoundError());
-  return {
-    accessedObject,
-    classDeclaration,
-    className: classDeclaration.name,
-    replacementSpan
-  };
-});
-var createEffectGenCallExpression = fn("AST.createEffectGenCallExpression")(function* (effectModuleIdentifierName, node) {
-  const ts2 = yield* service2(TypeScriptApi);
-  const generator = ts2.factory.createFunctionExpression(
-    void 0,
-    ts2.factory.createToken(ts2.SyntaxKind.AsteriskToken),
-    void 0,
-    [],
-    [],
-    void 0,
-    node
-    // NOTE(mattia): intended, to use same routine for both ConciseBody and Body
-  );
-  return ts2.factory.createCallExpression(
-    ts2.factory.createPropertyAccessExpression(
-      ts2.factory.createIdentifier(effectModuleIdentifierName),
-      "gen"
-    ),
-    void 0,
-    [generator]
-  );
-});
-var createEffectGenCallExpressionWithBlock = fn(
-  "AST.createEffectGenCallExpressionWithBlock"
-)(function* (effectModuleIdentifierName, statement) {
+// src/core/TypeParser.ts
+var TypeParser = Tag4("@effect/language-service/TypeParser");
+var nanoLayer2 = (fa) => gen3(function* () {
   const ts2 = yield* service2(TypeScriptApi);
-  return yield* createEffectGenCallExpression(
-    effectModuleIdentifierName,
-    ts2.factory.createBlock(Array.isArray(statement) ? statement : [statement], false)
+  const tsUtils = yield* service2(TypeScriptUtils);
+  const typeChecker = yield* service2(TypeCheckerApi);
+  return yield* pipe(
+    fa,
+    provideService7(TypeParser, make64(ts2, tsUtils, typeChecker))
   );
 });
-var createReturnYieldStarStatement = fn("AST.createReturnYieldStarStatement")(
-  function* (expr) {
-    const ts2 = yield* service2(TypeScriptApi);
-    return ts2.factory.createReturnStatement(
-      ts2.factory.createYieldExpression(
-        ts2.factory.createToken(ts2.SyntaxKind.AsteriskToken),
-        expr
-      )
-    );
-  }
-);
-
-// src/core/TypeParser.ts
-var TypeParser = Tag4("@effect/language-service/TypeParser");
 var TypeParserIssue = class _TypeParserIssue {
   _tag = "@effect/language-service/TypeParserIssue";
   static issue = fail18(new _TypeParserIssue());
@@ -29722,7 +29769,7 @@ var TypeParserIssue = class _TypeParserIssue {
 function typeParserIssue(_message, _type, _node) {
   return TypeParserIssue.issue;
 }
-function make64(ts2, typeChecker) {
+function make64(ts2, tsUtils, typeChecker) {
   function covariantTypeArgument(type2) {
     const signatures = type2.getCallSignatures();
     if (signatures.length !== 1) {
@@ -29875,10 +29922,40 @@ function make64(ts2, typeChecker) {
           atLocation
         );
       }
-      return yield* effectType(type2, atLocation);
+      return yield* effectType(type2, atLocation);
+    }),
+    "TypeParser.effectSubtype",
+    (type2) => type2
+  );
+  const importedSchemaModule = cachedBy(
+    fn("TypeParser.importedSchemaModule")(function* (node) {
+      const type2 = typeChecker.getTypeAtLocation(node);
+      const propertySymbol = typeChecker.getPropertyOfType(type2, "Class");
+      if (!propertySymbol) {
+        return yield* typeParserIssue("Type has no 'Class' property", type2, node);
+      }
+      if (!ts2.isExpression(node)) {
+        return yield* typeParserIssue("Node is not an expression", type2, node);
+      }
+      return node;
+    }),
+    "TypeParser.importedSchemaModule",
+    (node) => node
+  );
+  const importedContextModule = cachedBy(
+    fn("TypeParser.importedContextModule")(function* (node) {
+      const type2 = typeChecker.getTypeAtLocation(node);
+      const propertySymbol = typeChecker.getPropertyOfType(type2, "Tag");
+      if (!propertySymbol) {
+        return yield* typeParserIssue("Type has no 'Tag' property", type2, node);
+      }
+      if (!ts2.isExpression(node)) {
+        return yield* typeParserIssue("Node is not an expression", type2, node);
+      }
+      return node;
     }),
-    "TypeParser.effectSubtype",
-    (type2) => type2
+    "TypeParser.importedContextModule",
+    (node) => node
   );
   const importedEffectModule = cachedBy(
     fn("TypeParser.importedEffectModule")(function* (node) {
@@ -30064,15 +30141,11 @@ function make64(ts2, typeChecker) {
           if (!explicitReturn && !(successType.flags & ts2.TypeFlags.VoidLike)) {
             replacementNode = pipe(
               gen3(function* () {
-                const effectIdentifier = pipe(
-                  yield* option4(
-                    findImportedModuleIdentifierByPackageAndNameOrBarrel(node.getSourceFile(), "effect", "Effect")
-                  ),
-                  match2({
-                    onNone: () => "Effect",
-                    onSome: (_) => _.text
-                  })
-                );
+                const effectIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+                  node.getSourceFile(),
+                  "effect",
+                  "Effect"
+                ) || "Effect";
                 return ts2.factory.createCallExpression(
                   ts2.factory.createPropertyAccessExpression(
                     ts2.factory.createIdentifier(effectIdentifier),
@@ -30240,6 +30313,284 @@ function make64(ts2, typeChecker) {
     "TypeParser.promiseLike",
     (type2) => type2
   );
+  const extendsSchemaClass = cachedBy(
+    fn("TypeParser.extendsSchemaClass")(function* (atLocation) {
+      if (!atLocation.name) {
+        return yield* typeParserIssue("Class has no name", void 0, atLocation);
+      }
+      const heritageClauses = atLocation.heritageClauses;
+      if (!heritageClauses) {
+        return yield* typeParserIssue("Class has no heritage clauses", void 0, atLocation);
+      }
+      for (const heritageClause of heritageClauses) {
+        for (const typeX of heritageClause.types) {
+          if (ts2.isExpressionWithTypeArguments(typeX)) {
+            const expression = typeX.expression;
+            if (ts2.isCallExpression(expression)) {
+              const schemaCall = expression.expression;
+              if (ts2.isCallExpression(schemaCall) && schemaCall.typeArguments && schemaCall.typeArguments.length > 0) {
+                const selfTypeNode = schemaCall.typeArguments[0];
+                const schemaIdentifier = schemaCall.expression;
+                if (ts2.isPropertyAccessExpression(schemaIdentifier) && ts2.isIdentifier(schemaIdentifier.name) && schemaIdentifier.name.text === "Class") {
+                  const parsedSchemaModule = yield* pipe(
+                    importedSchemaModule(schemaIdentifier.expression),
+                    option4
+                  );
+                  if (isSome2(parsedSchemaModule)) {
+                    return {
+                      className: atLocation.name,
+                      selfTypeNode,
+                      Schema: parsedSchemaModule.value
+                    };
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      return yield* typeParserIssue("Class does not extend Schema.Class", void 0, atLocation);
+    }),
+    "TypeParser.extendsSchemaClass",
+    (atLocation) => atLocation
+  );
+  const extendsSchemaTaggedClass = cachedBy(
+    fn("TypeParser.extendsSchemaTaggedClass")(function* (atLocation) {
+      if (!atLocation.name) {
+        return yield* typeParserIssue("Class has no name", void 0, atLocation);
+      }
+      const heritageClauses = atLocation.heritageClauses;
+      if (!heritageClauses) {
+        return yield* typeParserIssue("Class has no heritage clauses", void 0, atLocation);
+      }
+      for (const heritageClause of heritageClauses) {
+        for (const typeX of heritageClause.types) {
+          if (ts2.isExpressionWithTypeArguments(typeX)) {
+            const expression = typeX.expression;
+            if (ts2.isCallExpression(expression)) {
+              const tagCall = expression.expression;
+              if (ts2.isCallExpression(tagCall)) {
+                const schemaCall = tagCall.expression;
+                if (ts2.isCallExpression(schemaCall) && schemaCall.typeArguments && schemaCall.typeArguments.length > 0) {
+                  const selfTypeNode = schemaCall.typeArguments[0];
+                  const schemaIdentifier = schemaCall.expression;
+                  if (ts2.isPropertyAccessExpression(schemaIdentifier) && ts2.isIdentifier(schemaIdentifier.name) && schemaIdentifier.name.text === "TaggedClass") {
+                    const parsedSchemaModule = yield* pipe(
+                      importedSchemaModule(schemaIdentifier.expression),
+                      option4
+                    );
+                    if (isSome2(parsedSchemaModule)) {
+                      return {
+                        className: atLocation.name,
+                        selfTypeNode,
+                        Schema: parsedSchemaModule.value
+                      };
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      return yield* typeParserIssue("Class does not extend Schema.TaggedClass", void 0, atLocation);
+    }),
+    "TypeParser.extendsSchemaTaggedClass",
+    (atLocation) => atLocation
+  );
+  const extendsSchemaTaggedError = cachedBy(
+    fn("TypeParser.extendsSchemaTaggedError")(function* (atLocation) {
+      if (!atLocation.name) {
+        return yield* typeParserIssue("Class has no name", void 0, atLocation);
+      }
+      const heritageClauses = atLocation.heritageClauses;
+      if (!heritageClauses) {
+        return yield* typeParserIssue("Class has no heritage clauses", void 0, atLocation);
+      }
+      for (const heritageClause of heritageClauses) {
+        for (const typeX of heritageClause.types) {
+          if (ts2.isExpressionWithTypeArguments(typeX)) {
+            const expression = typeX.expression;
+            if (ts2.isCallExpression(expression)) {
+              const tagCall = expression.expression;
+              if (ts2.isCallExpression(tagCall)) {
+                const schemaCall = tagCall.expression;
+                if (ts2.isCallExpression(schemaCall) && schemaCall.typeArguments && schemaCall.typeArguments.length > 0) {
+                  const selfTypeNode = schemaCall.typeArguments[0];
+                  const schemaIdentifier = schemaCall.expression;
+                  if (ts2.isPropertyAccessExpression(schemaIdentifier) && ts2.isIdentifier(schemaIdentifier.name) && schemaIdentifier.name.text === "TaggedError") {
+                    const parsedSchemaModule = yield* pipe(
+                      importedSchemaModule(schemaIdentifier.expression),
+                      option4
+                    );
+                    if (isSome2(parsedSchemaModule)) {
+                      return {
+                        className: atLocation.name,
+                        selfTypeNode,
+                        Schema: parsedSchemaModule.value
+                      };
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      return yield* typeParserIssue("Class does not extend Schema.TaggedError", void 0, atLocation);
+    }),
+    "TypeParser.extendsSchemaTaggedError",
+    (atLocation) => atLocation
+  );
+  const extendsSchemaTaggedRequest = cachedBy(
+    fn("TypeParser.extendsSchemaTaggedRequest")(function* (atLocation) {
+      if (!atLocation.name) {
+        return yield* typeParserIssue("Class has no name", void 0, atLocation);
+      }
+      const heritageClauses = atLocation.heritageClauses;
+      if (!heritageClauses) {
+        return yield* typeParserIssue("Class has no heritage clauses", void 0, atLocation);
+      }
+      for (const heritageClause of heritageClauses) {
+        for (const typeX of heritageClause.types) {
+          if (ts2.isExpressionWithTypeArguments(typeX)) {
+            const expression = typeX.expression;
+            if (ts2.isCallExpression(expression)) {
+              const tagCall = expression.expression;
+              if (ts2.isCallExpression(tagCall)) {
+                const schemaCall = tagCall.expression;
+                if (ts2.isCallExpression(schemaCall) && schemaCall.typeArguments && schemaCall.typeArguments.length > 0) {
+                  const selfTypeNode = schemaCall.typeArguments[0];
+                  const schemaIdentifier = schemaCall.expression;
+                  if (ts2.isPropertyAccessExpression(schemaIdentifier) && ts2.isIdentifier(schemaIdentifier.name) && schemaIdentifier.name.text === "TaggedRequest") {
+                    const parsedSchemaModule = yield* pipe(
+                      importedSchemaModule(schemaIdentifier.expression),
+                      option4
+                    );
+                    if (isSome2(parsedSchemaModule)) {
+                      return {
+                        className: atLocation.name,
+                        selfTypeNode,
+                        Schema: parsedSchemaModule.value
+                      };
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      return yield* typeParserIssue("Class does not extend Schema.TaggedRequest", void 0, atLocation);
+    }),
+    "TypeParser.extendsSchemaTaggedRequest",
+    (atLocation) => atLocation
+  );
+  const extendsContextTag = cachedBy(
+    fn("TypeParser.extendsContextTag")(function* (atLocation) {
+      if (!atLocation.name) {
+        return yield* typeParserIssue("Class has no name", void 0, atLocation);
+      }
+      const classSym = typeChecker.getSymbolAtLocation(atLocation.name);
+      if (!classSym) return yield* typeParserIssue("Class has no symbol", void 0, atLocation);
+      const type2 = typeChecker.getTypeOfSymbol(classSym);
+      const heritageClauses = atLocation.heritageClauses;
+      if (!heritageClauses) {
+        return yield* typeParserIssue("Class has no heritage clauses", void 0, atLocation);
+      }
+      for (const heritageClause of heritageClauses) {
+        for (const typeX of heritageClause.types) {
+          if (ts2.isExpressionWithTypeArguments(typeX)) {
+            const wholeCall = typeX.expression;
+            if (ts2.isCallExpression(wholeCall)) {
+              const contextTagCall = wholeCall.expression;
+              if (ts2.isCallExpression(contextTagCall) && wholeCall.typeArguments && wholeCall.typeArguments.length > 0) {
+                const contextTagIdentifier = contextTagCall.expression;
+                const selfTypeNode = wholeCall.typeArguments[0];
+                if (ts2.isPropertyAccessExpression(contextTagIdentifier) && ts2.isIdentifier(contextTagIdentifier.name) && contextTagIdentifier.name.text === "Tag") {
+                  const parsedContextModule = yield* pipe(
+                    importedContextModule(contextTagIdentifier.expression),
+                    option4
+                  );
+                  if (isSome2(parsedContextModule)) {
+                    const tagType = yield* contextTag(type2, atLocation);
+                    return {
+                      className: atLocation.name,
+                      selfTypeNode,
+                      args: contextTagCall.arguments,
+                      Identifier: tagType.Identifier,
+                      Tag: parsedContextModule.value
+                    };
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      return yield* typeParserIssue("Class does not extend Context.Tag", void 0, atLocation);
+    }),
+    "TypeParser.extendsContextTag",
+    (atLocation) => atLocation
+  );
+  const extendsEffectService = cachedBy(
+    fn("TypeParser.extendsEffectService")(function* (atLocation) {
+      if (!atLocation.name) {
+        return yield* typeParserIssue("Class has no name", void 0, atLocation);
+      }
+      const classSym = typeChecker.getSymbolAtLocation(atLocation.name);
+      if (!classSym) return yield* typeParserIssue("Class has no symbol", void 0, atLocation);
+      const type2 = typeChecker.getTypeOfSymbol(classSym);
+      const heritageClauses = atLocation.heritageClauses;
+      if (!heritageClauses) {
+        return yield* typeParserIssue("Class has no heritage clauses", void 0, atLocation);
+      }
+      for (const heritageClause of heritageClauses) {
+        for (const typeX of heritageClause.types) {
+          if (ts2.isExpressionWithTypeArguments(typeX)) {
+            const wholeCall = typeX.expression;
+            if (ts2.isCallExpression(wholeCall)) {
+              const effectServiceCall = wholeCall.expression;
+              if (ts2.isCallExpression(effectServiceCall) && effectServiceCall.typeArguments && effectServiceCall.typeArguments.length > 0) {
+                const effectServiceIdentifier = effectServiceCall.expression;
+                const selfTypeNode = effectServiceCall.typeArguments[0];
+                if (ts2.isPropertyAccessExpression(effectServiceIdentifier) && ts2.isIdentifier(effectServiceIdentifier.name) && effectServiceIdentifier.name.text === "Service") {
+                  const parsedContextTag = yield* pipe(
+                    importedEffectModule(effectServiceIdentifier.expression),
+                    flatMap18(() => contextTag(type2, atLocation)),
+                    option4
+                  );
+                  if (isSome2(parsedContextTag)) {
+                    let accessors2 = void 0;
+                    if (wholeCall.arguments.length >= 2) {
+                      const args3 = wholeCall.arguments[1];
+                      if (ts2.isObjectLiteralExpression(args3)) {
+                        for (const property of args3.properties) {
+                          if (ts2.isPropertyAssignment(property) && property.name && ts2.isIdentifier(property.name) && property.name.text === "accessors" && property.initializer && property.initializer.kind === ts2.SyntaxKind.TrueKeyword) {
+                            accessors2 = true;
+                          }
+                        }
+                      }
+                    }
+                    return {
+                      ...parsedContextTag.value,
+                      className: atLocation.name,
+                      selfTypeNode,
+                      args: wholeCall.arguments,
+                      accessors: accessors2
+                    };
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      return yield* typeParserIssue("Class does not extend Effect.Service", void 0, atLocation);
+    }),
+    "TypeParser.extendsEffectService",
+    (atLocation) => atLocation
+  );
   return {
     effectType,
     strictEffectType,
@@ -30256,10 +30607,79 @@ function make64(ts2, typeChecker) {
     pipeableType,
     pipeCall,
     scopeType,
-    promiseLike
+    promiseLike,
+    extendsEffectService,
+    extendsContextTag,
+    extendsSchemaClass,
+    extendsSchemaTaggedClass,
+    extendsSchemaTaggedError,
+    extendsSchemaTaggedRequest
   };
 }
 
+// src/diagnostics/classSelfMismatch.ts
+var classSelfMismatch = createDiagnostic({
+  name: "classSelfMismatch",
+  code: 20,
+  severity: "error",
+  apply: fn("classSelfMismatch.apply")(function* (sourceFile, report) {
+    const ts2 = yield* service2(TypeScriptApi);
+    const typeParser = yield* service2(TypeParser);
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts2.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      if (ts2.isClassDeclaration(node) && node.name && node.heritageClauses) {
+        const result = yield* pipe(
+          typeParser.extendsEffectService(node),
+          orElse14(() => typeParser.extendsContextTag(node)),
+          orElse14(() => typeParser.extendsSchemaClass(node)),
+          orElse14(() => typeParser.extendsSchemaTaggedClass(node)),
+          orElse14(() => typeParser.extendsSchemaTaggedError(node)),
+          orElse14(() => typeParser.extendsSchemaTaggedRequest(node)),
+          orElse14(() => void_8)
+        );
+        if (result) {
+          const { className, selfTypeNode } = result;
+          let actualName = "";
+          if (ts2.isTypeReferenceNode(selfTypeNode)) {
+            if (ts2.isIdentifier(selfTypeNode.typeName)) {
+              actualName = selfTypeNode.typeName.text;
+            } else if (ts2.isQualifiedName(selfTypeNode.typeName)) {
+              actualName = selfTypeNode.typeName.right.text;
+            }
+          }
+          const expectedName = className.text;
+          if (actualName !== expectedName) {
+            report({
+              location: selfTypeNode,
+              messageText: `Self type parameter should be '${expectedName}'`,
+              fixes: [{
+                fixName: "classSelfMismatch_fix",
+                description: `Replace '${actualName}' with '${expectedName}'`,
+                apply: gen3(function* () {
+                  const changeTracker = yield* service2(ChangeTracker);
+                  const typeArgs = ts2.isTypeReferenceNode(selfTypeNode) ? selfTypeNode.typeArguments : void 0;
+                  const newTypeReference = ts2.factory.createTypeReferenceNode(
+                    ts2.factory.createIdentifier(expectedName),
+                    typeArgs
+                  );
+                  changeTracker.replaceNode(sourceFile, selfTypeNode, newTypeReference);
+                })
+              }]
+            });
+          }
+        }
+      }
+      ts2.forEachChild(node, appendNodeToVisit);
+    }
+  })
+});
+
 // src/diagnostics/duplicatePackage.ts
 var checkedPackagesCache = /* @__PURE__ */ new Map();
 var programResolvedCacheSize = /* @__PURE__ */ new Map();
@@ -30269,6 +30689,7 @@ var duplicatePackage = createDiagnostic({
   severity: "warning",
   apply: fn("duplicatePackage.apply")(function* (sourceFile, report) {
     const program = yield* service2(TypeScriptProgram);
+    const tsUtils = yield* service2(TypeScriptUtils);
     const options3 = yield* service2(LanguageServicePluginOptions);
     if (sourceFile.statements.length < 1) return;
     let resolvedPackages = checkedPackagesCache.get(sourceFile.fileName) || {};
@@ -30278,7 +30699,7 @@ var duplicatePackage = createDiagnostic({
       const seenPackages = /* @__PURE__ */ new Set();
       resolvedPackages = {};
       program.getSourceFiles().map((_) => {
-        const packageInfo = parsePackageContentNameAndVersionFromScope(_);
+        const packageInfo = tsUtils.parsePackageContentNameAndVersionFromScope(_);
         if (!packageInfo) return;
         const packageNameAndVersion = packageInfo.name + "@" + packageInfo.version;
         if (seenPackages.has(packageNameAndVersion)) return;
@@ -30295,7 +30716,7 @@ var duplicatePackage = createDiagnostic({
       if (Object.keys(resolvedPackages[packageName]).length > 1) {
         const versions = Object.keys(resolvedPackages[packageName]);
         report({
-          node: sourceFile.statements[0],
+          location: 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(options3.allowedDuplicatedPackages.concat([packageName]))}.
@@ -30342,7 +30763,7 @@ var effectInVoidSuccess = createDiagnostic({
           map33(({ voidedEffect }) => {
             report(
               {
-                node,
+                location: node,
                 messageText: `There is a nested '${typeChecker.typeToString(voidedEffect)}' in the 'void' success channel, beware that this could lead to nested Effect<Effect<...>> that won't be executed.`,
                 fixes: []
               }
@@ -30391,7 +30812,7 @@ var floatingEffect = createDiagnostic({
         );
         if (isNone2(allowedFloatingEffects)) {
           report({
-            node,
+            location: node,
             messageText: `Effect must be yielded or assigned to a variable.`,
             fixes: []
           });
@@ -30434,7 +30855,7 @@ var genericEffectServices = createDiagnostic({
           typeParser.contextTag(type2, node),
           map33(() => {
             report({
-              node: reportAt,
+              location: reportAt,
               messageText: `Effect Services with type parameters are not supported because they cannot be properly discriminated at runtime, which may cause unexpected behavior.`,
               fixes: []
             });
@@ -30456,17 +30877,16 @@ var importFromBarrel = createDiagnostic({
     const languageServicePluginOptions = yield* service2(LanguageServicePluginOptions);
     if (languageServicePluginOptions.namespaceImportPackages.length === 0) return;
     const ts2 = yield* service2(TypeScriptApi);
+    const tsUtils = yield* service2(TypeScriptUtils);
     const typeChecker = yield* service2(TypeCheckerApi);
     const program = yield* service2(TypeScriptProgram);
     const packageNamesToCheck = flatten(
-      yield* all9(
-        ...languageServicePluginOptions.namespaceImportPackages.map(
-          (packageName) => resolveModulePattern(sourceFile, packageName)
-        )
+      languageServicePluginOptions.namespaceImportPackages.map(
+        (packageName) => tsUtils.resolveModulePattern(sourceFile, packageName)
       )
     );
     const isImportedFromBarrelExport = (element) => {
-      const getModuleSpecifier = makeGetModuleSpecifier(ts2);
+      const getModuleSpecifier = tsUtils.makeGetModuleSpecifier();
       const resolveExternalModuleName = makeResolveExternalModuleName(typeChecker);
       if (!(getModuleSpecifier && resolveExternalModuleName)) return;
       const importDeclaration = ts2.findAncestor(element, (node) => ts2.isImportDeclaration(node));
@@ -30542,7 +30962,7 @@ var importFromBarrel = createDiagnostic({
         unbarrelledFileName
       } = result;
       report({
-        node,
+        location: node,
         messageText: `Importing from barrel module ${barrelModuleName} is not allowed.`,
         fixes: [
           {
@@ -30656,7 +31076,7 @@ var leakingRequirements = createDiagnostic({
     function reportLeakingRequirements(node, requirements) {
       if (requirements.length === 0) return;
       report({
-        node,
+        location: node,
         messageText: `This Service is leaking the ${requirements.map((_) => typeChecker.typeToString(_)).join(" | ")} requirement.
 If these requirements cannot be cached and are expected to be provided per method invocation (e.g. HttpServerRequest), you can safely disable this diagnostic for this line through quickfixes.
 More info at https://effect.website/docs/requirements-management/layers/#avoiding-requirement-leakage`,
@@ -30736,7 +31156,7 @@ var missingEffectContext = createDiagnostic({
           map33(
             (missingTypes) => missingTypes.length > 0 ? report(
               {
-                node,
+                location: node,
                 messageText: `Missing '${sortTypes(missingTypes).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect context.`,
                 fixes: []
               }
@@ -30756,18 +31176,15 @@ var missingEffectError = createDiagnostic({
   severity: "error",
   apply: fn("missingEffectError.apply")(function* (sourceFile, report) {
     const ts2 = yield* service2(TypeScriptApi);
+    const tsUtils = yield* service2(TypeScriptUtils);
     const typeChecker = yield* service2(TypeCheckerApi);
     const typeParser = yield* service2(TypeParser);
     const typeOrder = yield* deterministicTypeOrder;
-    const effectModuleIdentifier = yield* pipe(
-      findImportedModuleIdentifierByPackageAndNameOrBarrel(
-        sourceFile,
-        "effect",
-        "Effect"
-      ),
-      map33((_) => _.text),
-      orElse14(() => succeed17("Effect"))
-    );
+    const effectModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+      sourceFile,
+      "effect",
+      "Effect"
+    ) || "Effect";
     const createDieMessage = (message) => ts2.factory.createCallExpression(
       ts2.factory.createPropertyAccessExpression(
         ts2.factory.createIdentifier(effectModuleIdentifier),
@@ -30869,7 +31286,7 @@ var missingEffectError = createDiagnostic({
             }
             report(
               {
-                node,
+                location: node,
                 messageText: `Missing '${sortTypes(result.missingErrorTypes).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect errors.`,
                 fixes
               }
@@ -30933,7 +31350,7 @@ var missingReturnYieldStar = createDiagnostic({
                   })
                 }] : [];
                 report({
-                  node,
+                  location: node,
                   messageText: `Yielded Effect never succeeds, so it is best to use a 'return yield*' instead.`,
                   fixes: fix
                 });
@@ -30989,7 +31406,7 @@ var missingStarInYieldEffectGen = createDiagnostic({
     }
     brokenGenerators.forEach(
       (node) => report({
-        node,
+        location: node,
         messageText: `Seems like you used yield instead of yield* inside this Effect.gen.`,
         fixes: []
       })
@@ -31011,7 +31428,7 @@ var missingStarInYieldEffectGen = createDiagnostic({
         })
       }] : [];
       report({
-        node,
+        location: node,
         messageText: `When yielding Effects inside Effect.gen, you should use yield* instead of yield.`,
         fixes: fix
       });
@@ -31026,26 +31443,19 @@ var multipleEffectProvide = createDiagnostic({
   severity: "warning",
   apply: fn("multipleEffectProvide.apply")(function* (sourceFile, report) {
     const ts2 = yield* service2(TypeScriptApi);
+    const tsUtils = yield* service2(TypeScriptUtils);
     const typeChecker = yield* service2(TypeCheckerApi);
     const typeParser = yield* service2(TypeParser);
-    const effectModuleIdentifier = yield* pipe(
-      findImportedModuleIdentifierByPackageAndNameOrBarrel(
-        sourceFile,
-        "effect",
-        "Effect"
-      ),
-      map33((_) => _.text),
-      orElse14(() => succeed17("Effect"))
-    );
-    const layerModuleIdentifier = yield* pipe(
-      findImportedModuleIdentifierByPackageAndNameOrBarrel(
-        sourceFile,
-        "effect",
-        "Layer"
-      ),
-      map33((_) => _.text),
-      orElse14(() => succeed17("Layer"))
-    );
+    const effectModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+      sourceFile,
+      "effect",
+      "Effect"
+    ) || "Effect";
+    const layerModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+      sourceFile,
+      "effect",
+      "Layer"
+    ) || "Layer";
     const parseEffectProvideLayer = (node) => {
       if (ts2.isCallExpression(node) && ts2.isPropertyAccessExpression(node.expression) && ts2.isIdentifier(node.expression.name) && node.expression.name.text === "provide" && node.arguments.length > 0) {
         const layer12 = node.arguments[0];
@@ -31075,7 +31485,7 @@ var multipleEffectProvide = createDiagnostic({
       for (const chunk4 of previousLayers) {
         if (chunk4.length < 2) continue;
         report({
-          node: chunk4[0].node,
+          location: chunk4[0].node,
           messageText: "Avoid chaining Effect.provide calls, as this can lead to service lifecycle issues. Instead, merge layers and provide them in a single call.",
           fixes: [{
             fixName: "multipleEffectProvide_fix",
@@ -31123,6 +31533,327 @@ var multipleEffectProvide = createDiagnostic({
   })
 });
 
+// src/refactors/writeTagClassAccessors.ts
+var generate = fn("writeTagClassAccessors.generate")(function* (sourceFile, service3, className, atLocation, involvedMembers) {
+  const ts2 = yield* service2(TypeScriptApi);
+  const tsUtils = yield* service2(TypeScriptUtils);
+  const typeChecker = yield* service2(TypeCheckerApi);
+  const typeParser = yield* service2(TypeParser);
+  const changeTracker = yield* service2(ChangeTracker);
+  const insertLocation = atLocation.members.length > 0 ? atLocation.members[0].pos : atLocation.getEnd() - 1;
+  const effectIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+    sourceFile,
+    "effect",
+    "Effect"
+  ) || "Effect";
+  const createFunctionProperty = (className2, propertyName, type2, forceAny) => {
+    const arrowBody = ts2.factory.createCallExpression(
+      ts2.factory.createPropertyAccessExpression(
+        ts2.factory.createIdentifier(effectIdentifier),
+        "andThen"
+      ),
+      void 0,
+      [
+        ts2.factory.createIdentifier(className2.text),
+        ts2.factory.createArrowFunction(
+          void 0,
+          void 0,
+          [ts2.factory.createParameterDeclaration(
+            void 0,
+            void 0,
+            "_",
+            void 0,
+            forceAny ? ts2.factory.createTypeReferenceNode("any") : void 0
+          )],
+          void 0,
+          void 0,
+          ts2.factory.createCallExpression(
+            ts2.factory.createPropertyAccessExpression(
+              ts2.factory.createIdentifier("_"),
+              propertyName
+            ),
+            void 0,
+            [
+              ts2.factory.createSpreadElement(ts2.factory.createIdentifier("args"))
+            ]
+          )
+        )
+      ]
+    );
+    return ts2.factory.createPropertyDeclaration(
+      [ts2.factory.createModifier(ts2.SyntaxKind.StaticKeyword)],
+      propertyName,
+      void 0,
+      type2,
+      ts2.factory.createArrowFunction(
+        void 0,
+        void 0,
+        [ts2.factory.createParameterDeclaration(
+          void 0,
+          ts2.factory.createToken(ts2.SyntaxKind.DotDotDotToken),
+          "args",
+          void 0,
+          forceAny ? ts2.factory.createArrayTypeNode(ts2.factory.createTypeReferenceNode("any")) : void 0
+        )],
+        void 0,
+        void 0,
+        forceAny ? ts2.factory.createAsExpression(arrowBody, ts2.factory.createTypeReferenceNode("any")) : arrowBody
+      )
+    );
+  };
+  const generateReturnType = (type2, atLocation2, className2) => pipe(
+    typeParser.effectType(type2, atLocation2),
+    flatMap18((returnedEffect) => {
+      const contextType = returnedEffect.R.flags & ts2.TypeFlags.Never ? ts2.factory.createTypeReferenceNode(className2.text) : ts2.factory.createUnionTypeNode(
+        [
+          ts2.factory.createTypeReferenceNode(className2.text),
+          typeChecker.typeToTypeNode(returnedEffect.R, atLocation2, ts2.NodeBuilderFlags.NoTruncation)
+        ]
+      );
+      const successType = typeChecker.typeToTypeNode(
+        returnedEffect.A,
+        atLocation2,
+        ts2.NodeBuilderFlags.NoTruncation
+      );
+      if (!successType) return fail18("error generating success type");
+      const failureType = typeChecker.typeToTypeNode(
+        returnedEffect.E,
+        atLocation2,
+        ts2.NodeBuilderFlags.NoTruncation
+      );
+      if (!failureType) return fail18("error generating failure type");
+      const typeNode = ts2.factory.createTypeReferenceNode(
+        ts2.factory.createQualifiedName(
+          ts2.factory.createIdentifier(effectIdentifier),
+          ts2.factory.createIdentifier("Effect")
+        ),
+        [successType, failureType, contextType]
+      );
+      return succeed17(typeNode);
+    }),
+    orElse14(
+      () => pipe(
+        typeParser.promiseLike(type2, atLocation2),
+        flatMap18(({ type: type3 }) => {
+          const successType = typeChecker.typeToTypeNode(
+            type3,
+            atLocation2,
+            ts2.NodeBuilderFlags.NoTruncation
+          );
+          if (!successType) return fail18("error generating success type");
+          return succeed17(ts2.factory.createTypeReferenceNode(
+            ts2.factory.createQualifiedName(
+              ts2.factory.createIdentifier(effectIdentifier),
+              ts2.factory.createIdentifier("Effect")
+            ),
+            [
+              successType,
+              ts2.factory.createTypeReferenceNode(
+                ts2.factory.createQualifiedName(
+                  ts2.factory.createIdentifier("Cause"),
+                  ts2.factory.createIdentifier("UnknownException")
+                )
+              ),
+              ts2.factory.createTypeReferenceNode(className2.text)
+            ]
+          ));
+        })
+      )
+    ),
+    orElse14(() => {
+      const successType = typeChecker.typeToTypeNode(type2, atLocation2, ts2.NodeBuilderFlags.NoTruncation);
+      if (!successType) return fail18("error generating success type");
+      const typeNode = ts2.factory.createTypeReferenceNode(
+        ts2.factory.createQualifiedName(
+          ts2.factory.createIdentifier(effectIdentifier),
+          ts2.factory.createIdentifier("Effect")
+        ),
+        [
+          successType,
+          ts2.factory.createTypeReferenceNode("never"),
+          ts2.factory.createTypeReferenceNode(className2.text)
+        ]
+      );
+      return succeed17(typeNode);
+    })
+  );
+  const proxySignature = (signature, atLocation2, className2) => gen3(function* () {
+    const signatureDeclaration = typeChecker.signatureToSignatureDeclaration(
+      signature,
+      ts2.SyntaxKind.FunctionType,
+      atLocation2,
+      ts2.NodeBuilderFlags.NoTruncation
+    );
+    if (!signatureDeclaration) return yield* fail18("error generating signature");
+    const returnType = yield* generateReturnType(signature.getReturnType(), atLocation2, className2);
+    return ts2.factory.createFunctionTypeNode(
+      signatureDeclaration.typeParameters,
+      signatureDeclaration.parameters,
+      returnType
+    );
+  });
+  for (const { property, propertyType } of involvedMembers) {
+    const callSignatures = [];
+    let propertyDeclaration = void 0;
+    for (const signature of propertyType.getCallSignatures()) {
+      yield* pipe(
+        proxySignature(signature, atLocation, className),
+        map33((sig) => {
+          callSignatures.push(sig);
+        }),
+        ignore3
+      );
+    }
+    const allSignatures = ts2.factory.createIntersectionTypeNode(callSignatures);
+    const type2 = tsUtils.simplifyTypeNode(allSignatures);
+    propertyDeclaration = createFunctionProperty(className, property.getName(), type2, callSignatures.length > 1);
+    const oldProperty = atLocation.members.filter(ts2.isPropertyDeclaration).find((p2) => {
+      const symbol3 = typeChecker.getSymbolAtLocation(p2.name);
+      return symbol3?.getName() === property.getName();
+    });
+    if (oldProperty) {
+      changeTracker.deleteRange(sourceFile, {
+        pos: oldProperty.getStart(sourceFile),
+        end: oldProperty.getEnd()
+      });
+      changeTracker.insertNodeAt(sourceFile, oldProperty.getStart(sourceFile), propertyDeclaration);
+    } else {
+      changeTracker.insertNodeAt(sourceFile, insertLocation, propertyDeclaration, { suffix: "\n" });
+    }
+  }
+});
+var parse5 = fn("writeTagClassAccessors.parse")(function* (node) {
+  const ts2 = yield* service2(TypeScriptApi);
+  const typeChecker = yield* service2(TypeCheckerApi);
+  const typeParser = yield* service2(TypeParser);
+  if (!ts2.isClassDeclaration(node)) return yield* fail18("not a class declaration");
+  const { Service, accessors: accessors2, className } = yield* pipe(
+    typeParser.extendsEffectService(node),
+    orElse14(() => fail18("not a class extending Effect.Service call"))
+  );
+  if (accessors2 !== true) return yield* fail18("accessors are not enabled in the Effect.Service call");
+  const involvedMembers = [];
+  for (const property of typeChecker.getPropertiesOfType(Service)) {
+    const propertyType = typeChecker.getTypeOfSymbolAtLocation(property, node);
+    const callSignatures = propertyType.getCallSignatures();
+    if (callSignatures.length > 0) {
+      const withTypeParameters = callSignatures.filter((_) => _.typeParameters && _.typeParameters.length > 0);
+      if (callSignatures.length > 1 || withTypeParameters.length > 0) involvedMembers.push({ property, propertyType });
+    }
+  }
+  const hash2 = involvedMembers.map(({ property, propertyType }) => {
+    return property.getName() + ": " + typeChecker.typeToString(propertyType);
+  }).concat([className.text]).join("\n");
+  return { Service, className, atLocation: node, hash: cyrb53(hash2), involvedMembers };
+});
+var writeTagClassAccessors = createRefactor({
+  name: "writeTagClassAccessors",
+  description: "Implement accessors methods with generics or multiple signatures",
+  apply: fn("writeTagClassAccessors.apply")(function* (sourceFile, textRange) {
+    const ts2 = yield* service2(TypeScriptApi);
+    const tsUtils = yield* service2(TypeScriptUtils);
+    const typeChecker = yield* service2(TypeCheckerApi);
+    const typeParser = yield* service2(TypeParser);
+    const parseNode = (node) => pipe(
+      parse5(node),
+      map33(({ Service, atLocation, className, involvedMembers }) => ({
+        kind: "refactor.rewrite.effect.writeTagClassAccessors",
+        description: "Implement Service accessors",
+        apply: pipe(
+          generate(sourceFile, Service, className, atLocation, involvedMembers),
+          provideService7(TypeScriptUtils, tsUtils),
+          provideService7(TypeParser, typeParser),
+          provideService7(TypeCheckerApi, typeChecker),
+          provideService7(TypeScriptApi, ts2)
+        )
+      }))
+    );
+    const parentNodes = tsUtils.getAncestorNodesInRange(sourceFile, textRange);
+    return yield* pipe(
+      firstSuccessOf2(parentNodes.map(parseNode)),
+      orElse14(() => fail18(new RefactorNotApplicableError()))
+    );
+  })
+});
+
+// src/codegens/accessors.ts
+var accessors = createCodegen({
+  name: "accessors",
+  apply: fn("accessors.apply")(function* (sourceFile, textRange) {
+    const ts2 = yield* service2(TypeScriptApi);
+    const tsUtils = yield* service2(TypeScriptUtils);
+    const typeChecker = yield* service2(TypeCheckerApi);
+    const typeParser = yield* service2(TypeParser);
+    const nodeAndCommentRange = tsUtils.findNodeWithLeadingCommentAtPosition(sourceFile, textRange.pos);
+    if (!nodeAndCommentRange) return yield* fail18(new CodegenNotApplicableError("no node and comment range"));
+    return yield* pipe(
+      parse5(nodeAndCommentRange.node),
+      map33(
+        (_) => ({
+          hash: _.hash,
+          description: "Generate accessors for the service",
+          apply: pipe(
+            generate(sourceFile, _.Service, _.className, _.atLocation, _.involvedMembers),
+            provideService7(TypeScriptApi, ts2),
+            provideService7(TypeScriptUtils, tsUtils),
+            provideService7(TypeCheckerApi, typeChecker),
+            provideService7(TypeParser, typeParser)
+          )
+        })
+      ),
+      orElse14((cause2) => fail18(new CodegenNotApplicableError(cause2)))
+    );
+  })
+});
+
+// src/codegens.ts
+var codegens = [accessors];
+
+// src/diagnostics/outdatedEffectCodegen.ts
+var outdatedEffectCodegen = createDiagnostic({
+  name: "outdatedEffectCodegen",
+  code: 19,
+  severity: "warning",
+  apply: fn("outdatedEffectCodegen.apply")(function* (sourceFile, _report) {
+    const codegensWithRanges = yield* getCodegensForSourceFile(codegens, sourceFile);
+    for (const { codegen, hash: hash2, range: range3 } of codegensWithRanges) {
+      yield* pipe(
+        getEditsForCodegen([codegen], sourceFile, range3),
+        map33((applicable) => {
+          if (applicable.hash !== hash2) {
+            _report({
+              location: range3,
+              messageText: `Codegen ${codegen.name} result is outdated`,
+              fixes: [
+                {
+                  fixName: "outdatedEffectCodegen_fix",
+                  description: `Re-run ${codegen.name}`,
+                  apply: applicable.apply
+                },
+                {
+                  fixName: "outdatedEffectCodegen_ignore",
+                  description: `Ignore this ${codegen.name} update`,
+                  apply: applicable.ignore
+                }
+              ]
+            });
+          }
+        }),
+        orElse14(
+          (e) => sync11(() => {
+            _report({
+              location: range3,
+              messageText: `Codegen ${codegen.name} is not applicable here: ${e.cause}`,
+              fixes: []
+            });
+          })
+        ),
+        ignore3
+      );
+    }
+  })
+});
+
 // src/diagnostics/returnEffectInGen.ts
 var returnEffectInGen = createDiagnostic({
   name: "returnEffectInGen",
@@ -31174,7 +31905,7 @@ var returnEffectInGen = createDiagnostic({
                   })
                 }] : [];
                 report({
-                  node,
+                  location: 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.`,
@@ -31197,17 +31928,14 @@ var scopeInLayerEffect = createDiagnostic({
   severity: "warning",
   apply: fn("scopeInLayerEffect.apply")(function* (sourceFile, report) {
     const ts2 = yield* service2(TypeScriptApi);
+    const tsUtils = yield* service2(TypeScriptUtils);
     const typeChecker = yield* service2(TypeCheckerApi);
     const typeParser = yield* service2(TypeParser);
-    const layerModuleIdentifier = yield* pipe(
-      findImportedModuleIdentifierByPackageAndNameOrBarrel(
-        sourceFile,
-        "effect",
-        "Layer"
-      ),
-      map33((_) => _.text),
-      orElse14(() => succeed17("Layer"))
-    );
+    const layerModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+      sourceFile,
+      "effect",
+      "Layer"
+    ) || "Layer";
     function parseLayerEffectApiCall(node) {
       if (!ts2.isCallExpression(node)) return;
       const expression = node.expression;
@@ -31233,7 +31961,7 @@ var scopeInLayerEffect = createDiagnostic({
         firstSuccessOf2(entries2.map((type3) => typeParser.scopeType(type3, node))),
         map33(
           () => report({
-            node,
+            location: node,
             messageText: `Seems like you are constructing a layer with a scope in the requirements.
 Consider using "scoped" instead to get rid of the scope in the requirements.`,
             fixes: methodIdentifier ? [{
@@ -31349,7 +32077,7 @@ var strictBooleanExpressions = createDiagnostic({
           if (type2.flags & ts2.TypeFlags.BooleanLiteral) continue;
           const typeName = typeChecker.typeToString(type2);
           report({
-            node: nodeToCheck,
+            location: nodeToCheck,
             messageText: `Unexpected \`${typeName}\` type in condition, expected strictly a boolean instead.`,
             fixes: []
           });
@@ -31391,7 +32119,7 @@ var tryCatchInEffectGen = createDiagnostic({
             orElse14(() => typeParser.effectFnGen(effectGenNode)),
             map33(() => {
               report({
-                node,
+                location: node,
                 messageText: "Avoid using try/catch inside Effect generators. Use Effect's error handling mechanisms instead (e.g., Effect.try, Effect.tryPromise, Effect.catchAll, Effect.catchTag).",
                 fixes: []
               });
@@ -31426,7 +32154,7 @@ var unnecessaryEffectGen = createDiagnostic({
           typeParser.unnecessaryEffectGen(node),
           map33(
             ({ replacementNode }) => report({
-              node,
+              location: node,
               messageText: `This Effect.gen contains a single return statement.`,
               fixes: [{
                 fixName: "unnecessaryEffectGen_fix",
@@ -31470,7 +32198,7 @@ var unnecessaryPipe = createDiagnostic({
           map33(({ args: args3, subject }) => {
             if (args3.length === 0) {
               report({
-                node,
+                location: node,
                 messageText: `This pipe call contains no arguments.`,
                 fixes: [{
                   fixName: "unnecessaryPipe_fix",
@@ -31517,7 +32245,7 @@ var unnecessaryPipeChain = createDiagnostic({
           ),
           map33(({ innerCall, pipeCall }) => {
             report({
-              node,
+              location: node,
               messageText: `Chained pipe calls can be simplified to a single pipe call`,
               fixes: [{
                 fixName: "unnecessaryPipeChain_fix",
@@ -31566,8 +32294,64 @@ var unnecessaryPipeChain = createDiagnostic({
   })
 });
 
+// src/diagnostics/unsupportedServiceAccessors.ts
+var unsupportedServiceAccessors = createDiagnostic({
+  name: "unsupportedServiceAccessors",
+  code: 21,
+  severity: "warning",
+  apply: fn("unsupportedServiceAccessors.apply")(function* (sourceFile, report) {
+    const ts2 = yield* service2(TypeScriptApi);
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts2.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts2.forEachChild(node, appendNodeToVisit);
+      if (ts2.isClassDeclaration(node)) {
+        const parseResult = yield* pipe(
+          parse5(node),
+          orElse14(() => succeed17(null))
+        );
+        if (parseResult && parseResult.involvedMembers.length > 0) {
+          const existingStaticMembers = /* @__PURE__ */ new Set();
+          node.members?.forEach((member) => {
+            if (ts2.isPropertyDeclaration(member) && member.modifiers?.some((mod) => mod.kind === ts2.SyntaxKind.StaticKeyword)) {
+              if (member.name && ts2.isIdentifier(member.name)) {
+                existingStaticMembers.add(member.name.text);
+              }
+            }
+          });
+          const missingMembers = parseResult.involvedMembers.filter(
+            ({ property }) => !existingStaticMembers.has(property.getName())
+          );
+          if (missingMembers.length > 0) {
+            const memberNames = missingMembers.map(({ property }) => `'${property.getName()}'`).join(", ");
+            report({
+              location: parseResult.className,
+              messageText: `Even if accessors are enabled, accessors for ${memberNames} won't be available because the signature have generic type parameters or multiple call signatures.`,
+              fixes: [{
+                fixName: "unsupportedServiceAccessors_enableCodegen",
+                description: "Enable accessors codegen",
+                apply: gen3(function* () {
+                  const changeTracker = yield* service2(ChangeTracker);
+                  const comment = "// @effect-codegens accessors\n";
+                  changeTracker.insertText(sourceFile, node.getStart(sourceFile), comment);
+                })
+              }]
+            });
+          }
+        }
+      }
+    }
+  })
+});
+
 // src/diagnostics.ts
 var diagnostics = [
+  classSelfMismatch,
   duplicatePackage,
   missingEffectContext,
   missingEffectError,
@@ -31585,7 +32369,9 @@ var diagnostics = [
   effectInVoidSuccess,
   unnecessaryPipeChain,
   strictBooleanExpressions,
-  multipleEffectProvide
+  multipleEffectProvide,
+  outdatedEffectCodegen,
+  unsupportedServiceAccessors
 ];
 
 // src/cli.ts
@@ -31728,14 +32514,11 @@ var checkEffect2 = (format6, file3) => gen2(function* () {
     for (const sourceFile of sourceFiles) {
       const outputDiagnostics = pipe(
         getSemanticDiagnosticsWithCodeFixes(diagnostics, sourceFile),
-        provideService7(TypeScriptApi, ts),
-        provideService7(TypeScriptProgram, program),
+        nanoLayer2,
         provideService7(TypeCheckerApi, program.getTypeChecker()),
-        provideService7(TypeParser, make64(ts, program.getTypeChecker())),
-        provideService7(
-          TypeCheckerApiCache,
-          makeTypeCheckerApiCache()
-        ),
+        provideService7(TypeScriptProgram, program),
+        nanoLayer,
+        provideService7(TypeScriptApi, ts),
         provideService7(
           LanguageServicePluginOptions,
           parse4(pluginOptions)