@effect/language-service 0.20.1 → 0.21.0

package/index.js

@@ -489,6 +489,7 @@ function compareBoth(self, that) {
   return structuralRegionState.enabled && structuralRegionState.tester ? structuralRegionState.tester(self, that) : false;
 }
 var isEqual = (u) => hasProperty(u, symbol2);
+var equivalence = () => equals;
 
 // node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Inspectable.js
 var NodeInspectSymbol = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
@@ -947,6 +948,20 @@ var sort = /* @__PURE__ */ dual(2, (self, O) => {
   out.sort(O);
   return out;
 });
+var containsWith = (isEquivalent) => dual(2, (self, a) => {
+  for (const i of self) {
+    if (isEquivalent(a, i)) {
+      return true;
+    }
+  }
+  return false;
+});
+var _equivalence = /* @__PURE__ */ equivalence();
+var intersectionWith = (isEquivalent) => {
+  const has = containsWith(isEquivalent);
+  return dual(2, (self, that) => fromIterable(self).filter((a) => has(that, a)));
+};
+var intersection = /* @__PURE__ */ intersectionWith(_equivalence);
 var empty = () => [];
 var map3 = /* @__PURE__ */ dual(2, (self, f) => self.map(f));
 var flatMap2 = /* @__PURE__ */ dual(2, (self, f) => {
@@ -1039,7 +1054,8 @@ function make3(run2) {
   return result;
 }
 var unsafeRun = (fa) => {
-  const result = fa.run(contextEmpty);
+  const program = provideService(internalNanoCache, {})(fa);
+  const result = program.run(contextEmpty);
   switch (result._tag) {
     case "Left":
       return left2(result.value);
@@ -1076,14 +1092,14 @@ var orElse3 = (f) => (fa) => make3((ctx) => {
 });
 var firstSuccessOf = (arr) => arr.slice(1).reduce((arr2, fa) => orElse3(() => fa)(arr2), arr[0]);
 var service = (tag) => make3(
-  (ctx) => tag.key in ctx.value ? makeInternalSuccess(ctx.value[tag.key]) : makeInternalDefect(`Cannot find service ${tag.key}`)
+  (ctx) => tag.key in ctx.value ? ctx.value[tag.key] : makeInternalDefect(`Cannot find service ${tag.key}`)
 );
 var provideService = (tag, value) => (fa) => make3((ctx) => {
   return fa.run({
     ...ctx,
     value: {
       ...ctx.value,
-      [tag.key]: value
+      [tag.key]: makeInternalSuccess(value)
     }
   });
 });
@@ -1124,14 +1140,41 @@ var option = (fa) => make3((ctx) => {
       return result;
   }
 });
-var all2 = (...args) => gen2(function* () {
+var successUndefined = makeInternalSuccess(void 0);
+var void_2 = make3(() => successUndefined);
+var ignore = (fa) => make3((ctx) => {
+  fa.run(ctx);
+  return successUndefined;
+});
+var all2 = (...args) => make3((ctx) => {
   const results = [];
   for (const arg of args) {
-    const result = yield* arg;
-    results.push(result);
+    const result = arg.run(ctx);
+    if (result._tag !== "Right") return result;
+    results.push(result.value);
   }
-  return results;
+  return makeInternalSuccess(results);
 });
+var internalNanoCache = Tag(
+  "@effect/language-service/internalNanoCache"
+);
+function cachedBy(fa, key, lookupKey) {
+  return (...args) => make3((ctx) => {
+    const cacheObj = ctx.value[internalNanoCache.key];
+    let cache = cacheObj[key];
+    if (!cache) {
+      cache = /* @__PURE__ */ new Map();
+      cacheObj[key] = cache;
+    }
+    const lookup = lookupKey(...args);
+    if (cache.has(lookup)) {
+      return cache.get(lookup);
+    }
+    const result = fa(...args).run(ctx);
+    cache.set(lookup, result);
+    return result;
+  });
+}
 
 // src/core/TypeScriptApi.ts
 var TypeScriptApi = Tag("TypeScriptApi");
@@ -1924,6 +1967,511 @@ var effectSelfInClasses = createCompletion({
   })
 });
 
+// src/core/TypeParser.ts
+var TypeParser = Tag("@effect/language-service/TypeParser");
+var TypeParserIssue = class _TypeParserIssue {
+  _tag = "@effect/language-service/TypeParserIssue";
+  static issue = fail(new _TypeParserIssue());
+};
+function make4(ts, typeChecker) {
+  function typeParserIssue(_message, _type, _node) {
+    return TypeParserIssue.issue;
+  }
+  function covariantTypeArgument(type) {
+    const signatures = type.getCallSignatures();
+    if (signatures.length !== 1) {
+      return typeParserIssue("Covariant type has no call signature", 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) {
+      return typeParserIssue("Invariant type has no call signature", type);
+    }
+    return succeed(signatures[0].getReturnType());
+  }
+  const pipeableType = cachedBy(
+    fn("TypeParser.pipeableType")(function* (type, atLocation) {
+      const pipeSymbol = typeChecker.getPropertyOfType(type, "pipe");
+      if (!pipeSymbol) {
+        return yield* typeParserIssue("Type has no 'pipe' property", type, atLocation);
+      }
+      const pipeType = typeChecker.getTypeOfSymbolAtLocation(pipeSymbol, atLocation);
+      const signatures = pipeType.getCallSignatures();
+      if (signatures.length === 0) {
+        return yield* typeParserIssue("'pipe' property is not callable", type, atLocation);
+      }
+      return type;
+    }),
+    "TypeParser.pipeableType",
+    (type) => type
+  );
+  const varianceStructCovariantType = (type, atLocation, propertyName) => {
+    const propertySymbol = typeChecker.getPropertyOfType(type, propertyName);
+    if (!propertySymbol) {
+      return typeParserIssue(`Type has no '${propertyName}' property`, type, atLocation);
+    }
+    const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
+    return covariantTypeArgument(propertyType);
+  };
+  const varianceStructContravariantType = (type, atLocation, propertyName) => {
+    const propertySymbol = typeChecker.getPropertyOfType(type, propertyName);
+    if (!propertySymbol) {
+      return typeParserIssue(`Type has no '${propertyName}' property`, type, atLocation);
+    }
+    const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
+    return contravariantTypeArgument(propertyType);
+  };
+  const varianceStructInvariantType = (type, atLocation, propertyName) => {
+    const propertySymbol = typeChecker.getPropertyOfType(type, propertyName);
+    if (!propertySymbol) {
+      return typeParserIssue(`Type has no '${propertyName}' property`, type, atLocation);
+    }
+    const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
+    return invariantTypeArgument(propertyType);
+  };
+  const effectVarianceStruct = (type, atLocation) => map4(
+    all2(
+      varianceStructCovariantType(type, atLocation, "_A"),
+      varianceStructCovariantType(type, atLocation, "_E"),
+      varianceStructCovariantType(type, atLocation, "_R")
+    ),
+    ([A, E, R]) => ({ A, E, R })
+  );
+  const layerVarianceStruct = (type, atLocation) => map4(
+    all2(
+      varianceStructContravariantType(type, atLocation, "_ROut"),
+      varianceStructCovariantType(type, atLocation, "_E"),
+      varianceStructCovariantType(type, atLocation, "_RIn")
+    ),
+    ([ROut, E, RIn]) => ({ ROut, E, RIn })
+  );
+  const effectType = cachedBy(
+    fn("TypeParser.effectType")(function* (type, atLocation) {
+      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("EffectTypeId") - a.name.indexOf("EffectTypeId"));
+      for (const propertySymbol of propertiesSymbols) {
+        const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
+        const varianceArgs = yield* option(effectVarianceStruct(
+          propertyType,
+          atLocation
+        ));
+        if (isSome2(varianceArgs)) {
+          return varianceArgs.value;
+        }
+      }
+      return yield* typeParserIssue("Type has no effect variance struct", type, atLocation);
+    }),
+    "TypeParser.effectType",
+    (type) => type
+  );
+  const layerType = cachedBy(
+    fn("TypeParser.layerType")(function* (type, atLocation) {
+      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);
+    }),
+    "TypeParser.layerType",
+    (type) => type
+  );
+  const fiberType = cachedBy(
+    fn("TypeParser.fiberType")(function* (type, atLocation) {
+      const awaitSymbol = typeChecker.getPropertyOfType(type, "await");
+      const pollSymbol = typeChecker.getPropertyOfType(type, "poll");
+      if (!awaitSymbol || !pollSymbol) {
+        return yield* typeParserIssue(
+          "Type is not a fiber because it does not have 'await' or 'poll' property",
+          type,
+          atLocation
+        );
+      }
+      return yield* effectType(type, atLocation);
+    }),
+    "TypeParser.fiberType",
+    (type) => type
+  );
+  const effectSubtype = cachedBy(
+    fn("TypeParser.effectSubtype")(function* (type, atLocation) {
+      const tagSymbol = typeChecker.getPropertyOfType(type, "_tag");
+      const getSymbol = typeChecker.getPropertyOfType(type, "get");
+      if (!(tagSymbol || getSymbol)) {
+        return yield* typeParserIssue(
+          "Type is not a subtype of effect because it does not have '_tag' or 'get' property",
+          type,
+          atLocation
+        );
+      }
+      return yield* effectType(type, atLocation);
+    }),
+    "TypeParser.effectSubtype",
+    (type) => type
+  );
+  const importedEffectModule = cachedBy(
+    fn("TypeParser.importedEffectModule")(function* (node) {
+      const type = typeChecker.getTypeAtLocation(node);
+      const propertySymbol = typeChecker.getPropertyOfType(type, "never");
+      if (!propertySymbol) {
+        return yield* typeParserIssue("Type has no 'never' property", type, node);
+      }
+      if (!ts.isExpression(node)) {
+        return yield* typeParserIssue("Node is not an expression", type, node);
+      }
+      const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, node);
+      yield* effectType(propertyType, node);
+      return node;
+    }),
+    "TypeParser.importedEffectModule",
+    (node) => node
+  );
+  const effectGen = cachedBy(
+    fn("TypeParser.effectGen")(function* (node) {
+      if (!ts.isCallExpression(node)) {
+        return yield* typeParserIssue("Node is not a call expression", void 0, node);
+      }
+      if (node.arguments.length === 0) {
+        return yield* typeParserIssue("Node has no arguments", void 0, node);
+      }
+      const generatorFunction = node.arguments[0];
+      if (!ts.isFunctionExpression(generatorFunction)) {
+        return yield* typeParserIssue("Node is not a function expression", void 0, node);
+      }
+      if (generatorFunction.asteriskToken === void 0) {
+        return yield* typeParserIssue("Node is not a generator function", void 0, node);
+      }
+      if (!ts.isPropertyAccessExpression(node.expression)) {
+        return yield* typeParserIssue("Node is not a property access expression", void 0, node);
+      }
+      const propertyAccess = node.expression;
+      if (propertyAccess.name.text !== "gen") {
+        return yield* typeParserIssue("Call expression name is not 'gen'", void 0, node);
+      }
+      const effectModule = yield* importedEffectModule(propertyAccess.expression);
+      return {
+        node,
+        effectModule,
+        generatorFunction,
+        body: generatorFunction.body,
+        functionStar: generatorFunction.getFirstToken()
+      };
+    }),
+    "TypeParser.effectGen",
+    (node) => node
+  );
+  const effectFnUntracedGen = cachedBy(
+    fn("TypeParser.effectFnUntracedGen")(
+      function* (node) {
+        if (!ts.isCallExpression(node)) {
+          return yield* typeParserIssue("Node is not a call expression", void 0, node);
+        }
+        if (node.arguments.length === 0) {
+          return yield* typeParserIssue("Node has no arguments", void 0, node);
+        }
+        const generatorFunction = node.arguments[0];
+        if (!ts.isFunctionExpression(generatorFunction)) {
+          return yield* typeParserIssue("Node is not a function expression", void 0, node);
+        }
+        if (generatorFunction.asteriskToken === void 0) {
+          return yield* typeParserIssue(
+            "Node is not a generator function",
+            void 0,
+            node
+          );
+        }
+        if (!ts.isPropertyAccessExpression(node.expression)) {
+          return yield* typeParserIssue(
+            "Node is not a property access expression",
+            void 0,
+            node
+          );
+        }
+        const propertyAccess = node.expression;
+        if (propertyAccess.name.text !== "fnUntraced") {
+          return yield* typeParserIssue(
+            "Call expression name is not 'fnUntraced'",
+            void 0,
+            node
+          );
+        }
+        const effectModule = yield* importedEffectModule(propertyAccess.expression);
+        return {
+          node,
+          effectModule,
+          generatorFunction,
+          body: generatorFunction.body,
+          functionStar: generatorFunction.getFirstToken()
+        };
+      }
+    ),
+    "TypeParser.effectFnUntracedGen",
+    (node) => node
+  );
+  const effectFnGen = cachedBy(
+    fn("TypeParser.effectFnGen")(function* (node) {
+      if (!ts.isCallExpression(node)) {
+        return yield* typeParserIssue("Node is not a call expression", void 0, node);
+      }
+      if (node.arguments.length === 0) {
+        return yield* typeParserIssue("Node has no arguments", void 0, node);
+      }
+      const generatorFunction = node.arguments[0];
+      if (!ts.isFunctionExpression(generatorFunction)) {
+        return yield* typeParserIssue(
+          "Node is not a function expression",
+          void 0,
+          node
+        );
+      }
+      if (generatorFunction.asteriskToken === void 0) {
+        return yield* typeParserIssue(
+          "Node is not a generator function",
+          void 0,
+          node
+        );
+      }
+      const expressionToTest = ts.isCallExpression(node.expression) ? node.expression.expression : node.expression;
+      if (!ts.isPropertyAccessExpression(expressionToTest)) {
+        return yield* typeParserIssue(
+          "Node is not a property access expression",
+          void 0,
+          node
+        );
+      }
+      const propertyAccess = expressionToTest;
+      if (propertyAccess.name.text !== "fn") {
+        return yield* typeParserIssue(
+          "Call expression name is not 'fn'",
+          void 0,
+          node
+        );
+      }
+      const effectModule = yield* importedEffectModule(propertyAccess.expression);
+      return {
+        node,
+        generatorFunction,
+        effectModule,
+        body: generatorFunction.body,
+        functionStar: generatorFunction.getFirstToken()
+      };
+    }),
+    "TypeParser.effectFnGen",
+    (node) => node
+  );
+  const unnecessaryEffectGen2 = cachedBy(
+    fn("TypeParser.unnecessaryEffectGen")(function* (node) {
+      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(
+        "Not an handled node",
+        void 0,
+        node
+      );
+    }),
+    "TypeParser.unnecessaryEffectGen",
+    (node) => node
+  );
+  const effectSchemaVarianceStruct = (type, atLocation) => map4(
+    all2(
+      varianceStructInvariantType(type, atLocation, "_A"),
+      varianceStructInvariantType(type, atLocation, "_I"),
+      varianceStructCovariantType(type, atLocation, "_R")
+    ),
+    ([A, I, R]) => ({ A, I, R })
+  );
+  const effectSchemaType = cachedBy(
+    fn("TypeParser.effectSchemaType")(function* (type, atLocation) {
+      yield* pipeableType(type, atLocation);
+      const ast = typeChecker.getPropertyOfType(type, "ast");
+      if (!ast) return yield* typeParserIssue("Has no 'ast' property", type, atLocation);
+      const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
+        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional)
+      );
+      propertiesSymbols.sort((a, b) => b.name.indexOf("TypeId") - a.name.indexOf("TypeId"));
+      for (const propertySymbol of propertiesSymbols) {
+        const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
+        const varianceArgs = yield* option(effectSchemaVarianceStruct(
+          propertyType,
+          atLocation
+        ));
+        if (isSome2(varianceArgs)) {
+          return varianceArgs.value;
+        }
+      }
+      return yield* typeParserIssue("Type has no schema variance struct", type, atLocation);
+    }),
+    "TypeParser.effectSchemaType",
+    (type) => type
+  );
+  const contextTagVarianceStruct = (type, atLocation) => map4(
+    all2(
+      varianceStructInvariantType(type, atLocation, "_Identifier"),
+      varianceStructInvariantType(type, atLocation, "_Service")
+    ),
+    ([Identifier, Service]) => ({ Identifier, Service })
+  );
+  const contextTag = cachedBy(
+    fn("TypeParser.contextTag")(function* (type, atLocation) {
+      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("TypeId") - a.name.indexOf("TypeId"));
+      for (const propertySymbol of propertiesSymbols) {
+        const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
+        const varianceArgs = yield* option(contextTagVarianceStruct(
+          propertyType,
+          atLocation
+        ));
+        if (isSome2(varianceArgs)) {
+          return varianceArgs.value;
+        }
+      }
+      return yield* typeParserIssue("Type has no tag variance struct", type, atLocation);
+    }),
+    "TypeParser.contextTag",
+    (type) => type
+  );
+  return {
+    effectType,
+    layerType,
+    fiberType,
+    effectSubtype,
+    importedEffectModule,
+    effectGen,
+    effectFnUntracedGen,
+    effectFnGen,
+    unnecessaryEffectGen: unnecessaryEffectGen2,
+    effectSchemaType,
+    contextTag
+  };
+}
+
+// src/completions/fnFunctionStar.ts
+var fnFunctionStar = createCompletion({
+  name: "fnFunctionStar",
+  apply: fn("fnFunctionStar")(function* (sourceFile, position) {
+    const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
+    const maybeInfos = yield* option(
+      parseAccessedExpressionForCompletion(sourceFile, position)
+    );
+    if (isNone2(maybeInfos)) return [];
+    const { accessedObject } = maybeInfos.value;
+    const isEffectModule = yield* option(typeParser.importedEffectModule(accessedObject));
+    if (isNone2(isEffectModule)) return [];
+    const span = ts.createTextSpan(
+      accessedObject.end + 1,
+      Math.max(0, position - accessedObject.end - 1)
+    );
+    const maybeFnName = pipe(
+      yield* getAncestorNodesInRange(sourceFile, toTextRange(accessedObject.pos)),
+      filter(ts.isVariableDeclaration),
+      map3((_) => _.name && ts.isIdentifier(_.name) ? _.name.text : ""),
+      filter((_) => _.length > 0),
+      head,
+      map2((name) => [
+        {
+          name: `fn("${name}")`,
+          kind: ts.ScriptElementKind.constElement,
+          insertText: `fn("${name}")(function*(${"${1}"}){${"${0}"}})`,
+          replacementSpan: span,
+          isSnippet: true
+        }
+      ]),
+      getOrElse2(() => [])
+    );
+    return maybeFnName.concat([{
+      name: `fn(function*(){})`,
+      kind: ts.ScriptElementKind.constElement,
+      insertText: `fn(function*(${"${1}"}){${"${0}"}})`,
+      replacementSpan: span,
+      isSnippet: true
+    }, {
+      name: `fnUntraced(function*(){})`,
+      kind: ts.ScriptElementKind.constElement,
+      insertText: `fnUntraced(function*(${"${1}"}){${"${0}"}})`,
+      replacementSpan: span,
+      isSnippet: true
+    }]);
+  })
+});
+
 // src/core/TypeCheckerApi.ts
 var TypeCheckerApi = Tag("TypeChecker");
 var TypeCheckerApiCache = Tag("TypeCheckerApiCache");
