@effect/language-service 0.35.1 → 0.36.0

package/index.js

@@ -1,6 +1,6 @@
 "use strict";
 
-// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/Function.js
+// node_modules/.pnpm/effect@3.17.8/node_modules/effect/dist/esm/Function.js
 var isFunction = (input) => typeof input === "function";
 var dual = function(arity, body) {
   if (typeof arity === "function") {
@@ -96,7 +96,7 @@ function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
   }
 }
 
-// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/Equivalence.js
+// node_modules/.pnpm/effect@3.17.8/node_modules/effect/dist/esm/Equivalence.js
 var make = (isEquivalent) => (self, that) => self === that || isEquivalent(self, that);
 var array = (item) => make((self, that) => {
   if (self.length !== that.length) {
@@ -111,7 +111,7 @@ var array = (item) => make((self, that) => {
   return true;
 });
 
-// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/GlobalValue.js
+// node_modules/.pnpm/effect@3.17.8/node_modules/effect/dist/esm/GlobalValue.js
 var globalStoreId = `effect/GlobalValue`;
 var globalStore;
 var globalValue = (id, compute) => {
@@ -125,7 +125,7 @@ var globalValue = (id, compute) => {
   return globalStore.get(id);
 };
 
-// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/Predicate.js
+// node_modules/.pnpm/effect@3.17.8/node_modules/effect/dist/esm/Predicate.js
 var isString = (input) => typeof input === "string";
 var isNumber = (input) => typeof input === "number";
 var isBoolean = (input) => typeof input === "boolean";
@@ -135,7 +135,7 @@ var isObject = (input) => isRecordOrArray(input) || isFunction2(input);
 var hasProperty = /* @__PURE__ */ dual(2, (self, property) => isObject(self) && property in self);
 var isRecord = (input) => isRecordOrArray(input) && !Array.isArray(input);
 
-// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/Utils.js
+// node_modules/.pnpm/effect@3.17.8/node_modules/effect/dist/esm/Utils.js
 var GenKindTypeId = /* @__PURE__ */ Symbol.for("effect/Gen/GenKind");
 var GenKindImpl = class {
   value;
@@ -257,7 +257,7 @@ var internalCall = isNotOptimizedAway ? standard.effect_internal_function : forc
 var genConstructor = function* () {
 }.constructor;
 
-// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/Hash.js
+// node_modules/.pnpm/effect@3.17.8/node_modules/effect/dist/esm/Hash.js
 var randomHashCache = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/Hash/randomHashCache"), () => /* @__PURE__ */ new WeakMap());
 var symbol = /* @__PURE__ */ Symbol.for("effect/Hash");
 var hash = (self) => {
@@ -356,7 +356,7 @@ var cached = function() {
   return hash2;
 };
 
-// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/Equal.js
+// node_modules/.pnpm/effect@3.17.8/node_modules/effect/dist/esm/Equal.js
 var symbol2 = /* @__PURE__ */ Symbol.for("effect/Equal");
 function equals() {
   if (arguments.length === 1) {
@@ -410,7 +410,7 @@ function compareBoth(self, that) {
 var isEqual = (u) => hasProperty(u, symbol2);
 var equivalence = () => equals;
 
-// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/Inspectable.js
+// node_modules/.pnpm/effect@3.17.8/node_modules/effect/dist/esm/Inspectable.js
 var NodeInspectSymbol = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
 var toJSON = (x) => {
   try {
@@ -462,7 +462,7 @@ var redact = (u) => {
   return u;
 };
 
-// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/Pipeable.js
+// node_modules/.pnpm/effect@3.17.8/node_modules/effect/dist/esm/Pipeable.js
 var pipeArguments = (self, args2) => {
   switch (args2.length) {
     case 0:
@@ -495,14 +495,14 @@ var pipeArguments = (self, args2) => {
   }
 };
 
-// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/internal/opCodes/effect.js
+// node_modules/.pnpm/effect@3.17.8/node_modules/effect/dist/esm/internal/opCodes/effect.js
 var OP_COMMIT = "Commit";
 
-// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/internal/version.js
-var moduleVersion = "3.17.1";
+// node_modules/.pnpm/effect@3.17.8/node_modules/effect/dist/esm/internal/version.js
+var moduleVersion = "3.17.8";
 var getCurrentVersion = () => moduleVersion;
 
-// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/internal/effectable.js
+// node_modules/.pnpm/effect@3.17.8/node_modules/effect/dist/esm/internal/effectable.js
 var EffectTypeId = /* @__PURE__ */ Symbol.for("effect/Effect");
 var StreamTypeId = /* @__PURE__ */ Symbol.for("effect/Stream");
 var SinkTypeId = /* @__PURE__ */ Symbol.for("effect/Sink");
@@ -589,7 +589,7 @@ var StructuralCommitPrototype = {
   ...StructuralPrototype
 };
 
-// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/internal/option.js
+// node_modules/.pnpm/effect@3.17.8/node_modules/effect/dist/esm/internal/option.js
 var TypeId = /* @__PURE__ */ Symbol.for("effect/Option");
 var CommonProto = {
   ...EffectPrototype,
@@ -647,7 +647,7 @@ var some = (value) => {
   return a;
 };
 
-// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/internal/either.js
+// node_modules/.pnpm/effect@3.17.8/node_modules/effect/dist/esm/internal/either.js
 var TypeId2 = /* @__PURE__ */ Symbol.for("effect/Either");
 var CommonProto2 = {
   ...EffectPrototype,
@@ -709,7 +709,7 @@ var right = (right3) => {
   return a;
 };
 
-// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/Either.js
+// node_modules/.pnpm/effect@3.17.8/node_modules/effect/dist/esm/Either.js
 var right2 = right;
 var left2 = left;
 var isLeft2 = isLeft;
@@ -717,11 +717,11 @@ var isRight2 = isRight;
 var map = /* @__PURE__ */ dual(2, (self, f) => isRight2(self) ? right2(f(self.right)) : left2(self.left));
 var getOrElse = /* @__PURE__ */ dual(2, (self, onLeft) => isLeft2(self) ? onLeft(self.left) : self.right);
 
-// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/Order.js
+// node_modules/.pnpm/effect@3.17.8/node_modules/effect/dist/esm/Order.js
 var make2 = (compare) => (self, that) => self === that ? 0 : compare(self, that);
 var string2 = /* @__PURE__ */ make2((self, that) => self < that ? -1 : 1);
 
-// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/Option.js
+// node_modules/.pnpm/effect@3.17.8/node_modules/effect/dist/esm/Option.js
 var none2 = () => none;
 var some2 = some;
 var isNone2 = isNone;
@@ -1036,10 +1036,10 @@ var TypeScriptApi = Tag("TypeScriptApi");
 var TypeScriptProgram = Tag("TypeScriptProgram");
 var ChangeTracker = Tag("ChangeTracker");
 
-// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/internal/array.js
+// node_modules/.pnpm/effect@3.17.8/node_modules/effect/dist/esm/internal/array.js
 var isNonEmptyArray = (self) => self.length > 0;
 
-// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/Array.js
+// node_modules/.pnpm/effect@3.17.8/node_modules/effect/dist/esm/Array.js
 var fromIterable = (collection) => Array.isArray(collection) ? collection : Array.from(collection);
 var append = /* @__PURE__ */ dual(2, (self, last) => [...self, last]);
 var appendAll = /* @__PURE__ */ dual(2, (self, that) => fromIterable(self).concat(fromIterable(that)));
@@ -1203,7 +1203,7 @@ function makeTypeScriptUtils(ts) {
     const sourceText = sourceFile.text;
     let result;
     function find(node) {
-      const leading = ts.getLeadingCommentRanges(sourceText, node.getFullStart());
+      const leading = ts.getLeadingCommentRanges(sourceText, node.pos);
       if (leading) {
         for (const commentRange of leading) {
           if (commentRange.pos <= position && position < commentRange.end) {
@@ -1212,8 +1212,8 @@ function makeTypeScriptUtils(ts) {
           }
         }
       }
-      if (node.getFullStart() <= position && position < node.getEnd()) {
-        node.forEachChild(find);
+      if (node.pos <= position && position < node.end) {
+        ts.forEachChild(node, find);
       }
     }
     find(sourceFile);
@@ -1232,7 +1232,7 @@ function makeTypeScriptUtils(ts) {
   }
   function findNodeAtPosition(sourceFile, position) {
     function find(node) {
-      if (position >= node.getStart() && position < node.getEnd()) {
+      if (position >= ts.getTokenPosOfNode(node, sourceFile) && position < node.end) {
         return ts.forEachChild(node, find) || node;
       }
       return void 0;
@@ -1259,7 +1259,6 @@ function makeTypeScriptUtils(ts) {
       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;
   }
@@ -1464,23 +1463,26 @@ function makeTypeScriptUtils(ts) {
     let replacementSpan = ts.createTextSpan(position, 0);
     let outerNode = precedingToken;
     if (ts.isIdentifier(precedingToken) && precedingToken.parent && ts.isPropertyAccessExpression(precedingToken.parent)) {
+      const spanStart = ts.getTokenPosOfNode(precedingToken.parent, sourceFile);
       replacementSpan = ts.createTextSpan(
-        precedingToken.parent.getStart(sourceFile),
-        precedingToken.end - precedingToken.parent.getStart(sourceFile)
+        spanStart,
+        precedingToken.end - spanStart
       );
       accessedObject = precedingToken.parent.expression;
       outerNode = precedingToken.parent;
     } else if (ts.isToken(precedingToken) && precedingToken.kind === ts.SyntaxKind.DotToken && ts.isPropertyAccessExpression(precedingToken.parent)) {
+      const precedingTokenSpanStart = ts.getTokenPosOfNode(precedingToken.parent, sourceFile);
       replacementSpan = ts.createTextSpan(
-        precedingToken.parent.getStart(sourceFile),
-        precedingToken.end - precedingToken.parent.getStart(sourceFile)
+        precedingTokenSpanStart,
+        precedingToken.end - precedingTokenSpanStart
       );
       accessedObject = precedingToken.parent.expression;
       outerNode = precedingToken.parent;
     } else if (ts.isIdentifier(precedingToken) && precedingToken.parent) {
+      const precedingTokenSpanStart = ts.getTokenPosOfNode(precedingToken, sourceFile);
       replacementSpan = ts.createTextSpan(
-        precedingToken.getStart(sourceFile),
-        precedingToken.end - precedingToken.getStart(sourceFile)
+        precedingTokenSpanStart,
+        precedingToken.end - precedingTokenSpanStart
       );
       accessedObject = precedingToken;
       outerNode = precedingToken;
@@ -1574,6 +1576,13 @@ function makeTypeScriptUtils(ts) {
       []
     );
   }
+  function getSourceFileOfNode(current) {
+    let node = current;
+    while (node && node.kind !== ts.SyntaxKind.SourceFile) {
+      node = node.parent;
+    }
+    return node;
+  }
   return {
     findNodeAtPositionIncludingTrivia,
     parsePackageContentNameAndVersionFromScope,
@@ -1593,7 +1602,8 @@ function makeTypeScriptUtils(ts) {
     createEffectGenCallExpressionWithBlock,
     createReturnYieldStarStatement,
     makeGetModuleSpecifier,
-    parseAccessedExpressionForCompletion
+    parseAccessedExpressionForCompletion,
+    getSourceFileOfNode
   };
 }
 
@@ -1653,6 +1663,18 @@ function createRefactor(definition) {
 function createDiagnostic(definition) {
   return definition;
 }
+function concatDiagnostics(fa, fb) {
+  const result = fa.slice(0);
+  for (const b of fb) {
+    const existing = result.find(
+      (a) => a.file === b.file && a.code === b.code && a.source === b.source && a.start === b.start && a.length === b.length && a.messageText === b.messageText
+    );
+    if (!existing) {
+      result.push(b);
+    }
+  }
+  return result;
+}
 function createCompletion(definition) {
   return definition;
 }
@@ -1753,7 +1775,7 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
                 if (foundNode) {
                   lineOverrides[ruleName] = lineOverrides[ruleName] || [];
                   lineOverrides[ruleName].unshift({
-                    pos: foundNode.node.getFullStart(),
+                    pos: foundNode.node.pos,
                     end: foundNode.node.end,
                     level: ruleLevel
                   });
@@ -1792,11 +1814,12 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
           service(ChangeTracker),
           (changeTracker) => gen(function* () {
             const disableAtNode = findParentStatementForDisableNextLine(node);
-            const { line } = ts.getLineAndCharacterOfPosition(sourceFile, disableAtNode.getStart());
+            const start = ts.getTokenPosOfNode(disableAtNode, sourceFile);
+            const { line } = ts.getLineAndCharacterOfPosition(sourceFile, start);
             changeTracker.insertCommentBeforeLine(
               sourceFile,
               line,
-              disableAtNode.getStart(),
+              start,
               ` @effect-diagnostics-next-line ${rule.name}:off`
             );
           })
@@ -1819,8 +1842,8 @@ 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);
+        const range = "kind" in entry.location ? { pos: ts.getTokenPosOfNode(entry.location, sourceFile), end: entry.location.end } : entry.location;
+        const node = "kind" in entry.location ? entry.location : tsUtils.findNodeAtPositionIncludingTrivia(sourceFile, entry.location.pos);
         applicableDiagnostics.push({
           range,
           messageText: entry.messageText,
@@ -1953,8 +1976,8 @@ var contextSelfInClasses = createCompletion({
       "effect",
       "Context"
     ) || "Context";
-    if (contextIdentifier !== accessedObject.text) return [];
-    const name = className.text;
+    if (contextIdentifier !== ts.idText(accessedObject)) return [];
+    const name = ts.idText(className);
     return [{
       name: `Tag("${name}")`,
       kind: ts.ScriptElementKind.constElement,
@@ -1977,29 +2000,6 @@ var deterministicTypeOrder = gen(function* () {
     return 0;
   });
 });
-var getMissingTypeEntriesInTargetType = fn(
-  "TypeCheckerApi.getMissingTypeEntriesInTargetType"
-)(
-  function* (realType, expectedType) {
-    if (realType === expectedType) return [];
-    const typeChecker = yield* service(TypeCheckerApi);
-    const result = [];
-    let toTest = [realType];
-    while (toTest.length > 0) {
-      const type = toTest.pop();
-      if (!type) return result;
-      if (type.isUnion()) {
-        toTest = toTest.concat(type.types);
-      } else {
-        const assignable = typeChecker.isTypeAssignableTo(type, expectedType);
-        if (!assignable) {
-          result.push(type);
-        }
-      }
-    }
-    return result;
-  }
-);
 var CannotFindAncestorConvertibleDeclarationError = class {
   constructor(node) {
     this.node = node;
@@ -2033,6 +2033,7 @@ var CannotInferReturnType = class {
 };
 var getInferredReturnType = fn("TypeCheckerApi.getInferredReturnType")(function* (declaration) {
   const typeChecker = yield* service(TypeCheckerApi);
+  const ts = yield* service(TypeScriptApi);
   if (!declaration.body) {
     return yield* fail(
       new CannotInferReturnTypeFromEmptyBody(declaration)
@@ -2040,10 +2041,13 @@ var getInferredReturnType = fn("TypeCheckerApi.getInferredReturnType")(function*
   }
   let returnType;
   if (typeChecker.isImplementationOfOverload(declaration)) {
-    const signatures = typeChecker.getTypeAtLocation(declaration).getCallSignatures();
+    const signatures = typeChecker.getSignaturesOfType(
+      typeChecker.getTypeAtLocation(declaration),
+      ts.SignatureKind.Call
+    );
     if (signatures.length > 1) {
       returnType = typeChecker.getUnionType(
-        signatures.map((s) => s.getReturnType()).filter((_) => !!_)
+        signatures.map((s) => typeChecker.getReturnTypeOfSignature(s)).filter((_) => !!_)
       );
     }
   }
@@ -2086,7 +2090,7 @@ var expectedAndRealType = cachedBy(
       } else if (ts.isCallExpression(node)) {
         const resolvedSignature = typeChecker.getResolvedSignature(node);
         if (resolvedSignature) {
-          resolvedSignature.getParameters().map((parameter, index) => {
+          resolvedSignature.parameters.map((parameter, index) => {
             const expectedType = typeChecker.getTypeOfSymbolAtLocation(parameter, node);
             const realType = typeChecker.getTypeAtLocation(node.arguments[index]);
             result.push([
@@ -2105,11 +2109,14 @@ var expectedAndRealType = cachedBy(
           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]);
+              const name = ts.isIdentifier(node) ? ts.idText(node) : ts.isStringLiteral(node) ? node.text : void 0;
+              if (name) {
+                const symbol3 = typeChecker.getPropertyOfType(type, name);
+                if (symbol3) {
+                  const expectedType = typeChecker.getTypeOfSymbolAtLocation(symbol3, node);
+                  const realType = typeChecker.getTypeAtLocation(node);
+                  result.push([node, expectedType, node, realType]);
+                }
               }
             }
           }
@@ -2165,70 +2172,124 @@ var expectedAndRealType = cachedBy(
   "TypeCheckerApi.expectedAndRealType",
   (sourceFile) => sourceFile
 );
-var unrollUnionMembers = (type) => {
-  const result = [];
-  let toTest = [type];
-  while (toTest.length > 0) {
-    const type2 = toTest.pop();
-    if (type2.isUnion()) {
-      toTest = toTest.concat(type2.types);
-    } else {
-      result.push(type2);
+function makeResolveExternalModuleName(typeChecker) {
+  if (!(hasProperty(typeChecker, "resolveExternalModuleName") && isFunction(typeChecker.resolveExternalModuleName))) {
+    return;
+  }
+  const _internal = typeChecker.resolveExternalModuleName;
+  return (moduleSpecifier) => {
+    return _internal(moduleSpecifier);
+  };
+}
+
+// src/core/TypeCheckerUtils.ts
+var TypeCheckerUtils = Tag("TypeCheckerUtils");
+var nanoLayer2 = (fa) => pipe(
+  service(TypeScriptApi),
+  flatMap(
+    (ts) => flatMap(service(TypeCheckerApi), (typeChecker) => pipe(fa, provideService(TypeCheckerUtils, makeTypeCheckerUtils(ts, typeChecker))))
+  )
+);
+function makeTypeCheckerUtils(ts, typeChecker) {
+  function isUnion(type) {
+    return !!(type.flags & ts.TypeFlags.Union);
+  }
+  function isIndexType(type) {
+    return !!(type.flags & ts.TypeFlags.Index);
+  }
+  function isThisTypeParameter(type) {
+    return !!(type.flags & ts.TypeFlags.TypeParameter && type.isThisType);
+  }
+  function getTypeParameterAtPosition(signature, pos) {
+    const type = typeChecker.getParameterType(signature, pos);
+    if (isIndexType(type) && isThisTypeParameter(type.type)) {
+      const constraint = typeChecker.getBaseConstraintOfType(type.type);
+      if (constraint) {
+        return typeChecker.getIndexType(constraint);
+      }
     }
+    return type;
   }
-  return result;
-};
-var appendToUniqueTypesMap = fn(
-  "TypeCheckerApi.appendToUniqueTypesMap"
-)(
-  function* (memory, initialType, shouldExclude) {
-    const typeChecker = yield* service(TypeCheckerApi);
-    const newIndexes = /* @__PURE__ */ new Set();
-    const knownIndexes = /* @__PURE__ */ new Set();
-    let toTest = [initialType];
+  const unrollUnionMembers = (type) => {
+    const result = [];
+    let toTest = [type];
     while (toTest.length > 0) {
-      const type = toTest.pop();
-      if (!type) break;
-      if (yield* shouldExclude(type)) {
-        continue;
+      const type2 = toTest.pop();
+      if (isUnion(type2)) {
+        toTest = toTest.concat(type2.types);
+      } else {
+        result.push(type2);
       }
-      if (type.isUnion()) {
+    }
+    return result;
+  };
+  const getMissingTypeEntriesInTargetType = function(realType, expectedType) {
+    if (realType === expectedType) return [];
+    const result = [];
+    let toTest = [realType];
+    while (toTest.length > 0) {
+      const type = toTest.pop();
+      if (!type) return result;
+      if (isUnion(type)) {
         toTest = toTest.concat(type.types);
       } else {
-        const foundMatch = [];
-        for (const [typeId, knownType] of memory.entries()) {
-          const areSame = typeChecker.isTypeAssignableTo(knownType, type) && typeChecker.isTypeAssignableTo(type, knownType);
-          if (areSame) {
-            foundMatch.push(typeId);
-            break;
-          }
+        const assignable = typeChecker.isTypeAssignableTo(type, expectedType);
+        if (!assignable) {
+          result.push(type);
         }
-        if (foundMatch.length === 0) {
-          const newId = "t" + (memory.size + 1);
-          memory.set(newId, type);
-          newIndexes.add(newId);
+      }
+    }
+    return result;
+  };
+  const appendToUniqueTypesMap = fn(
+    "TypeCheckerUtils.appendToUniqueTypesMap"
+  )(
+    function* (memory, initialType, shouldExclude) {
+      const newIndexes = /* @__PURE__ */ new Set();
+      const knownIndexes = /* @__PURE__ */ new Set();
+      let toTest = [initialType];
+      while (toTest.length > 0) {
+        const type = toTest.pop();
+        if (!type) break;
+        if (yield* shouldExclude(type)) {
+          continue;
+        }
+        if (isUnion(type)) {
+          toTest = toTest.concat(type.types);
         } else {
-          knownIndexes.add(foundMatch[0]);
+          const foundMatch = [];
+          for (const [typeId, knownType] of memory.entries()) {
+            const areSame = typeChecker.isTypeAssignableTo(knownType, type) && typeChecker.isTypeAssignableTo(type, knownType);
+            if (areSame) {
+              foundMatch.push(typeId);
+              break;
+            }
+          }
+          if (foundMatch.length === 0) {
+            const newId = "t" + (memory.size + 1);
+            memory.set(newId, type);
+            newIndexes.add(newId);
+          } else {
+            knownIndexes.add(foundMatch[0]);
+          }
         }
       }
+      return {
+        newIndexes,
+        knownIndexes,
+        allIndexes: pipe(
+          fromIterable(newIndexes),
+          appendAll(fromIterable(knownIndexes))
+        )
+      };
     }
-    return {
-      newIndexes,
-      knownIndexes,
-      allIndexes: pipe(
-        fromIterable(newIndexes),
-        appendAll(fromIterable(knownIndexes))
-      )
-    };
-  }
-);
-function makeResolveExternalModuleName(typeChecker) {
-  if (!(hasProperty(typeChecker, "resolveExternalModuleName") && isFunction(typeChecker.resolveExternalModuleName))) {
-    return;
-  }
-  const _internal = typeChecker.resolveExternalModuleName;
-  return (moduleSpecifier) => {
-    return _internal(moduleSpecifier);
+  );
+  return {
+    isUnion,
+    getTypeParameterAtPosition,
+    getMissingTypeEntriesInTargetType,
+    unrollUnionMembers,
+    appendToUniqueTypesMap
   };
 }
 
@@ -2238,11 +2299,12 @@ var durationInput = createCompletion({
   apply: fn("durationInput")(function* (sourceFile, position) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
     let isInString = false;
     const previousToken = ts.findPrecedingToken(position, sourceFile);
     if (previousToken && ts.isStringTextContainingNode(previousToken)) {
-      const start = previousToken.getStart(sourceFile);
-      const end = previousToken.getEnd();
+      const start = ts.getTokenPosOfNode(previousToken, sourceFile);
+      const end = previousToken.end;
       if (start < position && position < end) {
         isInString = true;
       }
@@ -2252,7 +2314,7 @@ var durationInput = createCompletion({
       if (isInString && ts.isExpression(previousToken)) {
         const type = typeChecker.getContextualType(previousToken);
         if (type) {
-          if (!type.isUnion()) return [];
+          if (!typeCheckerUtils.isUnion(type)) return [];
           for (const member of type.types) {
             if (member.flags & ts.TypeFlags.TemplateLiteral) {
               if (hasProperty(member, "texts") && isArray(member.texts) && member.texts.length === 2 && String(member.texts[1]).trim() === "nanos") {
@@ -2276,13 +2338,14 @@ var durationInput = createCompletion({
 
 // src/core/TypeParser.ts
 var TypeParser = Tag("@effect/language-service/TypeParser");
-var nanoLayer2 = (fa) => gen(function* () {
+var nanoLayer3 = (fa) => gen(function* () {
   const ts = yield* service(TypeScriptApi);
   const tsUtils = yield* service(TypeScriptUtils);
   const typeChecker = yield* service(TypeCheckerApi);
+  const typeCheckerUtils = yield* service(TypeCheckerUtils);
   return yield* pipe(
     fa,
-    provideService(TypeParser, make3(ts, tsUtils, typeChecker))
+    provideService(TypeParser, make3(ts, tsUtils, typeChecker, typeCheckerUtils))
   );
 });
 var TypeParserIssue = class _TypeParserIssue {
@@ -2292,27 +2355,27 @@ var TypeParserIssue = class _TypeParserIssue {
 function typeParserIssue(_message, _type, _node) {
   return TypeParserIssue.issue;
 }
-function make3(ts, tsUtils, typeChecker) {
+function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
   function covariantTypeArgument(type) {
-    const signatures = type.getCallSignatures();
+    const signatures = typeChecker.getSignaturesOfType(type, ts.SignatureKind.Call);
     if (signatures.length !== 1) {
       return typeParserIssue("Covariant type has no call signature", type);
     }
-    return succeed(signatures[0].getReturnType());
+    return succeed(typeChecker.getReturnTypeOfSignature(signatures[0]));
   }
   function contravariantTypeArgument(type) {
-    const signatures = type.getCallSignatures();
+    const signatures = typeChecker.getSignaturesOfType(type, ts.SignatureKind.Call);
     if (signatures.length !== 1) {
       return typeParserIssue("Contravariant type has no call signature", type);
     }
-    return succeed(signatures[0].getTypeParameterAtPosition(0));
+    return succeed(typeCheckerUtils.getTypeParameterAtPosition(signatures[0], 0));
   }
   function invariantTypeArgument(type) {
-    const signatures = type.getCallSignatures();
+    const signatures = typeChecker.getSignaturesOfType(type, ts.SignatureKind.Call);
     if (signatures.length !== 1) {
       return typeParserIssue("Invariant type has no call signature", type);
     }
-    return succeed(signatures[0].getReturnType());
+    return succeed(typeChecker.getReturnTypeOfSignature(signatures[0]));
   }
   const pipeableType = cachedBy(
     function(type, atLocation) {
@@ -2321,7 +2384,7 @@ function make3(ts, tsUtils, typeChecker) {
         return typeParserIssue("Type has no 'pipe' property", type, atLocation);
       }
       const pipeType = typeChecker.getTypeOfSymbolAtLocation(pipeSymbol, atLocation);
-      const signatures = pipeType.getCallSignatures();
+      const signatures = typeChecker.getSignaturesOfType(pipeType, ts.SignatureKind.Call);
       if (signatures.length === 0) {
         return typeParserIssue("'pipe' property is not callable", type, atLocation);
       }
@@ -2376,7 +2439,9 @@ function make3(ts, tsUtils, typeChecker) {
       const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
         (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration && ts.isPropertySignature(_.valueDeclaration) && ts.isComputedPropertyName(_.valueDeclaration.name)
       );
-      propertiesSymbols.sort((a, b) => b.name.indexOf("EffectTypeId") - a.name.indexOf("EffectTypeId"));
+      propertiesSymbols.sort(
+        (a, b) => ts.symbolName(b).indexOf("EffectTypeId") - ts.symbolName(a).indexOf("EffectTypeId")
+      );
       for (const propertySymbol of propertiesSymbols) {
         const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
         result = pipe(result, orElse2(() => effectVarianceStruct(propertyType, atLocation)));
@@ -2388,7 +2453,7 @@ function make3(ts, tsUtils, typeChecker) {
   );
   const strictEffectType = cachedBy(
     fn("TypeParser.strictEffectType")(function* (type, atLocation) {
-      if (!(type.symbol && type.symbol.name === "Effect" && !type.aliasSymbol)) {
+      if (!(type.symbol && ts.symbolName(type.symbol) === "Effect" && !type.aliasSymbol)) {
         return yield* typeParserIssue("Type name should be Effect with no alias symbol", type, atLocation);
       }
       return yield* effectType(type, atLocation);
@@ -2402,7 +2467,9 @@ function make3(ts, tsUtils, typeChecker) {
       const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
         (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration && ts.isPropertySignature(_.valueDeclaration) && ts.isComputedPropertyName(_.valueDeclaration.name)
       );
-      propertiesSymbols.sort((a, b) => b.name.indexOf("LayerTypeId") - a.name.indexOf("LayerTypeId"));
+      propertiesSymbols.sort(
+        (a, b) => ts.symbolName(b).indexOf("LayerTypeId") - ts.symbolName(a).indexOf("LayerTypeId")
+      );
       for (const propertySymbol of propertiesSymbols) {
         const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
         const varianceArgs = yield* option(layerVarianceStruct(
@@ -2712,7 +2779,7 @@ function make3(ts, tsUtils, typeChecker) {
       const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
         (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration && ts.isPropertySignature(_.valueDeclaration) && ts.isComputedPropertyName(_.valueDeclaration.name)
       );
-      propertiesSymbols.sort((a, b) => b.name.indexOf("TypeId") - a.name.indexOf("TypeId"));
+      propertiesSymbols.sort((a, b) => ts.symbolName(b).indexOf("TypeId") - ts.symbolName(a).indexOf("TypeId"));
       for (const propertySymbol of propertiesSymbols) {
         const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
         const varianceArgs = yield* option(effectSchemaVarianceStruct(
@@ -2741,7 +2808,7 @@ function make3(ts, tsUtils, typeChecker) {
       const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
         (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration && ts.isPropertySignature(_.valueDeclaration) && ts.isComputedPropertyName(_.valueDeclaration.name)
       );
-      propertiesSymbols.sort((a, b) => b.name.indexOf("TypeId") - a.name.indexOf("TypeId"));
+      propertiesSymbols.sort((a, b) => ts.symbolName(b).indexOf("TypeId") - ts.symbolName(a).indexOf("TypeId"));
       for (const propertySymbol of propertiesSymbols) {
         const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
         const varianceArgs = yield* option(contextTagVarianceStruct(
@@ -2759,7 +2826,7 @@ function make3(ts, tsUtils, typeChecker) {
   );
   const pipeCall = cachedBy(
     function(node) {
-      if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.name) && node.expression.name.text === "pipe") {
+      if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.name) && ts.idText(node.expression.name) === "pipe") {
         return succeed({
           node,
           subject: node.expression.expression,
@@ -2782,11 +2849,13 @@ function make3(ts, tsUtils, typeChecker) {
       const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
         (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration && ts.isPropertySignature(_.valueDeclaration) && ts.isComputedPropertyName(_.valueDeclaration.name)
       );
-      propertiesSymbols.sort((a, b) => b.name.indexOf("ScopeTypeId") - a.name.indexOf("ScopeTypeId"));
+      propertiesSymbols.sort(
+        (a, b) => ts.symbolName(b).indexOf("ScopeTypeId") - ts.symbolName(a).indexOf("ScopeTypeId")
+      );
       for (const propertySymbol of propertiesSymbols) {
         const computedPropertyExpression = propertySymbol.valueDeclaration.name;
         const symbol3 = typeChecker.getSymbolAtLocation(computedPropertyExpression.expression);
-        if (symbol3 && symbol3.name === "ScopeTypeId") {
+        if (symbol3 && ts.symbolName(symbol3) === "ScopeTypeId") {
           return type;
         }
       }
@@ -2801,19 +2870,19 @@ function make3(ts, tsUtils, typeChecker) {
       if (!thenProperty) return typeParserIssue("not a promise - missing then property", type, atLocation);
       const thenType = typeChecker.getTypeOfSymbolAtLocation(thenProperty, atLocation);
       if (!thenType) return typeParserIssue("not a promise - missing then property", type, atLocation);
-      for (const callSignature of thenType.getCallSignatures()) {
+      for (const callSignature of typeChecker.getSignaturesOfType(thenType, ts.SignatureKind.Call)) {
         const parameter = callSignature.parameters[0];
         if (!parameter) continue;
-        const parameterType = callSignature.getTypeParameterAtPosition(0);
+        const parameterType = typeCheckerUtils.getTypeParameterAtPosition(callSignature, 0);
         if (!parameterType) continue;
         let callbackCallSignatures = [];
         let toTest = [parameterType];
         while (toTest.length > 0) {
           const type2 = toTest.shift();
           if (!type2) continue;
-          const callSignatures = type2.getCallSignatures();
+          const callSignatures = typeChecker.getSignaturesOfType(type2, ts.SignatureKind.Call);
           callbackCallSignatures = callbackCallSignatures.concat(callSignatures);
-          if (type2.isUnion()) {
+          if (typeCheckerUtils.isUnion(type2)) {
             toTest = toTest.concat(type2.types);
           }
         }
@@ -2822,7 +2891,7 @@ function make3(ts, tsUtils, typeChecker) {
           if (!callbackParameter) {
             continue;
           }
-          const callbackParameterType = callableType.getTypeParameterAtPosition(0);
+          const callbackParameterType = typeCheckerUtils.getTypeParameterAtPosition(callableType, 0);
           if (!callbackParameterType) {
             continue;
           }
@@ -2854,7 +2923,7 @@ function make3(ts, tsUtils, typeChecker) {
               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") {
+                if (ts.isPropertyAccessExpression(schemaIdentifier) && ts.isIdentifier(schemaIdentifier.name) && ts.idText(schemaIdentifier.name) === "Class") {
                   const parsedSchemaModule = yield* pipe(
                     importedSchemaModule(schemaIdentifier.expression),
                     option
@@ -2891,24 +2960,21 @@ function make3(ts, tsUtils, typeChecker) {
           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
-                      };
-                    }
+              const schemaTaggedClassTCall = expression.expression;
+              if (ts.isCallExpression(schemaTaggedClassTCall) && schemaTaggedClassTCall.typeArguments && schemaTaggedClassTCall.typeArguments.length > 0) {
+                const selfTypeNode = schemaTaggedClassTCall.typeArguments[0];
+                const schemaIdentifier = schemaTaggedClassTCall.expression;
+                if (ts.isPropertyAccessExpression(schemaIdentifier) && ts.isIdentifier(schemaIdentifier.name) && ts.idText(schemaIdentifier.name) === "TaggedClass") {
+                  const parsedSchemaModule = yield* pipe(
+                    importedSchemaModule(schemaIdentifier.expression),
+                    option
+                  );
+                  if (isSome2(parsedSchemaModule)) {
+                    return {
+                      className: atLocation.name,
+                      selfTypeNode,
+                      Schema: parsedSchemaModule.value
+                    };
                   }
                 }
               }
@@ -2935,24 +3001,21 @@ function make3(ts, tsUtils, typeChecker) {
           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
-                      };
-                    }
+              const schemaTaggedErrorTCall = expression.expression;
+              if (ts.isCallExpression(schemaTaggedErrorTCall) && schemaTaggedErrorTCall.typeArguments && schemaTaggedErrorTCall.typeArguments.length > 0) {
+                const selfTypeNode = schemaTaggedErrorTCall.typeArguments[0];
+                const schemaIdentifier = schemaTaggedErrorTCall.expression;
+                if (ts.isPropertyAccessExpression(schemaIdentifier) && ts.isIdentifier(schemaIdentifier.name) && ts.idText(schemaIdentifier.name) === "TaggedError") {
+                  const parsedSchemaModule = yield* pipe(
+                    importedSchemaModule(schemaIdentifier.expression),
+                    option
+                  );
+                  if (isSome2(parsedSchemaModule)) {
+                    return {
+                      className: atLocation.name,
+                      selfTypeNode,
+                      Schema: parsedSchemaModule.value
+                    };
                   }
                 }
               }
@@ -2979,24 +3042,21 @@ function make3(ts, tsUtils, typeChecker) {
           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
-                      };
-                    }
+              const schemaTaggedRequestTCall = expression.expression;
+              if (ts.isCallExpression(schemaTaggedRequestTCall) && schemaTaggedRequestTCall.typeArguments && schemaTaggedRequestTCall.typeArguments.length > 0) {
+                const selfTypeNode = schemaTaggedRequestTCall.typeArguments[0];
+                const schemaIdentifier = schemaTaggedRequestTCall.expression;
+                if (ts.isPropertyAccessExpression(schemaIdentifier) && ts.isIdentifier(schemaIdentifier.name) && ts.idText(schemaIdentifier.name) === "TaggedRequest") {
+                  const parsedSchemaModule = yield* pipe(
+                    importedSchemaModule(schemaIdentifier.expression),
+                    option
+                  );
+                  if (isSome2(parsedSchemaModule)) {
+                    return {
+                      className: atLocation.name,
+                      selfTypeNode,
+                      Schema: parsedSchemaModule.value
+                    };
                   }
                 }
               }
@@ -3030,7 +3090,7 @@ function make3(ts, tsUtils, typeChecker) {
               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") {
+                if (ts.isPropertyAccessExpression(contextTagIdentifier) && ts.isIdentifier(contextTagIdentifier.name) && ts.idText(contextTagIdentifier.name) === "Tag") {
                   const parsedContextModule = yield* pipe(
                     importedContextModule(contextTagIdentifier.expression),
                     option
@@ -3077,7 +3137,7 @@ function make3(ts, tsUtils, typeChecker) {
               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") {
+                if (ts.isPropertyAccessExpression(effectServiceIdentifier) && ts.isIdentifier(effectServiceIdentifier.name) && ts.idText(effectServiceIdentifier.name) === "Service") {
                   const parsedContextTag = yield* pipe(
                     importedEffectModule(effectServiceIdentifier.expression),
                     flatMap(() => contextTag(type, atLocation)),
@@ -3090,10 +3150,10 @@ function make3(ts, tsUtils, typeChecker) {
                       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) {
+                          if (ts.isPropertyAssignment(property) && property.name && ts.isIdentifier(property.name) && ts.idText(property.name) === "accessors" && property.initializer && property.initializer.kind === ts.SyntaxKind.TrueKeyword) {
                             accessors2 = true;
                           }
-                          if (ts.isPropertyAssignment(property) && property.name && ts.isIdentifier(property.name) && property.name.text === "dependencies" && property.initializer && ts.isArrayLiteralExpression(property.initializer)) {
+                          if (ts.isPropertyAssignment(property) && property.name && ts.isIdentifier(property.name) && ts.idText(property.name) === "dependencies" && property.initializer && ts.isArrayLiteralExpression(property.initializer)) {
                             dependencies = property.initializer.elements;
                           }
                         }
@@ -3153,7 +3213,7 @@ var generate = fn("writeTagClassAccessors.generate")(function* (sourceFile, serv
   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 insertLocation = atLocation.members.length > 0 ? atLocation.members[0].pos : atLocation.end - 1;
   const effectIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
     sourceFile,
     "effect",
@@ -3298,7 +3358,11 @@ var generate = fn("writeTagClassAccessors.generate")(function* (sourceFile, serv
       ts.NodeBuilderFlags.NoTruncation
     );
     if (!signatureDeclaration) return yield* fail("error generating signature");
-    const returnType = yield* generateReturnType(signature.getReturnType(), atLocation2, className2);
+    const returnType = yield* generateReturnType(
+      typeChecker.getReturnTypeOfSignature(signature),
+      atLocation2,
+      className2
+    );
     return ts.factory.createFunctionTypeNode(
       signatureDeclaration.typeParameters,
       signatureDeclaration.parameters,
@@ -3308,7 +3372,7 @@ var generate = fn("writeTagClassAccessors.generate")(function* (sourceFile, serv
   for (const { property, propertyType } of involvedMembers) {
     const callSignatures = [];
     let propertyDeclaration = void 0;
-    for (const signature of propertyType.getCallSignatures()) {
+    for (const signature of typeChecker.getSignaturesOfType(propertyType, ts.SignatureKind.Call)) {
       yield* pipe(
         proxySignature(signature, atLocation, className),
         map3((sig) => {
@@ -3319,17 +3383,18 @@ var generate = fn("writeTagClassAccessors.generate")(function* (sourceFile, serv
     }
     const allSignatures = ts.factory.createIntersectionTypeNode(callSignatures);
     const type = tsUtils.simplifyTypeNode(allSignatures);
-    propertyDeclaration = createFunctionProperty(className, property.getName(), type, callSignatures.length > 1);
+    propertyDeclaration = createFunctionProperty(className, ts.symbolName(property), type, callSignatures.length > 1);
     const oldProperty = atLocation.members.filter(ts.isPropertyDeclaration).find((p) => {
       const symbol3 = typeChecker.getSymbolAtLocation(p.name);
-      return symbol3?.getName() === property.getName();
+      return symbol3 && ts.symbolName(symbol3) === ts.symbolName(property);
     });
     if (oldProperty) {
+      const start = ts.getTokenPosOfNode(oldProperty, sourceFile);
       changeTracker.deleteRange(sourceFile, {
-        pos: oldProperty.getStart(sourceFile),
-        end: oldProperty.getEnd()
+        pos: start,
+        end: oldProperty.end
       });
-      changeTracker.insertNodeAt(sourceFile, oldProperty.getStart(sourceFile), propertyDeclaration);
+      changeTracker.insertNodeAt(sourceFile, start, propertyDeclaration);
     } else {
       changeTracker.insertNodeAt(sourceFile, insertLocation, propertyDeclaration, { suffix: "\n" });
     }
@@ -3348,14 +3413,14 @@ var parse2 = fn("writeTagClassAccessors.parse")(function* (node) {
   const involvedMembers = [];
   for (const property of typeChecker.getPropertiesOfType(Service)) {
     const propertyType = typeChecker.getTypeOfSymbolAtLocation(property, node);
-    const callSignatures = propertyType.getCallSignatures();
+    const callSignatures = typeChecker.getSignaturesOfType(propertyType, ts.SignatureKind.Call);
     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);
+    return ts.symbolName(property) + ": " + typeChecker.typeToString(propertyType);
   }).concat([className.text]).join("\n");
   return { Service, className, atLocation: node, hash: cyrb53(hash2), involvedMembers };
 });
@@ -3481,10 +3546,10 @@ var effectDataClasses = createCompletion({
   })
 });
 
-// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/internal/encoding/common.js
+// node_modules/.pnpm/effect@3.17.8/node_modules/effect/dist/esm/internal/encoding/common.js
 var encoder = /* @__PURE__ */ new TextEncoder();
 
-// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/internal/encoding/base64.js
+// node_modules/.pnpm/effect@3.17.8/node_modules/effect/dist/esm/internal/encoding/base64.js
 var encode = (bytes) => {
   const length = bytes.length;
   let result = "";
@@ -3510,10 +3575,10 @@ var encode = (bytes) => {
 };
 var base64abc = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "+", "/"];
 
-// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/internal/encoding/base64Url.js
+// node_modules/.pnpm/effect@3.17.8/node_modules/effect/dist/esm/internal/encoding/base64Url.js
 var encode2 = (data) => encode(data).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
 
-// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/Encoding.js
+// node_modules/.pnpm/effect@3.17.8/node_modules/effect/dist/esm/Encoding.js
 var encodeBase64Url = (input) => typeof input === "string" ? encode2(encoder.encode(input)) : encode2(input);
 
 // src/diagnostics/classSelfMismatch.ts
@@ -3547,12 +3612,12 @@ var classSelfMismatch = createDiagnostic({
           let actualName = "";
           if (ts.isTypeReferenceNode(selfTypeNode)) {
             if (ts.isIdentifier(selfTypeNode.typeName)) {
-              actualName = selfTypeNode.typeName.text;
+              actualName = ts.idText(selfTypeNode.typeName);
             } else if (ts.isQualifiedName(selfTypeNode.typeName)) {
-              actualName = selfTypeNode.typeName.right.text;
+              actualName = ts.idText(selfTypeNode.typeName.right);
             }
           }
-          const expectedName = className.text;
+          const expectedName = ts.idText(className);
           if (actualName !== expectedName) {
             report({
               location: selfTypeNode,
@@ -3637,11 +3702,12 @@ var effectInVoidSuccess = createDiagnostic({
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const checkForEffectInVoid = fn("effectInVoidSuccess.checkForEffectInVoid")(function* (node, expectedType, valueNode, realType) {
       const expectedEffect = yield* typeParser.effectType(expectedType, node);
       const realEffect = yield* typeParser.effectType(realType, valueNode);
       if (expectedEffect.A.flags & ts.TypeFlags.Void) {
-        const voidValueTypes = unrollUnionMembers(realEffect.A);
+        const voidValueTypes = typeCheckerUtils.unrollUnionMembers(realEffect.A);
         const voidedEffect = yield* firstSuccessOf(
           voidValueTypes.map((_) => map3(typeParser.strictEffectType(_, node), () => _))
         );
@@ -3803,12 +3869,14 @@ var importFromBarrel = createDiagnostic({
       const moduleSymbol = resolveExternalModuleName(importDeclaration.moduleSpecifier);
       if (!moduleSymbol) return;
       if (!moduleSymbol.exports) return;
-      const sourceFile2 = importDeclaration.getSourceFile();
+      const sourceFile2 = tsUtils.getSourceFileOfNode(importDeclaration);
+      if (!sourceFile2) return;
       const nodeForSymbol = element.propertyName || element.name;
       const aliasSymbol = element.name || element.propertyName;
-      const aliasedName = aliasSymbol.text;
+      const aliasedName = ts.idText(aliasSymbol);
       if (!ts.isIdentifier(nodeForSymbol)) return;
-      const importedName = nodeForSymbol.text;
+      const importedName = ts.idText(nodeForSymbol);
+      if (!importedName) return;
       const reexportedSymbol = moduleSymbol.exports.get(ts.escapeLeadingUnderscores(importedName));
       if (!reexportedSymbol) return;
       if (!(reexportedSymbol.declarations && reexportedSymbol.declarations.length === 1)) return;
@@ -3820,7 +3888,8 @@ var importFromBarrel = createDiagnostic({
       const originalModuleSymbol = resolveExternalModuleName(exportDeclaration.moduleSpecifier);
       if (!originalModuleSymbol) return;
       if (!originalModuleSymbol.valueDeclaration) return;
-      const originalSourceFile = originalModuleSymbol.valueDeclaration.getSourceFile();
+      const originalSourceFile = tsUtils.getSourceFileOfNode(originalModuleSymbol.valueDeclaration);
+      if (!originalSourceFile) return;
       const unbarrelledFileName = getModuleSpecifier(
         program.getCompilerOptions(),
         sourceFile2,
@@ -3913,6 +3982,7 @@ var leakingRequirements = createDiagnostic({
   apply: fn("leakingRequirements.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const typeParser = yield* service(TypeParser);
     const typeOrder = yield* deterministicTypeOrder;
     const parseLeakedRequirements = cachedBy(
@@ -3930,10 +4000,16 @@ var leakingRequirements = createDiagnostic({
               typeParser.effectType(servicePropertyType, atLocation),
               map3((_) => effectContextType = _.R),
               orElse2(() => {
-                const servicePropertyCallSignatures = servicePropertyType.getCallSignatures();
+                const servicePropertyCallSignatures = typeChecker.getSignaturesOfType(
+                  servicePropertyType,
+                  ts.SignatureKind.Call
+                );
                 if (servicePropertyCallSignatures.length === 1) {
                   return pipe(
-                    typeParser.effectType(servicePropertyCallSignatures[0].getReturnType(), atLocation),
+                    typeParser.effectType(
+                      typeChecker.getReturnTypeOfSignature(servicePropertyCallSignatures[0]),
+                      atLocation
+                    ),
                     map3((_) => {
                       effectContextType = _.R;
                     })
@@ -3945,7 +4021,7 @@ var leakingRequirements = createDiagnostic({
             );
             if (effectContextType) {
               effectMembers++;
-              const { allIndexes } = yield* appendToUniqueTypesMap(
+              const { allIndexes } = yield* typeCheckerUtils.appendToUniqueTypesMap(
                 memory,
                 effectContextType,
                 (type) => {
@@ -3993,7 +4069,7 @@ More info at https://effect.website/docs/requirements-management/layers/#avoidin
     while (nodeToVisit.length > 0) {
       const node = nodeToVisit.shift();
       const typesToCheck = [];
-      if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.name) && node.expression.name.text === "GenericTag") {
+      if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.name) && ts.idText(node.expression.name) === "GenericTag") {
         typesToCheck.push([typeChecker.getTypeAtLocation(node), node]);
       } else if (ts.isClassDeclaration(node) && node.name && node.heritageClauses) {
         const classSym = typeChecker.getSymbolAtLocation(node.name);
@@ -4031,13 +4107,14 @@ var missingEffectContext = createDiagnostic({
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
     const typeOrder = yield* deterministicTypeOrder;
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const checkForMissingContextTypes = (node, expectedType, valueNode, realType) => pipe(
       all(
         typeParser.effectType(expectedType, node),
         typeParser.effectType(realType, valueNode)
       ),
-      flatMap(
-        ([expectedEffect, realEffect]) => getMissingTypeEntriesInTargetType(
+      map3(
+        ([expectedEffect, realEffect]) => typeCheckerUtils.getMissingTypeEntriesInTargetType(
           realEffect.R,
           expectedEffect.R
         )
@@ -4079,6 +4156,7 @@ var missingEffectError = createDiagnostic({
     const ts = yield* service(TypeScriptApi);
     const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const typeParser = yield* service(TypeParser);
     const typeOrder = yield* deterministicTypeOrder;
     const effectModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
@@ -4099,13 +4177,13 @@ var missingEffectError = createDiagnostic({
         typeParser.effectType(expectedType, node),
         typeParser.effectType(realType, valueNode)
       ),
-      flatMap(
+      map3(
         ([expectedEffect, realEffect]) => pipe(
-          getMissingTypeEntriesInTargetType(
+          typeCheckerUtils.getMissingTypeEntriesInTargetType(
             realEffect.E,
             expectedEffect.E
           ),
-          map3((missingErrorTypes) => ({ missingErrorTypes, expectedErrorType: expectedEffect.E }))
+          (missingErrorTypes) => ({ missingErrorTypes, expectedErrorType: expectedEffect.E })
         )
       )
     );
@@ -4129,14 +4207,18 @@ var missingEffectError = createDiagnostic({
                 description: "Catch all errors with Effect.catchAll",
                 apply: gen(function* () {
                   const changeTracker = yield* service(ChangeTracker);
-                  changeTracker.insertText(sourceFile, valueNode.getStart(), effectModuleIdentifier + ".catchAll(");
-                  changeTracker.insertText(sourceFile, valueNode.getEnd(), ", () => ");
+                  changeTracker.insertText(
+                    sourceFile,
+                    ts.getTokenPosOfNode(valueNode, sourceFile),
+                    effectModuleIdentifier + ".catchAll("
+                  );
+                  changeTracker.insertText(sourceFile, valueNode.end, ", () => ");
                   changeTracker.insertNodeAt(
                     sourceFile,
-                    valueNode.getEnd(),
+                    valueNode.end,
                     createDieMessage("TODO: catchAll not implemented")
                   );
-                  changeTracker.insertText(sourceFile, valueNode.getEnd(), ")");
+                  changeTracker.insertText(sourceFile, valueNode.end, ")");
                 })
               });
             }
@@ -4173,22 +4255,27 @@ var missingEffectError = createDiagnostic({
                   description: "Catch unexpected errors with Effect.catchTag",
                   apply: gen(function* () {
                     const changeTracker = yield* service(ChangeTracker);
-                    changeTracker.insertText(sourceFile, valueNode.getStart(), effectModuleIdentifier + ".catchTags(");
-                    changeTracker.insertText(sourceFile, valueNode.getEnd(), ", ");
+                    changeTracker.insertText(
+                      sourceFile,
+                      ts.getTokenPosOfNode(valueNode, sourceFile),
+                      effectModuleIdentifier + ".catchTags("
+                    );
+                    changeTracker.insertText(sourceFile, valueNode.end, ", ");
                     changeTracker.insertNodeAt(
                       sourceFile,
-                      valueNode.getEnd(),
+                      valueNode.end,
                       ts.factory.createObjectLiteralExpression(propertyAssignments)
                     );
-                    changeTracker.insertText(sourceFile, valueNode.getEnd(), ")");
+                    changeTracker.insertText(sourceFile, valueNode.end, ")");
                   })
                 });
               }
             }
+            const typeNames = sortTypes(result.missingErrorTypes).map((_) => typeChecker.typeToString(_));
             report(
               {
                 location: node,
-                messageText: `Missing '${sortTypes(result.missingErrorTypes).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect errors.`,
+                messageText: `Missing '${typeNames.join(" | ")}' in the expected Effect errors.`,
                 fixes
               }
             );
@@ -4208,6 +4295,7 @@ var missingEffectServiceDependency = createDiagnostic({
   apply: fn("missingEffectServiceDependency.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const typeParser = yield* service(TypeParser);
     const nodeToVisit = [];
     const appendNodeToVisit = (node) => {
@@ -4238,7 +4326,7 @@ var missingEffectServiceDependency = createDiagnostic({
               if (layerResult) {
                 const servicesMemory = /* @__PURE__ */ new Map();
                 const excludeNever = (type) => succeed((type.flags & ts.TypeFlags.Never) !== 0);
-                const { allIndexes: requiredIndexes } = yield* appendToUniqueTypesMap(
+                const { allIndexes: requiredIndexes } = yield* typeCheckerUtils.appendToUniqueTypesMap(
                   servicesMemory,
                   layerResult.RIn,
                   excludeNever
@@ -4249,8 +4337,8 @@ var missingEffectServiceDependency = createDiagnostic({
                 let types = [];
                 if (dependenciesProperty) {
                   const dependenciesTypes = typeChecker.getTypeOfSymbolAtLocation(dependenciesProperty, options);
-                  const numberIndexType = dependenciesTypes.getNumberIndexType();
-                  types = numberIndexType ? unrollUnionMembers(numberIndexType) : [];
+                  const numberIndexType = typeChecker.getIndexTypeOfType(dependenciesTypes, ts.IndexKind.Number);
+                  types = numberIndexType ? typeCheckerUtils.unrollUnionMembers(numberIndexType) : [];
                 }
                 for (const depType of types) {
                   const depLayerResult = yield* pipe(
@@ -4258,7 +4346,7 @@ var missingEffectServiceDependency = createDiagnostic({
                     orElse2(() => void_)
                   );
                   if (depLayerResult) {
-                    const { allIndexes } = yield* appendToUniqueTypesMap(
+                    const { allIndexes } = yield* typeCheckerUtils.appendToUniqueTypesMap(
                       servicesMemory,
                       depLayerResult.ROut,
                       excludeNever
@@ -4447,7 +4535,7 @@ var multipleEffectProvide = createDiagnostic({
       "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) {
+      if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.name) && ts.idText(node.expression.name) === "provide" && node.arguments.length > 0) {
         const layer = node.arguments[0];
         const type = typeChecker.getTypeAtLocation(layer);
         return pipe(
@@ -4483,8 +4571,8 @@ var multipleEffectProvide = createDiagnostic({
             apply: gen(function* () {
               const changeTracker = yield* service(ChangeTracker);
               changeTracker.deleteRange(sourceFile, {
-                pos: chunk[0].node.getStart(sourceFile),
-                end: chunk[chunk.length - 1].node.getEnd()
+                pos: ts.getTokenPosOfNode(chunk[0].node, sourceFile),
+                end: chunk[chunk.length - 1].node.end
               });
               const newNode = ts.factory.createCallExpression(
                 ts.factory.createPropertyAccessExpression(
@@ -4501,7 +4589,7 @@ var multipleEffectProvide = createDiagnostic({
                   chunk.map((c) => c.layer)
                 )]
               );
-              changeTracker.insertNodeAt(sourceFile, chunk[0].node.getStart(sourceFile), newNode);
+              changeTracker.insertNodeAt(sourceFile, ts.getTokenPosOfNode(chunk[0].node, sourceFile), newNode);
             })
           }]
         });
@@ -4707,6 +4795,7 @@ var scopeInLayerEffect = createDiagnostic({
     const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const layerModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
       sourceFile,
       "effect",
@@ -4717,22 +4806,13 @@ var scopeInLayerEffect = createDiagnostic({
       const expression = node.expression;
       if (!ts.isPropertyAccessExpression(expression)) return;
       const calledModule = expression.expression;
-      if (!(ts.isIdentifier(calledModule) && calledModule.text === layerModuleIdentifier)) return;
+      if (!(ts.isIdentifier(calledModule) && ts.idText(calledModule) === layerModuleIdentifier)) return;
       const methodIdentifier = expression.name;
-      if (!(ts.isIdentifier(methodIdentifier) && methodIdentifier.text.toLowerCase().startsWith("effect"))) return;
+      if (!(ts.isIdentifier(methodIdentifier) && ts.idText(methodIdentifier).toLowerCase().startsWith("effect"))) return;
       return { methodIdentifier };
     }
     const reportIfLayerRequireScope = (type, node, methodIdentifier) => {
-      let toCheck = [type];
-      const entries = [];
-      while (toCheck.length > 0) {
-        const type2 = toCheck.pop();
-        if (type2.isUnion()) {
-          toCheck = toCheck.concat(type2.types);
-        } else {
-          entries.push(type2);
-        }
-      }
+      const entries = typeCheckerUtils.unrollUnionMembers(type);
       return pipe(
         firstSuccessOf(entries.map((type2) => typeParser.scopeType(type2, node))),
         map3(
@@ -4804,6 +4884,7 @@ var strictBooleanExpressions = createDiagnostic({
   apply: fn("strictBooleanExpressions.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const conditionChecks = /* @__PURE__ */ new WeakMap();
     const nodeToVisit = [];
     const appendNodeToVisit = (node) => {
@@ -4844,7 +4925,7 @@ var strictBooleanExpressions = createDiagnostic({
         let typesToCheck = [constrainedType || nodeType];
         while (typesToCheck.length > 0) {
           const type = typesToCheck.pop();
-          if (type.isUnion()) {
+          if (typeCheckerUtils.isUnion(type)) {
             typesToCheck = typesToCheck.concat(type.types);
             continue;
           }
@@ -5096,15 +5177,15 @@ var unsupportedServiceAccessors = createDiagnostic({
           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);
+                existingStaticMembers.add(ts.idText(member.name));
               }
             }
           });
           const missingMembers = parseResult.involvedMembers.filter(
-            ({ property }) => !existingStaticMembers.has(property.getName())
+            ({ property }) => !existingStaticMembers.has(ts.symbolName(property))
           );
           if (missingMembers.length > 0) {
-            const memberNames = missingMembers.map(({ property }) => `'${property.getName()}'`).join(", ");
+            const memberNames = missingMembers.map(({ property }) => `'${ts.symbolName(property)}'`).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.`,
@@ -5114,7 +5195,7 @@ var unsupportedServiceAccessors = createDiagnostic({
                 apply: gen(function* () {
                   const changeTracker = yield* service(ChangeTracker);
                   const comment = "// @effect-codegens accessors\n";
-                  changeTracker.insertText(sourceFile, node.getStart(sourceFile), comment);
+                  changeTracker.insertText(sourceFile, ts.getTokenPosOfNode(node, sourceFile), comment);
                 })
               }]
             });
@@ -5318,7 +5399,7 @@ var genFunctionStar = createCompletion({
     const genMemberSymbol = type.getProperty("gen");
     if (!genMemberSymbol) return [];
     const genType = typeChecker.getTypeOfSymbolAtLocation(genMemberSymbol, accessedObject);
-    if (genType.getCallSignatures().length === 0) return [];
+    if (typeChecker.getSignaturesOfType(genType, ts.SignatureKind.Call).length === 0) return [];
     const span = ts.createTextSpan(
       accessedObject.end + 1,
       Math.max(0, position - accessedObject.end - 1)
@@ -5575,6 +5656,13 @@ var makeAutoImportProvider = fn("TypeScriptApi")(function* (fromSourceFile) {
                       exportName: namedExport.name
                     }
                   });
+                  mapFromBarrelToBarrel.set(reexportedFile.resolvedModule.resolvedFileName, {
+                    ...mapFromBarrelToBarrel.get(reexportedFile.resolvedModule.resolvedFileName) || {},
+                    [namedExport.name]: {
+                      fileName: reexportedFile.resolvedModule.resolvedFileName,
+                      exportName: namedExport.name
+                    }
+                  });
                 }
               }
             }
@@ -6031,7 +6119,7 @@ function effectRpcDefinition(applicableGotoDefinition, sourceFile, position) {
     for (const node of tsUtils.getAncestorNodesInRange(sourceFile, textRange)) {
       if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.name) && tsUtils.isNodeInRange(textRange)(node.name)) {
         const type = typeChecker.getTypeAtLocation(node);
-        for (const callSig of type.getCallSignatures()) {
+        for (const callSig of typeChecker.getSignaturesOfType(type, ts.SignatureKind.Call)) {
           if (callSig.parameters.length >= 2 && isSymbolFromEffectRpcClientModule(callSig.parameters[1])) {
             rpcName = node.name.text;
             callNode = node.name;
@@ -6078,7 +6166,7 @@ function effectRpcDefinition(applicableGotoDefinition, sourceFile, position) {
     if (result.length === 0) return applicableGotoDefinition;
     const effectRpcResult = result.map(([node]) => ({
       fileName: node.getSourceFile().fileName,
-      textSpan: ts.createTextSpan(node.getStart(), node.getEnd() - node.getStart()),
+      textSpan: ts.createTextSpan(node.getStart(), node.end - node.getStart()),
       kind: ts.ScriptElementKind.constElement,
       name: rpcName,
       containerKind: ts.ScriptElementKind.constElement,
@@ -6091,7 +6179,7 @@ function effectRpcDefinition(applicableGotoDefinition, sourceFile, position) {
       };
     }
     return {
-      textSpan: ts.createTextSpan(callNode.getStart(), callNode.getEnd() - callNode.getStart()),
+      textSpan: ts.createTextSpan(callNode.getStart(), callNode.end - callNode.getStart()),
       definitions: effectRpcResult
     };
   });
@@ -6127,7 +6215,7 @@ var middlewareGenLike = fn("middlewareGenLike")(function* (sourceFile, _span, pr
           parseType(possiblyGen),
           map3((_) => {
             const argsCloseParen = ts.findChildOfKind(_.generatorFunction, ts.SyntaxKind.CloseParenToken, sourceFile);
-            if (argsCloseParen && _.body && inlayHint.position >= argsCloseParen.getEnd() && inlayHint.position <= _.body.getStart(sourceFile)) {
+            if (argsCloseParen && _.body && inlayHint.position >= argsCloseParen.end && inlayHint.position <= _.body.getStart(sourceFile)) {
               shouldOmit = true;
             }
           }),
@@ -6223,9 +6311,9 @@ function effectTypeArgs(sourceFile, position, quickInfo2) {
         ),
         map3((_) => makeSymbolDisplayParts("Effect Type Parameters", _.A, _.E, _.R)),
         orElse2(() => {
-          const callSignatues = type.getCallSignatures();
+          const callSignatues = typeChecker.getSignaturesOfType(type, ts.SignatureKind.Call);
           if (callSignatues.length !== 1) return succeed([]);
-          const returnType = callSignatues[0].getReturnType();
+          const returnType = typeChecker.getReturnTypeOfSignature(callSignatues[0]);
           return pipe(
             typeParser.effectType(
               returnType,
@@ -6236,8 +6324,8 @@ function effectTypeArgs(sourceFile, position, quickInfo2) {
         })
       );
       if (!quickInfo2) {
-        const start = node.getStart();
-        const end = node.getEnd();
+        const start = ts.getTokenPosOfNode(node, sourceFile);
+        const end = node.end;
         return {
           kind: ts.ScriptElementKind.callSignatureElement,
           kindModifiers: "",
@@ -10466,6 +10554,7 @@ function processLayerGraphNode(ctx, node, pipedInGraphNode) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const excludeNever = (type) => succeed((type.flags & ts.TypeFlags.Never) !== 0);
     const maybePipe = yield* option(typeParser.pipeCall(node));
     if (isSome2(maybePipe)) {
@@ -10483,12 +10572,12 @@ function processLayerGraphNode(ctx, node, pipedInGraphNode) {
           all(...node.arguments.map((_) => processLayerGraphNode(ctx, _, void 0)))
         );
         if (isSome2(argNodes) && argNodes.value.length === node.arguments.length) {
-          const { allIndexes: outTypes } = yield* appendToUniqueTypesMap(
+          const { allIndexes: outTypes } = yield* typeCheckerUtils.appendToUniqueTypesMap(
             ctx.services,
             maybeLayer.value.ROut,
             excludeNever
           );
-          const { allIndexes: inTypes } = yield* appendToUniqueTypesMap(
+          const { allIndexes: inTypes } = yield* typeCheckerUtils.appendToUniqueTypesMap(
             ctx.services,
             maybeLayer.value.RIn,
             excludeNever
@@ -10506,18 +10595,18 @@ function processLayerGraphNode(ctx, node, pipedInGraphNode) {
     if (pipedInGraphNode && ts.isExpression(node)) {
       const type = typeChecker.getContextualType(node);
       if (type) {
-        const callSignatures = type.getCallSignatures();
+        const callSignatures = typeChecker.getSignaturesOfType(type, ts.SignatureKind.Call);
         if (callSignatures.length === 1) {
           const [signature] = callSignatures;
-          const returnType = signature.getReturnType();
+          const returnType = typeChecker.getReturnTypeOfSignature(signature);
           const maybeLayer = yield* option(typeParser.layerType(returnType, node));
           if (isSome2(maybeLayer)) {
-            const { allIndexes: outTypes } = yield* appendToUniqueTypesMap(
+            const { allIndexes: outTypes } = yield* typeCheckerUtils.appendToUniqueTypesMap(
               ctx.services,
               maybeLayer.value.ROut,
               excludeNever
             );
-            const { allIndexes: inTypes } = yield* appendToUniqueTypesMap(
+            const { allIndexes: inTypes } = yield* typeCheckerUtils.appendToUniqueTypesMap(
               ctx.services,
               maybeLayer.value.RIn,
               excludeNever
@@ -10562,12 +10651,12 @@ function processLayerGraphNode(ctx, node, pipedInGraphNode) {
       const type = typeChecker.getTypeAtLocation(node);
       const maybeLayer = yield* option(typeParser.layerType(type, node));
       if (isSome2(maybeLayer)) {
-        const { allIndexes: outTypes } = yield* appendToUniqueTypesMap(
+        const { allIndexes: outTypes } = yield* typeCheckerUtils.appendToUniqueTypesMap(
           ctx.services,
           maybeLayer.value.ROut,
           excludeNever
         );
-        const { allIndexes: inTypes } = yield* appendToUniqueTypesMap(
+        const { allIndexes: inTypes } = yield* typeCheckerUtils.appendToUniqueTypesMap(
           ctx.services,
           maybeLayer.value.RIn,
           excludeNever
@@ -10781,8 +10870,8 @@ function layerInfo(sourceFile, position, quickInfo2) {
         )
       );
       if (!quickInfo2) {
-        const start = node.getStart();
-        const end = node.getEnd();
+        const start = ts.getTokenPosOfNode(node, sourceFile);
+        const end = node.end;
         return {
           kind: ts.ScriptElementKind.callSignatureElement,
           kindModifiers: "",
@@ -11585,7 +11674,10 @@ var pipeableToDatafirst = createRefactor({
       if (!ts.isCallExpression(node2)) return none2();
       const signature = typeChecker.getResolvedSignature(node2);
       if (!signature) return none2();
-      const callSignatures = typeChecker.getTypeAtLocation(node2.expression).getCallSignatures();
+      const callSignatures = typeChecker.getSignaturesOfType(
+        typeChecker.getTypeAtLocation(node2.expression),
+        ts.SignatureKind.Call
+      );
       for (let i = 0; i < callSignatures.length; i++) {
         const callSignature = callSignatures[i];
         if (callSignature.parameters.length === node2.arguments.length + 1) {
@@ -12545,6 +12637,7 @@ var init = (modules) => {
     function runNano(program) {
       return (fa) => pipe(
         fa,
+        nanoLayer3,
         nanoLayer2,
         nanoLayer,
         provideService(TypeCheckerApi, program.getTypeChecker()),
@@ -12579,7 +12672,7 @@ var init = (modules) => {
     };
     proxy.getSemanticDiagnostics = (fileName, ...args2) => {
       const applicableDiagnostics = languageService.getSemanticDiagnostics(fileName, ...args2);
-      return runDiagnosticsAndCacheCodeFixes(fileName).concat(applicableDiagnostics);
+      return concatDiagnostics(runDiagnosticsAndCacheCodeFixes(fileName), applicableDiagnostics);
     };
     proxy.getSupportedCodeFixes = (...args2) => languageService.getSupportedCodeFixes(...args2).concat(
       diagnosticsErrorCodes.map((_) => "" + _)