@effect/language-service 0.18.0 → 0.20.0

package/index.js

@@ -5,7 +5,7 @@ var __export = (target, all3) => {
     __defProp(target, name, { get: all3[name], enumerable: true });
 };
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/Function.js
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Function.js
 var isFunction = (input) => typeof input === "function";
 var dual = function(arity, body) {
   if (typeof arity === "function") {
@@ -102,7 +102,7 @@ function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
   }
 }
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/Either.js
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Either.js
 var Either_exports = {};
 __export(Either_exports, {
   Do: () => Do,
@@ -146,7 +146,7 @@ __export(Either_exports, {
   zipWith: () => zipWith
 });
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/Equivalence.js
+// node_modules/.pnpm/effect@3.16.5/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) {
@@ -161,7 +161,7 @@ var array = (item) => make((self, that) => {
   return true;
 });
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/internal/doNotation.js
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/internal/doNotation.js
 var let_ = (map5) => dual(3, (self, name, f) => map5(self, (a) => Object.assign({}, a, {
   [name]: f(a)
 })));
@@ -172,11 +172,11 @@ var bind = (map5, flatMap4) => dual(3, (self, name, f) => flatMap4(self, (a) =>
   [name]: b
 }))));
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/internal/version.js
-var moduleVersion = "3.16.3";
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/internal/version.js
+var moduleVersion = "3.16.5";
 var getCurrentVersion = () => moduleVersion;
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/GlobalValue.js
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/GlobalValue.js
 var globalStoreId = `effect/GlobalValue/globalStoreId/${/* @__PURE__ */ getCurrentVersion()}`;
 var globalStore;
 var globalValue = (id, compute) => {
@@ -190,7 +190,7 @@ var globalValue = (id, compute) => {
   return globalStore.get(id);
 };
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/Predicate.js
+// node_modules/.pnpm/effect@3.16.5/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";
@@ -199,10 +199,10 @@ var isRecordOrArray = (input) => typeof input === "object" && input !== null;
 var isObject = (input) => isRecordOrArray(input) || isFunction2(input);
 var hasProperty = /* @__PURE__ */ dual(2, (self, property) => isObject(self) && property in self);
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/internal/errors.js
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/internal/errors.js
 var getBugErrorMessage = (message) => `BUG: ${message} - please report an issue at https://github.com/Effect-TS/effect/issues`;
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/Utils.js
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Utils.js
 var GenKindTypeId = /* @__PURE__ */ Symbol.for("effect/Gen/GenKind");
 var isGenKind = (u) => isObject(u) && GenKindTypeId in u;
 var GenKindImpl = class {
@@ -338,7 +338,7 @@ var internalCall = isNotOptimizedAway ? standard.effect_internal_function : forc
 var genConstructor = function* () {
 }.constructor;
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/Hash.js
+// node_modules/.pnpm/effect@3.16.5/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) => {
@@ -437,7 +437,7 @@ var cached = function() {
   return hash2;
 };
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/Equal.js
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Equal.js
 var symbol2 = /* @__PURE__ */ Symbol.for("effect/Equal");
 function equals() {
   if (arguments.length === 1) {
@@ -490,7 +490,7 @@ function compareBoth(self, that) {
 }
 var isEqual = (u) => hasProperty(u, symbol2);
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/Inspectable.js
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Inspectable.js
 var NodeInspectSymbol = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
 var toJSON = (x) => {
   try {
@@ -542,7 +542,7 @@ var redact = (u) => {
   return u;
 };
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/Pipeable.js
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Pipeable.js
 var pipeArguments = (self, args) => {
   switch (args.length) {
     case 0:
@@ -575,10 +575,10 @@ var pipeArguments = (self, args) => {
   }
 };
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/internal/opCodes/effect.js
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/internal/opCodes/effect.js
 var OP_COMMIT = "Commit";
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/internal/effectable.js
+// node_modules/.pnpm/effect@3.16.5/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");
@@ -665,7 +665,7 @@ var StructuralCommitPrototype = {
   ...StructuralPrototype
 };
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/internal/option.js
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/internal/option.js
 var TypeId = /* @__PURE__ */ Symbol.for("effect/Option");
 var CommonProto = {
   ...EffectPrototype,
@@ -723,7 +723,7 @@ var some = (value) => {
   return a;
 };
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/internal/either.js
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/internal/either.js
 var TypeId2 = /* @__PURE__ */ Symbol.for("effect/Either");
 var CommonProto2 = {
   ...EffectPrototype,
@@ -788,7 +788,7 @@ var getLeft = (self) => isRight(self) ? none : some(self.left);
 var getRight = (self) => isLeft(self) ? none : some(self.right);
 var fromOption = /* @__PURE__ */ dual(2, (self, onNone) => isNone(self) ? left(onNone()) : right(self.value));
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/Either.js
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Either.js
 var TypeId3 = TypeId2;
 var right2 = right;
 var void_ = /* @__PURE__ */ right2(void 0);
@@ -898,13 +898,13 @@ var transposeOption = (self) => {
 };
 var transposeMapOption = /* @__PURE__ */ dual(2, (self, f) => isNone(self) ? right2(none) : map(f(self.value), some));
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/internal/array.js
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/internal/array.js
 var isNonEmptyArray = (self) => self.length > 0;
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/Order.js
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Order.js
 var make2 = (compare) => (self, that) => self === that ? 0 : compare(self, that);
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/Option.js
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Option.js
 var none2 = () => none;
 var some2 = some;
 var isNone2 = isNone;
@@ -919,9 +919,10 @@ var fromNullable2 = (nullableValue) => nullableValue == null ? none2() : some2(n
 var getOrUndefined2 = /* @__PURE__ */ getOrElse2(constUndefined);
 var map2 = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : some2(f(self.value)));
 
-// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/Array.js
+// node_modules/.pnpm/effect@3.16.5/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)));
 var isArray = Array.isArray;
 var isEmptyArray = (self) => self.length === 0;
 var isEmptyReadonlyArray = isEmptyArray;
@@ -1136,6 +1137,27 @@ var all2 = (...args) => gen2(function* () {
 var TypeScriptApi = Tag("TypeScriptApi");
 var TypeScriptProgram = Tag("TypeScriptProgram");
 var ChangeTracker = Tag("ChangeTracker");
+function parsePackageContentNameAndVersionFromScope(v) {
+  if (!isObject(v)) return;
+  if (!hasProperty(v, "packageJsonScope")) return;
+  if (!v.packageJsonScope) return;
+  const packageJsonScope = v.packageJsonScope;
+  if (!hasProperty(packageJsonScope, "contents")) return;
+  if (!hasProperty(packageJsonScope.contents, "packageJsonContent")) return;
+  const packageJsonContent = packageJsonScope.contents.packageJsonContent;
+  if (!hasProperty(packageJsonContent, "name")) return;
+  if (!hasProperty(packageJsonContent, "version")) return;
+  const { name, version } = packageJsonContent;
+  if (!isString(name)) return;
+  if (!isString(version)) return;
+  const hasEffectInPeerDependencies = hasProperty(packageJsonContent, "peerDependencies") && isObject(packageJsonContent.peerDependencies) && hasProperty(packageJsonContent.peerDependencies, "effect");
+  return {
+    name: name.toLowerCase(),
+    version: version.toLowerCase(),
+    hasEffectInPeerDependencies,
+    contents: packageJsonContent
+  };
+}
 
 // src/core/AST.ts
 function collectSelfAndAncestorNodesInRange(node, textRange) {
@@ -1484,6 +1506,19 @@ var createReturnYieldStarStatement = fn("AST.createReturnYieldStarStatement")(
     );
   }
 );
+var parsePipeCall = fn("AST.parsePipeCall")(
+  function* (node) {
+    const ts = yield* service(TypeScriptApi);
+    if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.name) && node.expression.name.text === "pipe") {
+      return { node, subject: node.expression.expression, args: node.arguments };
+    }
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "pipe" && node.arguments.length > 0) {
+      const [subject, ...args] = node.arguments;
+      return { node, subject, args };
+    }
+    return yield* fail(new NodeNotFoundError());
+  }
+);
 
 // src/core/LSP.ts
 var RefactorNotApplicableError = class {
@@ -2094,6 +2129,51 @@ var expectedAndRealType = fn("TypeCheckerApi.expectedAndRealType")(function* (so
   cache.expectedAndRealType.set(sourceFile, result);
   return result;
 });
+var appendToUniqueTypesMap = fn(
+  "TypeCheckerApi.appendToUniqueTypesMap"
+)(
+  function* (memory, initialType, excludeNever) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const newIndexes = /* @__PURE__ */ new Set();
+    const knownIndexes = /* @__PURE__ */ new Set();
+    let toTest = [initialType];
+    while (toTest.length > 0) {
+      const type = toTest.pop();
+      if (!type) break;
+      if (excludeNever && type.flags & ts.TypeFlags.Never) {
+        continue;
+      }
+      if (type.isUnion()) {
+        toTest = toTest.concat(type.types);
+      } else {
+        const foundMatch = [];
+        for (const [typeId, knownType] of memory.entries()) {
+          const areSame = typeChecker.isTypeAssignableTo(knownType, type) && typeChecker.isTypeAssignableTo(type, knownType);
+          if (areSame) {
+            foundMatch.push(typeId);
+            break;
+          }
+        }
+        if (foundMatch.length === 0) {
+          const newId = "t" + (memory.size + 1);
+          memory.set(newId, type);
+          newIndexes.add(newId);
+        } else {
+          knownIndexes.add(foundMatch[0]);
+        }
+      }
+    }
+    return {
+      newIndexes,
+      knownIndexes,
+      allIndexes: pipe(
+        fromIterable(newIndexes),
+        appendAll(fromIterable(knownIndexes))
+      )
+    };
+  }
+);
 
 // src/utils/TypeParser.ts
 var TypeParserIssue = class {
@@ -2114,6 +2194,13 @@ function covariantTypeArgument(type) {
   }
   return succeed(signatures[0].getReturnType());
 }
+function contravariantTypeArgument(type) {
+  const signatures = type.getCallSignatures();
+  if (signatures.length !== 1) {
+    return typeParserIssue("Contravariant type has no call signature", type);
+  }
+  return succeed(signatures[0].getTypeParameterAtPosition(0));
+}
 function invariantTypeArgument(type) {
   const signatures = type.getCallSignatures();
   if (signatures.length !== 1) {
@@ -2145,6 +2232,19 @@ var varianceStructCovariantType = fn("TypeParser.varianceStructCovariantType")(
     return yield* covariantTypeArgument(propertyType);
   }
 );
+var varianceStructContravariantType = fn(
+  "TypeParser.varianceStructContravariantType"
+)(
+  function* (type, atLocation, propertyName) {
+    const typeChecker = yield* service(TypeCheckerApi);
+    const propertySymbol = typeChecker.getPropertyOfType(type, propertyName);
+    if (!propertySymbol) {
+      return yield* typeParserIssue(`Type has no '${propertyName}' property`, type, atLocation);
+    }
+    const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
+    return yield* contravariantTypeArgument(propertyType);
+  }
+);
 var varianceStructInvariantType = fn("TypeParser.varianceStructInvariantType")(
   function* (type, atLocation, propertyName) {
     const typeChecker = yield* service(TypeCheckerApi);
@@ -2163,6 +2263,13 @@ var effectVarianceStruct = fn("TypeParser.effectVarianceStruct")(function* (type
     R: yield* varianceStructCovariantType(type, atLocation, "_R")
   };
 });
+var layerVarianceStruct = fn("TypeParser.layerVarianceStruct")(function* (type, atLocation) {
+  return {
+    ROut: yield* varianceStructContravariantType(type, atLocation, "_ROut"),
+    E: yield* varianceStructCovariantType(type, atLocation, "_E"),
+    RIn: yield* varianceStructCovariantType(type, atLocation, "_RIn")
+  };
+});
 var effectType = fn("TypeParser.effectType")(function* (type, atLocation) {
   const ts = yield* service(TypeScriptApi);
   const typeChecker = yield* service(TypeCheckerApi);
@@ -2183,6 +2290,26 @@ var effectType = fn("TypeParser.effectType")(function* (type, atLocation) {
   }
   return yield* typeParserIssue("Type has no effect variance struct", type, atLocation);
 });
+var layerType = fn("TypeParser.layerType")(function* (type, atLocation) {
+  const ts = yield* service(TypeScriptApi);
+  const typeChecker = yield* service(TypeCheckerApi);
+  yield* pipeableType(type, atLocation);
+  const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
+    (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional)
+  );
+  propertiesSymbols.sort((a, b) => b.name.indexOf("LayerTypeId") - a.name.indexOf("LayerTypeId"));
+  for (const propertySymbol of propertiesSymbols) {
+    const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
+    const varianceArgs = yield* option(layerVarianceStruct(
+      propertyType,
+      atLocation
+    ));
+    if (isSome2(varianceArgs)) {
+      return varianceArgs.value;
+    }
+  }
+  return yield* typeParserIssue("Type has no layer variance struct", type, atLocation);
+});
 var fiberType = fn("TypeParser.fiberType")(function* (type, atLocation) {
   const typeChecker = yield* service(TypeCheckerApi);
   const awaitSymbol = typeChecker.getPropertyOfType(type, "await");
@@ -2348,19 +2475,68 @@ var effectFnGen = fn("TypeParser.effectFnGen")(function* (node) {
     functionStar: generatorFunction.getFirstToken()
   };
 });
-var returnYieldEffectBlock = fn("TypeParser.returnYieldEffectBlock")(function* (body) {
+var unnecessaryEffectGen = fn("TypeParser.unnecessaryEffectGen")(function* (node) {
   const ts = yield* service(TypeScriptApi);
   const typeChecker = yield* service(TypeCheckerApi);
-  if (ts.isBlock(body) && body.statements.length === 1 && ts.isReturnStatement(body.statements[0]) && body.statements[0].expression && ts.isYieldExpression(body.statements[0].expression) && body.statements[0].expression.expression) {
-    const nodeToCheck = body.statements[0].expression.expression;
-    const type = typeChecker.getTypeAtLocation(nodeToCheck);
-    yield* effectType(type, nodeToCheck);
-    return nodeToCheck;
+  const { body } = yield* effectGen(node);
+  if (body.statements.length !== 1) {
+    return yield* typeParserIssue(
+      "Generator body should have a single statement",
+      void 0,
+      node
+    );
+  }
+  let explicitReturn = false;
+  let nodeToCheck = body.statements[0];
+  while (nodeToCheck) {
+    if (ts.isReturnStatement(nodeToCheck) && nodeToCheck.expression) {
+      nodeToCheck = nodeToCheck.expression;
+      explicitReturn = true;
+      continue;
+    }
+    if (ts.isExpressionStatement(nodeToCheck)) {
+      nodeToCheck = nodeToCheck.expression;
+      continue;
+    }
+    if (ts.isYieldExpression(nodeToCheck) && nodeToCheck.asteriskToken && nodeToCheck.expression) {
+      const yieldedExpression = nodeToCheck.expression;
+      const type = typeChecker.getTypeAtLocation(yieldedExpression);
+      const { A: successType } = yield* effectType(type, yieldedExpression);
+      let replacementNode = succeed(yieldedExpression);
+      if (!explicitReturn && !(successType.flags & ts.TypeFlags.VoidLike)) {
+        replacementNode = pipe(
+          gen2(function* () {
+            const effectIdentifier = pipe(
+              yield* option(
+                findImportedModuleIdentifierByPackageAndNameOrBarrel(node.getSourceFile(), "effect", "Effect")
+              ),
+              match2({
+                onNone: () => "Effect",
+                onSome: (_) => _.text
+              })
+            );
+            return ts.factory.createCallExpression(
+              ts.factory.createPropertyAccessExpression(
+                ts.factory.createIdentifier(effectIdentifier),
+                "asVoid"
+              ),
+              void 0,
+              [
+                yieldedExpression
+              ]
+            );
+          }),
+          provideService(TypeScriptApi, ts)
+        );
+      }
+      return { node, body, yieldedExpression, replacementNode };
+    }
+    break;
   }
   return yield* typeParserIssue(
-    "Node is not a return statement with a yield expression",
+    "Not an handled node",
     void 0,
-    body
+    node
   );
 });
 var effectSchemaVarianceStruct = fn("TypeParser.effectSchemaVarianceStruct")(
@@ -2474,11 +2650,45 @@ var genFunctionStar = createCompletion({
   })
 });
 
+// src/completions/rpcMakeClasses.ts
+var rpcMakeClasses = createCompletion({
+  name: "rpcMakeClasses",
+  apply: fn("rpcMakeClasses")(function* (sourceFile, position) {
+    const ts = yield* service(TypeScriptApi);
+    const maybeInfos = yield* option(
+      parseDataForExtendsClassCompletion(sourceFile, position)
+    );
+    if (isNone2(maybeInfos)) return [];
+    const { accessedObject, className, replacementSpan } = maybeInfos.value;
+    const rpcName = yield* option(
+      findImportedModuleIdentifierByPackageAndNameOrBarrel(
+        sourceFile,
+        "@effect/rpc",
+        "Rpc"
+      )
+    );
+    const rpcIdentifier = match2(rpcName, {
+      onNone: () => "Rpc",
+      onSome: (_) => _.text
+    });
+    if (rpcIdentifier !== accessedObject.text) return [];
+    const name = className.text;
+    return [{
+      name: `make("${name}")`,
+      kind: ts.ScriptElementKind.constElement,
+      insertText: `${rpcIdentifier}.make("${name}", {${"${0}"}}) {}`,
+      replacementSpan,
+      isSnippet: true
+    }];
+  })
+});
+
 // src/completions.ts
 var completions = [
   effectSchemaSelfInClasses,
   effectSelfInClasses,
   contextSelfInClasses,
+  rpcMakeClasses,
   genFunctionStar,
   fnFunctionStar,
   effectDataClasses
@@ -2498,27 +2708,6 @@ function parse(config) {
 // src/diagnostics/duplicatePackage.ts
 var checkedPackagesCache = /* @__PURE__ */ new Map();
 var programResolvedCacheSize = /* @__PURE__ */ new Map();
-function parsePackageContentNameAndVersion(v) {
-  if (!isObject(v)) return;
-  if (!hasProperty(v, "packageJsonScope")) return;
-  if (!v.packageJsonScope) return;
-  const packageJsonScope = v.packageJsonScope;
-  if (!hasProperty(packageJsonScope, "contents")) return;
-  if (!hasProperty(packageJsonScope.contents, "packageJsonContent")) return;
-  const packageJsonContent = packageJsonScope.contents.packageJsonContent;
-  if (!hasProperty(packageJsonContent, "name")) return;
-  if (!hasProperty(packageJsonContent, "version")) return;
-  const { name, version } = packageJsonContent;
-  if (!isString(name)) return;
-  if (!isString(version)) return;
-  const hasEffectInPeerDependencies = hasProperty(packageJsonContent, "peerDependencies") && isObject(packageJsonContent.peerDependencies) && hasProperty(packageJsonContent.peerDependencies, "effect");
-  return {
-    name: name.toLowerCase(),
-    version: version.toLowerCase(),
-    hasEffectInPeerDependencies,
-    contents: packageJsonContent
-  };
-}
 var duplicatePackage = createDiagnostic({
   name: "duplicatePackage",
   code: 6,
@@ -2535,7 +2724,7 @@ var duplicatePackage = createDiagnostic({
       const seenPackages = /* @__PURE__ */ new Set();
       resolvedPackages = {};
       program.getSourceFiles().map((_) => {
-        const packageInfo = parsePackageContentNameAndVersion(_);
+        const packageInfo = parsePackageContentNameAndVersionFromScope(_);
         if (!packageInfo) return;
         const packageNameAndVersion = packageInfo.name + "@" + packageInfo.version;
         if (seenPackages.has(packageNameAndVersion)) return;
@@ -2716,6 +2905,75 @@ var missingEffectError = createDiagnostic({
   })
 });
 
+// src/diagnostics/missingReturnYieldStar.ts
+var missingReturnYieldStar = createDiagnostic({
+  name: "missingReturnYieldStar",
+  code: 7,
+  apply: fn("missingReturnYieldStar.apply")(function* (sourceFile) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const effectDiagnostics = [];
+    const brokenYields = /* @__PURE__ */ new Set();
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts.forEachChild(node, appendNodeToVisit);
+      if (ts.isYieldExpression(node) && node.expression && node.asteriskToken) {
+        const type = typeChecker.getTypeAtLocation(node.expression);
+        const maybeEffect = yield* option(effectType(type, node.expression));
+        if (isSome2(maybeEffect) && maybeEffect.value.A.flags & ts.TypeFlags.Never) {
+          const generatorFunctionOrReturnStatement = ts.findAncestor(
+            node,
+            (_) => ts.isFunctionExpression(_) || ts.isFunctionDeclaration(_) || ts.isMethodDeclaration(_) || ts.isReturnStatement(_)
+          );
+          if (generatorFunctionOrReturnStatement && !ts.isReturnStatement(generatorFunctionOrReturnStatement)) {
+            if (generatorFunctionOrReturnStatement && generatorFunctionOrReturnStatement.parent) {
+              const effectGenNode = generatorFunctionOrReturnStatement.parent;
+              const effectGenLike = yield* pipe(
+                effectGen(effectGenNode),
+                orElse3(() => effectFnUntracedGen(effectGenNode)),
+                orElse3(() => effectFnGen(effectGenNode)),
+                option
+              );
+              if (isSome2(effectGenLike)) {
+                brokenYields.add(node);
+              }
+            }
+          }
+        }
+      }
+    }
+    brokenYields.forEach((node) => {
+      const fix = node.expression ? [{
+        fixName: "missingReturnYieldStar_fix",
+        description: "Add return statement",
+        apply: gen2(function* () {
+          const changeTracker = yield* service(ChangeTracker);
+          changeTracker.replaceNode(
+            sourceFile,
+            node,
+            ts.factory.createReturnStatement(
+              node
+            )
+          );
+        })
+      }] : [];
+      effectDiagnostics.push({
+        node,
+        category: ts.DiagnosticCategory.Error,
+        messageText: `Yielded Effect never completes, so it is best to use a 'return yield*' instead.`,
+        fixes: fix
+      });
+    });
+    return effectDiagnostics;
+  })
+});
+
 // src/diagnostics/missingStarInYieldEffectGen.ts
 var missingStarInYieldEffectGen = createDiagnostic({
   name: "missingStarInYieldEffectGen",
@@ -2792,7 +3050,7 @@ var missingStarInYieldEffectGen = createDiagnostic({
 });
 
 // src/diagnostics/unnecessaryEffectGen.ts
-var unnecessaryEffectGen = createDiagnostic({
+var unnecessaryEffectGen2 = createDiagnostic({
   name: "unnecessaryEffectGen",
   code: 5,
   apply: fn("unnecessaryEffectGen.apply")(function* (sourceFile) {
@@ -2808,13 +3066,9 @@ var unnecessaryEffectGen = createDiagnostic({
     while (nodeToVisit.length > 0) {
       const node = nodeToVisit.shift();
       ts.forEachChild(node, appendNodeToVisit);
-      const maybeNode = yield* pipe(
-        effectGen(node),
-        flatMap3(({ body }) => returnYieldEffectBlock(body)),
-        option
-      );
+      const maybeNode = yield* option(unnecessaryEffectGen(node));
       if (isSome2(maybeNode)) {
-        unnecessaryGenerators.set(node, maybeNode.value);
+        unnecessaryGenerators.set(node, maybeNode.value.replacementNode);
       }
     }
     unnecessaryGenerators.forEach(
@@ -2829,7 +3083,7 @@ var unnecessaryEffectGen = createDiagnostic({
             const textChanges = yield* service(
               ChangeTracker
             );
-            textChanges.replaceNode(sourceFile, effectGenCall, yieldedResult);
+            textChanges.replaceNode(sourceFile, effectGenCall, yield* yieldedResult);
           })
         }]
       })
@@ -2845,24 +3099,132 @@ var diagnostics = [
   missingEffectError,
   floatingEffect,
   missingStarInYieldEffectGen,
-  unnecessaryEffectGen
+  unnecessaryEffectGen2,
+  missingReturnYieldStar
 ];
 
-// src/quickinfo.ts
+// src/goto/effectRpcDefinition.ts
+function effectRpcDefinition(applicableGotoDefinition, sourceFile, position) {
+  return gen2(function* () {
+    const program = yield* service(TypeScriptProgram);
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const textRange = toTextRange(position);
+    function isSymbolFromEffectRpcModule(symbol3) {
+      if (symbol3.valueDeclaration) {
+        const sourceFile2 = symbol3.valueDeclaration.getSourceFile();
+        const packageInfo = 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 = 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;
+    }
+    let rpcName = null;
+    let callNode = null;
+    for (const node of yield* getAncestorNodesInRange(sourceFile, textRange)) {
+      if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.name) && isNodeInRange(textRange)(node.name)) {
+        const type = typeChecker.getTypeAtLocation(node);
+        for (const callSig of type.getCallSignatures()) {
+          if (callSig.parameters.length >= 2 && isSymbolFromEffectRpcClientModule(callSig.parameters[1])) {
+            rpcName = node.name.text;
+            callNode = node.name;
+          }
+        }
+      }
+    }
+    if (rpcName === null || callNode === null) return applicableGotoDefinition;
+    const result = [];
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    const filesToTest = [];
+    for (const programFile of program.getSourceFiles()) {
+      if (programFile.isDeclarationFile) continue;
+      if (programFile.text.indexOf("make") === -1 && programFile.text.indexOf("fromTaggedRequest") === -1) continue;
+      if (programFile.text.indexOf(rpcName) > -1) {
+        filesToTest.unshift(programFile);
+      } else {
+        filesToTest.push(programFile);
+      }
+    }
+    for (const fileToTest of filesToTest) {
+      if (result.length > 0) break;
+      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")) {
+          const symbol3 = typeChecker.getSymbolAtLocation(node.expression.name);
+          if (symbol3 && isSymbolFromEffectRpcModule(symbol3)) {
+            const type = typeChecker.getTypeAtLocation(node);
+            const _tag = type.getProperty("_tag");
+            if (_tag) {
+              const tagValue = typeChecker.getTypeOfSymbolAtLocation(_tag, node);
+              if ("value" in tagValue && tagValue.value === rpcName) result.push([node, symbol3]);
+            }
+          }
+        }
+        ts.forEachChild(node, appendNodeToVisit);
+      }
+    }
+    if (result.length === 0) return applicableGotoDefinition;
+    const effectRpcResult = result.map(([node]) => ({
+      fileName: node.getSourceFile().fileName,
+      textSpan: ts.createTextSpan(node.getStart(), node.getEnd() - node.getStart()),
+      kind: ts.ScriptElementKind.constElement,
+      name: rpcName,
+      containerKind: ts.ScriptElementKind.constElement,
+      containerName: rpcName
+    }));
+    if (applicableGotoDefinition) {
+      return {
+        ...applicableGotoDefinition,
+        definitions: (applicableGotoDefinition.definitions || []).concat(effectRpcResult)
+      };
+    }
+    return {
+      textSpan: ts.createTextSpan(callNode.getStart(), callNode.getEnd() - callNode.getStart()),
+      definitions: effectRpcResult
+    };
+  });
+}
+
+// src/goto.ts
+function goto(applicableGotoDefinition, sourceFile, position) {
+  return effectRpcDefinition(applicableGotoDefinition, sourceFile, position);
+}
+
+// src/quickinfo/dedupeJsDocs.ts
 var SymbolDisplayPartEq = make((fa, fb) => fa.kind === fb.kind && fa.text === fb.text);
 var JSDocTagInfoEq = make(
   (fa, fb) => fa.name === fb.name && typeof fa.text === typeof fb.text && (typeof fa.text !== "undefined" ? array(SymbolDisplayPartEq)(fa.text, fb.text) : true)
 );
-function dedupeJsDocTags(quickInfo) {
-  if (!quickInfo) return quickInfo;
-  if (quickInfo.tags) {
-    return {
-      ...quickInfo,
-      tags: dedupeWith(quickInfo.tags, JSDocTagInfoEq)
-    };
+function dedupeJsDocs(quickInfo2) {
+  if (!quickInfo2) return succeed(quickInfo2);
+  if (quickInfo2.tags) {
+    return succeed({
+      ...quickInfo2,
+      tags: dedupeWith(quickInfo2.tags, JSDocTagInfoEq)
+    });
   }
-  return quickInfo;
+  return succeed(quickInfo2);
 }
+
+// src/quickinfo/effectTypeArgs.ts
 function formatTypeForQuickInfo(channelType, channelName) {
   return gen2(function* () {
     const ts = yield* service(TypeScriptApi);
@@ -2875,7 +3237,7 @@ function formatTypeForQuickInfo(channelType, channelName) {
     return `type ${channelName} = ${stringRepresentation}`;
   });
 }
-function prependEffectTypeArguments(sourceFile, position, quickInfo) {
+function effectTypeArgs(sourceFile, position, quickInfo2) {
   return pipe(
     gen2(function* () {
       const ts = yield* service(TypeScriptApi);
@@ -2884,11 +3246,11 @@ function prependEffectTypeArguments(sourceFile, position, quickInfo) {
         yield* getAncestorNodesInRange(sourceFile, toTextRange(position)),
         head
       );
-      if (isNone2(maybeNode)) return quickInfo;
+      if (isNone2(maybeNode)) return quickInfo2;
       const node = maybeNode.value;
-      const hasTruncationHappened = quickInfo && ts.displayPartsToString(quickInfo.displayParts).indexOf("...") > -1;
-      const nodeForType = !quickInfo && ts.isYieldExpression(node) && node.asteriskToken && node.expression ? node.expression : hasTruncationHappened ? node : void 0;
-      if (!nodeForType) return quickInfo;
+      const hasTruncationHappened = quickInfo2 && ts.displayPartsToString(quickInfo2.displayParts).indexOf("...") > -1;
+      const nodeForType = !quickInfo2 && ts.isYieldExpression(node) && node.asteriskToken && node.expression ? node.expression : hasTruncationHappened ? node : void 0;
+      if (!nodeForType) return quickInfo2;
       const effectType2 = yield* effectType(
         typeChecker.getTypeAtLocation(nodeForType),
         nodeForType
@@ -2897,7 +3259,7 @@ function prependEffectTypeArguments(sourceFile, position, quickInfo) {
         kind: "text",
         text: "```ts\n/* Effect Type Parameters */\n" + (yield* formatTypeForQuickInfo(effectType2.A, "Success")) + "\n" + (yield* formatTypeForQuickInfo(effectType2.E, "Failure")) + "\n" + (yield* formatTypeForQuickInfo(effectType2.R, "Requirements")) + "\n```\n"
       }];
-      if (!quickInfo) {
+      if (!quickInfo2) {
         const start = node.getStart();
         const end = node.getEnd();
         return {
@@ -2907,21 +3269,392 @@ function prependEffectTypeArguments(sourceFile, position, quickInfo) {
           documentation: effectTypeArgsDocumentation
         };
       }
-      if (quickInfo.documentation) {
+      if (quickInfo2.documentation) {
         return {
-          ...quickInfo,
-          documentation: effectTypeArgsDocumentation.concat(quickInfo.documentation)
+          ...quickInfo2,
+          documentation: effectTypeArgsDocumentation.concat(quickInfo2.documentation)
         };
       }
       return {
-        ...quickInfo,
+        ...quickInfo2,
         documentation: effectTypeArgsDocumentation
       };
     }),
-    orElse3(() => succeed(quickInfo))
+    orElse3(() => succeed(quickInfo2))
   );
 }
 
+// src/quickinfo/layerInfo.ts
+var UnableToProduceLayerGraphError = class {
+  constructor(message, node) {
+    this.message = message;
+    this.node = node;
+  }
+  _tag = "@effect/language-service/UnableToProduceLayerGraphError";
+};
+var GraphNodeLeaf = class {
+  constructor(id, node, rout, rin) {
+    this.id = id;
+    this.node = node;
+    this.rout = rout;
+    this.rin = rin;
+  }
+  _tag = "GraphNodeLeaf";
+};
+var GraphNodeCompoundTransform = class {
+  constructor(id, node, args, rout, rin) {
+    this.id = id;
+    this.node = node;
+    this.args = args;
+    this.rout = rout;
+    this.rin = rin;
+  }
+  _tag = "GraphNodeCompoundTransform";
+};
+function processLayerGraphNode(ctx, node, pipedInGraphNode) {
+  return gen2(function* () {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const maybePipe = yield* option(parsePipeCall(node));
+    if (isSome2(maybePipe)) {
+      let graphNode = yield* processLayerGraphNode(ctx, maybePipe.value.subject, void 0);
+      for (const entry of maybePipe.value.args) {
+        graphNode = yield* processLayerGraphNode(ctx, entry, graphNode);
+      }
+      return graphNode;
+    }
+    if (ts.isCallExpression(node)) {
+      const type = typeChecker.getTypeAtLocation(node);
+      const maybeLayer = yield* option(layerType(type, node));
+      if (isSome2(maybeLayer)) {
+        const argNodes = yield* option(
+          all2(...node.arguments.map((_) => processLayerGraphNode(ctx, _, void 0)))
+        );
+        if (isSome2(argNodes) && argNodes.value.length === node.arguments.length) {
+          const { allIndexes: outTypes } = yield* appendToUniqueTypesMap(
+            ctx.services,
+            maybeLayer.value.ROut,
+            true
+          );
+          const { allIndexes: inTypes } = yield* appendToUniqueTypesMap(
+            ctx.services,
+            maybeLayer.value.RIn,
+            true
+          );
+          return new GraphNodeCompoundTransform(
+            ctx.nextId(),
+            node,
+            argNodes.value,
+            outTypes,
+            inTypes
+          );
+        }
+      }
+    }
+    if (pipedInGraphNode && ts.isExpression(node)) {
+      const type = typeChecker.getContextualType(node);
+      if (type) {
+        const callSignatures = type.getCallSignatures();
+        if (callSignatures.length === 1) {
+          const [signature] = callSignatures;
+          const returnType = signature.getReturnType();
+          const maybeLayer = yield* option(layerType(returnType, node));
+          if (isSome2(maybeLayer)) {
+            const { allIndexes: outTypes } = yield* appendToUniqueTypesMap(
+              ctx.services,
+              maybeLayer.value.ROut,
+              true
+            );
+            const { allIndexes: inTypes } = yield* appendToUniqueTypesMap(
+              ctx.services,
+              maybeLayer.value.RIn,
+              true
+            );
+            if (ts.isCallExpression(node)) {
+              const argNodes = yield* option(
+                all2(...node.arguments.map((_) => processLayerGraphNode(ctx, _, void 0)))
+              );
+              if (isSome2(argNodes) && argNodes.value.length === node.arguments.length) {
+                return new GraphNodeCompoundTransform(
+                  ctx.nextId(),
+                  node,
+                  [pipedInGraphNode, ...argNodes.value],
+                  outTypes,
+                  inTypes
+                );
+              }
+            }
+            const argNode = yield* option(processLayerGraphNode(ctx, node, void 0));
+            if (isSome2(argNode)) {
+              return new GraphNodeCompoundTransform(
+                ctx.nextId(),
+                node,
+                [pipedInGraphNode, argNode.value],
+                outTypes,
+                inTypes
+              );
+            } else {
+              return new GraphNodeCompoundTransform(
+                ctx.nextId(),
+                node,
+                [pipedInGraphNode],
+                outTypes,
+                inTypes
+              );
+            }
+          }
+        }
+      }
+    }
+    if (ts.isExpression(node)) {
+      const type = typeChecker.getTypeAtLocation(node);
+      const maybeLayer = yield* option(layerType(type, node));
+      if (isSome2(maybeLayer)) {
+        const { allIndexes: outTypes } = yield* appendToUniqueTypesMap(
+          ctx.services,
+          maybeLayer.value.ROut,
+          true
+        );
+        const { allIndexes: inTypes } = yield* appendToUniqueTypesMap(
+          ctx.services,
+          maybeLayer.value.RIn,
+          true
+        );
+        return new GraphNodeLeaf(ctx.nextId(), node, outTypes, inTypes);
+      }
+    }
+    return yield* fail(new UnableToProduceLayerGraphError(node.getText()));
+  });
+}
+function findInnermostGraphEdge(graph, kind, key) {
+  switch (graph._tag) {
+    case "GraphNodeLeaf":
+      return graph[kind].indexOf(key) > -1 ? [graph] : [];
+    case "GraphNodeCompoundTransform": {
+      if (graph[kind].indexOf(key) > -1) {
+        let result = [];
+        for (const child of graph.args) {
+          result = result.concat(findInnermostGraphEdge(child, kind, key));
+        }
+        if (result.length > 0) return result;
+        return [graph];
+      }
+      return [];
+    }
+  }
+}
+function escapeMermaid(text) {
+  return text.replace(/"/mg, "#quot;").replace(/\n/mg, " ");
+}
+function processNodeMermaid(graph, ctx, ctxL) {
+  return gen2(function* () {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    let subgraphDefs = [];
+    if (!ctx.seenIds.has(graph.id)) {
+      const subgraphsIn = [];
+      for (const serviceId of graph.rin) {
+        const type = ctxL.services.get(serviceId);
+        const typeString = typeChecker.typeToString(type, void 0, ts.TypeFormatFlags.NoTruncation);
+        subgraphsIn.push("subgraph " + graph.id + "_rin_" + serviceId + ' ["`' + escapeMermaid(typeString) + '`"]');
+        subgraphsIn.push("end");
+      }
+      const subgraphsOut = [];
+      for (const serviceId of graph.rout) {
+        const type = ctxL.services.get(serviceId);
+        const typeString = typeChecker.typeToString(type, void 0, ts.TypeFormatFlags.NoTruncation);
+        subgraphsOut.push("subgraph " + graph.id + "_rout_" + serviceId + ' ["`' + escapeMermaid(typeString) + '`"]');
+        subgraphsOut.push("end");
+      }
+      const sourceFile = graph.node.getSourceFile();
+      const nodePosition = graph.node.getStart(sourceFile, false);
+      const { character, line } = ts.getLineAndCharacterOfPosition(sourceFile, nodePosition);
+      if (subgraphsIn.length > 0) {
+        subgraphDefs = [
+          ...subgraphDefs,
+          "subgraph " + graph.id + "_rin [Requires]",
+          ...subgraphsIn,
+          "end",
+          "style " + graph.id + "_rin stroke:none"
+        ];
+      }
+      if (subgraphsOut.length > 0) {
+        subgraphDefs = [
+          ...subgraphDefs,
+          "subgraph " + graph.id + "_rout [Provides]",
+          ...subgraphsOut,
+          "end",
+          "style " + graph.id + "_rout stroke:none"
+        ];
+      }
+      subgraphDefs = [
+        "subgraph " + graph.id + ' ["`' + escapeMermaid(graph.node.getText()) + " _at ln " + (line + 1) + " col " + character + '_`"]',
+        ...subgraphDefs,
+        "end",
+        "style " + graph.id + " fill:transparent"
+      ];
+      ctx.seenIds.add(graph.id);
+    }
+    switch (graph._tag) {
+      case "GraphNodeLeaf": {
+        return subgraphDefs;
+      }
+      case "GraphNodeCompoundTransform": {
+        const childs = flatten(yield* all2(...graph.args.map((_) => processNodeMermaid(_, ctx, ctxL))));
+        let currentEdges = [];
+        const connectedNodes = /* @__PURE__ */ new Set();
+        for (const requiredServiceKey of graph.rin) {
+          for (const childNode of graph.args.filter((childNode2) => childNode2.rin.indexOf(requiredServiceKey) > -1)) {
+            currentEdges = [
+              ...currentEdges,
+              graph.id + "_rin_" + requiredServiceKey + " -.-> " + childNode.id + "_rin_" + requiredServiceKey
+            ];
+            connectedNodes.add(childNode.id);
+          }
+        }
+        for (const providedServiceKey of graph.rout) {
+          for (const childNode of graph.args.filter((childNode2) => childNode2.rout.indexOf(providedServiceKey) > -1)) {
+            currentEdges = [
+              ...currentEdges,
+              graph.id + "_rout_" + providedServiceKey + " -.-> " + childNode.id + "_rout_" + providedServiceKey
+            ];
+            connectedNodes.add(childNode.id);
+          }
+        }
+        for (const childNode of graph.args) {
+          if (!connectedNodes.has(childNode.id)) {
+            currentEdges = [...currentEdges, graph.id + " -.-x " + childNode.id];
+          }
+        }
+        return [...subgraphDefs, ...childs, ...currentEdges];
+      }
+    }
+  });
+}
+function generateMarmaidUri(graph, ctxL) {
+  return gen2(function* () {
+    const ctx = {
+      seenIds: /* @__PURE__ */ new Set()
+    };
+    const lines = yield* processNodeMermaid(graph, ctx, ctxL);
+    const code = "flowchart TB\n" + lines.join("\n");
+    const state = btoa(JSON.stringify({ code }));
+    return "https://www.mermaidchart.com/play#" + state;
+  });
+}
+function layerInfo(sourceFile, position, quickInfo2) {
+  return pipe(
+    gen2(function* () {
+      const ts = yield* service(TypeScriptApi);
+      const typeChecker = yield* service(TypeCheckerApi);
+      const range = toTextRange(position);
+      const maybeNode = pipe(
+        yield* getAncestorNodesInRange(sourceFile, range),
+        filter((_) => ts.isVariableDeclaration(_) || ts.isPropertyDeclaration(_)),
+        filter((_) => isNodeInRange(range)(_.name)),
+        head
+      );
+      if (isNone2(maybeNode)) return quickInfo2;
+      const node = maybeNode.value;
+      const layerNode = node.initializer ? node.initializer : node;
+      const layerType2 = typeChecker.getTypeAtLocation(layerNode);
+      const maybeLayer = yield* option(layerType(layerType2, layerNode));
+      if (isNone2(maybeLayer)) return quickInfo2;
+      let lastId = 0;
+      const graphCtx = {
+        services: /* @__PURE__ */ new Map(),
+        serviceTypeToString: /* @__PURE__ */ new Map(),
+        nextId: () => "id" + lastId++
+      };
+      const layerInfoDisplayParts = yield* pipe(
+        processLayerGraphNode(graphCtx, layerNode, void 0),
+        flatMap3(
+          (rootNode) => gen2(function* () {
+            yield* succeed(void 0);
+            const lines = [];
+            const appendInfo = (providesNode, type, kindText) => {
+              const typeString = typeChecker.typeToString(
+                type,
+                void 0,
+                ts.TypeFormatFlags.NoTruncation
+              );
+              const positions = providesNode.map((_) => {
+                const nodePosition = _.node.getStart(sourceFile, false);
+                const { character, line } = ts.getLineAndCharacterOfPosition(sourceFile, nodePosition);
+                const nodeText = _.node.getText().trim().substr(0, 100);
+                return "ln " + (line + 1) + " col " + character + " by `" + nodeText + "`";
+              });
+              lines.push("- " + typeString + " " + kindText + " at " + positions.join(", "));
+            };
+            for (const providesKey of rootNode.rout) {
+              const providesNode = findInnermostGraphEdge(rootNode, "rout", providesKey);
+              appendInfo(providesNode, graphCtx.services.get(providesKey), "provided");
+            }
+            lines.push("");
+            for (const requiresKey of rootNode.rin) {
+              const requiresNode = findInnermostGraphEdge(rootNode, "rin", requiresKey);
+              appendInfo(requiresNode, graphCtx.services.get(requiresKey), "required");
+            }
+            const mermaidUri = yield* option(generateMarmaidUri(rootNode, graphCtx));
+            const linkParts = [];
+            if (isSome2(mermaidUri)) {
+              linkParts.push({ kind: "space", text: "\n" });
+              linkParts.push({ kind: "link", text: "{@link " });
+              linkParts.push({ kind: "linkText", text: mermaidUri.value + " Show full Layer graph" });
+              linkParts.push({ kind: "link", text: "}" });
+              linkParts.push({ kind: "space", text: "\n" });
+            }
+            return [
+              {
+                kind: "text",
+                text: "```\n/**\n" + lines.map((l) => " * " + l).join("\n") + "\n */\n```\n"
+              },
+              ...linkParts
+            ];
+          })
+        ),
+        orElse3(
+          (e) => succeed([{
+            kind: "text",
+            text: "```\n/** layer graph not created: " + e.message + " */\n```\n"
+          }])
+        )
+      );
+      if (!quickInfo2) {
+        const start = node.getStart();
+        const end = node.getEnd();
+        return {
+          kind: ts.ScriptElementKind.callSignatureElement,
+          kindModifiers: "",
+          textSpan: { start, length: end - start },
+          documentation: layerInfoDisplayParts
+        };
+      }
+      if (quickInfo2.documentation) {
+        return {
+          ...quickInfo2,
+          documentation: quickInfo2.documentation.concat([{ kind: "space", text: "\n" }]).concat(layerInfoDisplayParts)
+        };
+      }
+      return {
+        ...quickInfo2,
+        documentation: layerInfoDisplayParts
+      };
+    }),
+    orElse3(() => succeed(quickInfo2))
+  );
+}
+
+// src/quickinfo.ts
+function quickInfo(sourceFile, position, quickInfo2) {
+  return gen2(function* () {
+    const deduped = yield* dedupeJsDocs(quickInfo2);
+    const withEffectTypeArgs = yield* effectTypeArgs(sourceFile, position, deduped);
+    const withLayerInfo = yield* layerInfo(sourceFile, position, withEffectTypeArgs);
+    return withLayerInfo;
+  });
+}
+
 // src/refactors/asyncAwaitToGen.ts
 var asyncAwaitToGen = createRefactor({
   name: "asyncAwaitToGen",
@@ -3118,14 +3851,14 @@ var effectGenToFn = createRefactor({
           nodeToReplace2 = parent;
           continue;
         }
-        if (ts.isPropertyAccessExpression(parent) && parent.expression === nodeToReplace2 && parent.name.text === "pipe" && ts.isCallExpression(parent.parent)) {
-          pipeArgs2 = ts.factory.createNodeArray(pipeArgs2.concat(parent.parent.arguments));
-          nodeToReplace2 = parent.parent;
-          continue;
-        }
-        if (ts.isCallExpression(parent) && ts.isIdentifier(parent.expression) && parent.expression.text === "pipe" && parent.arguments.length > 0 && parent.arguments[0] === nodeToReplace2) {
-          pipeArgs2 = ts.factory.createNodeArray(pipeArgs2.concat(parent.arguments.slice(1)));
-          nodeToReplace2 = parent;
+        const maybePipe = yield* pipe(
+          parsePipeCall(parent),
+          orElse3((e) => parent.parent ? parsePipeCall(parent.parent) : fail(e)),
+          option
+        );
+        if (isSome2(maybePipe) && maybePipe.value.subject === nodeToReplace2) {
+          pipeArgs2 = ts.factory.createNodeArray(pipeArgs2.concat(maybePipe.value.args));
+          nodeToReplace2 = maybePipe.value.node;
           continue;
         }
         break;
@@ -3611,19 +4344,15 @@ var removeUnnecessaryEffectGen = createRefactor({
   description: "Remove unnecessary Effect.gen",
   apply: fn("removeUnnecessaryEffectGen.apply")(function* (sourceFile, textRange) {
     for (const nodeToReplace of yield* getAncestorNodesInRange(sourceFile, textRange)) {
-      const maybeNode = yield* pipe(
-        effectGen(nodeToReplace),
-        flatMap3(({ body }) => returnYieldEffectBlock(body)),
-        option
-      );
+      const maybeNode = yield* option(unnecessaryEffectGen(nodeToReplace));
       if (isNone2(maybeNode)) continue;
-      const returnedYieldedEffect = maybeNode.value;
+      const replacementNode = maybeNode.value.replacementNode;
       return {
         kind: "refactor.rewrite.effect.removeUnnecessaryEffectGen",
         description: "Remove unnecessary Effect.gen",
         apply: gen2(function* () {
           const changeTracker = yield* service(ChangeTracker);
-          changeTracker.replaceNode(sourceFile, nodeToReplace, returnedYieldedEffect);
+          changeTracker.replaceNode(sourceFile, nodeToReplace, yield* replacementNode);
         })
       };
     }
@@ -4558,27 +5287,25 @@ var init = (modules) => {
       );
     };
     proxy.getQuickInfoAtPosition = (fileName, position, ...args) => {
-      const quickInfo = languageService.getQuickInfoAtPosition(fileName, position, ...args);
+      const applicableQuickInfo = languageService.getQuickInfoAtPosition(fileName, position, ...args);
       if (languageServicePluginOptions.quickinfo) {
-        const dedupedTagsQuickInfo = dedupeJsDocTags(quickInfo);
         const program = languageService.getProgram();
         if (program) {
           const sourceFile = program.getSourceFile(fileName);
           if (sourceFile) {
             return pipe(
-              prependEffectTypeArguments(
+              quickInfo(
                 sourceFile,
                 position,
-                dedupedTagsQuickInfo
+                applicableQuickInfo
               ),
               runNano(program),
-              Either_exports.getOrElse(() => dedupedTagsQuickInfo)
+              Either_exports.getOrElse(() => applicableQuickInfo)
             );
           }
         }
-        return dedupedTagsQuickInfo;
       }
-      return quickInfo;
+      return applicableQuickInfo;
     };
     proxy.getCompletionsAtPosition = (fileName, position, options, formattingSettings, ...args) => {
       const applicableCompletions = languageService.getCompletionsAtPosition(
@@ -4620,6 +5347,21 @@ var init = (modules) => {
       }
       return applicableCompletions;
     };
+    proxy.getDefinitionAndBoundSpan = (fileName, position, ...args) => {
+      const applicableDefinition = languageService.getDefinitionAndBoundSpan(fileName, position, ...args);
+      const program = languageService.getProgram();
+      if (program) {
+        const sourceFile = program.getSourceFile(fileName);
+        if (sourceFile) {
+          return pipe(
+            goto(applicableDefinition, sourceFile, position),
+            runNano(program),
+            Either_exports.getOrElse(() => applicableDefinition)
+          );
+        }
+      }
+      return applicableDefinition;
+    };
     return proxy;
   }
   return { create };