@@ -2071,554 +2619,109 @@ var expectedAndRealType = fn("TypeCheckerApi.expectedAndRealType")(function* (so
         if (ts.isObjectLiteralExpression(parent.parent) && parent.name === node) {
           const type = typeChecker.getContextualType(parent.parent);
           if (type) {
-            const symbol3 = typeChecker.getPropertyOfType(type, node.text);
-            if (symbol3) {
-              const expectedType = typeChecker.getTypeOfSymbolAtLocation(symbol3, node);
-              const realType = typeChecker.getTypeAtLocation(node);
-              result.push([node, expectedType, node, realType]);
-            }
-          }
-        }
-      }
-      ts.forEachChild(node, appendNodeToVisit);
-      continue;
-    } else if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
-      const expectedType = typeChecker.getTypeAtLocation(node.left);
-      const realType = typeChecker.getTypeAtLocation(node.right);
-      result.push([node.left, expectedType, node.right, realType]);
-      appendNodeToVisit(node.right);
-      continue;
-    } else if (ts.isReturnStatement(node) && node.expression) {
-      const parentDeclaration = yield* option(getAncestorConvertibleDeclaration(node));
-      if (isSome2(parentDeclaration)) {
-        const expectedType = yield* option(getInferredReturnType(parentDeclaration.value));
-        const realType = typeChecker.getTypeAtLocation(node.expression);
-        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);
-  }
-  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 {
-  constructor(type, node, message) {
-    this.type = type;
-    this.node = node;
-    this.message = message;
-  }
-  _tag = "@effect/language-service/TypeParserIssue";
-};
-function typeParserIssue(message, type, node) {
-  return fail(new TypeParserIssue(type, node, message));
-}
-function covariantTypeArgument(type) {
-  const signatures = type.getCallSignatures();
-  if (signatures.length !== 1) {
-    return typeParserIssue("Covariant type has no call signature", 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) {
-    return typeParserIssue("Invariant type has no call signature", type);
-  }
-  return succeed(signatures[0].getReturnType());
-}
-var pipeableType = fn("TypeParser.pipeableType")(function* (type, atLocation) {
-  const typeChecker = yield* service(TypeCheckerApi);
-  const pipeSymbol = typeChecker.getPropertyOfType(type, "pipe");
-  if (!pipeSymbol) {
-    return yield* typeParserIssue("Type has no 'pipe' property", type, atLocation);
-  }
-  const pipeType = typeChecker.getTypeOfSymbolAtLocation(pipeSymbol, atLocation);
-  const signatures = pipeType.getCallSignatures();
-  if (signatures.length === 0) {
-    return yield* typeParserIssue("'pipe' property is not callable", type, atLocation);
-  }
-  return type;
-});
-var varianceStructCovariantType = fn("TypeParser.varianceStructCovariantType")(
-  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* 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);
-    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* invariantTypeArgument(propertyType);
-  }
-);
-var effectVarianceStruct = fn("TypeParser.effectVarianceStruct")(function* (type, atLocation) {
-  return {
-    A: yield* varianceStructCovariantType(type, atLocation, "_A"),
-    E: yield* varianceStructCovariantType(type, atLocation, "_E"),
-    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);
-  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("EffectTypeId") - a.name.indexOf("EffectTypeId"));
-  for (const propertySymbol of propertiesSymbols) {
-    const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
-    const varianceArgs = yield* option(effectVarianceStruct(
-      propertyType,
-      atLocation
-    ));
-    if (isSome2(varianceArgs)) {
-      return varianceArgs.value;
-    }
-  }
-  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");
-  const pollSymbol = typeChecker.getPropertyOfType(type, "poll");
-  if (!awaitSymbol || !pollSymbol) {
-    return yield* typeParserIssue(
-      "Type is not a fiber because it does not have 'await' or 'poll' property",
-      type,
-      atLocation
-    );
-  }
-  return yield* effectType(type, atLocation);
-});
-var effectSubtype = fn("TypeParser.effectSubtype")(function* (type, atLocation) {
-  const typeChecker = yield* service(TypeCheckerApi);
-  const tagSymbol = typeChecker.getPropertyOfType(type, "_tag");
-  const getSymbol = typeChecker.getPropertyOfType(type, "get");
-  if (!(tagSymbol || getSymbol)) {
-    return yield* typeParserIssue(
-      "Type is not a subtype of effect because it does not have '_tag' or 'get' property",
-      type,
-      atLocation
-    );
-  }
-  return yield* effectType(type, atLocation);
-});
-var importedEffectModule = fn("TypeParser.importedEffectModule")(function* (node) {
-  const ts = yield* service(TypeScriptApi);
-  const typeChecker = yield* service(TypeCheckerApi);
-  const type = typeChecker.getTypeAtLocation(node);
-  const propertySymbol = typeChecker.getPropertyOfType(type, "never");
-  if (!propertySymbol) {
-    return yield* typeParserIssue("Type has no 'never' property", type, node);
-  }
-  if (!ts.isExpression(node)) {
-    return yield* typeParserIssue("Node is not an expression", type, node);
-  }
-  const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, node);
-  yield* effectType(propertyType, node);
-  return node;
-});
-var effectGen = fn("TypeParser.effectGen")(function* (node) {
-  const ts = yield* service(TypeScriptApi);
-  if (!ts.isCallExpression(node)) {
-    return yield* typeParserIssue("Node is not a call expression", void 0, node);
-  }
-  if (node.arguments.length === 0) {
-    return yield* typeParserIssue("Node has no arguments", void 0, node);
-  }
-  const generatorFunction = node.arguments[0];
-  if (!ts.isFunctionExpression(generatorFunction)) {
-    return yield* typeParserIssue("Node is not a function expression", void 0, node);
-  }
-  if (generatorFunction.asteriskToken === void 0) {
-    return yield* typeParserIssue("Node is not a generator function", void 0, node);
-  }
-  if (!ts.isPropertyAccessExpression(node.expression)) {
-    return yield* typeParserIssue("Node is not a property access expression", void 0, node);
-  }
-  const propertyAccess = node.expression;
-  if (propertyAccess.name.text !== "gen") {
-    return yield* typeParserIssue("Call expression name is not 'gen'", void 0, node);
-  }
-  const effectModule = yield* importedEffectModule(propertyAccess.expression);
-  return {
-    node,
-    effectModule,
-    generatorFunction,
-    body: generatorFunction.body,
-    functionStar: generatorFunction.getFirstToken()
-  };
-});
-var effectFnUntracedGen = fn("TypeParser.effectFnUntracedGen")(
-  function* (node) {
-    const ts = yield* service(TypeScriptApi);
-    if (!ts.isCallExpression(node)) {
-      return yield* typeParserIssue("Node is not a call expression", void 0, node);
-    }
-    if (node.arguments.length === 0) {
-      return yield* typeParserIssue("Node has no arguments", void 0, node);
-    }
-    const generatorFunction = node.arguments[0];
-    if (!ts.isFunctionExpression(generatorFunction)) {
-      return yield* typeParserIssue("Node is not a function expression", void 0, node);
-    }
-    if (generatorFunction.asteriskToken === void 0) {
-      return yield* typeParserIssue(
-        "Node is not a generator function",
-        void 0,
-        node
-      );
-    }
-    if (!ts.isPropertyAccessExpression(node.expression)) {
-      return yield* typeParserIssue(
-        "Node is not a property access expression",
-        void 0,
-        node
-      );
-    }
-    const propertyAccess = node.expression;
-    if (propertyAccess.name.text !== "fnUntraced") {
-      return yield* typeParserIssue(
-        "Call expression name is not 'fnUntraced'",
-        void 0,
-        node
-      );
-    }
-    const effectModule = yield* importedEffectModule(propertyAccess.expression);
-    return {
-      node,
-      effectModule,
-      generatorFunction,
-      body: generatorFunction.body,
-      functionStar: generatorFunction.getFirstToken()
-    };
-  }
-);
-var effectFnGen = fn("TypeParser.effectFnGen")(function* (node) {
-  const ts = yield* service(TypeScriptApi);
-  if (!ts.isCallExpression(node)) {
-    return yield* typeParserIssue("Node is not a call expression", void 0, node);
-  }
-  if (node.arguments.length === 0) {
-    return yield* typeParserIssue("Node has no arguments", void 0, node);
-  }
-  const generatorFunction = node.arguments[0];
-  if (!ts.isFunctionExpression(generatorFunction)) {
-    return yield* typeParserIssue(
-      "Node is not a function expression",
-      void 0,
-      node
-    );
-  }
-  if (generatorFunction.asteriskToken === void 0) {
-    return yield* typeParserIssue(
-      "Node is not a generator function",
-      void 0,
-      node
-    );
-  }
-  const expressionToTest = ts.isCallExpression(node.expression) ? node.expression.expression : node.expression;
-  if (!ts.isPropertyAccessExpression(expressionToTest)) {
-    return yield* typeParserIssue(
-      "Node is not a property access expression",
-      void 0,
-      node
-    );
-  }
-  const propertyAccess = expressionToTest;
-  if (propertyAccess.name.text !== "fn") {
-    return yield* typeParserIssue(
-      "Call expression name is not 'fn'",
-      void 0,
-      node
-    );
-  }
-  const effectModule = yield* importedEffectModule(propertyAccess.expression);
-  return {
-    node,
-    generatorFunction,
-    effectModule,
-    body: generatorFunction.body,
-    functionStar: generatorFunction.getFirstToken()
-  };
-});
-var unnecessaryEffectGen = fn("TypeParser.unnecessaryEffectGen")(function* (node) {
-  const ts = yield* service(TypeScriptApi);
-  const typeChecker = yield* service(TypeCheckerApi);
-  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;
+            const symbol3 = typeChecker.getPropertyOfType(type, node.text);
+            if (symbol3) {
+              const expectedType = typeChecker.getTypeOfSymbolAtLocation(symbol3, node);
+              const realType = typeChecker.getTypeAtLocation(node);
+              result.push([node, expectedType, node, realType]);
+            }
+          }
+        }
+      }
+      ts.forEachChild(node, appendNodeToVisit);
       continue;
