@effect/language-service 0.28.3 → 0.30.0

package/transform.js

@@ -745,10 +745,6 @@ var none2 = () => none;
 var some2 = some;
 var isNone2 = isNone;
 var isSome2 = isSome;
-var match = /* @__PURE__ */ dual(2, (self, {
-  onNone,
-  onSome
-}) => isNone2(self) ? onNone() : onSome(self.value));
 var orElse = /* @__PURE__ */ dual(2, (self, that) => isNone2(self) ? that() : self);
 var fromNullable = (nullableValue) => nullableValue == null ? none2() : some2(nullableValue);
 
@@ -995,7 +991,7 @@ var MatchProto = {
     return this[args];
   }
 };
-var match2 = (fa, opts) => {
+var match = (fa, opts) => {
   const nano = Object.create(MatchProto);
   nano[args] = fa;
   nano[contA] = opts.onSuccess;
@@ -1018,7 +1014,7 @@ var ProvideServiceProto = {
       ...fiber._services,
       [tag.key]: value
     };
-    return match2(fa, {
+    return match(fa, {
       onSuccess: (_) => {
         fiber._services = prevServices;
         return succeed(_);
@@ -1061,7 +1057,7 @@ var CachedProto = {
     fiber._cache[type] = cache;
     const cached2 = cache.get(key);
     if (cached2) return cached2;
-    return match2(fa, {
+    return match(fa, {
       onSuccess: (_) => {
         cache.set(key, succeed(_));
         return succeed(_);
@@ -1137,44 +1133,50 @@ function parse(config) {
 var TypeScriptApi = Tag("TypeScriptApi");
 var TypeScriptProgram = Tag("TypeScriptProgram");
 var ChangeTracker = Tag("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, pattern) {
+
+// src/core/TypeScriptUtils.ts
+var TypeScriptUtils = Tag("TypeScriptUtils");
+var nanoLayer = (fa) => pipe(
+  service(TypeScriptApi),
+  flatMap2((ts) => pipe(fa, provideService(TypeScriptUtils, makeTypeScriptUtils(ts))))
+);
+function makeTypeScriptUtils(ts) {
+  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, pattern) {
     if (pattern.indexOf("*") === -1) return [pattern.toLowerCase()];
-    const ts = yield* service(TypeScriptApi);
     const packageJsonScope = parsePackageContentNameAndVersionFromScope(sourceFile);
     const referencedPackages = [];
     for (const statement of sourceFile.statements) {
@@ -1193,19 +1195,338 @@ var resolveModulePattern = fn("resolveModulePattern")(
       )
     );
   }
-);
-function makeGetModuleSpecifier(ts) {
-  if (!(hasProperty(ts, "moduleSpecifiers") && hasProperty(ts.moduleSpecifiers, "getModuleSpecifier") && isFunction2(ts.moduleSpecifiers.getModuleSpecifier))) return;
-  const _internal = ts.moduleSpecifiers.getModuleSpecifier;
-  return (compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host, options) => {
-    return _internal(
-      compilerOptions,
-      importingSourceFile,
-      importingSourceFileName,
-      toFileName,
-      host,
-      options
+  function makeGetModuleSpecifier() {
+    if (!(hasProperty(ts, "moduleSpecifiers") && hasProperty(ts.moduleSpecifiers, "getModuleSpecifier") && isFunction2(ts.moduleSpecifiers.getModuleSpecifier))) return;
+    const _internal = ts.moduleSpecifiers.getModuleSpecifier;
+    return (compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host, options) => {
+      return _internal(
+        compilerOptions,
+        importingSourceFile,
+        importingSourceFileName,
+        toFileName,
+        host,
+        options
+      );
+    };
+  }
+  function findNodeWithLeadingCommentAtPosition(sourceFile, position) {
+    const sourceText = sourceFile.text;
+    let result;
+    function find(node) {
+      const leading = ts.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(find);
+      }
+    }
+    find(sourceFile);
+    return result;
+  }
+  function collectSelfAndAncestorNodesInRange(node, textRange) {
+    let result = empty();
+    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 find(node) {
+      if (position >= node.getStart() && position < node.getEnd()) {
+        return ts.forEachChild(node, find) || node;
+      }
+      return void 0;
+    }
+    return find(sourceFile);
+  }
+  function findNodeAtPositionIncludingTrivia(sourceFile, position) {
+    function find(node) {
+      if (position >= node.pos && position < node.end) {
+        return ts.forEachChild(node, find) || node;
+      }
+      return void 0;
+    }
+    return find(sourceFile);
+  }
+  function getAncestorNodesInRange(sourceFile, textRange) {
+    const nodeAtPosition = findNodeAtPosition(sourceFile, textRange.pos);
+    if (!nodeAtPosition) return empty();
+    return collectSelfAndAncestorNodesInRange(nodeAtPosition, textRange);
+  }
+  function getCommentAtPosition(sourceFile, pos) {
+    const token = findNodeAtPositionIncludingTrivia(sourceFile, pos);
+    if (token === void 0 || token.kind === ts.SyntaxKind.JsxText || pos >= token.end - (ts.tokenToString(token.kind) || "").length) {
+      return;
+    }
+    const startPos = token.pos === 0 ? (ts.getShebang(sourceFile.text) || "").length : token.pos;
+    if (startPos === 0) return;
+    const result = ts.forEachTrailingCommentRange(sourceFile.text, startPos, isCommentInRange, pos) || ts.forEachLeadingCommentRange(sourceFile.text, startPos, isCommentInRange, pos);
+    return result;
+  }
+  function isCommentInRange(pos, end, kind, _nl, at) {
+    return at >= pos && at < end ? { pos, end, 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 (ts.isAwaitExpression(_)) {
+        const expression = ts.visitEachChild(_.expression, visitor, ts.nullTransformationContext);
+        return ts.factory.createYieldExpression(
+          ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+          onAwait(expression)
+        );
+      }
+      return ts.visitEachChild(_, visitor, ts.nullTransformationContext);
+    }
+    const generatorBody = visitor(node.body);
+    const effectGenCallExp = createEffectGenCallExpression(effectModuleName, generatorBody);
+    let currentFlags = ts.getCombinedModifierFlags(node);
+    currentFlags &= ~ts.ModifierFlags.Async;
+    const newModifiers = ts.factory.createModifiersFromModifierFlags(currentFlags);
+    if (ts.isArrowFunction(node)) {
+      return ts.factory.createArrowFunction(
+        newModifiers,
+        node.typeParameters,
+        node.parameters,
+        void 0,
+        node.equalsGreaterThanToken,
+        effectGenCallExp
+      );
+    }
+    const newBody = ts.factory.createBlock([
+      ts.factory.createReturnStatement(effectGenCallExp)
+    ]);
+    if (ts.isFunctionDeclaration(node)) {
+      return ts.factory.createFunctionDeclaration(
+        newModifiers,
+        node.asteriskToken,
+        node.name,
+        node.typeParameters,
+        node.parameters,
+        void 0,
+        newBody
+      );
+    }
+    return ts.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 (!ts.isImportDeclaration(statement)) continue;
+      const importClause = statement.importClause;
+      if (!importClause) continue;
+      const namedBindings = importClause.namedBindings;
+      if (!namedBindings) continue;
+      if (ts.isNamespaceImport(namedBindings)) {
+        if (test(namedBindings.name, statement.moduleSpecifier, none2())) {
+          return namedBindings.name.text;
+        }
+      } else if (ts.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) && ts.isStringLiteral(fromModule) && fromModule.text === packageName + "/" + moduleName) {
+          return true;
+        }
+        if (isSome2(importProperty) && ts.isIdentifier(importProperty.value) && importProperty.value.text === moduleName && ts.isStringLiteral(fromModule) && fromModule.text === packageName) {
+          return true;
+        }
+        return false;
+      }
     );
+  }
+  function simplifyTypeNode(typeNode) {
+    function collectCallable(typeNode2) {
+      if (ts.isParenthesizedTypeNode(typeNode2)) return collectCallable(typeNode2.type);
+      if (ts.isFunctionTypeNode(typeNode2)) {
+        return some2([
+          ts.factory.createCallSignature(typeNode2.typeParameters, typeNode2.parameters, typeNode2.type)
+        ]);
+      }
+      if (ts.isTypeLiteralNode(typeNode2)) {
+        const allCallSignatures = typeNode2.members.every(ts.isCallSignatureDeclaration);
+        if (allCallSignatures) {
+          return some2(typeNode2.members);
+        }
+      }
+      if (ts.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 ts.factory.createTypeLiteralNode(callSignatures.value);
+    }
+    return typeNode;
+  }
+  function tryPreserveDeclarationSemantics(nodeToReplace, node) {
+    if (!ts.isExpression(node)) return node;
+    if (ts.isFunctionDeclaration(nodeToReplace)) {
+      if (!nodeToReplace.name) return node;
+      return ts.factory.createVariableStatement(
+        nodeToReplace.modifiers,
+        ts.factory.createVariableDeclarationList(
+          [ts.factory.createVariableDeclaration(
+            nodeToReplace.name,
+            void 0,
+            void 0,
+            node
+          )],
+          ts.NodeFlags.Const
+        )
+      );
+    } else if (ts.isMethodDeclaration(nodeToReplace)) {
+      return ts.factory.createPropertyDeclaration(
+        nodeToReplace.modifiers,
+        nodeToReplace.name,
+        void 0,
+        void 0,
+        node
+      );
+    }
+    return node;
+  }
+  function parseAccessedExpressionForCompletion(sourceFile, position) {
+    const precedingToken = ts.findPrecedingToken(position, sourceFile, void 0, true);
+    if (!precedingToken) return;
+    let accessedObject = precedingToken;
+    let replacementSpan = ts.createTextSpan(position, 0);
+    let outerNode = precedingToken;
+    if (ts.isIdentifier(precedingToken) && precedingToken.parent && ts.isPropertyAccessExpression(precedingToken.parent)) {
+      replacementSpan = ts.createTextSpan(
+        precedingToken.parent.getStart(sourceFile),
+        precedingToken.end - precedingToken.parent.getStart(sourceFile)
+      );
+      accessedObject = precedingToken.parent.expression;
+      outerNode = precedingToken.parent;
+    } else if (ts.isToken(precedingToken) && precedingToken.kind === ts.SyntaxKind.DotToken && ts.isPropertyAccessExpression(precedingToken.parent)) {
+      replacementSpan = ts.createTextSpan(
+        precedingToken.parent.getStart(sourceFile),
+        precedingToken.end - precedingToken.parent.getStart(sourceFile)
+      );
+      accessedObject = precedingToken.parent.expression;
+      outerNode = precedingToken.parent;
+    } else if (ts.isIdentifier(precedingToken) && precedingToken.parent) {
+      replacementSpan = ts.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 (!ts.isIdentifier(accessedObject)) return;
+    let classDeclaration = outerNode.parent;
+    while (ts.isExpressionWithTypeArguments(classDeclaration) || ts.isHeritageClause(classDeclaration)) {
+      if (!classDeclaration.parent) break;
+      classDeclaration = classDeclaration.parent;
+    }
+    if (!ts.isClassDeclaration(classDeclaration)) return;
+    if (!classDeclaration.name) return;
+    return {
+      accessedObject,
+      classDeclaration,
+      className: classDeclaration.name,
+      replacementSpan
+    };
+  }
+  function createEffectGenCallExpression(effectModuleIdentifierName, node) {
+    const generator = ts.factory.createFunctionExpression(
+      void 0,
+      ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+      void 0,
+      [],
+      [],
+      void 0,
+      node
+      // NOTE(mattia): intended, to use same routine for both ConciseBody and Body
+    );
+    return ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(
+        ts.factory.createIdentifier(effectModuleIdentifierName),
+        "gen"
+      ),
+      void 0,
+      [generator]
+    );
+  }
+  function createEffectGenCallExpressionWithBlock(effectModuleIdentifierName, statement) {
+    return createEffectGenCallExpression(
+      effectModuleIdentifierName,
+      ts.factory.createBlock(isArray(statement) ? statement : [statement], false)
+    );
+  }
+  function createReturnYieldStarStatement(expr) {
+    return ts.factory.createReturnStatement(
+      ts.factory.createYieldExpression(
+        ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+        expr
+      )
+    );
+  }
+  return {
+    findNodeAtPositionIncludingTrivia,
+    parsePackageContentNameAndVersionFromScope,
+    resolveModulePattern,
+    findNodeWithLeadingCommentAtPosition,
+    getCommentAtPosition,
+    getAncestorNodesInRange,
+    toTextRange,
+    isNodeInRange,
+    transformAsyncAwaitToEffectGen,
+    findImportedModuleIdentifierByPackageAndNameOrBarrel,
+    simplifyTypeNode,
+    tryPreserveDeclarationSemantics,
+    parseDataForExtendsClassCompletion,
+    createEffectGenCallExpressionWithBlock,
+    createReturnYieldStarStatement,
+    makeGetModuleSpecifier,
+    parseAccessedExpressionForCompletion
   };
 }
 
@@ -1213,6 +1534,9 @@ function makeGetModuleSpecifier(ts) {
 var RefactorNotApplicableError = class {
   _tag = "@effect/language-service/RefactorNotApplicableError";
 };
+function createRefactor(definition) {
+  return definition;
+}
 function createDiagnostic(definition) {
   return definition;
 }
@@ -1275,27 +1599,8 @@ var getCompletionsAtPosition = fn("LSP.getCompletionsAtPosition")(function* (com
 var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
   function* (sourceFile) {
     const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
     const pluginOptions = yield* service(LanguageServicePluginOptions);
-    function findNodeWithLeadingCommentAtPosition(position) {
-      const sourceText = sourceFile.text;
-      let result;
-      function find(node) {
-        const leading = ts.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(find);
-        }
-      }
-      find(sourceFile);
-      return result;
-    }
     function findParentStatementForDisableNextLine(node) {
       let result;
       function find(node2) {
@@ -1313,10 +1618,10 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
     const sectionOverrides = {};
     const skippedRules = [];
     const regex = /@effect-diagnostics(-next-line)?((?:\s[a-zA-Z0-9/]+:(?:off|warning|error|message|suggestion|skip-file))+)?/gm;
-    let match3;
-    while ((match3 = regex.exec(sourceFile.text)) !== null) {
-      const nextLineCaptureGroup = match3[1];
-      const rulesCaptureGroup = match3[2];
+    let match2;
+    while ((match2 = regex.exec(sourceFile.text)) !== null) {
+      const nextLineCaptureGroup = match2[1];
+      const rulesCaptureGroup = match2[2];
       if (rulesCaptureGroup) {
         const trimmedRuleString = rulesCaptureGroup.trim();
         if (trimmedRuleString) {
@@ -1328,19 +1633,19 @@ 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(match3.index);
-                if (node) {
+                const foundNode = tsUtils.findNodeWithLeadingCommentAtPosition(sourceFile, match2.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
                   });
                 }
               } else {
                 sectionOverrides[ruleName] = sectionOverrides[ruleName] || [];
                 sectionOverrides[ruleName].unshift({
-                  pos: match3.index,
+                  pos: match2.index,
                   level: ruleLevel
                 });
               }
@@ -1355,7 +1660,7 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
       message: ts.DiagnosticCategory.Message,
       suggestion: ts.DiagnosticCategory.Suggestion
     };
-    const execute = fn("LSP.ruleExecutor")(function* (rule) {
+    const execute = (rule) => gen(function* () {
       const diagnostics2 = [];
       const codeFixes = [];
       const ruleNameLowered = rule.name.toLowerCase();
@@ -1364,13 +1669,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: flatMap2(
           service(ChangeTracker),
-          (changeTracker) => sync(() => {
-            const disableAtNode = findParentStatementForDisableNextLine(_.node);
+          (changeTracker) => gen(function* () {
+            const disableAtNode = findParentStatementForDisableNextLine(node);
             const { line } = ts.getLineAndCharacterOfPosition(sourceFile, disableAtNode.getStart());
             changeTracker.insertCommentBeforeLine(
               sourceFile,
@@ -1398,29 +1703,30 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
       };
       const applicableDiagnostics = [];
       yield* rule.apply(sourceFile, (entry) => {
+        const range = "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,
+          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,
@@ -1430,8 +1736,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
           });
         }
       }
@@ -1440,15 +1746,85 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
     return { execute };
   }
 );
+var cyrb53 = (str, seed = 0) => {
+  let h1 = 3735928559 ^ seed, h2 = 1103547991 ^ seed;
+  for (let i = 0, ch; i < str.length; i++) {
+    ch = str.charCodeAt(i);
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507);
+  h1 ^= Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507);
+  h2 ^= Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  return (h2 >>> 0).toString(16).padStart(8, "0") + (h1 >>> 0).toString(16).padStart(8, "0");
+};
+var CodegenNotApplicableError = class {
+  constructor(cause) {
+    this.cause = cause;
+  }
+  _tag = "@effect/language-service/CodegenNotApplicableError";
+};
+function createCodegen(definition) {
+  return definition;
+}
+var getCodegensForSourceFile = fn("LSP.getApplicableCodegens")(function* (codegens2, sourceFile) {
+  const tsUtils = yield* service(TypeScriptUtils);
+  const result = [];
+  const regex = /@effect-codegens((?:\s[a-zA-Z0-9]+(?::(?:[a-zA-Z0-9]+))?)+)+/gmid;
+  let match2;
+  while ((match2 = regex.exec(sourceFile.text)) !== null) {
+    const pos = match2.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 range = {
+        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 });
+    }
+  }
+  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* fail(new CodegenNotApplicableError("zero or multiple codegens in range"));
+  }
+  const { codegen, range } = inRangeCodegens[0];
+  const edit = yield* codegen.apply(sourceFile, range);
+  const updateHashComment = pipe(
+    service(ChangeTracker),
+    map3((changeTracker) => {
+      changeTracker.deleteRange(sourceFile, range);
+      changeTracker.insertText(sourceFile, range.pos, `${codegen.name}:${edit.hash}`);
+    })
+  );
+  return {
+    ...edit,
+    apply: pipe(
+      edit.apply,
+      flatMap2(() => updateHashComment)
+    ),
+    ignore: updateHashComment
+  };
+});
 
 // src/core/TypeCheckerApi.ts
 var TypeCheckerApi = Tag("TypeChecker");
-var TypeCheckerApiCache = Tag("TypeCheckerApiCache");
-function makeTypeCheckerApiCache() {
-  return {
-    expectedAndRealType: /* @__PURE__ */ new WeakMap()
-  };
-}
 var deterministicTypeOrder = gen(function* () {
   const typeChecker = yield* service(TypeCheckerApi);
   return make((a, b) => {
@@ -1547,106 +1923,106 @@ var getInferredReturnType = fn("TypeCheckerApi.getInferredReturnType")(function*
   }
   return returnType;
 });
-var expectedAndRealType = fn("TypeCheckerApi.expectedAndRealType")(function* (sourceFile) {
-  const cache = yield* service(TypeCheckerApiCache);
-  const resultCached = cache.expectedAndRealType.get(sourceFile);
-  if (resultCached) return resultCached;
-  const typeChecker = yield* service(TypeCheckerApi);
-  const ts = yield* service(TypeScriptApi);
-  const result = [];
-  const nodeToVisit = [sourceFile];
-  const appendNodeToVisit = (node) => {
-    nodeToVisit.push(node);
-    return void 0;
-  };
-  while (nodeToVisit.length > 0) {
-    const node = nodeToVisit.shift();
-    if (ts.isVariableDeclaration(node) && node.initializer) {
-      const expectedType = typeChecker.getTypeAtLocation(node.name);
-      const realType = typeChecker.getTypeAtLocation(node.initializer);
-      result.push([node.name, expectedType, node.initializer, realType]);
-      appendNodeToVisit(node.initializer);
-      continue;
-    } else if (ts.isCallExpression(node)) {
-      const resolvedSignature = typeChecker.getResolvedSignature(node);
-      if (resolvedSignature) {
-        resolvedSignature.getParameters().map((parameter, index) => {
-          const expectedType = typeChecker.getTypeOfSymbolAtLocation(parameter, node);
-          const realType = typeChecker.getTypeAtLocation(node.arguments[index]);
-          result.push([
-            node.arguments[index],
-            expectedType,
-            node.arguments[index],
-            realType
-          ]);
-        });
-      }
-      ts.forEachChild(node, appendNodeToVisit);
-      continue;
-    } else if (ts.isIdentifier(node) || ts.isStringLiteral(node) || ts.isNumericLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
-      const parent = node.parent;
-      if (ts.isObjectLiteralElement(parent)) {
-        if (ts.isObjectLiteralExpression(parent.parent) && parent.name === node) {
-          const type = typeChecker.getContextualType(parent.parent);
-          if (type) {
-            const symbol3 = typeChecker.getPropertyOfType(type, node.text);
-            if (symbol3) {
-              const expectedType = typeChecker.getTypeOfSymbolAtLocation(symbol3, node);
-              const realType = typeChecker.getTypeAtLocation(node);
-              result.push([node, expectedType, node, realType]);
+var expectedAndRealType = cachedBy(
+  fn("TypeCheckerApi.expectedAndRealType")(function* (sourceFile) {
+    const typeChecker = yield* service(TypeCheckerApi);
+    const ts = yield* service(TypeScriptApi);
+    const result = [];
+    const nodeToVisit = [sourceFile];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      if (ts.isVariableDeclaration(node) && node.initializer) {
+        const expectedType = typeChecker.getTypeAtLocation(node.name);
+        const realType = typeChecker.getTypeAtLocation(node.initializer);
+        result.push([node.name, expectedType, node.initializer, realType]);
+        appendNodeToVisit(node.initializer);
+        continue;
+      } else if (ts.isCallExpression(node)) {
+        const resolvedSignature = typeChecker.getResolvedSignature(node);
+        if (resolvedSignature) {
+          resolvedSignature.getParameters().map((parameter, index) => {
+            const expectedType = typeChecker.getTypeOfSymbolAtLocation(parameter, node);
+            const realType = typeChecker.getTypeAtLocation(node.arguments[index]);
+            result.push([
+              node.arguments[index],
+              expectedType,
+              node.arguments[index],
+              realType
+            ]);
+          });
+        }
+        ts.forEachChild(node, appendNodeToVisit);
+        continue;
+      } else if (ts.isIdentifier(node) || ts.isStringLiteral(node) || ts.isNumericLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+        const parent = node.parent;
+        if (ts.isObjectLiteralElement(parent)) {
+          if (ts.isObjectLiteralExpression(parent.parent) && parent.name === node) {
+            const type = typeChecker.getContextualType(parent.parent);
+            if (type) {
+              const symbol3 = typeChecker.getPropertyOfType(type, node.text);
+              if (symbol3) {
+                const expectedType = typeChecker.getTypeOfSymbolAtLocation(symbol3, node);
+                const realType = typeChecker.getTypeAtLocation(node);
+                result.push([node, expectedType, node, realType]);
+              }
             }
           }
         }
-      }
-      ts.forEachChild(node, appendNodeToVisit);
-      continue;
-    } else if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
-      const expectedType = typeChecker.getTypeAtLocation(node.left);
-      const realType = typeChecker.getTypeAtLocation(node.right);
-      result.push([node.left, expectedType, node.right, realType]);
-      appendNodeToVisit(node.right);
-      continue;
-    } else if (ts.isReturnStatement(node) && node.expression) {
-      const parentDeclaration = yield* option(getAncestorConvertibleDeclaration(node));
-      if (isSome2(parentDeclaration)) {
-        const expectedType = yield* option(getInferredReturnType(parentDeclaration.value));
-        const realType = typeChecker.getTypeAtLocation(node.expression);
+        ts.forEachChild(node, appendNodeToVisit);
+        continue;
+      } else if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+        const expectedType = typeChecker.getTypeAtLocation(node.left);
+        const realType = typeChecker.getTypeAtLocation(node.right);
+        result.push([node.left, expectedType, node.right, realType]);
+        appendNodeToVisit(node.right);
+        continue;
+      } else if (ts.isReturnStatement(node) && node.expression) {
+        const parentDeclaration = yield* option(getAncestorConvertibleDeclaration(node));
+        if (isSome2(parentDeclaration)) {
+          const expectedType = yield* option(getInferredReturnType(parentDeclaration.value));
+          const realType = typeChecker.getTypeAtLocation(node.expression);
+          if (isSome2(expectedType)) {
+            result.push([node, expectedType.value, node, realType]);
+          }
+        }
+        ts.forEachChild(node, appendNodeToVisit);
+        continue;
+      } else if (ts.isArrowFunction(node) && (node.typeParameters || []).length === 0 && ts.isExpression(node.body)) {
+        const body = node.body;
+        const expectedType = typeChecker.getContextualType(body);
+        const realType = typeChecker.getTypeAtLocation(body);
+        if (expectedType) {
+          result.push([body, expectedType, body, realType]);
+        }
+        ts.forEachChild(body, appendNodeToVisit);
+        continue;
+      } else if (ts.isArrowFunction(node) && (node.typeParameters || []).length > 0 && ts.isExpression(node.body)) {
+        const body = node.body;
+        const expectedType = yield* option(getInferredReturnType(node));
+        const realType = typeChecker.getTypeAtLocation(body);
         if (isSome2(expectedType)) {
-          result.push([node, expectedType.value, node, realType]);
+          result.push([body, expectedType.value, body, realType]);
         }
+        ts.forEachChild(body, appendNodeToVisit);
+        continue;
+      } else if (ts.isSatisfiesExpression(node)) {
+        const expectedType = typeChecker.getTypeAtLocation(node.type);
+        const realType = typeChecker.getTypeAtLocation(node.expression);
+        result.push([node.expression, expectedType, node.expression, realType]);
+        appendNodeToVisit(node.expression);
+        continue;
       }
       ts.forEachChild(node, appendNodeToVisit);
-      continue;
-    } else if (ts.isArrowFunction(node) && (node.typeParameters || []).length === 0 && ts.isExpression(node.body)) {
-      const body = node.body;
-      const expectedType = typeChecker.getContextualType(body);
-      const realType = typeChecker.getTypeAtLocation(body);
-      if (expectedType) {
-        result.push([body, expectedType, body, realType]);
-      }
-      ts.forEachChild(body, appendNodeToVisit);
-      continue;
-    } else if (ts.isArrowFunction(node) && (node.typeParameters || []).length > 0 && ts.isExpression(node.body)) {
-      const body = node.body;
-      const expectedType = yield* option(getInferredReturnType(node));
-      const realType = typeChecker.getTypeAtLocation(body);
-      if (isSome2(expectedType)) {
-        result.push([body, expectedType.value, body, realType]);
-      }
-      ts.forEachChild(body, appendNodeToVisit);
-      continue;
-    } else if (ts.isSatisfiesExpression(node)) {
-      const expectedType = typeChecker.getTypeAtLocation(node.type);
-      const realType = typeChecker.getTypeAtLocation(node.expression);
-      result.push([node.expression, expectedType, node.expression, realType]);
-      appendNodeToVisit(node.expression);
-      continue;
-    }
-    ts.forEachChild(node, appendNodeToVisit);
-  }
-  cache.expectedAndRealType.set(sourceFile, result);
-  return result;
-});
+    }
+    return result;
+  }),
+  "TypeCheckerApi.expectedAndRealType",
+  (sourceFile) => sourceFile
+);
 var unrollUnionMembers = (type) => {
   const result = [];
   let toTest = [type];
@@ -1714,350 +2090,17 @@ function makeResolveExternalModuleName(typeChecker) {
   };
 }
 
-// src/core/AST.ts
-function collectSelfAndAncestorNodesInRange(node, textRange) {
-  return sync(() => {
-    let result = empty();
-    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* option(findNodeAtPosition(sourceFile, textRange.pos));
-  if (isNone2(nodeAtPosition)) return empty();
-  return yield* collectSelfAndAncestorNodesInRange(nodeAtPosition.value, textRange);
-});
-var NodeNotFoundError = class {
-  _tag = "@effect/language-service/NodeNotFoundError";
-};
-var findNodeAtPosition = fn("AST.findNodeAtPosition")(function* (sourceFile, position) {
-  const ts = yield* service(TypeScriptApi);
-  function find(node) {
-    if (position >= node.getStart() && position < node.getEnd()) {
-      return ts.forEachChild(node, find) || node;
-    }
-    return void 0;
-  }
-  const result = find(sourceFile);
-  if (!result) return yield* fail(new NodeNotFoundError());
-  return result;
-});
-var getCommentAtPosition = fn("TypeScriptApi.getCommentAtPosition")(function* (sourceFile, pos) {
-  const ts = yield* service(TypeScriptApi);
-  const token = yield* findNodeAtPosition(sourceFile, pos);
-  if (token === void 0 || token.kind === ts.SyntaxKind.JsxText || pos >= token.end - (ts.tokenToString(token.kind) || "").length) {
-    return yield* fail(new NodeNotFoundError());
-  }
-  const startPos = token.pos === 0 ? (ts.getShebang(sourceFile.text) || "").length : token.pos;
-  if (startPos === 0) return yield* fail(new NodeNotFoundError());
-  const result = ts.forEachTrailingCommentRange(sourceFile.text, startPos, isCommentInRange, pos) || ts.forEachLeadingCommentRange(sourceFile.text, startPos, isCommentInRange, pos);
-  if (!result) return yield* fail(new NodeNotFoundError());
-  return result;
-});
-function isCommentInRange(pos, end, kind, _nl, at) {
-  return at >= pos && at < end ? { pos, end, kind } : void 0;
-}
-var transformAsyncAwaitToEffectGen = fn("AST.transformAsyncAwaitToEffectGen")(
-  function* (node, effectModuleName, onAwait) {
-    const ts = yield* service(TypeScriptApi);
-    function visitor(_) {
-      if (ts.isAwaitExpression(_)) {
-        const expression = ts.visitEachChild(_.expression, visitor, ts.nullTransformationContext);
-        return ts.factory.createYieldExpression(
-          ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
-          onAwait(expression)
-        );
-      }
-      return ts.visitEachChild(_, visitor, ts.nullTransformationContext);
-    }
-    const generatorBody = visitor(node.body);
-    const effectGenCallExp = yield* createEffectGenCallExpression(effectModuleName, generatorBody);
-    let currentFlags = ts.getCombinedModifierFlags(node);
-    currentFlags &= ~ts.ModifierFlags.Async;
-    const newModifiers = ts.factory.createModifiersFromModifierFlags(currentFlags);
-    if (ts.isArrowFunction(node)) {
-      return ts.factory.createArrowFunction(
-        newModifiers,
-        node.typeParameters,
-        node.parameters,
-        void 0,
-        node.equalsGreaterThanToken,
-        effectGenCallExp
-      );
-    }
-    const newBody = ts.factory.createBlock([
-      ts.factory.createReturnStatement(effectGenCallExp)
-    ]);
-    if (ts.isFunctionDeclaration(node)) {
-      return ts.factory.createFunctionDeclaration(
-        newModifiers,
-        node.asteriskToken,
-        node.name,
-        node.typeParameters,
-        node.parameters,
-        void 0,
-        newBody
-      );
-    }
-    return ts.factory.createFunctionExpression(
-      newModifiers,
-      node.asteriskToken,
-      node.name,
-      node.typeParameters,
-      node.parameters,
-      void 0,
-      newBody
-    );
-  }
-);
-var addReturnTypeAnnotation = fn("AST.addReturnTypeAnnotation")(function* (sourceFile, declaration, typeNode) {
-  const ts = yield* service(TypeScriptApi);
-  const changes = yield* service(ChangeTracker);
-  const closeParen = ts.findChildOfKind(declaration, ts.SyntaxKind.CloseParenToken, sourceFile);
-  const needParens = ts.isArrowFunction(declaration) && closeParen === void 0;
-  const endNode = needParens ? declaration.parameters[0] : closeParen;
-  if (endNode) {
-    if (needParens) {
-      changes.insertNodeBefore(
-        sourceFile,
-        endNode,
-        ts.factory.createToken(ts.SyntaxKind.OpenParenToken)
-      );
-      changes.insertNodeAfter(
-        sourceFile,
-        endNode,
-        ts.factory.createToken(ts.SyntaxKind.CloseParenToken)
-      );
-    }
-    changes.insertNodeAt(sourceFile, endNode.end, typeNode, { prefix: ": " });
-  }
-});
-var removeReturnTypeAnnotation = fn("AST.removeReturnTypeAnnotation")(function* (sourceFile, declaration) {
-  const ts = yield* service(TypeScriptApi);
-  const changes = yield* service(ChangeTracker);
-  const closeParen = ts.findChildOfKind(declaration, ts.SyntaxKind.CloseParenToken, sourceFile);
-  const needParens = ts.isArrowFunction(declaration) && closeParen === void 0;
-  const endNode = needParens ? declaration.parameters[0] : closeParen;
-  if (endNode && declaration.type) {
-    changes.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 ts = yield* service(TypeScriptApi);
-    for (const statement of sourceFile.statements) {
-      if (!ts.isImportDeclaration(statement)) continue;
-      const importClause = statement.importClause;
-      if (!importClause) continue;
-      const namedBindings = importClause.namedBindings;
-      if (!namedBindings) continue;
-      if (ts.isNamespaceImport(namedBindings)) {
-        if (yield* test(namedBindings.name, statement.moduleSpecifier, none2())) {
-          return namedBindings.name;
-        }
-      } else if (ts.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* fail(new ImportModuleIdentifierNotFoundError());
-  }
-);
-function findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, packageName, moduleName) {
-  return findImportedModuleIdentifier(
-    sourceFile,
-    fn(
-      "AST.findImportedModuleIdentifierByPackageAndNameOrBarrel.findImportedModuleIdentifier"
-    )(function* (_, fromModule, importProperty) {
-      const ts = yield* service(TypeScriptApi);
-      if (isNone2(importProperty) && ts.isStringLiteral(fromModule) && fromModule.text === packageName + "/" + moduleName) {
-        return true;
-      }
-      if (isSome2(importProperty) && ts.isIdentifier(importProperty.value) && importProperty.value.text === moduleName && ts.isStringLiteral(fromModule) && fromModule.text === packageName) {
-        return true;
-      }
-      return false;
-    })
-  );
-}
-var simplifyTypeNode = fn("AST.simplifyTypeNode")(function* (typeNode) {
-  const ts = yield* service(TypeScriptApi);
-  function collectCallable(typeNode2) {
-    if (ts.isParenthesizedTypeNode(typeNode2)) return collectCallable(typeNode2.type);
-    if (ts.isFunctionTypeNode(typeNode2)) {
-      return some2([
-        ts.factory.createCallSignature(typeNode2.typeParameters, typeNode2.parameters, typeNode2.type)
-      ]);
-    }
-    if (ts.isTypeLiteralNode(typeNode2)) {
-      const allCallSignatures = typeNode2.members.every(ts.isCallSignatureDeclaration);
-      if (allCallSignatures) {
-        return some2(typeNode2.members);
-      }
-    }
-    if (ts.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 ts.factory.createTypeLiteralNode(callSignatures.value);
-  }
-  return typeNode;
-});
-var tryPreserveDeclarationSemantics = fn("AST.tryPreserveDeclarationSemantics")(
-  function* (nodeToReplace, node) {
-    const ts = yield* service(TypeScriptApi);
-    if (!ts.isExpression(node)) return node;
-    if (ts.isFunctionDeclaration(nodeToReplace)) {
-      if (!nodeToReplace.name) return node;
-      return ts.factory.createVariableStatement(
-        nodeToReplace.modifiers,
-        ts.factory.createVariableDeclarationList(
-          [ts.factory.createVariableDeclaration(
-            nodeToReplace.name,
-            void 0,
-            void 0,
-            node
-          )],
-          ts.NodeFlags.Const
-        )
-      );
-    } else if (ts.isMethodDeclaration(nodeToReplace)) {
-      return ts.factory.createPropertyDeclaration(
-        nodeToReplace.modifiers,
-        nodeToReplace.name,
-        void 0,
-        void 0,
-        node
-      );
-    }
-    return node;
-  }
-);
-var parseAccessedExpressionForCompletion = fn(
-  "AST.parseAccessedExpressionForCompletion"
-)(
-  function* (sourceFile, position) {
-    const ts = yield* service(TypeScriptApi);
-    const precedingToken = ts.findPrecedingToken(position, sourceFile, void 0, true);
-    if (!precedingToken) return yield* fail(new NodeNotFoundError());
-    let accessedObject = precedingToken;
-    let replacementSpan = ts.createTextSpan(position, 0);
-    let outerNode = precedingToken;
-    if (ts.isIdentifier(precedingToken) && precedingToken.parent && ts.isPropertyAccessExpression(precedingToken.parent)) {
-      replacementSpan = ts.createTextSpan(
-        precedingToken.parent.getStart(sourceFile),
-        precedingToken.end - precedingToken.parent.getStart(sourceFile)
-      );
-      accessedObject = precedingToken.parent.expression;
-      outerNode = precedingToken.parent;
-    } else if (ts.isToken(precedingToken) && precedingToken.kind === ts.SyntaxKind.DotToken && ts.isPropertyAccessExpression(precedingToken.parent)) {
-      replacementSpan = ts.createTextSpan(
-        precedingToken.parent.getStart(sourceFile),
-        precedingToken.end - precedingToken.parent.getStart(sourceFile)
-      );
-      accessedObject = precedingToken.parent.expression;
-      outerNode = precedingToken.parent;
-    } else if (ts.isIdentifier(precedingToken) && precedingToken.parent) {
-      replacementSpan = ts.createTextSpan(
-        precedingToken.getStart(sourceFile),
-        precedingToken.end - precedingToken.getStart(sourceFile)
-      );
-      accessedObject = precedingToken;
-      outerNode = precedingToken;
-    } else {
-      return yield* fail(new NodeNotFoundError());
-    }
-    return { accessedObject, outerNode, replacementSpan };
-  }
-);
-var parseDataForExtendsClassCompletion = fn(
-  "AST.parseDataForExtendsClassCompletion"
-)(function* (sourceFile, position) {
-  const ts = yield* service(TypeScriptApi);
-  const { accessedObject, outerNode, replacementSpan } = yield* parseAccessedExpressionForCompletion(
-    sourceFile,
-    position
-  );
-  if (!ts.isIdentifier(accessedObject)) return yield* fail(new NodeNotFoundError());
-  let classDeclaration = outerNode.parent;
-  while (ts.isExpressionWithTypeArguments(classDeclaration) || ts.isHeritageClause(classDeclaration)) {
-    if (!classDeclaration.parent) break;
-    classDeclaration = classDeclaration.parent;
-  }
-  if (!ts.isClassDeclaration(classDeclaration)) return yield* fail(new NodeNotFoundError());
-  if (!classDeclaration.name) return yield* fail(new NodeNotFoundError());
-  return {
-    accessedObject,
-    classDeclaration,
-    className: classDeclaration.name,
-    replacementSpan
-  };
-});
-var createEffectGenCallExpression = fn("AST.createEffectGenCallExpression")(function* (effectModuleIdentifierName, node) {
-  const ts = yield* service(TypeScriptApi);
-  const generator = ts.factory.createFunctionExpression(
-    void 0,
-    ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
-    void 0,
-    [],
-    [],
-    void 0,
-    node
-    // NOTE(mattia): intended, to use same routine for both ConciseBody and Body
-  );
-  return ts.factory.createCallExpression(
-    ts.factory.createPropertyAccessExpression(
-      ts.factory.createIdentifier(effectModuleIdentifierName),
-      "gen"
-    ),
-    void 0,
-    [generator]
-  );
-});
-var createEffectGenCallExpressionWithBlock = fn(
-  "AST.createEffectGenCallExpressionWithBlock"
-)(function* (effectModuleIdentifierName, statement) {
+// src/core/TypeParser.ts
+var TypeParser = Tag("@effect/language-service/TypeParser");
+var nanoLayer2 = (fa) => gen(function* () {
   const ts = yield* service(TypeScriptApi);
-  return yield* createEffectGenCallExpression(
-    effectModuleIdentifierName,
-    ts.factory.createBlock(Array.isArray(statement) ? statement : [statement], false)
+  const tsUtils = yield* service(TypeScriptUtils);
+  const typeChecker = yield* service(TypeCheckerApi);
+  return yield* pipe(
+    fa,
+    provideService(TypeParser, make2(ts, tsUtils, typeChecker))
   );
 });
-var createReturnYieldStarStatement = fn("AST.createReturnYieldStarStatement")(
-  function* (expr) {
-    const ts = yield* service(TypeScriptApi);
-    return ts.factory.createReturnStatement(
-      ts.factory.createYieldExpression(
-        ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
-        expr
-      )
-    );
-  }
-);
-
-// src/core/TypeParser.ts
-var TypeParser = Tag("@effect/language-service/TypeParser");
 var TypeParserIssue = class _TypeParserIssue {
   _tag = "@effect/language-service/TypeParserIssue";
   static issue = fail(new _TypeParserIssue());
@@ -2065,7 +2108,7 @@ var TypeParserIssue = class _TypeParserIssue {
 function typeParserIssue(_message, _type, _node) {
   return TypeParserIssue.issue;
 }
-function make2(ts, typeChecker) {
+function make2(ts, tsUtils, typeChecker) {
   function covariantTypeArgument(type) {
     const signatures = type.getCallSignatures();
     if (signatures.length !== 1) {
@@ -2223,6 +2266,36 @@ function make2(ts, typeChecker) {
     "TypeParser.effectSubtype",
     (type) => type
   );
+  const importedSchemaModule = cachedBy(
+    fn("TypeParser.importedSchemaModule")(function* (node) {
+      const type = typeChecker.getTypeAtLocation(node);
+      const propertySymbol = typeChecker.getPropertyOfType(type, "Class");
+      if (!propertySymbol) {
+        return yield* typeParserIssue("Type has no 'Class' property", type, node);
+      }
+      if (!ts.isExpression(node)) {
+        return yield* typeParserIssue("Node is not an expression", type, node);
+      }
+      return node;
+    }),
+    "TypeParser.importedSchemaModule",
+    (node) => node
+  );
+  const importedContextModule = cachedBy(
+    fn("TypeParser.importedContextModule")(function* (node) {
+      const type = typeChecker.getTypeAtLocation(node);
+      const propertySymbol = typeChecker.getPropertyOfType(type, "Tag");
+      if (!propertySymbol) {
+        return yield* typeParserIssue("Type has no 'Tag' property", type, node);
+      }
+      if (!ts.isExpression(node)) {
+        return yield* typeParserIssue("Node is not an expression", type, node);
+      }
+      return node;
+    }),
+    "TypeParser.importedContextModule",
+    (node) => node
+  );
   const importedEffectModule = cachedBy(
     fn("TypeParser.importedEffectModule")(function* (node) {
       const type = typeChecker.getTypeAtLocation(node);
@@ -2407,15 +2480,11 @@ function make2(ts, typeChecker) {
           if (!explicitReturn && !(successType.flags & ts.TypeFlags.VoidLike)) {
             replacementNode = pipe(
               gen(function* () {
-                const effectIdentifier = pipe(
-                  yield* option(
-                    findImportedModuleIdentifierByPackageAndNameOrBarrel(node.getSourceFile(), "effect", "Effect")
-                  ),
-                  match({
-                    onNone: () => "Effect",
-                    onSome: (_) => _.text
-                  })
-                );
+                const effectIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+                  node.getSourceFile(),
+                  "effect",
+                  "Effect"
+                ) || "Effect";
                 return ts.factory.createCallExpression(
                   ts.factory.createPropertyAccessExpression(
                     ts.factory.createIdentifier(effectIdentifier),
@@ -2583,6 +2652,284 @@ function make2(ts, typeChecker) {
     "TypeParser.promiseLike",
     (type) => type
   );
+  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 (ts.isExpressionWithTypeArguments(typeX)) {
+            const expression = typeX.expression;
+            if (ts.isCallExpression(expression)) {
+              const schemaCall = expression.expression;
+              if (ts.isCallExpression(schemaCall) && schemaCall.typeArguments && schemaCall.typeArguments.length > 0) {
+                const selfTypeNode = schemaCall.typeArguments[0];
+                const schemaIdentifier = schemaCall.expression;
+                if (ts.isPropertyAccessExpression(schemaIdentifier) && ts.isIdentifier(schemaIdentifier.name) && schemaIdentifier.name.text === "Class") {
+                  const parsedSchemaModule = yield* pipe(
+                    importedSchemaModule(schemaIdentifier.expression),
+                    option
+                  );
+                  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 (ts.isExpressionWithTypeArguments(typeX)) {
+            const expression = typeX.expression;
+            if (ts.isCallExpression(expression)) {
+              const tagCall = expression.expression;
+              if (ts.isCallExpression(tagCall)) {
+                const schemaCall = tagCall.expression;
+                if (ts.isCallExpression(schemaCall) && schemaCall.typeArguments && schemaCall.typeArguments.length > 0) {
+                  const selfTypeNode = schemaCall.typeArguments[0];
+                  const schemaIdentifier = schemaCall.expression;
+                  if (ts.isPropertyAccessExpression(schemaIdentifier) && ts.isIdentifier(schemaIdentifier.name) && schemaIdentifier.name.text === "TaggedClass") {
+                    const parsedSchemaModule = yield* pipe(
+                      importedSchemaModule(schemaIdentifier.expression),
+                      option
+                    );
+                    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 (ts.isExpressionWithTypeArguments(typeX)) {
+            const expression = typeX.expression;
+            if (ts.isCallExpression(expression)) {
+              const tagCall = expression.expression;
+              if (ts.isCallExpression(tagCall)) {
+                const schemaCall = tagCall.expression;
+                if (ts.isCallExpression(schemaCall) && schemaCall.typeArguments && schemaCall.typeArguments.length > 0) {
+                  const selfTypeNode = schemaCall.typeArguments[0];
+                  const schemaIdentifier = schemaCall.expression;
+                  if (ts.isPropertyAccessExpression(schemaIdentifier) && ts.isIdentifier(schemaIdentifier.name) && schemaIdentifier.name.text === "TaggedError") {
+                    const parsedSchemaModule = yield* pipe(
+                      importedSchemaModule(schemaIdentifier.expression),
+                      option
+                    );
+                    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 (ts.isExpressionWithTypeArguments(typeX)) {
+            const expression = typeX.expression;
+            if (ts.isCallExpression(expression)) {
+              const tagCall = expression.expression;
+              if (ts.isCallExpression(tagCall)) {
+                const schemaCall = tagCall.expression;
+                if (ts.isCallExpression(schemaCall) && schemaCall.typeArguments && schemaCall.typeArguments.length > 0) {
+                  const selfTypeNode = schemaCall.typeArguments[0];
+                  const schemaIdentifier = schemaCall.expression;
+                  if (ts.isPropertyAccessExpression(schemaIdentifier) && ts.isIdentifier(schemaIdentifier.name) && schemaIdentifier.name.text === "TaggedRequest") {
+                    const parsedSchemaModule = yield* pipe(
+                      importedSchemaModule(schemaIdentifier.expression),
+                      option
+                    );
+                    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 type = 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 (ts.isExpressionWithTypeArguments(typeX)) {
+            const wholeCall = typeX.expression;
+            if (ts.isCallExpression(wholeCall)) {
+              const contextTagCall = wholeCall.expression;
+              if (ts.isCallExpression(contextTagCall) && wholeCall.typeArguments && wholeCall.typeArguments.length > 0) {
+                const contextTagIdentifier = contextTagCall.expression;
+                const selfTypeNode = wholeCall.typeArguments[0];
+                if (ts.isPropertyAccessExpression(contextTagIdentifier) && ts.isIdentifier(contextTagIdentifier.name) && contextTagIdentifier.name.text === "Tag") {
+                  const parsedContextModule = yield* pipe(
+                    importedContextModule(contextTagIdentifier.expression),
+                    option
+                  );
+                  if (isSome2(parsedContextModule)) {
+                    const tagType = yield* contextTag(type, 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 type = 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 (ts.isExpressionWithTypeArguments(typeX)) {
+            const wholeCall = typeX.expression;
+            if (ts.isCallExpression(wholeCall)) {
+              const effectServiceCall = wholeCall.expression;
+              if (ts.isCallExpression(effectServiceCall) && effectServiceCall.typeArguments && effectServiceCall.typeArguments.length > 0) {
+                const effectServiceIdentifier = effectServiceCall.expression;
+                const selfTypeNode = effectServiceCall.typeArguments[0];
+                if (ts.isPropertyAccessExpression(effectServiceIdentifier) && ts.isIdentifier(effectServiceIdentifier.name) && effectServiceIdentifier.name.text === "Service") {
+                  const parsedContextTag = yield* pipe(
+                    importedEffectModule(effectServiceIdentifier.expression),
+                    flatMap2(() => contextTag(type, atLocation)),
+                    option
+                  );
+                  if (isSome2(parsedContextTag)) {
+                    let accessors2 = void 0;
+                    if (wholeCall.arguments.length >= 2) {
+                      const args2 = wholeCall.arguments[1];
+                      if (ts.isObjectLiteralExpression(args2)) {
+                        for (const property of args2.properties) {
+                          if (ts.isPropertyAssignment(property) && property.name && ts.isIdentifier(property.name) && property.name.text === "accessors" && property.initializer && property.initializer.kind === ts.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,
@@ -2599,10 +2946,79 @@ function make2(ts, 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 ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      if (ts.isClassDeclaration(node) && node.name && node.heritageClauses) {
+        const result = yield* pipe(
+          typeParser.extendsEffectService(node),
+          orElse2(() => typeParser.extendsContextTag(node)),
+          orElse2(() => typeParser.extendsSchemaClass(node)),
+          orElse2(() => typeParser.extendsSchemaTaggedClass(node)),
+          orElse2(() => typeParser.extendsSchemaTaggedError(node)),
+          orElse2(() => typeParser.extendsSchemaTaggedRequest(node)),
+          orElse2(() => void_)
+        );
+        if (result) {
+          const { className, selfTypeNode } = result;
+          let actualName = "";
+          if (ts.isTypeReferenceNode(selfTypeNode)) {
+            if (ts.isIdentifier(selfTypeNode.typeName)) {
+              actualName = selfTypeNode.typeName.text;
+            } else if (ts.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: gen(function* () {
+                  const changeTracker = yield* service(ChangeTracker);
+                  const typeArgs = ts.isTypeReferenceNode(selfTypeNode) ? selfTypeNode.typeArguments : void 0;
+                  const newTypeReference = ts.factory.createTypeReferenceNode(
+                    ts.factory.createIdentifier(expectedName),
+                    typeArgs
+                  );
+                  changeTracker.replaceNode(sourceFile, selfTypeNode, newTypeReference);
+                })
+              }]
+            });
+          }
+        }
+      }
+      ts.forEachChild(node, appendNodeToVisit);
+    }
+  })
+});
+
 // src/diagnostics/duplicatePackage.ts
 var checkedPackagesCache = /* @__PURE__ */ new Map();
 var programResolvedCacheSize = /* @__PURE__ */ new Map();
@@ -2612,6 +3028,7 @@ var duplicatePackage = createDiagnostic({
   severity: "warning",
   apply: fn("duplicatePackage.apply")(function* (sourceFile, report) {
     const program = yield* service(TypeScriptProgram);
+    const tsUtils = yield* service(TypeScriptUtils);
     const options = yield* service(LanguageServicePluginOptions);
     if (sourceFile.statements.length < 1) return;
     let resolvedPackages = checkedPackagesCache.get(sourceFile.fileName) || {};
@@ -2621,7 +3038,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;
@@ -2638,7 +3055,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(options.allowedDuplicatedPackages.concat([packageName]))}.
@@ -2685,7 +3102,7 @@ var effectInVoidSuccess = createDiagnostic({
           map3(({ 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: []
               }
@@ -2734,7 +3151,7 @@ var floatingEffect = createDiagnostic({
         );
         if (isNone2(allowedFloatingEffects)) {
           report({
-            node,
+            location: node,
             messageText: `Effect must be yielded or assigned to a variable.`,
             fixes: []
           });
@@ -2777,7 +3194,7 @@ var genericEffectServices = createDiagnostic({
           typeParser.contextTag(type, node),
           map3(() => {
             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: []
             });
@@ -2799,17 +3216,16 @@ var importFromBarrel = createDiagnostic({
     const languageServicePluginOptions = yield* service(LanguageServicePluginOptions);
     if (languageServicePluginOptions.namespaceImportPackages.length === 0) return;
     const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
     const program = yield* service(TypeScriptProgram);
     const packageNamesToCheck = flatten(
-      yield* all(
-        ...languageServicePluginOptions.namespaceImportPackages.map(
-          (packageName) => resolveModulePattern(sourceFile, packageName)
-        )
+      languageServicePluginOptions.namespaceImportPackages.map(
+        (packageName) => tsUtils.resolveModulePattern(sourceFile, packageName)
       )
     );
     const isImportedFromBarrelExport = (element) => {
-      const getModuleSpecifier = makeGetModuleSpecifier(ts);
+      const getModuleSpecifier = tsUtils.makeGetModuleSpecifier();
       const resolveExternalModuleName = makeResolveExternalModuleName(typeChecker);
       if (!(getModuleSpecifier && resolveExternalModuleName)) return;
       const importDeclaration = ts.findAncestor(element, (node) => ts.isImportDeclaration(node));
@@ -2885,7 +3301,7 @@ var importFromBarrel = createDiagnostic({
         unbarrelledFileName
       } = result;
       report({
-        node,
+        location: node,
         messageText: `Importing from barrel module ${barrelModuleName} is not allowed.`,
         fixes: [
           {
@@ -2999,7 +3415,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`,
@@ -3079,7 +3495,7 @@ var missingEffectContext = createDiagnostic({
           map3(
             (missingTypes) => missingTypes.length > 0 ? report(
               {
-                node,
+                location: node,
                 messageText: `Missing '${sortTypes(missingTypes).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect context.`,
                 fixes: []
               }
@@ -3099,18 +3515,15 @@ var missingEffectError = createDiagnostic({
   severity: "error",
   apply: fn("missingEffectError.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
     const typeOrder = yield* deterministicTypeOrder;
-    const effectModuleIdentifier = yield* pipe(
-      findImportedModuleIdentifierByPackageAndNameOrBarrel(
-        sourceFile,
-        "effect",
-        "Effect"
-      ),
-      map3((_) => _.text),
-      orElse2(() => succeed("Effect"))
-    );
+    const effectModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+      sourceFile,
+      "effect",
+      "Effect"
+    ) || "Effect";
     const createDieMessage = (message) => ts.factory.createCallExpression(
       ts.factory.createPropertyAccessExpression(
         ts.factory.createIdentifier(effectModuleIdentifier),
@@ -3212,7 +3625,7 @@ var missingEffectError = createDiagnostic({
             }
             report(
               {
-                node,
+                location: node,
                 messageText: `Missing '${sortTypes(result.missingErrorTypes).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect errors.`,
                 fixes
               }
@@ -3276,7 +3689,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
                 });
@@ -3332,7 +3745,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: []
       })
@@ -3354,7 +3767,7 @@ var missingStarInYieldEffectGen = createDiagnostic({
         })
       }] : [];
       report({
-        node,
+        location: node,
         messageText: `When yielding Effects inside Effect.gen, you should use yield* instead of yield.`,
         fixes: fix
       });
@@ -3369,26 +3782,19 @@ var multipleEffectProvide = createDiagnostic({
   severity: "warning",
   apply: fn("multipleEffectProvide.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
-    const effectModuleIdentifier = yield* pipe(
-      findImportedModuleIdentifierByPackageAndNameOrBarrel(
-        sourceFile,
-        "effect",
-        "Effect"
-      ),
-      map3((_) => _.text),
-      orElse2(() => succeed("Effect"))
-    );
-    const layerModuleIdentifier = yield* pipe(
-      findImportedModuleIdentifierByPackageAndNameOrBarrel(
-        sourceFile,
-        "effect",
-        "Layer"
-      ),
-      map3((_) => _.text),
-      orElse2(() => succeed("Layer"))
-    );
+    const effectModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+      sourceFile,
+      "effect",
+      "Effect"
+    ) || "Effect";
+    const layerModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+      sourceFile,
+      "effect",
+      "Layer"
+    ) || "Layer";
     const parseEffectProvideLayer = (node) => {
       if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.name) && node.expression.name.text === "provide" && node.arguments.length > 0) {
         const layer = node.arguments[0];
@@ -3418,7 +3824,7 @@ var multipleEffectProvide = createDiagnostic({
       for (const chunk of previousLayers) {
         if (chunk.length < 2) continue;
         report({
-          node: chunk[0].node,
+          location: chunk[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",
@@ -3466,6 +3872,327 @@ var multipleEffectProvide = createDiagnostic({
   })
 });
 
+// src/refactors/writeTagClassAccessors.ts
+var generate = fn("writeTagClassAccessors.generate")(function* (sourceFile, service2, className, atLocation, involvedMembers) {
+  const ts = yield* service(TypeScriptApi);
+  const tsUtils = yield* service(TypeScriptUtils);
+  const typeChecker = yield* service(TypeCheckerApi);
+  const typeParser = yield* service(TypeParser);
+  const changeTracker = yield* service(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, type, forceAny) => {
+    const arrowBody = ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(
+        ts.factory.createIdentifier(effectIdentifier),
+        "andThen"
+      ),
+      void 0,
+      [
+        ts.factory.createIdentifier(className2.text),
+        ts.factory.createArrowFunction(
+          void 0,
+          void 0,
+          [ts.factory.createParameterDeclaration(
+            void 0,
+            void 0,
+            "_",
+            void 0,
+            forceAny ? ts.factory.createTypeReferenceNode("any") : void 0
+          )],
+          void 0,
+          void 0,
+          ts.factory.createCallExpression(
+            ts.factory.createPropertyAccessExpression(
+              ts.factory.createIdentifier("_"),
+              propertyName
+            ),
+            void 0,
+            [
+              ts.factory.createSpreadElement(ts.factory.createIdentifier("args"))
+            ]
+          )
+        )
+      ]
+    );
+    return ts.factory.createPropertyDeclaration(
+      [ts.factory.createModifier(ts.SyntaxKind.StaticKeyword)],
+      propertyName,
+      void 0,
+      type,
+      ts.factory.createArrowFunction(
+        void 0,
+        void 0,
+        [ts.factory.createParameterDeclaration(
+          void 0,
+          ts.factory.createToken(ts.SyntaxKind.DotDotDotToken),
+          "args",
+          void 0,
+          forceAny ? ts.factory.createArrayTypeNode(ts.factory.createTypeReferenceNode("any")) : void 0
+        )],
+        void 0,
+        void 0,
+        forceAny ? ts.factory.createAsExpression(arrowBody, ts.factory.createTypeReferenceNode("any")) : arrowBody
+      )
+    );
+  };
+  const generateReturnType = (type, atLocation2, className2) => pipe(
+    typeParser.effectType(type, atLocation2),
+    flatMap2((returnedEffect) => {
+      const contextType = returnedEffect.R.flags & ts.TypeFlags.Never ? ts.factory.createTypeReferenceNode(className2.text) : ts.factory.createUnionTypeNode(
+        [
+          ts.factory.createTypeReferenceNode(className2.text),
+          typeChecker.typeToTypeNode(returnedEffect.R, atLocation2, ts.NodeBuilderFlags.NoTruncation)
+        ]
+      );
+      const successType = typeChecker.typeToTypeNode(
+        returnedEffect.A,
+        atLocation2,
+        ts.NodeBuilderFlags.NoTruncation
+      );
+      if (!successType) return fail("error generating success type");
+      const failureType = typeChecker.typeToTypeNode(
+        returnedEffect.E,
+        atLocation2,
+        ts.NodeBuilderFlags.NoTruncation
+      );
+      if (!failureType) return fail("error generating failure type");
+      const typeNode = ts.factory.createTypeReferenceNode(
+        ts.factory.createQualifiedName(
+          ts.factory.createIdentifier(effectIdentifier),
+          ts.factory.createIdentifier("Effect")
+        ),
+        [successType, failureType, contextType]
+      );
+      return succeed(typeNode);
+    }),
+    orElse2(
+      () => pipe(
+        typeParser.promiseLike(type, atLocation2),
+        flatMap2(({ type: type2 }) => {
+          const successType = typeChecker.typeToTypeNode(
+            type2,
+            atLocation2,
+            ts.NodeBuilderFlags.NoTruncation
+          );
+          if (!successType) return fail("error generating success type");
+          return succeed(ts.factory.createTypeReferenceNode(
+            ts.factory.createQualifiedName(
+              ts.factory.createIdentifier(effectIdentifier),
+              ts.factory.createIdentifier("Effect")
+            ),
+            [
+              successType,
+              ts.factory.createTypeReferenceNode(
+                ts.factory.createQualifiedName(
+                  ts.factory.createIdentifier("Cause"),
+                  ts.factory.createIdentifier("UnknownException")
+                )
+              ),
+              ts.factory.createTypeReferenceNode(className2.text)
+            ]
+          ));
+        })
+      )
+    ),
+    orElse2(() => {
+      const successType = typeChecker.typeToTypeNode(type, atLocation2, ts.NodeBuilderFlags.NoTruncation);
+      if (!successType) return fail("error generating success type");
+      const typeNode = ts.factory.createTypeReferenceNode(
+        ts.factory.createQualifiedName(
+          ts.factory.createIdentifier(effectIdentifier),
+          ts.factory.createIdentifier("Effect")
+        ),
+        [
+          successType,
+          ts.factory.createTypeReferenceNode("never"),
+          ts.factory.createTypeReferenceNode(className2.text)
+        ]
+      );
+      return succeed(typeNode);
+    })
+  );
+  const proxySignature = (signature, atLocation2, className2) => gen(function* () {
+    const signatureDeclaration = typeChecker.signatureToSignatureDeclaration(
+      signature,
+      ts.SyntaxKind.FunctionType,
+      atLocation2,
+      ts.NodeBuilderFlags.NoTruncation
+    );
+    if (!signatureDeclaration) return yield* fail("error generating signature");
+    const returnType = yield* generateReturnType(signature.getReturnType(), atLocation2, className2);
+    return ts.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),
+        map3((sig) => {
+          callSignatures.push(sig);
+        }),
+        ignore
+      );
+    }
+    const allSignatures = ts.factory.createIntersectionTypeNode(callSignatures);
+    const type = tsUtils.simplifyTypeNode(allSignatures);
+    propertyDeclaration = createFunctionProperty(className, property.getName(), type, callSignatures.length > 1);
+    const oldProperty = atLocation.members.filter(ts.isPropertyDeclaration).find((p) => {
+      const symbol3 = typeChecker.getSymbolAtLocation(p.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 parse2 = fn("writeTagClassAccessors.parse")(function* (node) {
+  const ts = yield* service(TypeScriptApi);
+  const typeChecker = yield* service(TypeCheckerApi);
+  const typeParser = yield* service(TypeParser);
+  if (!ts.isClassDeclaration(node)) return yield* fail("not a class declaration");
+  const { Service, accessors: accessors2, className } = yield* pipe(
+    typeParser.extendsEffectService(node),
+    orElse2(() => fail("not a class extending Effect.Service call"))
+  );
+  if (accessors2 !== true) return yield* fail("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 ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
+    const parseNode = (node) => pipe(
+      parse2(node),
+      map3(({ Service, atLocation, className, involvedMembers }) => ({
+        kind: "refactor.rewrite.effect.writeTagClassAccessors",
+        description: "Implement Service accessors",
+        apply: pipe(
+          generate(sourceFile, Service, className, atLocation, involvedMembers),
+          provideService(TypeScriptUtils, tsUtils),
+          provideService(TypeParser, typeParser),
+          provideService(TypeCheckerApi, typeChecker),
+          provideService(TypeScriptApi, ts)
+        )
+      }))
+    );
+    const parentNodes = tsUtils.getAncestorNodesInRange(sourceFile, textRange);
+    return yield* pipe(
+      firstSuccessOf(parentNodes.map(parseNode)),
+      orElse2(() => fail(new RefactorNotApplicableError()))
+    );
+  })
+});
+
+// src/codegens/accessors.ts
+var accessors = createCodegen({
+  name: "accessors",
+  apply: fn("accessors.apply")(function* (sourceFile, textRange) {
+    const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
+    const nodeAndCommentRange = tsUtils.findNodeWithLeadingCommentAtPosition(sourceFile, textRange.pos);
+    if (!nodeAndCommentRange) return yield* fail(new CodegenNotApplicableError("no node and comment range"));
+    return yield* pipe(
+      parse2(nodeAndCommentRange.node),
+      map3(
+        (_) => ({
+          hash: _.hash,
+          description: "Generate accessors for the service",
+          apply: pipe(
+            generate(sourceFile, _.Service, _.className, _.atLocation, _.involvedMembers),
+            provideService(TypeScriptApi, ts),
+            provideService(TypeScriptUtils, tsUtils),
+            provideService(TypeCheckerApi, typeChecker),
+            provideService(TypeParser, typeParser)
+          )
+        })
+      ),
+      orElse2((cause) => fail(new CodegenNotApplicableError(cause)))
+    );
+  })
+});
+
+// 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 } of codegensWithRanges) {
+      yield* pipe(
+        getEditsForCodegen([codegen], sourceFile, range),
+        map3((applicable) => {
+          if (applicable.hash !== hash2) {
+            _report({
+              location: range,
+              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
+                }
+              ]
+            });
+          }
+        }),
+        orElse2(
+          (e) => sync(() => {
+            _report({
+              location: range,
+              messageText: `Codegen ${codegen.name} is not applicable here: ${e.cause}`,
+              fixes: []
+            });
+          })
+        ),
+        ignore
+      );
+    }
+  })
+});
+
 // src/diagnostics/returnEffectInGen.ts
 var returnEffectInGen = createDiagnostic({
   name: "returnEffectInGen",
@@ -3517,7 +4244,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.`,
@@ -3540,17 +4267,14 @@ var scopeInLayerEffect = createDiagnostic({
   severity: "warning",
   apply: fn("scopeInLayerEffect.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
-    const layerModuleIdentifier = yield* pipe(
-      findImportedModuleIdentifierByPackageAndNameOrBarrel(
-        sourceFile,
-        "effect",
-        "Layer"
-      ),
-      map3((_) => _.text),
-      orElse2(() => succeed("Layer"))
-    );
+    const layerModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+      sourceFile,
+      "effect",
+      "Layer"
+    ) || "Layer";
     function parseLayerEffectApiCall(node) {
       if (!ts.isCallExpression(node)) return;
       const expression = node.expression;
@@ -3576,7 +4300,7 @@ var scopeInLayerEffect = createDiagnostic({
         firstSuccessOf(entries.map((type2) => typeParser.scopeType(type2, node))),
         map3(
           () => 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 ? [{
@@ -3692,7 +4416,7 @@ var strictBooleanExpressions = createDiagnostic({
           if (type.flags & ts.TypeFlags.BooleanLiteral) continue;
           const typeName = typeChecker.typeToString(type);
           report({
-            node: nodeToCheck,
+            location: nodeToCheck,
             messageText: `Unexpected \`${typeName}\` type in condition, expected strictly a boolean instead.`,
             fixes: []
           });
@@ -3734,7 +4458,7 @@ var tryCatchInEffectGen = createDiagnostic({
             orElse2(() => typeParser.effectFnGen(effectGenNode)),
             map3(() => {
               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: []
               });
@@ -3769,7 +4493,7 @@ var unnecessaryEffectGen = createDiagnostic({
           typeParser.unnecessaryEffectGen(node),
           map3(
             ({ replacementNode }) => report({
-              node,
+              location: node,
               messageText: `This Effect.gen contains a single return statement.`,
               fixes: [{
                 fixName: "unnecessaryEffectGen_fix",
@@ -3813,7 +4537,7 @@ var unnecessaryPipe = createDiagnostic({
           map3(({ args: args2, subject }) => {
             if (args2.length === 0) {
               report({
-                node,
+                location: node,
                 messageText: `This pipe call contains no arguments.`,
                 fixes: [{
                   fixName: "unnecessaryPipe_fix",
@@ -3860,7 +4584,7 @@ var unnecessaryPipeChain = createDiagnostic({
           ),
           map3(({ innerCall, pipeCall }) => {
             report({
-              node,
+              location: node,
               messageText: `Chained pipe calls can be simplified to a single pipe call`,
               fixes: [{
                 fixName: "unnecessaryPipeChain_fix",
@@ -3909,8 +4633,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 ts = yield* service(TypeScriptApi);
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts.forEachChild(node, appendNodeToVisit);
+      if (ts.isClassDeclaration(node)) {
+        const parseResult = yield* pipe(
+          parse2(node),
+          orElse2(() => succeed(null))
+        );
+        if (parseResult && parseResult.involvedMembers.length > 0) {
+          const existingStaticMembers = /* @__PURE__ */ new Set();
+          node.members?.forEach((member) => {
+            if (ts.isPropertyDeclaration(member) && member.modifiers?.some((mod) => mod.kind === ts.SyntaxKind.StaticKeyword)) {
+              if (member.name && ts.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: gen(function* () {
+                  const changeTracker = yield* service(ChangeTracker);
+                  const comment = "// @effect-codegens accessors\n";
+                  changeTracker.insertText(sourceFile, node.getStart(sourceFile), comment);
+                })
+              }]
+            });
+          }
+        }
+      }
+    }
+  })
+});
+
 // src/diagnostics.ts
 var diagnostics = [
+  classSelfMismatch,
   duplicatePackage,
   missingEffectContext,
   missingEffectError,
@@ -3928,7 +4708,9 @@ var diagnostics = [
   effectInVoidSuccess,
   unnecessaryPipeChain,
   strictBooleanExpressions,
-  multipleEffectProvide
+  multipleEffectProvide,
+  outdatedEffectCodegen,
+  unsupportedServiceAccessors
 ];
 
 // src/transform.ts
@@ -3937,14 +4719,11 @@ function transform_default(program, pluginConfig, { addDiagnostic, ts: tsInstanc
     return (sourceFile) => {
       pipe(
         getSemanticDiagnosticsWithCodeFixes(diagnostics, sourceFile),
-        provideService(TypeScriptApi, tsInstance),
-        provideService(TypeScriptProgram, program),
+        nanoLayer2,
+        nanoLayer,
         provideService(TypeCheckerApi, program.getTypeChecker()),
-        provideService(TypeParser, make2(tsInstance, program.getTypeChecker())),
-        provideService(
-          TypeCheckerApiCache,
-          makeTypeCheckerApiCache()
-        ),
+        provideService(TypeScriptProgram, program),
+        provideService(TypeScriptApi, tsInstance),
         provideService(
           LanguageServicePluginOptions,
           parse(pluginConfig)