@effect/language-service 0.36.0 → 0.38.0

package/index.js

@@ -324,10 +324,10 @@ var string = (str) => {
   }
   return optimize(h);
 };
-var structureKeys = (o, keys) => {
+var structureKeys = (o, keys2) => {
   let h = 12289;
-  for (let i = 0; i < keys.length; i++) {
-    h ^= pipe(string(keys[i]), combine(hash(o[keys[i]])));
+  for (let i = 0; i < keys2.length; i++) {
+    h ^= pipe(string(keys2[i]), combine(hash(o[keys2[i]])));
   }
   return optimize(h);
 };
@@ -829,6 +829,7 @@ var NanoFiber = class {
   _yielded = void 0;
   _services = {};
   _cache = {};
+  _perf = false;
   runLoop(nano) {
     let current = nano;
     while (true) {
@@ -852,6 +853,34 @@ var NanoFiber = class {
     return NanoYield;
   }
 };
+var timings = {};
+var timingsCount = {};
+var WithSpanProto = {
+  ...PrimitiveProto,
+  [evaluate](fiber) {
+    const [fa, name] = this[args];
+    if (!fiber._perf) return fa;
+    const start = performance.now();
+    timingsCount[name] = (timingsCount[name] || 0) + 1;
+    return match(fa, {
+      onSuccess: (_) => {
+        const end = performance.now();
+        timings[name] = (timings[name] || 0) + (end - start);
+        return succeed(_);
+      },
+      onFailure: (_) => {
+        const end = performance.now();
+        timings[name] = (timings[name] || 0) + (end - start);
+        return fail(_);
+      }
+    });
+  }
+};
+var withSpan = (name) => (fa) => {
+  const nano = Object.create(WithSpanProto);
+  nano[args] = [fa, name];
+  return nano;
+};
 var unsafeRun = (nano) => {
   const fiber = new NanoFiber();
   const result = fiber.runLoop(nano);
@@ -913,7 +942,7 @@ var unsafeFromIterator = (iterator, initial) => {
   return nano;
 };
 var gen = (...args2) => suspend(() => unsafeFromIterator(args2[0]()));
-var fn = (_) => (body) => (...args2) => suspend(() => unsafeFromIterator(body(...args2)));
+var fn = (_) => (body) => (...args2) => withSpan(_)(suspend(() => unsafeFromIterator(body(...args2))));
 var MatchProto = {
   ...PrimitiveProto,
   [evaluate](fiber) {
@@ -1039,6 +1068,18 @@ var ChangeTracker = Tag("ChangeTracker");
 // 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.8/node_modules/effect/dist/esm/Record.js
+var map4 = /* @__PURE__ */ dual(2, (self, f) => {
+  const out = {
+    ...self
+  };
+  for (const key of keys(self)) {
+    out[key] = f(self[key], key);
+  }
+  return out;
+});
+var keys = (self) => Object.keys(self);
+
 // 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]);
@@ -1082,7 +1123,7 @@ var intersectionWith = (isEquivalent) => {
 };
 var intersection = /* @__PURE__ */ intersectionWith(_equivalence);
 var empty = () => [];
-var map4 = /* @__PURE__ */ dual(2, (self, f) => self.map(f));
+var map5 = /* @__PURE__ */ dual(2, (self, f) => self.map(f));
 var flatMap2 = /* @__PURE__ */ dual(2, (self, f) => {
   if (isEmptyReadonlyArray(self)) {
     return [];
@@ -1179,7 +1220,7 @@ function makeTypeScriptUtils(ts) {
     return pipe(
       referencedPackages.concat(packageJsonScope?.referencedPackages || []),
       dedupe,
-      map4((packageName) => packageName.toLowerCase()),
+      map5((packageName) => packageName.toLowerCase()),
       filter(
         (packageName) => pattern.endsWith("*") && packageName.startsWith(pattern.toLowerCase().substring(0, pattern.length - 1))
       )
@@ -1295,7 +1336,7 @@ function makeTypeScriptUtils(ts) {
       fnCall = ts.factory.createCallExpression(
         fnCall,
         void 0,
-        [ts.factory.createStringLiteral(fnName.text)]
+        [ts.factory.createStringLiteral(ts.idText(fnName))]
       );
     }
     return tryPreserveDeclarationSemantics(
@@ -1367,7 +1408,7 @@ function makeTypeScriptUtils(ts) {
       if (!namedBindings) continue;
       if (ts.isNamespaceImport(namedBindings)) {
         if (test(namedBindings.name, statement.moduleSpecifier, none2())) {
-          return namedBindings.name.text;
+          return ts.idText(namedBindings.name);
         }
       } else if (ts.isNamedImports(namedBindings)) {
         for (const importSpecifier of namedBindings.elements) {
@@ -1375,7 +1416,7 @@ function makeTypeScriptUtils(ts) {
             orElse(() => some2(importSpecifier.name))
           );
           if (test(importSpecifier.name, statement.moduleSpecifier, importProperty)) {
-            return importSpecifier.name.text;
+            return ts.idText(importSpecifier.name);
           }
         }
       }
@@ -1388,7 +1429,7 @@ function makeTypeScriptUtils(ts) {
         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) {
+        if (isSome2(importProperty) && ts.isIdentifier(importProperty.value) && ts.idText(importProperty.value) === moduleName && ts.isStringLiteral(fromModule) && fromModule.text === packageName) {
           return true;
         }
         return false;
@@ -1615,7 +1656,7 @@ function parseDiagnosticSeverity(config) {
     pipe(
       Object.entries(config),
       filter(([key, value]) => isString(key) && isString(value)),
-      map4(([key, value]) => [String(key).toLowerCase(), String(value).toLowerCase()]),
+      map5(([key, value]) => [String(key).toLowerCase(), String(value).toLowerCase()]),
       filter(
         ([_, value]) => value === "off" || value === "error" || value === "warning" || value === "message" || value === "suggestion"
       )
@@ -1633,8 +1674,10 @@ var defaults = {
   inlays: true,
   allowedDuplicatedPackages: [],
   namespaceImportPackages: [],
+  topLevelNamedReexports: "ignore",
   barrelImportPackages: [],
-  topLevelNamedReexports: "ignore"
+  importAliases: {},
+  renames: true
 };
 function parse(config) {
   return {
@@ -1649,7 +1692,9 @@ function parse(config) {
     allowedDuplicatedPackages: isObject(config) && hasProperty(config, "allowedDuplicatedPackages") && isArray(config.allowedDuplicatedPackages) && config.allowedDuplicatedPackages.every(isString) ? config.allowedDuplicatedPackages.map((_) => _.toLowerCase()) : defaults.allowedDuplicatedPackages,
     namespaceImportPackages: isObject(config) && hasProperty(config, "namespaceImportPackages") && isArray(config.namespaceImportPackages) && config.namespaceImportPackages.every(isString) ? config.namespaceImportPackages.map((_) => _.toLowerCase()) : defaults.namespaceImportPackages,
     barrelImportPackages: isObject(config) && hasProperty(config, "barrelImportPackages") && isArray(config.barrelImportPackages) && config.barrelImportPackages.every(isString) ? config.barrelImportPackages.map((_) => _.toLowerCase()) : defaults.barrelImportPackages,
-    topLevelNamedReexports: isObject(config) && hasProperty(config, "topLevelNamedReexports") && isString(config.topLevelNamedReexports) && ["ignore", "follow"].includes(config.topLevelNamedReexports.toLowerCase()) ? config.topLevelNamedReexports.toLowerCase() : defaults.topLevelNamedReexports
+    importAliases: isObject(config) && hasProperty(config, "importAliases") && isRecord(config.importAliases) ? map4(config.importAliases, (value) => String(value)) : defaults.importAliases,
+    topLevelNamedReexports: isObject(config) && hasProperty(config, "topLevelNamedReexports") && isString(config.topLevelNamedReexports) && ["ignore", "follow"].includes(config.topLevelNamedReexports.toLowerCase()) ? config.topLevelNamedReexports.toLowerCase() : defaults.topLevelNamedReexports,
+    renames: isObject(config) && hasProperty(config, "renames") && isBoolean(config.renames) ? config.renames : defaults.renames
   };
 }
 
@@ -1961,6 +2006,9 @@ var getEditsForCodegen = fn("LSP.getEditsForCodegen")(function* (codegens2, sour
     ignore: updateHashComment
   };
 });
+var getEffectLspPatchSourceFileMetadata = (sourceFile) => {
+  return sourceFile["@effect-lsp-patch/metadata"];
+};
 
 // src/completions/contextSelfInClasses.ts
 var contextSelfInClasses = createCompletion({
@@ -1990,188 +2038,6 @@ var contextSelfInClasses = createCompletion({
 
 // src/core/TypeCheckerApi.ts
 var TypeCheckerApi = Tag("TypeChecker");
-var deterministicTypeOrder = gen(function* () {
-  const typeChecker = yield* service(TypeCheckerApi);
-  return make2((a, b) => {
-    const aName = typeChecker.typeToString(a);
-    const bName = typeChecker.typeToString(b);
-    if (aName < bName) return -1;
-    if (aName > bName) return 1;
-    return 0;
-  });
-});
-var CannotFindAncestorConvertibleDeclarationError = class {
-  constructor(node) {
-    this.node = node;
-  }
-  _tag = "@effect/language-service/CannotFindAncestorConvertibleDeclarationError";
-};
-var getAncestorConvertibleDeclaration = fn(
-  "TypeCheckerApi.getAncestorConvertibleDeclaration"
-)(function* (node) {
-  const ts = yield* service(TypeScriptApi);
-  let current = node;
-  while (current) {
-    if (ts.isFunctionDeclaration(current) || ts.isFunctionExpression(current) || ts.isArrowFunction(current) || ts.isMethodDeclaration(current)) {
-      return current;
-    }
-    current = current.parent;
-  }
-  return yield* fail(new CannotFindAncestorConvertibleDeclarationError(node));
-});
-var CannotInferReturnTypeFromEmptyBody = class {
-  constructor(declaration) {
-    this.declaration = declaration;
-  }
-  _tag = "@effect/language-service/CannotInferReturnTypeFromEmptyBody";
-};
-var CannotInferReturnType = class {
-  constructor(declaration) {
-    this.declaration = declaration;
-  }
-  _tag = "@effect/language-service/CannotInferReturnType";
-};
-var getInferredReturnType = fn("TypeCheckerApi.getInferredReturnType")(function* (declaration) {
-  const typeChecker = yield* service(TypeCheckerApi);
-  const ts = yield* service(TypeScriptApi);
-  if (!declaration.body) {
-    return yield* fail(
-      new CannotInferReturnTypeFromEmptyBody(declaration)
-    );
-  }
-  let returnType;
-  if (typeChecker.isImplementationOfOverload(declaration)) {
-    const signatures = typeChecker.getSignaturesOfType(
-      typeChecker.getTypeAtLocation(declaration),
-      ts.SignatureKind.Call
-    );
-    if (signatures.length > 1) {
-      returnType = typeChecker.getUnionType(
-        signatures.map((s) => typeChecker.getReturnTypeOfSignature(s)).filter((_) => !!_)
-      );
-    }
-  }
-  if (!returnType) {
-    const signature = typeChecker.getSignatureFromDeclaration(declaration);
-    if (signature) {
-      const typePredicate = typeChecker.getTypePredicateOfSignature(signature);
-      if (typePredicate && typePredicate.type) {
-        return typePredicate.type;
-      } else {
-        returnType = typeChecker.getReturnTypeOfSignature(signature);
-      }
-    }
-  }
-  if (!returnType) {
-    return yield* fail(
-      new CannotInferReturnType(declaration)
-    );
-  }
-  return returnType;
-});
-var expectedAndRealType = 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.parameters.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 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]);
-                }
-              }
-            }
-          }
-        }
-        ts.forEachChild(node, appendNodeToVisit);
-        continue;
-      } else if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
-        const expectedType = typeChecker.getTypeAtLocation(node.left);
-        const realType = typeChecker.getTypeAtLocation(node.right);
-        result.push([node.left, expectedType, node.right, realType]);
-        appendNodeToVisit(node.right);
-        continue;
-      } else if (ts.isReturnStatement(node) && node.expression) {
-        const parentDeclaration = yield* option(getAncestorConvertibleDeclaration(node));
-        if (isSome2(parentDeclaration)) {
-          const expectedType = yield* option(getInferredReturnType(parentDeclaration.value));
-          const realType = typeChecker.getTypeAtLocation(node.expression);
-          if (isSome2(expectedType)) {
-            result.push([node, expectedType.value, node, realType]);
-          }
-        }
-        ts.forEachChild(node, appendNodeToVisit);
-        continue;
-      } else if (ts.isArrowFunction(node) && (node.typeParameters || []).length === 0 && ts.isExpression(node.body)) {
-        const body = node.body;
-        const expectedType = typeChecker.getContextualType(body);
-        const realType = typeChecker.getTypeAtLocation(body);
-        if (expectedType) {
-          result.push([body, expectedType, body, realType]);
-        }
-        ts.forEachChild(body, appendNodeToVisit);
-        continue;
-      } else if (ts.isArrowFunction(node) && (node.typeParameters || []).length > 0 && ts.isExpression(node.body)) {
-        const body = node.body;
-        const expectedType = yield* option(getInferredReturnType(node));
-        const realType = typeChecker.getTypeAtLocation(body);
-        if (isSome2(expectedType)) {
-          result.push([body, expectedType.value, body, realType]);
-        }
-        ts.forEachChild(body, appendNodeToVisit);
-        continue;
-      } else if (ts.isSatisfiesExpression(node)) {
-        const expectedType = typeChecker.getTypeAtLocation(node.type);
-        const realType = typeChecker.getTypeAtLocation(node.expression);
-        result.push([node.expression, expectedType, node.expression, realType]);
-        appendNodeToVisit(node.expression);
-        continue;
-      }
-      ts.forEachChild(node, appendNodeToVisit);
-    }
-    return result;
-  }),
-  "TypeCheckerApi.expectedAndRealType",
-  (sourceFile) => sourceFile
-);
 function makeResolveExternalModuleName(typeChecker) {
   if (!(hasProperty(typeChecker, "resolveExternalModuleName") && isFunction(typeChecker.resolveExternalModuleName))) {
     return;
@@ -2284,12 +2150,161 @@ function makeTypeCheckerUtils(ts, typeChecker) {
       };
     }
   );
+  const deterministicTypeOrder = make2((a, b) => {
+    const aName = typeChecker.typeToString(a);
+    const bName = typeChecker.typeToString(b);
+    if (aName < bName) return -1;
+    if (aName > bName) return 1;
+    return 0;
+  });
+  const getAncestorConvertibleDeclaration = (node) => {
+    let current = node;
+    while (current) {
+      if (ts.isFunctionDeclaration(current) || ts.isFunctionExpression(current) || ts.isArrowFunction(current) || ts.isMethodDeclaration(current)) {
+        return current;
+      }
+      current = current.parent;
+    }
+  };
+  const getInferredReturnType = (declaration) => {
+    if (!declaration.body) {
+      return;
+    }
+    let returnType;
+    if (typeChecker.isImplementationOfOverload(declaration)) {
+      const signatures = typeChecker.getSignaturesOfType(
+        typeChecker.getTypeAtLocation(declaration),
+        ts.SignatureKind.Call
+      );
+      if (signatures.length > 1) {
+        returnType = typeChecker.getUnionType(
+          signatures.map((s) => typeChecker.getReturnTypeOfSignature(s)).filter((_) => !!_)
+        );
+      }
+    }
+    if (!returnType) {
+      const signature = typeChecker.getSignatureFromDeclaration(declaration);
+      if (signature) {
+        const typePredicate = typeChecker.getTypePredicateOfSignature(signature);
+        if (typePredicate && typePredicate.type) {
+          return typePredicate.type;
+        } else {
+          returnType = typeChecker.getReturnTypeOfSignature(signature);
+        }
+      }
+    }
+    return returnType;
+  };
+  const expectedAndRealTypeCache = /* @__PURE__ */ new WeakMap();
+  const expectedAndRealType = (sourceFile) => {
+    const cached2 = expectedAndRealTypeCache.get(sourceFile);
+    if (cached2) return cached2;
+    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.parameters.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 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]);
+                }
+              }
+            }
+          }
+        }
+        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 = getAncestorConvertibleDeclaration(node);
+        if (parentDeclaration) {
+          const expectedType = getInferredReturnType(parentDeclaration);
+          const realType = typeChecker.getTypeAtLocation(node.expression);
+          if (expectedType) {
+            result.push([node, expectedType, 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 = getInferredReturnType(node);
+        const realType = typeChecker.getTypeAtLocation(body);
+        if (expectedType) {
+          result.push([body, expectedType, 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);
+    }
+    expectedAndRealTypeCache.set(sourceFile, result);
+    return result;
+  };
   return {
     isUnion,
     getTypeParameterAtPosition,
     getMissingTypeEntriesInTargetType,
     unrollUnionMembers,
-    appendToUniqueTypesMap
+    appendToUniqueTypesMap,
+    deterministicTypeOrder,
+    getInferredReturnType,
+    expectedAndRealType
   };
 }
 
@@ -2564,6 +2579,21 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
     "TypeParser.importedEffectModule",
     (node) => node
   );
+  const importedDataModule = cachedBy(
+    fn("TypeParser.importedDataModule")(function* (node) {
+      const type = typeChecker.getTypeAtLocation(node);
+      const propertySymbol = typeChecker.getPropertyOfType(type, "TaggedError");
+      if (!propertySymbol) {
+        return yield* typeParserIssue("Type has no 'TaggedError' property", type, node);
+      }
+      if (!ts.isExpression(node)) {
+        return yield* typeParserIssue("Node is not an expression", type, node);
+      }
+      return node;
+    }),
+    "TypeParser.importedDataModule",
+    (node) => node
+  );
   const effectGen = cachedBy(
     function(node) {
       if (!ts.isCallExpression(node)) {
@@ -2583,7 +2613,7 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
         return typeParserIssue("Node is not a property access expression", void 0, node);
       }
       const propertyAccess = node.expression;
-      if (propertyAccess.name.text !== "gen") {
+      if (!(ts.isIdentifier(propertyAccess.name) && ts.idText(propertyAccess.name) === "gen")) {
         return typeParserIssue("Call expression name is not 'gen'", void 0, node);
       }
       return pipe(
@@ -2627,7 +2657,7 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
         );
       }
       const propertyAccess = node.expression;
-      if (propertyAccess.name.text !== "fnUntraced") {
+      if (!(ts.isIdentifier(propertyAccess.name) && ts.idText(propertyAccess.name) === "fnUntraced")) {
         return typeParserIssue(
           "Call expression name is not 'fnUntraced'",
           void 0,
@@ -2680,7 +2710,7 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
         );
       }
       const propertyAccess = expressionToTest;
-      if (propertyAccess.name.text !== "fn") {
+      if (!(ts.isIdentifier(propertyAccess.name) && ts.idText(propertyAccess.name) === "fn")) {
         return typeParserIssue(
           "Call expression name is not 'fn'",
           void 0,
@@ -2834,7 +2864,7 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
           kind: "pipeable"
         });
       }
-      if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "pipe" && node.arguments.length > 0) {
+      if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && ts.idText(node.expression) === "pipe" && node.arguments.length > 0) {
         const [subject, ...args2] = node.arguments;
         return succeed({ node, subject, args: args2, kind: "pipe" });
       }
@@ -2959,7 +2989,7 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
         for (const typeX of heritageClause.types) {
           if (ts.isExpressionWithTypeArguments(typeX)) {
             const expression = typeX.expression;
-            if (ts.isCallExpression(expression)) {
+            if (ts.isCallExpression(expression) && expression.arguments.length > 0) {
               const schemaTaggedClassTCall = expression.expression;
               if (ts.isCallExpression(schemaTaggedClassTCall) && schemaTaggedClassTCall.typeArguments && schemaTaggedClassTCall.typeArguments.length > 0) {
                 const selfTypeNode = schemaTaggedClassTCall.typeArguments[0];
@@ -2973,6 +3003,8 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
                     return {
                       className: atLocation.name,
                       selfTypeNode,
+                      keyStringLiteral: schemaTaggedClassTCall.arguments.length > 0 && ts.isStringLiteral(schemaTaggedClassTCall.arguments[0]) ? schemaTaggedClassTCall.arguments[0] : void 0,
+                      tagStringLiteral: expression.arguments.length > 0 && ts.isStringLiteral(expression.arguments[0]) ? expression.arguments[0] : void 0,
                       Schema: parsedSchemaModule.value
                     };
                   }
@@ -3014,6 +3046,8 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
                     return {
                       className: atLocation.name,
                       selfTypeNode,
+                      keyStringLiteral: schemaTaggedErrorTCall.arguments.length > 0 && ts.isStringLiteral(schemaTaggedErrorTCall.arguments[0]) ? schemaTaggedErrorTCall.arguments[0] : void 0,
+                      tagStringLiteral: expression.arguments.length > 0 && ts.isStringLiteral(expression.arguments[0]) ? expression.arguments[0] : void 0,
                       Schema: parsedSchemaModule.value
                     };
                   }
@@ -3028,6 +3062,82 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
     "TypeParser.extendsSchemaTaggedError",
     (atLocation) => atLocation
   );
+  const extendsDataTaggedError = cachedBy(
+    fn("TypeParser.extendsDataTaggedError")(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 dataTaggedErrorCall = expression;
+              const dataIdentifier = dataTaggedErrorCall.expression;
+              if (ts.isPropertyAccessExpression(dataIdentifier) && ts.isIdentifier(dataIdentifier.name) && ts.idText(dataIdentifier.name) === "TaggedError") {
+                const parsedDataModule = yield* pipe(
+                  importedDataModule(dataIdentifier.expression),
+                  option
+                );
+                if (isSome2(parsedDataModule)) {
+                  return {
+                    className: atLocation.name,
+                    keyStringLiteral: dataTaggedErrorCall.arguments.length > 0 && ts.isStringLiteral(dataTaggedErrorCall.arguments[0]) ? dataTaggedErrorCall.arguments[0] : void 0,
+                    Data: parsedDataModule.value
+                  };
+                }
+              }
+            }
+          }
+        }
+      }
+      return yield* typeParserIssue("Class does not extend Data.TaggedError", void 0, atLocation);
+    }),
+    "TypeParser.extendsDataTaggedError",
+    (atLocation) => atLocation
+  );
+  const extendsDataTaggedClass = cachedBy(
+    fn("TypeParser.extendsDataTaggedClass")(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 dataTaggedClassCall = expression;
+              const dataIdentifier = dataTaggedClassCall.expression;
+              if (ts.isPropertyAccessExpression(dataIdentifier) && ts.isIdentifier(dataIdentifier.name) && ts.idText(dataIdentifier.name) === "TaggedClass") {
+                const parsedDataModule = yield* pipe(
+                  importedDataModule(dataIdentifier.expression),
+                  option
+                );
+                if (isSome2(parsedDataModule)) {
+                  return {
+                    className: atLocation.name,
+                    keyStringLiteral: dataTaggedClassCall.arguments.length > 0 && ts.isStringLiteral(dataTaggedClassCall.arguments[0]) ? dataTaggedClassCall.arguments[0] : void 0,
+                    Data: parsedDataModule.value
+                  };
+                }
+              }
+            }
+          }
+        }
+      }
+      return yield* typeParserIssue("Class does not extend Data.TaggedClass", void 0, atLocation);
+    }),
+    "TypeParser.extendsDataTaggedClass",
+    (atLocation) => atLocation
+  );
   const extendsSchemaTaggedRequest = cachedBy(
     fn("TypeParser.extendsSchemaTaggedRequest")(function* (atLocation) {
       if (!atLocation.name) {
@@ -3055,6 +3165,8 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
                     return {
                       className: atLocation.name,
                       selfTypeNode,
+                      tagStringLiteral: expression.arguments.length > 0 && ts.isStringLiteral(expression.arguments[0]) ? expression.arguments[0] : void 0,
+                      keyStringLiteral: schemaTaggedRequestTCall.arguments.length > 0 && ts.isStringLiteral(schemaTaggedRequestTCall.arguments[0]) ? schemaTaggedRequestTCall.arguments[0] : void 0,
                       Schema: parsedSchemaModule.value
                     };
                   }
@@ -3074,9 +3186,6 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
       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);
@@ -3096,10 +3205,14 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
                     option
                   );
                   if (isSome2(parsedContextModule)) {
+                    const classSym = typeChecker.getSymbolAtLocation(atLocation.name);
+                    if (!classSym) return yield* typeParserIssue("Class has no symbol", void 0, atLocation);
+                    const type = typeChecker.getTypeOfSymbol(classSym);
                     const tagType = yield* contextTag(type, atLocation);
                     return {
                       className: atLocation.name,
                       selfTypeNode,
+                      keyStringLiteral: ts.isStringLiteral(contextTagCall.arguments[0]) ? contextTagCall.arguments[0] : void 0,
                       args: contextTagCall.arguments,
                       Identifier: tagType.Identifier,
                       Tag: parsedContextModule.value
@@ -3121,9 +3234,6 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
       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);
@@ -3138,6 +3248,9 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
                 const effectServiceIdentifier = effectServiceCall.expression;
                 const selfTypeNode = effectServiceCall.typeArguments[0];
                 if (ts.isPropertyAccessExpression(effectServiceIdentifier) && ts.isIdentifier(effectServiceIdentifier.name) && ts.idText(effectServiceIdentifier.name) === "Service") {
+                  const classSym = typeChecker.getSymbolAtLocation(atLocation.name);
+                  if (!classSym) return yield* typeParserIssue("Class has no symbol", void 0, atLocation);
+                  const type = typeChecker.getTypeOfSymbol(classSym);
                   const parsedContextTag = yield* pipe(
                     importedEffectModule(effectServiceIdentifier.expression),
                     flatMap(() => contextTag(type, atLocation)),
@@ -3164,6 +3277,7 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
                       className: atLocation.name,
                       selfTypeNode,
                       args: wholeCall.arguments,
+                      keyStringLiteral: ts.isStringLiteral(wholeCall.arguments[0]) ? wholeCall.arguments[0] : void 0,
                       options: wholeCall.arguments[1],
                       accessors: accessors2,
                       dependencies
@@ -3202,6 +3316,8 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils) {
     extendsSchemaClass,
     extendsSchemaTaggedClass,
     extendsSchemaTaggedError,
+    extendsDataTaggedError,
+    extendsDataTaggedClass,
     extendsSchemaTaggedRequest
   };
 }
@@ -3227,7 +3343,7 @@ var generate = fn("writeTagClassAccessors.generate")(function* (sourceFile, serv
       ),
       void 0,
       [
-        ts.factory.createIdentifier(className2.text),
+        ts.factory.createIdentifier(ts.idText(className2)),
         ts.factory.createArrowFunction(
           void 0,
           void 0,
@@ -3277,9 +3393,9 @@ var generate = fn("writeTagClassAccessors.generate")(function* (sourceFile, serv
   const generateReturnType = (type, atLocation2, className2) => pipe(
     typeParser.effectType(type, atLocation2),
     flatMap((returnedEffect) => {
-      const contextType = returnedEffect.R.flags & ts.TypeFlags.Never ? ts.factory.createTypeReferenceNode(className2.text) : ts.factory.createUnionTypeNode(
+      const contextType = returnedEffect.R.flags & ts.TypeFlags.Never ? ts.factory.createTypeReferenceNode(ts.idText(className2)) : ts.factory.createUnionTypeNode(
         [
-          ts.factory.createTypeReferenceNode(className2.text),
+          ts.factory.createTypeReferenceNode(ts.idText(className2)),
           typeChecker.typeToTypeNode(returnedEffect.R, atLocation2, ts.NodeBuilderFlags.NoTruncation)
         ]
       );
@@ -3327,7 +3443,7 @@ var generate = fn("writeTagClassAccessors.generate")(function* (sourceFile, serv
                   ts.factory.createIdentifier("UnknownException")
                 )
               ),
-              ts.factory.createTypeReferenceNode(className2.text)
+              ts.factory.createTypeReferenceNode(ts.idText(className2))
             ]
           ));
         })
@@ -3344,7 +3460,7 @@ var generate = fn("writeTagClassAccessors.generate")(function* (sourceFile, serv
         [
           successType,
           ts.factory.createTypeReferenceNode("never"),
-          ts.factory.createTypeReferenceNode(className2.text)
+          ts.factory.createTypeReferenceNode(ts.idText(className2))
         ]
       );
       return succeed(typeNode);
@@ -3421,7 +3537,7 @@ var parse2 = fn("writeTagClassAccessors.parse")(function* (node) {
   }
   const hash2 = involvedMembers.map(({ property, propertyType }) => {
     return ts.symbolName(property) + ": " + typeChecker.typeToString(propertyType);
-  }).concat([className.text]).join("\n");
+  }).concat([ts.idText(className)]).join("\n");
   return { Service, className, atLocation: node, hash: cyrb53(hash2), involvedMembers };
 });
 var writeTagClassAccessors = createRefactor({
@@ -3528,8 +3644,8 @@ var effectDataClasses = createCompletion({
       "effect",
       "Data"
     ) || "Data";
-    if (effectDataIdentifier !== accessedObject.text) return [];
-    const name = className.text;
+    if (effectDataIdentifier !== ts.idText(accessedObject)) return [];
+    const name = ts.idText(className);
     return [{
       name: `TaggedError("${name}")`,
       kind: ts.ScriptElementKind.constElement,
@@ -3715,7 +3831,7 @@ var effectInVoidSuccess = createDiagnostic({
       }
       return yield* fail(typeParserIssue("expectedEffect success is not void"));
     });
-    const entries = yield* expectedAndRealType(sourceFile);
+    const entries = typeCheckerUtils.expectedAndRealType(sourceFile);
     for (const [node, expectedType, valueNode, realType] of entries) {
       if (expectedType !== realType) {
         yield* pipe(
@@ -3984,7 +4100,6 @@ var leakingRequirements = createDiagnostic({
     const typeChecker = yield* service(TypeCheckerApi);
     const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const typeParser = yield* service(TypeParser);
-    const typeOrder = yield* deterministicTypeOrder;
     const parseLeakedRequirements = cachedBy(
       fn("leakingServices.checkServiceLeaking")(
         function* (service2, atLocation) {
@@ -4087,7 +4202,9 @@ More info at https://effect.website/docs/requirements-management/layers/#avoidin
           flatMap(
             ({ Service }) => pipe(
               parseLeakedRequirements(Service, node),
-              map3((requirements) => reportLeakingRequirements(reportAt, sort(requirements, typeOrder)))
+              map3(
+                (requirements) => reportLeakingRequirements(reportAt, sort(requirements, typeCheckerUtils.deterministicTypeOrder))
+              )
             )
           ),
           orElse2(() => sync(() => ts.forEachChild(node, appendNodeToVisit))),
@@ -4106,7 +4223,6 @@ var missingEffectContext = createDiagnostic({
   apply: fn("missingEffectContext.apply")(function* (sourceFile, report) {
     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(
@@ -4120,8 +4236,8 @@ var missingEffectContext = createDiagnostic({
         )
       )
     );
-    const sortTypes = sort(typeOrder);
-    const entries = yield* expectedAndRealType(sourceFile);
+    const sortTypes = sort(typeCheckerUtils.deterministicTypeOrder);
+    const entries = getEffectLspPatchSourceFileMetadata(sourceFile)?.relationErrors || typeCheckerUtils.expectedAndRealType(sourceFile);
     for (const [node, expectedType, valueNode, realType] of entries) {
       if (expectedType !== realType) {
         yield* pipe(
@@ -4158,7 +4274,6 @@ var missingEffectError = createDiagnostic({
     const typeChecker = yield* service(TypeCheckerApi);
     const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const typeParser = yield* service(TypeParser);
-    const typeOrder = yield* deterministicTypeOrder;
     const effectModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
       sourceFile,
       "effect",
@@ -4187,8 +4302,8 @@ var missingEffectError = createDiagnostic({
         )
       )
     );
-    const sortTypes = sort(typeOrder);
-    const entries = yield* expectedAndRealType(sourceFile);
+    const sortTypes = sort(typeCheckerUtils.deterministicTypeOrder);
+    const entries = getEffectLspPatchSourceFileMetadata(sourceFile)?.relationErrors || typeCheckerUtils.expectedAndRealType(sourceFile);
     for (const [node, expectedType, valueNode, realType] of entries) {
       if (expectedType !== realType) {
         yield* pipe(
@@ -4225,17 +4340,17 @@ var missingEffectError = createDiagnostic({
             if (ts.isExpression(valueNode)) {
               const propertyAssignments = pipe(
                 result.missingErrorTypes,
-                map4((_) => typeChecker.getPropertyOfType(_, "_tag")),
+                map5((_) => typeChecker.getPropertyOfType(_, "_tag")),
                 filter((_) => !!_),
-                map4((_) => typeChecker.getTypeOfSymbolAtLocation(_, valueNode)),
+                map5((_) => typeChecker.getTypeOfSymbolAtLocation(_, valueNode)),
                 filter((_) => !!(_.flags & ts.TypeFlags.Literal)),
-                map4((_) => typeChecker.typeToTypeNode(_, void 0, ts.NodeBuilderFlags.NoTruncation)),
+                map5((_) => typeChecker.typeToTypeNode(_, void 0, ts.NodeBuilderFlags.NoTruncation)),
                 filter((_) => !!_ && ts.isLiteralTypeNode(_)),
-                map4((_) => _.literal),
+                map5((_) => _.literal),
                 filter((_) => ts.isLiteralExpression(_)),
-                map4((_) => _.text),
+                map5((_) => _.text),
                 sort(string2),
-                map4(
+                map5(
                   (_) => ts.factory.createPropertyAssignment(
                     ts.factory.createIdentifier(_),
                     ts.factory.createArrowFunction(
@@ -5280,8 +5395,8 @@ var effectSchemaSelfInClasses = createCompletion({
       "effect",
       "Schema"
     ) || "Schema";
-    if (schemaIdentifier !== accessedObject.text) return [];
-    const name = className.text;
+    if (schemaIdentifier !== ts.idText(accessedObject)) return [];
+    const name = ts.idText(className);
     return [{
       name: `Class<${name}>`,
       kind: ts.ScriptElementKind.constElement,
@@ -5324,8 +5439,8 @@ var effectSelfInClasses = createCompletion({
       "effect",
       "Effect"
     ) || "Effect";
-    if (effectIdentifier !== accessedObject.text) return [];
-    const name = className.text;
+    if (effectIdentifier !== ts.idText(accessedObject)) return [];
+    const name = ts.idText(className);
     return [{
       name: `Service<${name}>`,
       kind: ts.ScriptElementKind.constElement,
@@ -5355,7 +5470,7 @@ var fnFunctionStar = createCompletion({
     const maybeFnName = pipe(
       tsUtils.getAncestorNodesInRange(sourceFile, tsUtils.toTextRange(accessedObject.pos)),
       filter(ts.isVariableDeclaration),
-      map4((_) => _.name && ts.isIdentifier(_.name) ? _.name.text : ""),
+      map5((_) => _.name && ts.isIdentifier(_.name) ? ts.idText(_.name) : ""),
       filter((_) => _.length > 0),
       head,
       map2((name) => [
@@ -5428,8 +5543,8 @@ var rpcMakeClasses = createCompletion({
       "@effect/rpc",
       "Rpc"
     ) || "Rpc";
-    if (rpcIdentifier !== accessedObject.text) return [];
-    const name = className.text;
+    if (rpcIdentifier !== ts.idText(accessedObject)) return [];
+    const name = ts.idText(className);
     return [{
       name: `make("${name}")`,
       kind: ts.ScriptElementKind.constElement,
@@ -5455,7 +5570,7 @@ var schemaBrand = createCompletion({
       "effect",
       "Schema"
     ) || "Schema";
-    if (schemaName !== accessedObject.text) return [];
+    if (schemaName !== ts.idText(accessedObject)) return [];
     const span = ts.createTextSpan(
       accessedObject.end + 1,
       Math.max(0, position - accessedObject.end - 1)
@@ -5463,7 +5578,7 @@ var schemaBrand = createCompletion({
     return pipe(
       tsUtils.getAncestorNodesInRange(sourceFile, tsUtils.toTextRange(accessedObject.pos)),
       filter(ts.isVariableDeclaration),
-      map4((_) => _.name && ts.isIdentifier(_.name) ? _.name.text : ""),
+      map5((_) => _.name && ts.isIdentifier(_.name) ? ts.idText(_.name) : ""),
       filter((_) => _.length > 0),
       head,
       map2((name) => [
@@ -5519,7 +5634,7 @@ var makeAutoImportProvider = fn("TypeScriptApi")(function* (fromSourceFile) {
         namespaceExports.push({
           moduleSpecifier,
           exportClause,
-          name: exportClause.name.text
+          name: ts.idText(exportClause.name)
         });
       }
       if (ts.isNamedExports(exportClause)) {
@@ -5530,8 +5645,8 @@ var makeAutoImportProvider = fn("TypeScriptApi")(function* (fromSourceFile) {
           namedExports.push({
             moduleSpecifier,
             exportClause,
-            name: exportName.text,
-            aliasName: exportSpecifier.name.text
+            name: ts.idText(exportName),
+            aliasName: ts.idText(exportSpecifier.name)
           });
         }
       }
@@ -5691,6 +5806,11 @@ var makeAutoImportProvider = fn("TypeScriptApi")(function* (fromSourceFile) {
     if (!moduleSpecifier) return fileName;
     return moduleSpecifier;
   };
+  const resolveAliasName = (chosenName) => {
+    const aliasName = languageServicePluginOptions.importAliases[chosenName];
+    if (aliasName) return aliasName;
+    return void 0;
+  };
   const resolve = (exportFileName, exportName) => {
     const excludedExports = mapFilenameToExportExcludes.get(exportFileName);
     if (excludedExports && excludedExports.includes(exportName)) return;
@@ -5702,7 +5822,9 @@ var makeAutoImportProvider = fn("TypeScriptApi")(function* (fromSourceFile) {
           _tag: "NamedImport",
           fileName: reexportedFile.fileName,
           moduleName: resolveModuleName(reexportedFile.fileName),
-          name: exportName
+          name: exportName,
+          aliasName: resolveAliasName(exportName),
+          introducedPrefix: void 0
         };
       }
     }
@@ -5717,6 +5839,7 @@ var makeAutoImportProvider = fn("TypeScriptApi")(function* (fromSourceFile) {
             fileName: namespacedFileName,
             moduleName: resolveModuleName(namespacedFileName),
             name: introducedAlias2,
+            aliasName: resolveAliasName(introducedAlias2),
             introducedPrefix: void 0
           };
         }
@@ -5729,7 +5852,8 @@ var makeAutoImportProvider = fn("TypeScriptApi")(function* (fromSourceFile) {
         fileName: exportFileName,
         moduleName: resolveModuleName(exportFileName),
         name: introducedAlias,
-        introducedPrefix: introducedAlias
+        aliasName: resolveAliasName(introducedAlias),
+        introducedPrefix: resolveAliasName(introducedAlias) || introducedAlias
       };
     }
     const mapToBarrel = mapFromNamespaceToBarrel.get(exportFileName);
@@ -5739,7 +5863,8 @@ var makeAutoImportProvider = fn("TypeScriptApi")(function* (fromSourceFile) {
         fileName: mapToBarrel.fileName,
         moduleName: resolveModuleName(mapToBarrel.fileName),
         name: mapToBarrel.alias,
-        introducedPrefix: mapToBarrel.alias
+        aliasName: resolveAliasName(mapToBarrel.alias),
+        introducedPrefix: resolveAliasName(mapToBarrel.alias) || mapToBarrel.alias
       };
     }
   };
@@ -5782,7 +5907,7 @@ var parseImportOnlyChanges = fn("parseImportOnlyChanges")(function* (sourceFile,
           if (ts.isNamedImports(namedBindings)) {
             for (const importSpecifier of namedBindings.elements) {
               if (!ts.isIdentifier(importSpecifier.name)) return;
-              const exportName = importSpecifier.name.text;
+              const exportName = ts.idText(importSpecifier.name);
               imports.push({ moduleName, exportName });
               continue;
             }
@@ -5816,8 +5941,9 @@ var addImport = (ts, sourceFile, changeTracker, preferences, effectAutoImport) =
   let description = "";
   switch (effectAutoImport._tag) {
     case "NamespaceImport": {
+      const aliasName = effectAutoImport.aliasName || effectAutoImport.name;
       const importModule = effectAutoImport.moduleName || effectAutoImport.fileName;
-      description = `Import * as ${effectAutoImport.name} from "${importModule}"`;
+      description = `Import * as ${aliasName} from "${importModule}"`;
       ts.insertImports(
         changeTracker,
         sourceFile,
@@ -5826,7 +5952,7 @@ var addImport = (ts, sourceFile, changeTracker, preferences, effectAutoImport) =
           ts.factory.createImportClause(
             false,
             void 0,
-            ts.factory.createNamespaceImport(ts.factory.createIdentifier(effectAutoImport.name))
+            ts.factory.createNamespaceImport(ts.factory.createIdentifier(aliasName))
           ),
           ts.factory.createStringLiteral(importModule)
         ),
@@ -5837,7 +5963,11 @@ var addImport = (ts, sourceFile, changeTracker, preferences, effectAutoImport) =
     }
     case "NamedImport": {
       const importModule = effectAutoImport.moduleName || effectAutoImport.fileName;
-      description = `Import { ${effectAutoImport.name} } from "${importModule}"`;
+      if (effectAutoImport.aliasName) {
+        description = `Import { ${effectAutoImport.name} as ${effectAutoImport.aliasName} } from "${importModule}"`;
+      } else {
+        description = `Import { ${effectAutoImport.name} } from "${importModule}"`;
+      }
       let foundImportDeclaration = false;
       for (const statement of sourceFile.statements) {
         if (ts.isImportDeclaration(statement)) {
@@ -5846,9 +5976,12 @@ var addImport = (ts, sourceFile, changeTracker, preferences, effectAutoImport) =
             const importClause = statement.importClause;
             if (importClause && importClause.namedBindings && ts.isNamedImports(importClause.namedBindings)) {
               const namedImports = importClause.namedBindings;
-              const existingImportSpecifier = namedImports.elements.find(
-                (element) => element.name.text === effectAutoImport.name
-              );
+              const existingImportSpecifier = namedImports.elements.find((element) => {
+                if (effectAutoImport.aliasName) {
+                  return ts.idText(element.name) === effectAutoImport.name && element.propertyName && ts.isIdentifier(element.propertyName) && ts.idText(element.propertyName) === effectAutoImport.aliasName;
+                }
+                return ts.idText(element.name) === effectAutoImport.name;
+              });
               if (existingImportSpecifier) {
                 foundImportDeclaration = true;
                 break;
@@ -5860,8 +5993,8 @@ var addImport = (ts, sourceFile, changeTracker, preferences, effectAutoImport) =
                   namedImports.elements.concat([
                     ts.factory.createImportSpecifier(
                       false,
-                      void 0,
-                      ts.factory.createIdentifier(effectAutoImport.name)
+                      effectAutoImport.aliasName ? ts.factory.createIdentifier(effectAutoImport.name) : void 0,
+                      ts.factory.createIdentifier(effectAutoImport.aliasName || effectAutoImport.name)
                     )
                   ])
                 )
@@ -5885,8 +6018,8 @@ var addImport = (ts, sourceFile, changeTracker, preferences, effectAutoImport) =
                 [
                   ts.factory.createImportSpecifier(
                     false,
-                    void 0,
-                    ts.factory.createIdentifier(effectAutoImport.name)
+                    effectAutoImport.aliasName ? ts.factory.createIdentifier(effectAutoImport.name) : void 0,
+                    ts.factory.createIdentifier(effectAutoImport.aliasName || effectAutoImport.name)
                   )
                 ]
               )
@@ -6094,22 +6227,26 @@ function effectRpcDefinition(applicableGotoDefinition, sourceFile, position) {
     const textRange = tsUtils.toTextRange(position);
     function isSymbolFromEffectRpcModule(symbol3) {
       if (symbol3.valueDeclaration) {
-        const sourceFile2 = symbol3.valueDeclaration.getSourceFile();
-        const packageInfo = tsUtils.parsePackageContentNameAndVersionFromScope(sourceFile2);
-        if (packageInfo && packageInfo.name === "@effect/rpc") {
-          const fileSymbol = typeChecker.getSymbolAtLocation(sourceFile2);
-          return fileSymbol && fileSymbol.exports && fileSymbol.exports.has("isRpc") && fileSymbol.exports.has("make") && fileSymbol.exports.has("fromTaggedRequest");
+        const sourceFile2 = tsUtils.getSourceFileOfNode(symbol3.valueDeclaration);
+        if (sourceFile2) {
+          const packageInfo = tsUtils.parsePackageContentNameAndVersionFromScope(sourceFile2);
+          if (packageInfo && packageInfo.name === "@effect/rpc") {
+            const fileSymbol = typeChecker.getSymbolAtLocation(sourceFile2);
+            return fileSymbol && fileSymbol.exports && fileSymbol.exports.has("isRpc") && fileSymbol.exports.has("make") && fileSymbol.exports.has("fromTaggedRequest");
+          }
         }
       }
       return false;
     }
     function isSymbolFromEffectRpcClientModule(symbol3) {
       if (symbol3.valueDeclaration) {
-        const sourceFile2 = symbol3.valueDeclaration.getSourceFile();
-        const packageInfo = tsUtils.parsePackageContentNameAndVersionFromScope(sourceFile2);
-        if (packageInfo && packageInfo.name === "@effect/rpc") {
-          const fileSymbol = typeChecker.getSymbolAtLocation(sourceFile2);
-          return fileSymbol && fileSymbol.exports && fileSymbol.exports.has("RpcClient") && fileSymbol.exports.has("make");
+        const sourceFile2 = tsUtils.getSourceFileOfNode(symbol3.valueDeclaration);
+        if (sourceFile2) {
+          const packageInfo = tsUtils.parsePackageContentNameAndVersionFromScope(sourceFile2);
+          if (packageInfo && packageInfo.name === "@effect/rpc") {
+            const fileSymbol = typeChecker.getSymbolAtLocation(sourceFile2);
+            return fileSymbol && fileSymbol.exports && fileSymbol.exports.has("RpcClient") && fileSymbol.exports.has("make");
+          }
         }
       }
       return false;
@@ -6121,7 +6258,7 @@ function effectRpcDefinition(applicableGotoDefinition, sourceFile, position) {
         const type = typeChecker.getTypeAtLocation(node);
         for (const callSig of typeChecker.getSignaturesOfType(type, ts.SignatureKind.Call)) {
           if (callSig.parameters.length >= 2 && isSymbolFromEffectRpcClientModule(callSig.parameters[1])) {
-            rpcName = node.name.text;
+            rpcName = ts.idText(node.name);
             callNode = node.name;
           }
         }
@@ -6149,7 +6286,7 @@ function effectRpcDefinition(applicableGotoDefinition, sourceFile, position) {
       ts.forEachChild(fileToTest, appendNodeToVisit);
       while (result.length === 0 && nodeToVisit.length > 0) {
         const node = nodeToVisit.shift();
-        if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.name) && (node.expression.name.text === "make" || node.expression.name.text === "fromTaggedRequest")) {
+        if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.name) && (ts.idText(node.expression.name) === "make" || ts.idText(node.expression.name) === "fromTaggedRequest")) {
           const symbol3 = typeChecker.getSymbolAtLocation(node.expression.name);
           if (symbol3 && isSymbolFromEffectRpcModule(symbol3)) {
             const type = typeChecker.getTypeAtLocation(node);
@@ -11273,11 +11410,11 @@ var effectGenToFn = createRefactor({
       parentNodes,
       filter((_) => ts.isVariableDeclaration(_) && _.initializer ? true : false),
       filter((_) => tsUtils.isNodeInRange(textRange)(_.name)),
-      map4((_) => _.initializer)
+      map5((_) => _.initializer)
     );
     const maybeNode = yield* pipe(
       nodesFromInitializers.concat(parentNodes),
-      map4(parseFunctionLikeReturnEffectGen),
+      map5(parseFunctionLikeReturnEffectGen),
       firstSuccessOf,
       option
     );
@@ -11285,7 +11422,7 @@ var effectGenToFn = createRefactor({
     const { effectModule, fnIdentifier, generatorFunction, nodeToReplace, pipeArgs } = maybeNode.value;
     return {
       kind: "refactor.rewrite.effect.effectGenToFn",
-      description: fnIdentifier ? `Convert to Effect.fn("${fnIdentifier.text}")` : "Convert to Effect.fn",
+      description: fnIdentifier ? `Convert to Effect.fn("${ts.idText(fnIdentifier)}")` : "Convert to Effect.fn",
       apply: pipe(
         gen(function* () {
           const changeTracker = yield* service(ChangeTracker);
@@ -11295,7 +11432,7 @@ var effectGenToFn = createRefactor({
               "fn"
             ),
             void 0,
-            [ts.factory.createStringLiteral(fnIdentifier.text)]
+            [ts.factory.createStringLiteral(ts.idText(fnIdentifier))]
           ) : ts.factory.createPropertyAccessExpression(
             effectModule,
             "fn"
@@ -11383,6 +11520,301 @@ var functionToArrow = createRefactor({
   })
 });
 
+// src/refactors/layerMagic.ts
+function sortDependencies(nodes) {
+  const result = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const cycles = [];
+  const providesMap = /* @__PURE__ */ new Map();
+  Object.entries(nodes).forEach(([nodeId, node]) => {
+    node.provides.forEach((service2) => {
+      if (!providesMap.has(service2)) {
+        providesMap.set(service2, []);
+      }
+      providesMap.get(service2).push(nodeId);
+    });
+  });
+  providesMap.forEach((nodeIds) => {
+    nodeIds.sort((a, b) => {
+      const nodeA = nodes[a];
+      const nodeB = nodes[b];
+      return nodeA.requires.length - nodeB.requires.length;
+    });
+  });
+  const visit = (nodeId, path) => {
+    if (visited.has(nodeId)) {
+      return;
+    }
+    if (visiting.has(nodeId)) {
+      const cycleStart = path.indexOf(nodeId);
+      const cycle = path.slice(cycleStart).concat([nodeId]);
+      const cycleServices = cycle.map((id) => {
+        const node2 = nodes[id];
+        return `${node2.provides.join(", ")} (requires: ${node2.requires.join(", ")})`;
+      });
+      cycles.push(cycleServices);
+      return;
+    }
+    visiting.add(nodeId);
+    const currentPath = [...path, nodeId];
+    const dependencies = /* @__PURE__ */ new Set();
+    const node = nodes[nodeId];
+    node.requires.forEach((requiredService) => {
+      const providers = providesMap.get(requiredService) || [];
+      providers.forEach((providerId) => {
+        if (providerId !== nodeId) {
+          dependencies.add(providerId);
+        }
+      });
+    });
+    dependencies.forEach((depId) => {
+      visit(depId, currentPath);
+    });
+    visiting.delete(nodeId);
+    visited.add(nodeId);
+    result.push(node);
+  };
+  Object.keys(nodes).forEach((nodeId) => {
+    if (!visited.has(nodeId)) {
+      visit(nodeId, []);
+    }
+  });
+  return {
+    sorted: result,
+    cycles,
+    hasCycles: cycles.length > 0
+  };
+}
+var layerMagic = createRefactor({
+  name: "layerMagic",
+  description: "Layer Magic",
+  apply: fn("layerMagic.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 typeCheckerUtils = yield* service(TypeCheckerUtils);
+    const layerIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+      sourceFile,
+      "effect",
+      "Layer"
+    ) || "Layer";
+    const extractArrayLiteral = (node) => {
+      if (ts.isArrayLiteralExpression(node)) {
+        return pipe(
+          all(...node.elements.map((element) => extractLayers(element, false))),
+          map3(flatten)
+        );
+      }
+      return TypeParserIssue.issue;
+    };
+    const extractLayerExpression = (node) => {
+      if (ts.isExpression(node)) {
+        return pipe(
+          typeParser.layerType(typeChecker.getTypeAtLocation(node), node),
+          map3((_) => [{ node, ..._ }])
+        );
+      }
+      return TypeParserIssue.issue;
+    };
+    const extractLayerApi = (node) => {
+      if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression) && ts.idText(node.expression.expression) === layerIdentifier && ts.isIdentifier(node.expression.name) && ["provide", "provideMerge", "merge", "mergeAll"].map((_) => _.toLowerCase()).indexOf(
+        ts.idText(node.expression.name).toLowerCase()
+      ) > -1) {
+        return pipe(
+          all(...node.arguments.map((element) => extractLayers(element, false))),
+          map3(flatten)
+        );
+      }
+      return TypeParserIssue.issue;
+    };
+    const extractPipeSequencing = (node) => {
+      return pipe(
+        typeParser.pipeCall(node),
+        flatMap((_) => {
+          return all(...[_.subject, ..._.args].map((element) => extractLayers(element, true)));
+        }),
+        map3(flatten)
+      );
+    };
+    const extractLayers = cachedBy(
+      fn("layerMagic.apply.extractLayerArray")(function* (node, _inPipeContext) {
+        return yield* pipe(
+          extractArrayLiteral(node),
+          orElse2(() => extractLayerApi(node)),
+          _inPipeContext ? (x) => x : orElse2(() => extractPipeSequencing(node)),
+          orElse2(() => extractLayerExpression(node))
+        );
+      }),
+      "layerMagic.apply.extractLayerArray",
+      (node) => node
+    );
+    const adjustedNode = (node) => {
+      if (ts.isIdentifier(node) && ts.isVariableDeclaration(node.parent) && node.parent.initializer) {
+        return adjustedNode(node.parent.initializer);
+      }
+      if (ts.isIdentifier(node) && ts.isPropertyDeclaration(node.parent) && node.parent.initializer) {
+        return adjustedNode(node.parent.initializer);
+      }
+      return node;
+    };
+    const computeAsAnyAsLayerRefactor = (node) => {
+      const atLocation = adjustedNode(node);
+      return pipe(
+        extractLayers(atLocation, false),
+        flatMap(
+          (extractedLayer) => extractedLayer.length < 1 ? TypeParserIssue.issue : succeed(extractedLayer)
+        ),
+        map3((extractedLayers) => ({
+          kind: "refactor.rewrite.effect.layerMagicPrepare",
+          description: "Prepare layers for automatic composition",
+          apply: pipe(
+            gen(function* () {
+              const changeTracker = yield* service(ChangeTracker);
+              const memory = /* @__PURE__ */ new Map();
+              for (const layer of extractedLayers) {
+                yield* typeCheckerUtils.appendToUniqueTypesMap(
+                  memory,
+                  layer.ROut,
+                  (_) => succeed((_.flags & ts.TypeFlags.Never) !== 0)
+                );
+              }
+              const typeReferences = pipe(
+                fromIterable(memory.values()),
+                sort(typeCheckerUtils.deterministicTypeOrder),
+                map5((_) => typeChecker.typeToTypeNode(_, void 0, ts.NodeBuilderFlags.NoTruncation)),
+                filter((_) => !!_)
+              );
+              const newDeclaration = ts.factory.createAsExpression(
+                ts.factory.createAsExpression(
+                  ts.factory.createArrayLiteralExpression(extractedLayers.map((_) => _.node)),
+                  ts.factory.createTypeReferenceNode("any")
+                ),
+                ts.factory.createTypeReferenceNode(
+                  ts.factory.createQualifiedName(ts.factory.createIdentifier(layerIdentifier), "Layer"),
+                  typeReferences.length === 0 ? [
+                    ts.factory.createTypeReferenceNode("never")
+                  ] : [ts.factory.createUnionTypeNode(typeReferences)]
+                )
+              );
+              changeTracker.replaceNode(sourceFile, atLocation, newDeclaration, {
+                leadingTriviaOption: ts.textChanges.LeadingTriviaOption.IncludeAll,
+                trailingTriviaOption: ts.textChanges.TrailingTriviaOption.Exclude
+              });
+            }),
+            provideService(TypeScriptApi, ts)
+          )
+        }))
+      );
+    };
+    const parseAsAnyAsLayer = (node) => {
+      if (ts.isAsExpression(node) && ts.isTypeReferenceNode(node.type)) {
+        const expression = node.expression;
+        if (ts.isAsExpression(expression) && expression.type.kind === ts.SyntaxKind.AnyKeyword) {
+          return pipe(
+            typeParser.layerType(typeChecker.getTypeAtLocation(node.type), node.type),
+            map3((_) => ({ node, ..._, castedStructure: expression.expression }))
+          );
+        }
+      }
+      return TypeParserIssue.issue;
+    };
+    const computeBuildRefactor = (node) => {
+      const atLocation = adjustedNode(node);
+      return pipe(
+        parseAsAnyAsLayer(atLocation),
+        flatMap(
+          (_targetLayer) => pipe(
+            extractArrayLiteral(_targetLayer.castedStructure),
+            orElse2(() => extractLayers(_targetLayer.castedStructure, false)),
+            flatMap(
+              (extractedLayer) => extractedLayer.length < 1 ? TypeParserIssue.issue : succeed(extractedLayer)
+            ),
+            map3((extractedLayers) => ({
+              kind: "refactor.rewrite.effect.layerMagicBuild",
+              description: "Compose layers automatically with target output services",
+              apply: gen(function* () {
+                const changeTracker = yield* service(ChangeTracker);
+                const memory = /* @__PURE__ */ new Map();
+                const { allIndexes: outputIndexes } = yield* typeCheckerUtils.appendToUniqueTypesMap(
+                  memory,
+                  _targetLayer.ROut,
+                  (_) => succeed((_.flags & ts.TypeFlags.Never) !== 0)
+                );
+                const nodes = {};
+                for (let i = 0; i < extractedLayers.length; i++) {
+                  const layer = extractedLayers[i];
+                  const { allIndexes: providedIndexes } = yield* typeCheckerUtils.appendToUniqueTypesMap(
+                    memory,
+                    layer.ROut,
+                    (_) => succeed((_.flags & ts.TypeFlags.Never) !== 0)
+                  );
+                  const { allIndexes: requiredIndexes } = yield* typeCheckerUtils.appendToUniqueTypesMap(
+                    memory,
+                    layer.RIn,
+                    (_) => succeed((_.flags & ts.TypeFlags.Never) !== 0)
+                  );
+                  nodes[`node_${i}`] = {
+                    provides: providedIndexes.filter((_) => requiredIndexes.indexOf(_) === -1),
+                    // only provide indexes that are not required
+                    requires: requiredIndexes,
+                    node: layer.node
+                  };
+                }
+                const sortResult = sortDependencies(nodes);
+                const sortedNodes = sortResult.sorted.reverse();
+                const missingOutput = new Set(outputIndexes);
+                const missingInternal = /* @__PURE__ */ new Set();
+                const outputEntry = [];
+                for (const graphNode of sortedNodes) {
+                  const mergeOutput = graphNode.provides.filter((_) => missingOutput.has(_));
+                  const provideInternal = graphNode.provides.filter((_) => missingInternal.has(_));
+                  graphNode.requires.forEach((_) => missingInternal.add(_));
+                  mergeOutput.forEach((_) => missingOutput.delete(_));
+                  outputEntry.push({
+                    merges: mergeOutput.length > 0,
+                    provides: provideInternal.length > 0,
+                    node: graphNode.node
+                  });
+                }
+                const newDeclaration = ts.factory.createCallExpression(
+                  ts.factory.createPropertyAccessExpression(
+                    outputEntry[0].node,
+                    "pipe"
+                  ),
+                  [],
+                  outputEntry.slice(1).map(
+                    (_) => ts.factory.createCallExpression(
+                      ts.factory.createPropertyAccessExpression(
+                        ts.factory.createIdentifier(layerIdentifier),
+                        _.merges && _.provides ? "provideMerge" : _.merges ? "merge" : "provide"
+                      ),
+                      [],
+                      [_.node]
+                    )
+                  )
+                );
+                changeTracker.replaceNode(sourceFile, atLocation, newDeclaration, {
+                  leadingTriviaOption: ts.textChanges.LeadingTriviaOption.IncludeAll,
+                  trailingTriviaOption: ts.textChanges.TrailingTriviaOption.Exclude
+                });
+              })
+            }))
+          )
+        )
+      );
+    };
+    const parentNodes = tsUtils.getAncestorNodesInRange(sourceFile, textRange);
+    if (parentNodes.length === 0) return yield* fail(new RefactorNotApplicableError());
+    return yield* pipe(
+      firstSuccessOf(parentNodes.map(computeBuildRefactor)),
+      orElse2(() => firstSuccessOf(parentNodes.map(computeAsAnyAsLayerRefactor))),
+      orElse2(() => fail(new RefactorNotApplicableError()))
+    );
+  })
+});
+
 // src/refactors/makeSchemaOpaque.ts
 var _findSchemaVariableDeclaration = fn(
   "makeSchemaOpaque._findSchemaVariableDeclaration"
@@ -11416,7 +11848,7 @@ var _findSchemaVariableDeclaration = fn(
     );
     return yield* pipe(
       tsUtils.getAncestorNodesInRange(sourceFile, textRange),
-      map4(findSchema),
+      map5(findSchema),
       firstSuccessOf,
       option
     );
@@ -11518,15 +11950,15 @@ var makeSchemaOpaque = createRefactor({
             "effect",
             "Schema"
           ) || "Schema";
-          const newIdentifier = ts.factory.createIdentifier(identifier.text + "_");
+          const newIdentifier = ts.factory.createIdentifier(ts.idText(identifier) + "_");
           const { contextType, encodedType, opaqueType } = yield* _createOpaqueTypes(
             effectSchemaName,
-            newIdentifier.text,
+            ts.idText(newIdentifier),
             types.A,
-            identifier.text,
+            ts.idText(identifier),
             types.I,
-            identifier.text + "Encoded",
-            identifier.text + "Context"
+            ts.idText(identifier) + "Encoded",
+            ts.idText(identifier) + "Context"
           );
           changeTracker.replaceNode(
             sourceFile,
@@ -11551,10 +11983,10 @@ var makeSchemaOpaque = createRefactor({
             variableStatement.modifiers,
             ts.factory.createVariableDeclarationList(
               [ts.factory.createVariableDeclaration(
-                identifier.text,
+                ts.idText(identifier),
                 void 0,
                 newSchemaType,
-                ts.factory.createIdentifier(newIdentifier.text)
+                ts.factory.createIdentifier(ts.idText(newIdentifier))
               )],
               variableDeclarationList.flags
             )
@@ -11589,19 +12021,19 @@ var makeSchemaOpaqueWithNs = createRefactor({
             "effect",
             "Schema"
           ) || "Schema";
-          const newIdentifier = ts.factory.createIdentifier(identifier.text + "_");
+          const newIdentifier = ts.factory.createIdentifier(ts.idText(identifier) + "_");
           const { contextType, encodedType, opaqueType } = yield* _createOpaqueTypes(
             effectSchemaName,
-            newIdentifier.text,
+            ts.idText(newIdentifier),
             types.A,
-            identifier.text,
+            ts.idText(identifier),
             types.I,
             "Encoded",
             "Context"
           );
           const namespace = ts.factory.createModuleDeclaration(
             [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
-            ts.factory.createIdentifier(identifier.text),
+            ts.factory.createIdentifier(ts.idText(identifier)),
             ts.factory.createModuleBlock([
               encodedType,
               contextType
@@ -11615,6 +12047,7 @@ var makeSchemaOpaqueWithNs = createRefactor({
           );
           changeTracker.insertNodeAfter(sourceFile, variableStatement, opaqueType);
           changeTracker.insertNodeAfter(sourceFile, variableStatement, namespace);
+          const namespaceName = ts.isStringLiteral(namespace.name) ? namespace.name.text : ts.idText(namespace.name);
           const newSchemaType = ts.factory.createTypeReferenceNode(
             ts.factory.createQualifiedName(
               ts.factory.createIdentifier(effectSchemaName),
@@ -11624,13 +12057,15 @@ var makeSchemaOpaqueWithNs = createRefactor({
               ts.factory.createTypeReferenceNode(opaqueType.name),
               ts.factory.createTypeReferenceNode(
                 ts.factory.createQualifiedName(
-                  ts.factory.createIdentifier(namespace.name.text),
-                  encodedType.name
+                  ts.factory.createIdentifier(
+                    namespaceName
+                  ),
+                  ts.idText(encodedType.name)
                 )
               ),
               ts.factory.createTypeReferenceNode(ts.factory.createQualifiedName(
-                ts.factory.createIdentifier(namespace.name.text),
-                contextType.name
+                ts.factory.createIdentifier(namespaceName),
+                ts.idText(contextType.name)
               ))
             ]
           );
@@ -11638,10 +12073,10 @@ var makeSchemaOpaqueWithNs = createRefactor({
             variableStatement.modifiers,
             ts.factory.createVariableDeclarationList(
               [ts.factory.createVariableDeclaration(
-                identifier.text,
+                ts.idText(identifier),
                 void 0,
                 newSchemaType,
-                ts.factory.createIdentifier(newIdentifier.text)
+                ts.factory.createIdentifier(ts.idText(newIdentifier))
               )],
               variableDeclarationList.flags
             )
@@ -11667,7 +12102,7 @@ var pipeableToDatafirst = createRefactor({
       if (!ts.isCallExpression(node2)) return false;
       const expression = node2.expression;
       if (!ts.isIdentifier(expression)) return false;
-      if (expression.text !== "pipe") return false;
+      if (ts.idText(expression) !== "pipe") return false;
       return true;
     }
     function asDataFirstExpression(node2, self) {
@@ -11699,7 +12134,7 @@ var pipeableToDatafirst = createRefactor({
       filter(
         (node2) => node2.arguments.length > 0
       ),
-      map4((node2) => {
+      map5((node2) => {
         let newNode2 = node2.arguments[0];
         let didSomething = false;
         for (let i = 1; i < node2.arguments.length; i++) {
@@ -11726,7 +12161,7 @@ var pipeableToDatafirst = createRefactor({
         return didSomething ? some2([node2, newNode2]) : none2();
       }),
       filter(isSome2),
-      map4((_) => _.value),
+      map5((_) => _.value),
       head
     );
     if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
@@ -11876,6 +12311,7 @@ var toggleReturnTypeAnnotation = createRefactor({
     const ts = yield* service(TypeScriptApi);
     const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
     function addReturnTypeAnnotation(sourceFile2, changeTracker, declaration, typeNode) {
       const closeParen = ts.findChildOfKind(declaration, ts.SyntaxKind.CloseParenToken, sourceFile2);
       const needParens = ts.isArrowFunction(declaration) && closeParen === void 0;
@@ -11923,10 +12359,10 @@ var toggleReturnTypeAnnotation = createRefactor({
         )
       };
     }
-    const returnType = yield* option(getInferredReturnType(node));
-    if (isNone2(returnType)) return yield* fail(new RefactorNotApplicableError());
+    const returnType = typeCheckerUtils.getInferredReturnType(node);
+    if (!returnType) return yield* fail(new RefactorNotApplicableError());
     const returnTypeNode = typeChecker.typeToTypeNode(
-      returnType.value,
+      returnType,
       node,
       ts.NodeBuilderFlags.NoTruncation
     );
@@ -12071,12 +12507,12 @@ var makeSchemaGenContext = fn("SchemaGen.makeSchemaGenContext")(function* (sourc
     ),
     entityNameToDataTypeName: (name) => {
       if (ts.isIdentifier(name)) {
-        switch (name.text) {
+        switch (ts.idText(name)) {
           case "Date":
           case "Pick":
           case "Omit":
           case "Record":
-            return some2(name.text);
+            return some2(ts.idText(name));
           case "ReadonlyArray":
           case "Array":
             return some2("Array");
@@ -12085,7 +12521,7 @@ var makeSchemaGenContext = fn("SchemaGen.makeSchemaGenContext")(function* (sourc
       }
       if (!ts.isIdentifier(name.left)) return none2();
       for (const moduleName in moduleToImportedName) {
-        if (name.left.text === moduleToImportedName[moduleName] && name.right.text === moduleName) {
+        if (ts.idText(name.left) === moduleToImportedName[moduleName] && ts.idText(name.right) === moduleName) {
           return some2(moduleName);
         }
       }
@@ -12099,11 +12535,11 @@ var typeEntityNameToNode = fn(
 )(
   function* (entityName) {
     const { ts } = yield* service(SchemaGenContext);
-    if (ts.isIdentifier(entityName)) return ts.factory.createIdentifier(entityName.text);
+    if (ts.isIdentifier(entityName)) return ts.factory.createIdentifier(ts.idText(entityName));
     const left3 = yield* typeEntityNameToNode(entityName.left);
     return ts.factory.createPropertyAccessExpression(
       left3,
-      ts.factory.createIdentifier(entityName.right.text)
+      ts.factory.createIdentifier(ts.idText(entityName.right))
     );
   }
 );
@@ -12348,13 +12784,13 @@ var processInterfaceDeclaration = fn("SchemaGen.processInterfaceDeclaration")(
     );
     const { properties, records } = yield* processMembers(node.members, false);
     if (preferClass && records.length === 0) {
-      return yield* createExportSchemaClassDeclaration(node.name.text, properties);
+      return yield* createExportSchemaClassDeclaration(ts.idText(node.name), properties);
     }
     const schemaStruct = createApiCall(
       "Struct",
       [ts.factory.createObjectLiteralExpression(properties, true)].concat(records)
     );
-    return yield* createExportVariableDeclaration(node.name.text, schemaStruct);
+    return yield* createExportVariableDeclaration(ts.idText(node.name), schemaStruct);
   }
 );
 var processTypeAliasDeclaration = fn("SchemaGen.processInterfaceDeclaration")(
@@ -12366,11 +12802,11 @@ var processTypeAliasDeclaration = fn("SchemaGen.processInterfaceDeclaration")(
     if (preferClass && ts.isTypeLiteralNode(node.type)) {
       const { properties, records } = yield* processMembers(node.type.members, false);
       if (records.length === 0) {
-        return yield* createExportSchemaClassDeclaration(node.name.text, properties);
+        return yield* createExportSchemaClassDeclaration(ts.idText(node.name), properties);
       }
     }
     const effectSchema = yield* processNode(node.type, false);
-    return yield* createExportVariableDeclaration(node.name.text, effectSchema);
+    return yield* createExportVariableDeclaration(ts.idText(node.name), effectSchema);
   }
 );
 var createExportVariableDeclaration = fn("SchemaGen.createExportVariableDeclaration")(
@@ -12475,6 +12911,7 @@ var typeToEffectSchema = createRefactor({
     const ts = yield* service(TypeScriptApi);
     const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const maybeNode = yield* findNodeToProcess(sourceFile, textRange);
     if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
     const node = maybeNode.value;
@@ -12485,7 +12922,8 @@ var typeToEffectSchema = createRefactor({
         applyAtNode(sourceFile, node, false),
         provideService(TypeCheckerApi, typeChecker),
         provideService(TypeScriptUtils, tsUtils),
-        provideService(TypeScriptApi, ts)
+        provideService(TypeScriptApi, ts),
+        provideService(TypeCheckerUtils, typeCheckerUtils)
       )
     };
   })
@@ -12499,6 +12937,7 @@ var typeToEffectSchemaClass = createRefactor({
     const ts = yield* service(TypeScriptApi);
     const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const maybeNode = yield* findNodeToProcess(sourceFile, textRange);
     if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
     const node = maybeNode.value;
@@ -12509,7 +12948,8 @@ var typeToEffectSchemaClass = createRefactor({
         applyAtNode(sourceFile, node, true),
         provideService(TypeCheckerApi, typeChecker),
         provideService(TypeScriptUtils, tsUtils),
-        provideService(TypeScriptApi, ts)
+        provideService(TypeScriptApi, ts),
+        provideService(TypeCheckerUtils, typeCheckerUtils)
       )
     };
   })
@@ -12536,7 +12976,7 @@ var wrapWithEffectGen = createRefactor({
     );
     const maybeNode = yield* pipe(
       tsUtils.getAncestorNodesInRange(sourceFile, textRange),
-      map4(findEffectToWrap),
+      map5(findEffectToWrap),
       firstSuccessOf,
       option
     );
@@ -12587,6 +13027,7 @@ var wrapWithPipe = createRefactor({
 
 // src/refactors.ts
 var refactors = [
+  layerMagic,
   asyncAwaitToGen,
   asyncAwaitToGenTryPromise,
   asyncAwaitToFn,
@@ -12608,6 +13049,57 @@ var refactors = [
   writeTagClassAccessors
 ];
 
+// src/renames/keyStrings.ts
+var renameKeyStrings = (sourceFile, position, _findInStrings, _findInComments, _preferences, renameLocations) => gen(function* () {
+  const ts = yield* service(TypeScriptApi);
+  const tsUtils = yield* service(TypeScriptUtils);
+  const typeParser = yield* service(TypeParser);
+  const additionalPositions = [];
+  const node = tsUtils.findNodeAtPositionIncludingTrivia(sourceFile, position);
+  if (node && ts.isIdentifier(node)) {
+    const textToReplace = ts.idText(node);
+    const parentClass = node.parent;
+    if (ts.isClassDeclaration(parentClass) && parentClass.name === node) {
+      const baseIdentifier = yield* pipe(
+        map3(typeParser.extendsContextTag(parentClass), (_) => [_.keyStringLiteral]),
+        orElse2(() => map3(typeParser.extendsEffectService(parentClass), (_) => [_.keyStringLiteral])),
+        orElse2(
+          () => map3(typeParser.extendsSchemaTaggedClass(parentClass), (_) => [_.keyStringLiteral, _.tagStringLiteral])
+        ),
+        orElse2(
+          () => map3(typeParser.extendsSchemaTaggedError(parentClass), (_) => [_.keyStringLiteral, _.tagStringLiteral])
+        ),
+        orElse2(() => map3(typeParser.extendsDataTaggedError(parentClass), (_) => [_.keyStringLiteral])),
+        orElse2(() => map3(typeParser.extendsDataTaggedClass(parentClass), (_) => [_.keyStringLiteral])),
+        orElse2(
+          () => map3(
+            typeParser.extendsSchemaTaggedRequest(parentClass),
+            (_) => [_.keyStringLiteral, _.tagStringLiteral]
+          )
+        ),
+        option
+      );
+      if (isSome2(baseIdentifier)) {
+        for (const keyStringLiteral of baseIdentifier.value) {
+          if (!keyStringLiteral) continue;
+          const baseText = sourceFile.text.slice(keyStringLiteral.pos, keyStringLiteral.end);
+          const lastIndex = baseText.lastIndexOf(textToReplace);
+          if (lastIndex !== -1) {
+            additionalPositions.push({
+              fileName: sourceFile.fileName,
+              textSpan: {
+                start: keyStringLiteral.pos + lastIndex,
+                length: textToReplace.length
+              }
+            });
+          }
+        }
+      }
+    }
+  }
+  return additionalPositions.length === 0 ? renameLocations : additionalPositions.concat(renameLocations || []);
+});
+
 // src/index.ts
 var LSP_INJECTED_URI = "@effect/language-service/injected";
 var init = (modules) => {
@@ -12940,6 +13432,37 @@ var init = (modules) => {
       }
       return applicableInlayHints;
     };
+    proxy.findRenameLocations = (fileName, position, findInStrings, findInComments, userPreferences, ...args2) => {
+      const applicableRenameInfo = languageService.findRenameLocations(
+        fileName,
+        position,
+        findInStrings,
+        findInComments,
+        userPreferences,
+        ...args2
+      );
+      if (languageServicePluginOptions.renames) {
+        const program = languageService.getProgram();
+        if (program) {
+          const sourceFile = program.getSourceFile(fileName);
+          if (sourceFile) {
+            return pipe(
+              renameKeyStrings(
+                sourceFile,
+                position,
+                findInStrings,
+                findInComments,
+                userPreferences,
+                applicableRenameInfo
+              ),
+              runNano(program),
+              getOrElse(() => applicableRenameInfo)
+            );
+          }
+        }
+      }
+      return applicableRenameInfo;
+    };
     return proxy;
   }
   return { create, onConfigurationChanged };