-    }
-    if (ts.isExpressionStatement(nodeToCheck)) {
-      nodeToCheck = nodeToCheck.expression;
+    } 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;
-    }
-    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)
-        );
+    } 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]);
       }
-      return { node, body, yieldedExpression, replacementNode };
+      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;
     }
-    break;
+    ts.forEachChild(node, appendNodeToVisit);
   }
-  return yield* typeParserIssue(
-    "Not an handled node",
-    void 0,
-    node
-  );
+  cache.expectedAndRealType.set(sourceFile, result);
+  return result;
 });
-var effectSchemaVarianceStruct = fn("TypeParser.effectSchemaVarianceStruct")(
-  function* (type, atLocation) {
+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 {
-      A: yield* varianceStructInvariantType(type, atLocation, "_A"),
-      I: yield* varianceStructInvariantType(type, atLocation, "_I"),
-      R: yield* varianceStructCovariantType(type, atLocation, "_R")
+      newIndexes,
+      knownIndexes,
+      allIndexes: pipe(
+        fromIterable(newIndexes),
+        appendAll(fromIterable(knownIndexes))
+      )
     };
   }
 );
-var effectSchemaType = fn("TypeParser.effectSchemaType")(function* (type, atLocation) {
-  const ts = yield* service(TypeScriptApi);
-  const typeChecker = yield* service(TypeCheckerApi);
-  yield* pipeableType(type, atLocation);
-  const ast = typeChecker.getPropertyOfType(type, "ast");
-  if (!ast) return yield* typeParserIssue("Has no 'ast' property", type, atLocation);
-  const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
-    (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional)
-  );
-  propertiesSymbols.sort((a, b) => b.name.indexOf("TypeId") - a.name.indexOf("TypeId"));
-  for (const propertySymbol of propertiesSymbols) {
-    const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
-    const varianceArgs = yield* option(effectSchemaVarianceStruct(
-      propertyType,
-      atLocation
-    ));
-    if (isSome2(varianceArgs)) {
-      return varianceArgs.value;
-    }
-  }
-  return yield* typeParserIssue("Type has no schema variance struct", type, atLocation);
-});
-
-// src/completions/fnFunctionStar.ts
-var fnFunctionStar = createCompletion({
-  name: "fnFunctionStar",
-  apply: fn("fnFunctionStar")(function* (sourceFile, position) {
-    const ts = yield* service(TypeScriptApi);
-    const maybeInfos = yield* option(
-      parseAccessedExpressionForCompletion(sourceFile, position)
-    );
-    if (isNone2(maybeInfos)) return [];
-    const { accessedObject } = maybeInfos.value;
-    const isEffectModule = yield* option(importedEffectModule(accessedObject));
-    if (isNone2(isEffectModule)) return [];
-    const span = ts.createTextSpan(
-      accessedObject.end + 1,
-      Math.max(0, position - accessedObject.end - 1)
-    );
-    const maybeFnName = pipe(
-      yield* getAncestorNodesInRange(sourceFile, toTextRange(accessedObject.pos)),
-      filter(ts.isVariableDeclaration),
-      map3((_) => _.name && ts.isIdentifier(_.name) ? _.name.text : ""),
-      filter((_) => _.length > 0),
-      head,
-      map2((name) => [
-        {
-          name: `fn("${name}")`,
-          kind: ts.ScriptElementKind.constElement,
-          insertText: `fn("${name}")(function*(${"${1}"}){${"${0}"}})`,
-          replacementSpan: span,
-          isSnippet: true
-        }
-      ]),
-      getOrElse2(() => [])
-    );
-    return maybeFnName.concat([{
-      name: `fn(function*(){})`,
-      kind: ts.ScriptElementKind.constElement,
-      insertText: `fn(function*(${"${1}"}){${"${0}"}})`,
-      replacementSpan: span,
-      isSnippet: true
-    }, {
-      name: `fnUntraced(function*(){})`,
-      kind: ts.ScriptElementKind.constElement,
-      insertText: `fnUntraced(function*(${"${1}"}){${"${0}"}})`,
-      replacementSpan: span,
-      isSnippet: true
-    }]);
-  })
-});
 
 // src/completions/genFunctionStar.ts
 var genFunctionStar = createCompletion({
@@ -2701,6 +2804,7 @@ function parse(config) {
     diagnostics: isObject(config) && hasProperty(config, "diagnostics") && isBoolean(config.diagnostics) ? config.diagnostics : true,
     quickinfo: isObject(config) && hasProperty(config, "quickinfo") && isBoolean(config.quickinfo) ? config.quickinfo : true,
     completions: isObject(config) && hasProperty(config, "completions") && isBoolean(config.completions) ? config.completions : true,
+    goto: isObject(config) && hasProperty(config, "goto") && isBoolean(config.goto) ? config.goto : true,
     allowedDuplicatedPackages: isObject(config) && hasProperty(config, "allowedDuplicatedPackages") && isArray(config.allowedDuplicatedPackages) && config.allowedDuplicatedPackages.every(isString) ? config.allowedDuplicatedPackages.map((_) => _.toLowerCase()) : []
   };
 }
@@ -2761,6 +2865,7 @@ var floatingEffect = createDiagnostic({
   apply: fn("floatingEffect.apply")(function* (sourceFile) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
     function isFloatingExpression(node) {
       if (!ts.isExpressionStatement(node)) return false;
       if (!(ts.isBlock(node.parent) || ts.isSourceFile(node.parent))) return false;
@@ -2780,11 +2885,11 @@ var floatingEffect = createDiagnostic({
       ts.forEachChild(node, appendNodeToVisit);
       if (!isFloatingExpression(node)) continue;
       const type = typeChecker.getTypeAtLocation(node.expression);
-      const effect = yield* option(effectType(type, node.expression));
+      const effect = yield* option(typeParser.effectType(type, node.expression));
       if (isSome2(effect)) {
         const allowedFloatingEffects = yield* pipe(
-          fiberType(type, node.expression),
-          orElse3(() => effectSubtype(type, node.expression)),
+          typeParser.fiberType(type, node.expression),
+          orElse3(() => typeParser.effectSubtype(type, node.expression)),
           option
         );
         if (isNone2(allowedFloatingEffects)) {
@@ -2801,6 +2906,112 @@ var floatingEffect = createDiagnostic({
   })
 });
 
+// src/diagnostics/leakingRequirements.ts
+var leakingRequirements = createDiagnostic({
+  name: "leakingRequirements",
+  code: 8,
+  apply: fn("leakingRequirements.apply")(function* (sourceFile) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
+    const typeOrder = yield* deterministicTypeOrder;
+    const effectDiagnostics = [];
+    const parseLeakedRequirements = cachedBy(
+      fn("leakingServices.checkServiceLeaking")(
+        function* (service2, atLocation) {
+          const properties = typeChecker.getPropertiesOfType(service2);
+          if (properties.length < 1) return [];
+          const memory = /* @__PURE__ */ new Map();
+          let sharedRequirementsKeys = void 0;
+          let effectMembers = 0;
+          for (const property of properties) {
+            const servicePropertyType = typeChecker.getTypeOfSymbolAtLocation(property, atLocation);
+            let effectContextType = void 0;
+            yield* pipe(
+              typeParser.effectType(servicePropertyType, atLocation),
+              map4((_) => effectContextType = _.R),
+              orElse3(() => {
+                const servicePropertyCallSignatures = servicePropertyType.getCallSignatures();
+                if (servicePropertyCallSignatures.length === 1) {
+                  return pipe(
+                    typeParser.effectType(servicePropertyCallSignatures[0].getReturnType(), atLocation),
+                    map4((_) => {
+                      effectContextType = _.R;
+                    })
+                  );
+                }
+                return void_2;
+              }),
+              ignore
+            );
+            if (effectContextType) {
+              effectMembers++;
+              const { allIndexes } = yield* appendToUniqueTypesMap(memory, effectContextType, true);
+              if (!sharedRequirementsKeys) {
+                sharedRequirementsKeys = allIndexes;
+              } else {
+                sharedRequirementsKeys = intersection(sharedRequirementsKeys, allIndexes);
+                if (sharedRequirementsKeys.length === 0) return [];
+              }
+            }
+          }
+          if (sharedRequirementsKeys && sharedRequirementsKeys.length > 0 && effectMembers >= 2) {
+            return sharedRequirementsKeys.map((key) => memory.get(key));
+          }
+          return [];
+        }
+      ),
+      "leakingServices.checkServiceLeaking",
+      (_, service2) => service2
+    );
+    function reportLeakingRequirements(node, requirements) {
+      if (requirements.length === 0) return;
+      effectDiagnostics.push({
+        node,
+        category: ts.DiagnosticCategory.Warning,
+        messageText: `This Service is leaking the ${requirements.map((_) => typeChecker.typeToString(_)).join(" | ")} requirement`,
+        fixes: []
+      });
+    }
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      const typesToCheck = [];
+      if (ts.isCallExpression(node)) {
+        typesToCheck.push([typeChecker.getTypeAtLocation(node), node]);
+      } else if (ts.isClassDeclaration(node) && node.name) {
+        const classSym = typeChecker.getSymbolAtLocation(node.name);
+        if (classSym) {
+          const type = typeChecker.getTypeOfSymbol(classSym);
+          typesToCheck.push([type, node.name]);
+        }
+      } else {
+        ts.forEachChild(node, appendNodeToVisit);
+        continue;
+      }
+      for (const [type, reportAt] of typesToCheck) {
+        yield* pipe(
+          typeParser.contextTag(type, node),
+          flatMap3(
+            ({ Service }) => pipe(
+              parseLeakedRequirements(Service, node),
+              map4((requirements) => reportLeakingRequirements(reportAt, sort(requirements, typeOrder)))
+            )
+          ),
+          orElse3(() => sync(() => ts.forEachChild(node, appendNodeToVisit))),
+          ignore
+        );
+      }
+    }
+    return effectDiagnostics;
+  })
+});
+
 // src/diagnostics/missingEffectContext.ts
 var missingEffectContext = createDiagnostic({
   name: "missingEffectContext",
@@ -2808,15 +3019,16 @@ var missingEffectContext = createDiagnostic({
   apply: fn("missingEffectContext.apply")(function* (sourceFile) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
     const typeOrder = yield* deterministicTypeOrder;
     const checkForMissingContextTypes = fn(
       "missingEffectContext.apply.checkForMissingContextTypes"
     )(function* (node, expectedType, valueNode, realType) {
-      const expectedEffect = yield* effectType(
+      const expectedEffect = yield* typeParser.effectType(
         expectedType,
         node
       );
-      const realEffect = yield* effectType(
+      const realEffect = yield* typeParser.effectType(
         realType,
         valueNode
       );
@@ -2860,14 +3072,15 @@ var missingEffectError = createDiagnostic({
   apply: fn("missingEffectError.apply")(function* (sourceFile) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
     const typeOrder = yield* deterministicTypeOrder;
     const checkForMissingErrorTypes = fn("missingEffectError.apply.checkForMissingErrorTypes")(
       function* (node, expectedType, valueNode, realType) {
-        const expectedEffect = yield* effectType(
+        const expectedEffect = yield* typeParser.effectType(
           expectedType,
           node
         );
-        const realEffect = yield* effectType(
+        const realEffect = yield* typeParser.effectType(
           realType,
           valueNode
         );
@@ -2912,6 +3125,7 @@ var missingReturnYieldStar = createDiagnostic({
   apply: fn("missingReturnYieldStar.apply")(function* (sourceFile) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
     const effectDiagnostics = [];
     const brokenYields = /* @__PURE__ */ new Set();
     const nodeToVisit = [];
@@ -2925,7 +3139,7 @@ var missingReturnYieldStar = createDiagnostic({
       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));
+        const maybeEffect = yield* option(typeParser.effectType(type, node.expression));
         if (isSome2(maybeEffect) && maybeEffect.value.A.flags & ts.TypeFlags.Never) {
           const generatorFunctionOrReturnStatement = ts.findAncestor(
             node,
@@ -2935,9 +3149,9 @@ var missingReturnYieldStar = createDiagnostic({
             if (generatorFunctionOrReturnStatement && generatorFunctionOrReturnStatement.parent) {
               const effectGenNode = generatorFunctionOrReturnStatement.parent;
               const effectGenLike = yield* pipe(
-                effectGen(effectGenNode),
-                orElse3(() => effectFnUntracedGen(effectGenNode)),
-                orElse3(() => effectFnGen(effectGenNode)),
+                typeParser.effectGen(effectGenNode),
+                orElse3(() => typeParser.effectFnUntracedGen(effectGenNode)),
+                orElse3(() => typeParser.effectFnGen(effectGenNode)),
                 option
               );
               if (isSome2(effectGenLike)) {
@@ -2980,6 +3194,7 @@ var missingStarInYieldEffectGen = createDiagnostic({
   code: 4,
   apply: fn("missingStarInYieldEffectGen.apply")(function* (sourceFile) {
     const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
     const effectDiagnostics = [];
     const brokenGenerators = /* @__PURE__ */ new Set();
     const brokenYields = /* @__PURE__ */ new Set();
@@ -2999,18 +3214,18 @@ var missingStarInYieldEffectGen = createDiagnostic({
         );
         if (functionStarNode && functionStarNode.parent) {
           const effectGenNode = functionStarNode.parent;
-          const effectGenLike = yield* pipe(
-            effectGen(effectGenNode),
-            orElse3(() => effectFnUntracedGen(effectGenNode)),
-            orElse3(() => effectFnGen(effectGenNode)),
-            option
+          yield* pipe(
+            typeParser.effectGen(effectGenNode),
+            orElse3(() => typeParser.effectFnUntracedGen(effectGenNode)),
+            orElse3(() => typeParser.effectFnGen(effectGenNode)),
+            map4(({ functionStar }) => {
+              if (functionStar) {
+                brokenGenerators.add(functionStar);
+              }
+              brokenYields.add(node);
+            }),
+            ignore
           );
-          if (isSome2(effectGenLike)) {
-            if (effectGenLike.value.functionStar) {
-              brokenGenerators.add(effectGenLike.value.functionStar);
-            }
-            brokenYields.add(node);
-          }
         }
       }
     }
@@ -3050,11 +3265,12 @@ var missingStarInYieldEffectGen = createDiagnostic({
 });
 
 // src/diagnostics/unnecessaryEffectGen.ts
-var unnecessaryEffectGen2 = createDiagnostic({
+var unnecessaryEffectGen = createDiagnostic({
   name: "unnecessaryEffectGen",
   code: 5,
   apply: fn("unnecessaryEffectGen.apply")(function* (sourceFile) {
     const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
     const effectDiagnostics = [];
     const unnecessaryGenerators = /* @__PURE__ */ new Map();
     const nodeToVisit = [];
@@ -3066,9 +3282,12 @@ var unnecessaryEffectGen2 = createDiagnostic({
     while (nodeToVisit.length > 0) {
       const node = nodeToVisit.shift();
       ts.forEachChild(node, appendNodeToVisit);
-      const maybeNode = yield* option(unnecessaryEffectGen(node));
-      if (isSome2(maybeNode)) {
-        unnecessaryGenerators.set(node, maybeNode.value.replacementNode);
+      if (ts.isCallExpression(node)) {
+        yield* pipe(
+          typeParser.unnecessaryEffectGen(node),
+          map4(({ replacementNode }) => unnecessaryGenerators.set(node, replacementNode)),
+          ignore
+        );
       }
     }
     unnecessaryGenerators.forEach(
@@ -3099,8 +3318,9 @@ var diagnostics = [
   missingEffectError,
   floatingEffect,
   missingStarInYieldEffectGen,
-  unnecessaryEffectGen2,
-  missingReturnYieldStar
+  unnecessaryEffectGen,
+  missingReturnYieldStar,
+  leakingRequirements
 ];
 
 // src/goto/effectRpcDefinition.ts
@@ -3242,6 +3462,7 @@ function effectTypeArgs(sourceFile, position, quickInfo2) {
     gen2(function* () {
       const ts = yield* service(TypeScriptApi);
       const typeChecker = yield* service(TypeCheckerApi);
+      const typeParser = yield* service(TypeParser);
       const maybeNode = pipe(
         yield* getAncestorNodesInRange(sourceFile, toTextRange(position)),
         head
@@ -3251,13 +3472,13 @@ function effectTypeArgs(sourceFile, position, quickInfo2) {
       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(
+      const effectType = yield* typeParser.effectType(
         typeChecker.getTypeAtLocation(nodeForType),
         nodeForType
       );
       const effectTypeArgsDocumentation = [{
         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"
+        text: "```ts\n/* Effect Type Parameters */\n" + (yield* formatTypeForQuickInfo(effectType.A, "Success")) + "\n" + (yield* formatTypeForQuickInfo(effectType.E, "Failure")) + "\n" + (yield* formatTypeForQuickInfo(effectType.R, "Requirements")) + "\n```\n"
       }];
       if (!quickInfo2) {
         const start = node.getStart();
@@ -3315,6 +3536,7 @@ function processLayerGraphNode(ctx, node, pipedInGraphNode) {
   return gen2(function* () {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
     const maybePipe = yield* option(parsePipeCall(node));
     if (isSome2(maybePipe)) {
       let graphNode = yield* processLayerGraphNode(ctx, maybePipe.value.subject, void 0);
@@ -3325,7 +3547,7 @@ function processLayerGraphNode(ctx, node, pipedInGraphNode) {
     }
     if (ts.isCallExpression(node)) {
       const type = typeChecker.getTypeAtLocation(node);
-      const maybeLayer = yield* option(layerType(type, node));
+      const maybeLayer = yield* option(typeParser.layerType(type, node));
       if (isSome2(maybeLayer)) {
         const argNodes = yield* option(
           all2(...node.arguments.map((_) => processLayerGraphNode(ctx, _, void 0)))
@@ -3358,7 +3580,7 @@ function processLayerGraphNode(ctx, node, pipedInGraphNode) {
         if (callSignatures.length === 1) {
           const [signature] = callSignatures;
           const returnType = signature.getReturnType();
-          const maybeLayer = yield* option(layerType(returnType, node));
+          const maybeLayer = yield* option(typeParser.layerType(returnType, node));
           if (isSome2(maybeLayer)) {
             const { allIndexes: outTypes } = yield* appendToUniqueTypesMap(
               ctx.services,
@@ -3408,7 +3630,7 @@ function processLayerGraphNode(ctx, node, pipedInGraphNode) {
     }
     if (ts.isExpression(node)) {
       const type = typeChecker.getTypeAtLocation(node);
-      const maybeLayer = yield* option(layerType(type, node));
+      const maybeLayer = yield* option(typeParser.layerType(type, node));
       if (isSome2(maybeLayer)) {
         const { allIndexes: outTypes } = yield* appendToUniqueTypesMap(
           ctx.services,
@@ -3547,6 +3769,7 @@ function layerInfo(sourceFile, position, quickInfo2) {
     gen2(function* () {
       const ts = yield* service(TypeScriptApi);
       const typeChecker = yield* service(TypeCheckerApi);
+      const typeParser = yield* service(TypeParser);
       const range = toTextRange(position);
       const maybeNode = pipe(
         yield* getAncestorNodesInRange(sourceFile, range),
@@ -3557,8 +3780,8 @@ function layerInfo(sourceFile, position, quickInfo2) {
       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));
+      const layerType = typeChecker.getTypeAtLocation(layerNode);
+      const maybeLayer = yield* option(typeParser.layerType(layerType, layerNode));
       if (isNone2(maybeLayer)) return quickInfo2;
       let lastId = 0;
       const graphCtx = {
@@ -3662,6 +3885,7 @@ var asyncAwaitToGen = createRefactor({
   apply: fn("asyncAwaitToGen.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
     const maybeNode = pipe(
       yield* getAncestorNodesInRange(sourceFile, textRange),
       filter(
@@ -3684,7 +3908,7 @@ var asyncAwaitToGen = createRefactor({
               findImportedModuleIdentifier(
                 sourceFile,
                 (node2) => pipe(
-                  importedEffectModule(node2),
+                  typeParser.importedEffectModule(node2),
                   option,
                   map4(isSome2)
                 )
@@ -3732,6 +3956,7 @@ var asyncAwaitToGenTryPromise = createRefactor({
   apply: fn("asyncAwaitToGenTryPromise.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
     const maybeNode = pipe(
       yield* getAncestorNodesInRange(sourceFile, textRange),
       filter(
@@ -3754,7 +3979,7 @@ var asyncAwaitToGenTryPromise = createRefactor({
               findImportedModuleIdentifier(
                 sourceFile,
                 (node2) => pipe(
-                  importedEffectModule(node2),
+                  typeParser.importedEffectModule(node2),
                   option,
                   map4(isSome2)
                 )
@@ -3831,17 +4056,18 @@ var effectGenToFn = createRefactor({
   description: "Convert to Effect.fn",
   apply: fn("effectGenToFn.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
     const parseEffectGenNode = fn("asyncAwaitToGen.apply")(function* (node) {
-      const effectGen2 = yield* effectGen(node);
+      const effectGen = yield* typeParser.effectGen(node);
       let pipeArgs2 = ts.factory.createNodeArray([]);
       let nodeToReplace2 = node;
       while (nodeToReplace2.parent) {
         const parent = nodeToReplace2.parent;
         if (ts.isConciseBody(nodeToReplace2) && ts.isArrowFunction(parent) && parent.body === nodeToReplace2) {
-          return { ...effectGen2, pipeArgs: pipeArgs2, nodeToReplace: parent };
+          return { ...effectGen, pipeArgs: pipeArgs2, nodeToReplace: parent };
         }
         if ((ts.isFunctionDeclaration(parent) || ts.isMethodDeclaration(parent)) && parent.body === nodeToReplace2) {
-          return { ...effectGen2, pipeArgs: pipeArgs2, nodeToReplace: parent };
+          return { ...effectGen, pipeArgs: pipeArgs2, nodeToReplace: parent };
         }
         if (ts.isBlock(parent) && parent.statements.length === 1 && parent.statements[0] === nodeToReplace2) {
           nodeToReplace2 = parent;
@@ -3978,6 +4204,7 @@ var _findSchemaVariableDeclaration = fn(
   function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
     const findSchema = fn("makeSchemaOpaque.apply.findSchema")(
       function* (node) {
         if (!ts.isVariableDeclaration(node)) {
@@ -3996,7 +4223,7 @@ var _findSchemaVariableDeclaration = fn(
           return yield* fail("parent not variable declaration statement");
         }
         const type = typeChecker.getTypeAtLocation(initializer);
-        const types = yield* effectSchemaType(type, initializer);
+        const types = yield* typeParser.effectSchemaType(type, initializer);
         return { identifier, variableStatement, variableDeclarationList, types };
       }
     );
@@ -4343,8 +4570,9 @@ var removeUnnecessaryEffectGen = createRefactor({
   name: "removeUnnecessaryEffectGen",
   description: "Remove unnecessary Effect.gen",
   apply: fn("removeUnnecessaryEffectGen.apply")(function* (sourceFile, textRange) {
+    const typeParser = yield* service(TypeParser);
     for (const nodeToReplace of yield* getAncestorNodesInRange(sourceFile, textRange)) {
-      const maybeNode = yield* option(unnecessaryEffectGen(nodeToReplace));
+      const maybeNode = yield* option(typeParser.unnecessaryEffectGen(nodeToReplace));
       if (isNone2(maybeNode)) continue;
       const replacementNode = maybeNode.value.replacementNode;
       return {
@@ -5027,13 +5255,14 @@ var wrapWithEffectGen = createRefactor({
   apply: fn("wrapWithEffectGen.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
     const findEffectToWrap = fn("wrapWithEffectGen.apply.findEffectToWrap")(
       function* (node) {
         if (!ts.isExpression(node)) return yield* fail("is not an expression");
         const parent = node.parent;
         if (parent != null && ts.isVariableDeclaration(parent) && parent.initializer !== node) return yield* fail("is LHS of variable declaration");
         const type = typeChecker.getTypeAtLocation(node);
-        yield* effectType(type, node);
+        yield* typeParser.effectType(type, node);
         return node;
       }
     );
@@ -5044,19 +5273,35 @@ var wrapWithEffectGen = createRefactor({
       option
     );
     if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
+    const effectModuleIdentifier = match2(
+      yield* option(
+        findImportedModuleIdentifier(
+          sourceFile,
+          (node) => pipe(
+            typeParser.importedEffectModule(node),
+            option,
+            map4(isSome2)
+          )
+        )
+      ),
+      {
+        onNone: () => "Effect",
+        onSome: (node) => node.text
+      }
+    );
     return {
       kind: "refactor.rewrite.effect.wrapWithEffectGen",
       description: `Wrap with Effect.gen`,
       apply: pipe(
         gen2(function* () {
           const changeTracker = yield* service(ChangeTracker);
-          const effectGen2 = yield* pipe(
+          const effectGen = yield* pipe(
             createEffectGenCallExpressionWithBlock(
-              yield* getEffectModuleIdentifierName(sourceFile),
+              effectModuleIdentifier,
               yield* createReturnYieldStarStatement(maybeNode.value)
             )
           );
-          changeTracker.replaceNode(sourceFile, maybeNode.value, effectGen2);
+          changeTracker.replaceNode(sourceFile, maybeNode.value, effectGen);
         }),
         provideService(TypeScriptApi, ts),
         provideService(TypeCheckerApi, typeChecker)
@@ -5064,26 +5309,6 @@ var wrapWithEffectGen = createRefactor({
     };
   })
 });
-var getEffectModuleIdentifierName = fn("getEffectModuleIdentifierName")(
-  function* (sourceFile) {
-    return match2(
-      yield* option(
-        findImportedModuleIdentifier(
-          sourceFile,
-          (node) => pipe(
-            importedEffectModule(node),
-            option,
-            map4(isSome2)
-          )
-        )
-      ),
-      {
-        onNone: () => "Effect",
-        onSome: (node) => node.text
-      }
-    );
-  }
-);
 
 // src/refactors/wrapWithPipe.ts
 var wrapWithPipe = createRefactor({
@@ -5148,6 +5373,7 @@ var init = (modules) => {
     function runNano(program) {
       return (fa) => pipe(
         fa,
+        provideService(TypeParser, make4(modules.typescript, program.getTypeChecker())),
         provideService(TypeScriptProgram, program),
         provideService(TypeCheckerApi, program.getTypeChecker()),
         provideService(
@@ -5358,15 +5584,17 @@ var init = (modules) => {
     };
     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)
-          );
+      if (languageServicePluginOptions.goto) {
+        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;