@effect/language-service 0.17.0 → 0.18.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.12.5/node_modules/effect/dist/esm/Function.js
+// node_modules/.pnpm/effect@3.16.3/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.12.5/node_modules/effect/dist/esm/Either.js
+// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/Either.js
 var Either_exports = {};
 __export(Either_exports, {
   Do: () => Do,
@@ -139,11 +139,14 @@ __export(Either_exports, {
   merge: () => merge,
   orElse: () => orElse,
   right: () => right2,
+  transposeMapOption: () => transposeMapOption,
+  transposeOption: () => transposeOption,
   try: () => try_,
+  void: () => void_,
   zipWith: () => zipWith
 });
 
-// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Equivalence.js
+// node_modules/.pnpm/effect@3.16.3/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) {
@@ -158,22 +161,22 @@ var array = (item) => make((self, that) => {
   return true;
 });
 
-// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/doNotation.js
-var let_ = (map4) => dual(3, (self, name, f) => map4(self, (a) => Object.assign({}, a, {
+// node_modules/.pnpm/effect@3.16.3/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)
 })));
-var bindTo = (map4) => dual(2, (self, name) => map4(self, (a) => ({
+var bindTo = (map5) => dual(2, (self, name) => map5(self, (a) => ({
   [name]: a
 })));
-var bind = (map4, flatMap4) => dual(3, (self, name, f) => flatMap4(self, (a) => map4(f(a), (b) => Object.assign({}, a, {
+var bind = (map5, flatMap4) => dual(3, (self, name, f) => flatMap4(self, (a) => map5(f(a), (b) => Object.assign({}, a, {
   [name]: b
 }))));
 
-// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/version.js
-var moduleVersion = "3.12.5";
+// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/internal/version.js
+var moduleVersion = "3.16.3";
 var getCurrentVersion = () => moduleVersion;
 
-// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/GlobalValue.js
+// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/GlobalValue.js
 var globalStoreId = `effect/GlobalValue/globalStoreId/${/* @__PURE__ */ getCurrentVersion()}`;
 var globalStore;
 var globalValue = (id, compute) => {
@@ -187,16 +190,19 @@ var globalValue = (id, compute) => {
   return globalStore.get(id);
 };
 
-// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Predicate.js
+// node_modules/.pnpm/effect@3.16.3/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";
 var isFunction2 = isFunction;
 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.12.5/node_modules/effect/dist/esm/internal/errors.js
+// node_modules/.pnpm/effect@3.16.3/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.12.5/node_modules/effect/dist/esm/Utils.js
+// node_modules/.pnpm/effect@3.16.3/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 {
@@ -314,10 +320,25 @@ var structuralRegionState = /* @__PURE__ */ globalValue("effect/Utils/isStructur
   enabled: false,
   tester: void 0
 }));
+var standard = {
+  effect_internal_function: (body) => {
+    return body();
+  }
+};
+var forced = {
+  effect_internal_function: (body) => {
+    try {
+      return body();
+    } finally {
+    }
+  }
+};
+var isNotOptimizedAway = /* @__PURE__ */ standard.effect_internal_function(() => new Error().stack)?.includes("effect_internal_function") === true;
+var internalCall = isNotOptimizedAway ? standard.effect_internal_function : forced.effect_internal_function;
 var genConstructor = function* () {
 }.constructor;
 
-// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Hash.js
+// node_modules/.pnpm/effect@3.16.3/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) => {
@@ -343,6 +364,8 @@ var hash = (self) => {
         return string("null");
       } else if (self instanceof Date) {
         return hash(self.toISOString());
+      } else if (self instanceof URL) {
+        return hash(self.href);
       } else if (isHash(self)) {
         return self[symbol]();
       } else {
@@ -414,7 +437,7 @@ var cached = function() {
   return hash2;
 };
 
-// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Equal.js
+// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/Equal.js
 var symbol2 = /* @__PURE__ */ Symbol.for("effect/Equal");
 function equals() {
   if (arguments.length === 1) {
@@ -440,6 +463,8 @@ function compareBoth(self, that) {
         }
       } else if (self instanceof Date && that instanceof Date) {
         return self.toISOString() === that.toISOString();
+      } else if (self instanceof URL && that instanceof URL) {
+        return self.href === that.href;
       }
     }
     if (structuralRegionState.enabled) {
@@ -465,7 +490,7 @@ function compareBoth(self, that) {
 }
 var isEqual = (u) => hasProperty(u, symbol2);
 
-// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Inspectable.js
+// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/Inspectable.js
 var NodeInspectSymbol = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
 var toJSON = (x) => {
   try {
@@ -474,7 +499,7 @@ var toJSON = (x) => {
     } else if (Array.isArray(x)) {
       return x.map(toJSON);
     }
-  } catch (_) {
+  } catch {
     return {};
   }
   return redact(x);
@@ -517,7 +542,7 @@ var redact = (u) => {
   return u;
 };
 
-// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Pipeable.js
+// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/Pipeable.js
 var pipeArguments = (self, args) => {
   switch (args.length) {
     case 0:
@@ -550,10 +575,10 @@ var pipeArguments = (self, args) => {
   }
 };
 
-// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/opCodes/effect.js
+// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/internal/opCodes/effect.js
 var OP_COMMIT = "Commit";
 
-// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/effectable.js
+// node_modules/.pnpm/effect@3.16.3/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");
@@ -640,7 +665,7 @@ var StructuralCommitPrototype = {
   ...StructuralPrototype
 };
 
-// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/option.js
+// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/internal/option.js
 var TypeId = /* @__PURE__ */ Symbol.for("effect/Option");
 var CommonProto = {
   ...EffectPrototype,
@@ -698,7 +723,7 @@ var some = (value) => {
   return a;
 };
 
-// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/either.js
+// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/internal/either.js
 var TypeId2 = /* @__PURE__ */ Symbol.for("effect/Either");
 var CommonProto2 = {
   ...EffectPrototype,
@@ -763,9 +788,10 @@ 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.12.5/node_modules/effect/dist/esm/Either.js
+// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/Either.js
 var TypeId3 = TypeId2;
 var right2 = right;
+var void_ = /* @__PURE__ */ right2(void 0);
 var left2 = left;
 var fromNullable = /* @__PURE__ */ dual(2, (self, onNullable) => self == null ? left2(onNullable(self)) : right2(self));
 var fromOption2 = fromOption;
@@ -854,47 +880,31 @@ var gen = (...args) => {
   const f = args.length === 1 ? args[0] : args[1].bind(args[0]);
   const iterator = f(adapter2);
   let state = iterator.next();
-  if (state.done) {
-    return right2(state.value);
-  } else {
-    let current = state.value;
-    if (isGenKind(current)) {
-      current = current.value;
-    } else {
-      current = yieldWrapGet(current);
-    }
+  while (!state.done) {
+    const current = isGenKind(state.value) ? state.value.value : yieldWrapGet(state.value);
     if (isLeft2(current)) {
       return current;
     }
-    while (!state.done) {
-      state = iterator.next(current.right);
-      if (!state.done) {
-        current = state.value;
-        if (isGenKind(current)) {
-          current = current.value;
-        } else {
-          current = yieldWrapGet(current);
-        }
-        if (isLeft2(current)) {
-          return current;
-        }
-      }
-    }
-    return right2(state.value);
+    state = iterator.next(current.right);
   }
+  return right2(state.value);
 };
 var Do = /* @__PURE__ */ right2({});
 var bind2 = /* @__PURE__ */ bind(map, flatMap);
 var bindTo2 = /* @__PURE__ */ bindTo(map);
 var let_2 = /* @__PURE__ */ let_(map);
+var transposeOption = (self) => {
+  return isNone(self) ? right2(none) : map(self.value, some);
+};
+var transposeMapOption = /* @__PURE__ */ dual(2, (self, f) => isNone(self) ? right2(none) : map(f(self.value), some));
 
-// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/array.js
+// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/internal/array.js
 var isNonEmptyArray = (self) => self.length > 0;
 
-// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Order.js
+// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/Order.js
 var make2 = (compare) => (self, that) => self === that ? 0 : compare(self, that);
 
-// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Option.js
+// node_modules/.pnpm/effect@3.16.3/node_modules/effect/dist/esm/Option.js
 var none2 = () => none;
 var some2 = some;
 var isNone2 = isNone;
@@ -907,22 +917,23 @@ var getOrElse2 = /* @__PURE__ */ dual(2, (self, onNone) => isNone2(self) ? onNon
 var orElse2 = /* @__PURE__ */ dual(2, (self, that) => isNone2(self) ? that() : self);
 var fromNullable2 = (nullableValue) => nullableValue == null ? none2() : some2(nullableValue);
 var getOrUndefined2 = /* @__PURE__ */ getOrElse2(constUndefined);
+var map2 = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : some2(f(self.value)));
 
-// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Array.js
+// node_modules/.pnpm/effect@3.16.3/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 isArray = Array.isArray;
 var isEmptyArray = (self) => self.length === 0;
 var isEmptyReadonlyArray = isEmptyArray;
 var isNonEmptyReadonlyArray = isNonEmptyArray;
-var isOutOfBound = (i, as) => i < 0 || i >= as.length;
+var isOutOfBounds = (i, as) => i < 0 || i >= as.length;
 var get = /* @__PURE__ */ dual(2, (self, index) => {
   const i = Math.floor(index);
-  return isOutOfBound(i, self) ? none2() : some2(self[i]);
+  return isOutOfBounds(i, self) ? none2() : some2(self[i]);
 });
 var unsafeGet = /* @__PURE__ */ dual(2, (self, index) => {
   const i = Math.floor(index);
-  if (isOutOfBound(i, self)) {
+  if (isOutOfBounds(i, self)) {
     throw new Error(`Index ${i} out of bounds`);
   }
   return self[i];
@@ -936,7 +947,7 @@ var sort = /* @__PURE__ */ dual(2, (self, O) => {
   return out;
 });
 var empty = () => [];
-var map2 = /* @__PURE__ */ dual(2, (self, f) => self.map(f));
+var map3 = /* @__PURE__ */ dual(2, (self, f) => self.map(f));
 var flatMap2 = /* @__PURE__ */ dual(2, (self, f) => {
   if (isEmptyReadonlyArray(self)) {
     return [];
@@ -1052,7 +1063,7 @@ var flatMap3 = dual(2, (fa, f) => make3((ctx) => {
   if (result._tag !== "Right") return result;
   return f(result.value).run(ctx);
 }));
-var map3 = dual(2, (fa, f) => make3((ctx) => {
+var map4 = dual(2, (fa, f) => make3((ctx) => {
   const result = fa.run(ctx);
   if (result._tag !== "Right") return result;
   return makeInternalSuccess(f(result.value));
@@ -1413,7 +1424,10 @@ var parseDataForExtendsClassCompletion = fn(
   "AST.parseDataForExtendsClassCompletion"
 )(function* (sourceFile, position) {
   const ts = yield* service(TypeScriptApi);
-  const { accessedObject, outerNode, replacementSpan } = yield* parseAccessedExpressionForCompletion(sourceFile, position);
+  const { accessedObject, outerNode, replacementSpan } = yield* parseAccessedExpressionForCompletion(
+    sourceFile,
+    position
+  );
   if (!ts.isIdentifier(accessedObject)) return yield* fail(new NodeNotFoundError());
   let classDeclaration = outerNode.parent;
   while (ts.isExpressionWithTypeArguments(classDeclaration) || ts.isHeritageClause(classDeclaration)) {
@@ -1481,31 +1495,22 @@ function createRefactor(definition) {
 function createDiagnostic(definition) {
   return definition;
 }
-function parsePluginOptions(config) {
-  return {
-    diagnostics: config && "diagnostics" in config && typeof config.diagnostics === "boolean" ? config.diagnostics : true,
-    quickinfo: config && "quickinfo" in config && typeof config.quickinfo === "boolean" ? config.quickinfo : true,
-    completions: config && "completions" in config && typeof config.completions === "boolean" ? config.completions : true,
-    multipleEffectCheck: config && "multipleEffectCheck" in config && typeof config.multipleEffectCheck === "boolean" ? config.multipleEffectCheck : true
-  };
-}
 function createCompletion(definition) {
   return definition;
 }
-var PluginOptions = Tag("PluginOptions");
 var getSemanticDiagnosticsWithCodeFixes = fn(
   "LSP.getSemanticDiagnosticsWithCodeFixes"
 )(function* (rules, sourceFile) {
-  const effectDiagnostics = [];
-  const effectCodeFixes = [];
+  let effectDiagnostics = [];
+  let effectCodeFixes = [];
   const executor = yield* createDiagnosticExecutor(sourceFile);
   for (const rule of rules) {
     const result = yield* option(executor.execute(rule));
     if (isSome2(result)) {
-      effectDiagnostics.push(
-        ...pipe(
+      effectDiagnostics = effectDiagnostics.concat(
+        pipe(
           result.value,
-          map2((_) => ({
+          map3((_) => ({
             file: sourceFile,
             start: _.node.getStart(sourceFile),
             length: _.node.getEnd() - _.node.getStart(sourceFile),
@@ -1516,11 +1521,11 @@ var getSemanticDiagnosticsWithCodeFixes = fn(
           }))
         )
       );
-      effectCodeFixes.push(
-        ...pipe(
+      effectCodeFixes = effectCodeFixes.concat(
+        pipe(
           result.value,
-          map2(
-            (_) => map2(
+          map3(
+            (_) => map3(
               _.fixes,
               (fix) => ({
                 ...fix,
@@ -1540,6 +1545,9 @@ var getSemanticDiagnosticsWithCodeFixes = fn(
     codeFixes: effectCodeFixes
   };
 });
+function refactorNameToFullyQualifiedName(name) {
+  return `@effect/language-service/refactors/${name}`;
+}
 var getApplicableRefactors = fn("LSP.getApplicableRefactors")(function* (refactors2, sourceFile, positionOrRange) {
   const textRange = typeof positionOrRange === "number" ? { pos: positionOrRange, end: positionOrRange } : positionOrRange;
   const effectRefactors = [];
@@ -1547,10 +1555,10 @@ var getApplicableRefactors = fn("LSP.getApplicableRefactors")(function* (refacto
     const result = yield* option(refactor.apply(sourceFile, textRange));
     if (isSome2(result)) {
       effectRefactors.push({
-        name: refactor.name,
+        name: refactorNameToFullyQualifiedName(refactor.name),
         description: refactor.description,
         actions: [{
-          name: refactor.name,
+          name: refactorNameToFullyQualifiedName(refactor.name),
           description: result.value.description,
           kind: result.value.kind
         }]
@@ -1560,7 +1568,7 @@ var getApplicableRefactors = fn("LSP.getApplicableRefactors")(function* (refacto
   return effectRefactors;
 });
 var getEditsForRefactor = fn("LSP.getEditsForRefactor")(function* (refactors2, sourceFile, positionOrRange, refactorName) {
-  const refactor = refactors2.find((refactor2) => refactor2.name === refactorName);
+  const refactor = refactors2.find((refactor2) => refactorNameToFullyQualifiedName(refactor2.name) === refactorName);
   if (!refactor) {
     return yield* fail(new RefactorNotApplicableError());
   }
@@ -1568,11 +1576,11 @@ var getEditsForRefactor = fn("LSP.getEditsForRefactor")(function* (refactors2, s
   return yield* refactor.apply(sourceFile, textRange);
 });
 var getCompletionsAtPosition = fn("LSP.getCompletionsAtPosition")(function* (completions2, sourceFile, position, options, formatCodeSettings) {
-  const effectCompletions = [];
+  let effectCompletions = [];
   for (const completion of completions2) {
     const result = yield* completion.apply(sourceFile, position, options, formatCodeSettings);
-    effectCompletions.push(
-      ...result.map((_) => ({ sortText: "11", ..._ }))
+    effectCompletions = effectCompletions.concat(
+      result.map((_) => ({ sortText: "11", ..._ }))
     );
   }
   return effectCompletions;
@@ -1580,27 +1588,74 @@ var getCompletionsAtPosition = fn("LSP.getCompletionsAtPosition")(function* (com
 var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
   function* (sourceFile) {
     const ts = yield* service(TypeScriptApi);
-    const ruleOverrides = {};
+    function findNodeWithLeadingCommentAtPosition(position) {
+      const sourceText = sourceFile.text;
+      let result;
+      function find(node) {
+        const leading = ts.getLeadingCommentRanges(sourceText, node.getFullStart());
+        if (leading) {
+          for (const r of leading) {
+            if (r.pos <= position && position < r.end) {
+              result = node;
+              return;
+            }
+          }
+        }
+        if (node.getFullStart() <= position && position < node.getEnd()) {
+          node.forEachChild(find);
+        }
+      }
+      find(sourceFile);
+      return result;
+    }
+    function findParentStatementForDisableNextLine(node) {
+      let result;
+      function find(node2) {
+        if (ts.isStatement(node2)) {
+          result = node2;
+          return;
+        }
+        if (result) return;
+        if (node2.parent) find(node2.parent);
+      }
+      find(node);
+      return result || node;
+    }
+    const lineOverrides = {};
+    const sectionOverrides = {};
     const skippedRules = [];
-    const regex = /@effect-diagnostics((?:\s[a-zA-Z0-9/]+:(?:off|warning|error|message|suggestion|skip-file))+)?/gm;
+    const regex = /@effect-diagnostics(-next-line)?((?:\s[a-zA-Z0-9/]+:(?:off|warning|error|message|suggestion|skip-file))+)?/gm;
     let match3;
     while ((match3 = regex.exec(sourceFile.text)) !== null) {
-      const rulesCaptureGroup = match3[1];
+      const nextLineCaptureGroup = match3[1];
+      const rulesCaptureGroup = match3[2];
       if (rulesCaptureGroup) {
         const trimmedRuleString = rulesCaptureGroup.trim();
         if (trimmedRuleString) {
           const individualRules = trimmedRuleString.split(/\s+/);
           for (const rulePair of individualRules) {
-            const [ruleName, ruleLevel] = rulePair.toLowerCase().split(":");
+            const [rawRuleName, ruleLevel] = rulePair.toLowerCase().split(":");
+            const ruleName = rawRuleName.startsWith("effect/") ? rawRuleName.substring("effect/".length) : rawRuleName;
             if (ruleName && ruleLevel) {
               if (ruleLevel === "skip-file") skippedRules.push(ruleName);
-              ruleOverrides[ruleName] = ruleOverrides[ruleName] || [];
-              const newLength = ruleOverrides[ruleName].push({
-                start: match3.index,
-                end: Number.MAX_SAFE_INTEGER,
-                level: ruleLevel
-              });
-              if (newLength > 1) ruleOverrides[ruleName][newLength - 2].end = match3.index;
+              const isOverrideNextLine = nextLineCaptureGroup && nextLineCaptureGroup.trim().toLowerCase() === "-next-line";
+              if (isOverrideNextLine) {
+                const node = findNodeWithLeadingCommentAtPosition(match3.index);
+                if (node) {
+                  lineOverrides[ruleName] = lineOverrides[ruleName] || [];
+                  lineOverrides[ruleName].unshift({
+                    pos: node.getFullStart(),
+                    end: node.end,
+                    level: ruleLevel
+                  });
+                }
+              } else {
+                sectionOverrides[ruleName] = sectionOverrides[ruleName] || [];
+                sectionOverrides[ruleName].unshift({
+                  pos: match3.index,
+                  level: ruleLevel
+                });
+              }
             }
           }
         }
@@ -1616,22 +1671,46 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
       const ruleNameLowered = rule.name.toLowerCase();
       if (skippedRules.indexOf(ruleNameLowered) > -1) return [];
       let modifiedDiagnostics = yield* rule.apply(sourceFile);
-      for (const override of ruleOverrides[ruleNameLowered] || []) {
-        if (override.level === "off") {
-          modifiedDiagnostics = modifiedDiagnostics.filter(
-            (_) => !(_.node.getStart(sourceFile) >= override.start && _.node.getEnd() <= override.end)
+      for (const emitted of modifiedDiagnostics.slice(0)) {
+        let newLevel = void 0;
+        if (!(ruleNameLowered in sectionOverrides || ruleNameLowered in lineOverrides)) continue;
+        const lineOverride = (lineOverrides[ruleNameLowered] || []).find(
+          (_) => _.pos < emitted.node.getStart(sourceFile) && _.end >= emitted.node.getEnd()
+        );
+        if (lineOverride) {
+          newLevel = lineOverride.level;
+        } else {
+          const sectionOverride = (sectionOverrides[ruleNameLowered] || []).find(
+            (_) => _.pos < emitted.node.getStart(sourceFile)
           );
+          if (sectionOverride) newLevel = sectionOverride.level;
+        }
+        if (newLevel === "off") {
+          modifiedDiagnostics = modifiedDiagnostics.filter((_) => _ !== emitted);
         } else {
-          for (const message of modifiedDiagnostics.filter(
-            (_) => _.node.getStart(sourceFile) >= override.start && _.node.getEnd() <= override.end
-          )) {
-            message.category = override.level in levelToDiagnosticCategory ? levelToDiagnosticCategory[override.level] : message.category;
-          }
+          emitted.category = newLevel && newLevel in levelToDiagnosticCategory ? levelToDiagnosticCategory[newLevel] : emitted.category;
         }
       }
+      const fixByDisableNextLine = (_) => ({
+        fixName: rule.name + "_skipNextLine",
+        description: "Disable " + rule.name + " for this line",
+        apply: flatMap3(
+          service(ChangeTracker),
+          (changeTracker) => sync(() => {
+            const disableAtNode = findParentStatementForDisableNextLine(_.node);
+            const { line } = ts.getLineAndCharacterOfPosition(sourceFile, disableAtNode.getStart());
+            changeTracker.insertCommentBeforeLine(
+              sourceFile,
+              line,
+              disableAtNode.getStart(),
+              ` @effect-diagnostics-next-line ${rule.name}:off`
+            );
+          })
+        )
+      });
       const fixByDisableEntireFile = {
         fixName: rule.name + "_skipFile",
-        description: "Disable " + rule.name + " for this file",
+        description: "Disable " + rule.name + " for this entire file",
         apply: flatMap3(
           service(ChangeTracker),
           (changeTracker) => sync(
@@ -1646,7 +1725,7 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
       };
       const rulesWithDisableFix = modifiedDiagnostics.map((diagnostic) => ({
         ...diagnostic,
-        fixes: diagnostic.fixes.concat([fixByDisableEntireFile])
+        fixes: diagnostic.fixes.concat([fixByDisableNextLine(diagnostic), fixByDisableEntireFile])
       }));
       return rulesWithDisableFix;
     });
@@ -1656,7 +1735,7 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
 
 // src/completions/contextSelfInClasses.ts
 var contextSelfInClasses = createCompletion({
-  name: "effect/contextSelfInClasses",
+  name: "contextSelfInClasses",
   apply: fn("contextSelfInClasses")(function* (sourceFile, position) {
     const ts = yield* service(TypeScriptApi);
     const maybeInfos = yield* option(
@@ -1689,7 +1768,7 @@ var contextSelfInClasses = createCompletion({
 
 // src/completions/effectDataClasses.ts
 var effectDataClasses = createCompletion({
-  name: "effect/effectDataClasses",
+  name: "effectDataClasses",
   apply: fn("effectDataClasses")(function* (sourceFile, position) {
     const ts = yield* service(TypeScriptApi);
     const maybeInfos = yield* option(
@@ -1728,7 +1807,7 @@ var effectDataClasses = createCompletion({
 
 // src/completions/effectSchemaSelfInClasses.ts
 var effectSchemaSelfInClasses = createCompletion({
-  name: "effect/effectSchemaSelfInClasses",
+  name: "effectSchemaSelfInClasses",
   apply: fn("effectSchemaSelfInClasses")(function* (sourceFile, position) {
     const ts = yield* service(TypeScriptApi);
     const maybeInfos = yield* option(
@@ -1779,7 +1858,7 @@ var effectSchemaSelfInClasses = createCompletion({
 
 // src/completions/effectSelfInClasses.ts
 var effectSelfInClasses = createCompletion({
-  name: "effect/effectSelfInClasses",
+  name: "effectSelfInClasses",
   apply: fn("effectSelfInClasses")(function* (sourceFile, position) {
     const ts = yield* service(TypeScriptApi);
     const maybeInfos = yield* option(
@@ -1834,12 +1913,12 @@ var getMissingTypeEntriesInTargetType = fn(
   function* (realType, expectedType) {
     const typeChecker = yield* service(TypeCheckerApi);
     const result = [];
-    const toTest = [realType];
+    let toTest = [realType];
     while (toTest.length > 0) {
       const type = toTest.pop();
       if (!type) return result;
       if (type.isUnion()) {
-        toTest.push(...type.types);
+        toTest = toTest.concat(type.types);
       } else {
         const assignable = typeChecker.isTypeAssignableTo(type, expectedType);
         if (!assignable) {
@@ -2016,45 +2095,6 @@ var expectedAndRealType = fn("TypeCheckerApi.expectedAndRealType")(function* (so
   return result;
 });
 
-// src/completions/genFunctionStar.ts
-var genFunctionStar = createCompletion({
-  name: "effect/genFunctionStar",
-  apply: fn("genFunctionStar")(function* (sourceFile, position) {
-    const ts = yield* service(TypeScriptApi);
-    const typeChecker = yield* service(TypeCheckerApi);
-    const maybeInfos = yield* option(
-      parseAccessedExpressionForCompletion(sourceFile, position)
-    );
-    if (isNone2(maybeInfos)) return [];
-    const { accessedObject } = maybeInfos.value;
-    const type = typeChecker.getTypeAtLocation(accessedObject);
-    const genMemberSymbol = type.getProperty("gen");
-    if (!genMemberSymbol) return [];
-    const genType = typeChecker.getTypeOfSymbolAtLocation(genMemberSymbol, accessedObject);
-    if (genType.getCallSignatures().length === 0) return [];
-    const span = ts.createTextSpan(
-      accessedObject.end + 1,
-      Math.max(0, position - accessedObject.end - 1)
-    );
-    return [{
-      name: `gen(function*(){})`,
-      kind: ts.ScriptElementKind.constElement,
-      insertText: `gen(function*(){${"${0}"}})`,
-      replacementSpan: span,
-      isSnippet: true
-    }];
-  })
-});
-
-// src/completions.ts
-var completions = [
-  effectSchemaSelfInClasses,
-  effectSelfInClasses,
-  contextSelfInClasses,
-  genFunctionStar,
-  effectDataClasses
-];
-
 // src/utils/TypeParser.ts
 var TypeParserIssue = class {
   constructor(type, node, message) {
@@ -2159,9 +2199,10 @@ var fiberType = fn("TypeParser.fiberType")(function* (type, atLocation) {
 var effectSubtype = fn("TypeParser.effectSubtype")(function* (type, atLocation) {
   const typeChecker = yield* service(TypeCheckerApi);
   const tagSymbol = typeChecker.getPropertyOfType(type, "_tag");
-  if (!tagSymbol) {
+  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' property",
+      "Type is not a subtype of effect because it does not have '_tag' or 'get' property",
       type,
       atLocation
     );
@@ -2354,9 +2395,179 @@ var effectSchemaType = fn("TypeParser.effectSchemaType")(function* (type, atLoca
   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({
+  name: "genFunctionStar",
+  apply: fn("genFunctionStar")(function* (sourceFile, position) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const maybeInfos = yield* option(
+      parseAccessedExpressionForCompletion(sourceFile, position)
+    );
+    if (isNone2(maybeInfos)) return [];
+    const { accessedObject } = maybeInfos.value;
+    const type = typeChecker.getTypeAtLocation(accessedObject);
+    const genMemberSymbol = type.getProperty("gen");
+    if (!genMemberSymbol) return [];
+    const genType = typeChecker.getTypeOfSymbolAtLocation(genMemberSymbol, accessedObject);
+    if (genType.getCallSignatures().length === 0) return [];
+    const span = ts.createTextSpan(
+      accessedObject.end + 1,
+      Math.max(0, position - accessedObject.end - 1)
+    );
+    return [{
+      name: `gen(function*(){})`,
+      kind: ts.ScriptElementKind.constElement,
+      insertText: `gen(function*(){${"${0}"}})`,
+      replacementSpan: span,
+      isSnippet: true
+    }];
+  })
+});
+
+// src/completions.ts
+var completions = [
+  effectSchemaSelfInClasses,
+  effectSelfInClasses,
+  contextSelfInClasses,
+  genFunctionStar,
+  fnFunctionStar,
+  effectDataClasses
+];
+
+// src/core/LanguageServicePluginOptions.ts
+var LanguageServicePluginOptions = Tag("PluginOptions");
+function parse(config) {
+  return {
+    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,
+    allowedDuplicatedPackages: isObject(config) && hasProperty(config, "allowedDuplicatedPackages") && isArray(config.allowedDuplicatedPackages) && config.allowedDuplicatedPackages.every(isString) ? config.allowedDuplicatedPackages.map((_) => _.toLowerCase()) : []
+  };
+}
+
+// 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,
+  apply: fn("duplicatePackage.apply")(function* (sourceFile) {
+    const ts = yield* service(TypeScriptApi);
+    const program = yield* service(TypeScriptProgram);
+    const options = yield* service(LanguageServicePluginOptions);
+    const effectDiagnostics = [];
+    if (sourceFile.statements.length < 1) return [];
+    let resolvedPackages = checkedPackagesCache.get(sourceFile.fileName) || {};
+    const newResolvedModuleSize = hasProperty(program, "resolvedModules") && hasProperty(program.resolvedModules, "size") && isNumber(program.resolvedModules.size) ? program.resolvedModules.size : 0;
+    const oldResolvedSize = programResolvedCacheSize.get(sourceFile.fileName) || -1;
+    if (newResolvedModuleSize !== oldResolvedSize) {
+      const seenPackages = /* @__PURE__ */ new Set();
+      resolvedPackages = {};
+      program.getSourceFiles().map((_) => {
+        const packageInfo = parsePackageContentNameAndVersion(_);
+        if (!packageInfo) return;
+        const packageNameAndVersion = packageInfo.name + "@" + packageInfo.version;
+        if (seenPackages.has(packageNameAndVersion)) return;
+        seenPackages.add(packageNameAndVersion);
+        if (!(packageInfo.name === "effect" || packageInfo.hasEffectInPeerDependencies)) return;
+        if (options.allowedDuplicatedPackages.indexOf(packageInfo.name) > -1) return;
+        resolvedPackages[packageInfo.name] = resolvedPackages[packageInfo.name] || {};
+        resolvedPackages[packageInfo.name][packageInfo.version] = packageInfo.contents;
+      });
+      checkedPackagesCache.set(sourceFile.fileName, resolvedPackages);
+      programResolvedCacheSize.set(sourceFile.fileName, newResolvedModuleSize);
+    }
+    for (const packageName of Object.keys(resolvedPackages)) {
+      if (Object.keys(resolvedPackages[packageName]).length > 1) {
+        const versions = Object.keys(resolvedPackages[packageName]);
+        effectDiagnostics.push({
+          node: sourceFile.statements[0],
+          category: ts.DiagnosticCategory.Warning,
+          messageText: `Package ${packageName} is referenced multiple times with different versions (${versions.join(", ")}) and may cause unexpected type errors.
+Cleanup your dependencies and your package lockfile to avoid multiple instances of this package and reload the project.
+If this is intended set the LSP config "allowedDuplicatedPackages" to ${JSON.stringify(options.allowedDuplicatedPackages.concat([packageName]))}.`,
+          fixes: []
+        });
+      }
+    }
+    return effectDiagnostics;
+  })
+});
+
 // src/diagnostics/floatingEffect.ts
 var floatingEffect = createDiagnostic({
-  name: "effect/floatingEffect",
+  name: "floatingEffect",
   code: 3,
   apply: fn("floatingEffect.apply")(function* (sourceFile) {
     const ts = yield* service(TypeScriptApi);
@@ -2365,7 +2576,7 @@ var floatingEffect = createDiagnostic({
       if (!ts.isExpressionStatement(node)) return false;
       if (!(ts.isBlock(node.parent) || ts.isSourceFile(node.parent))) return false;
       const expression = node.expression;
-      if (ts.isBinaryExpression(expression) && expression.operatorToken && expression.operatorToken.kind === ts.SyntaxKind.EqualsToken) return false;
+      if (ts.isBinaryExpression(expression) && expression.operatorToken && (expression.operatorToken.kind === ts.SyntaxKind.EqualsToken || expression.operatorToken.kind === ts.SyntaxKind.QuestionQuestionEqualsToken || expression.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandEqualsToken || expression.operatorToken.kind === ts.SyntaxKind.BarBarEqualsToken)) return false;
       return true;
     }
     const effectDiagnostics = [];
@@ -2403,7 +2614,7 @@ var floatingEffect = createDiagnostic({
 
 // src/diagnostics/missingEffectContext.ts
 var missingEffectContext = createDiagnostic({
-  name: "effect/missingEffectContext",
+  name: "missingEffectContext",
   code: 1,
   apply: fn("missingEffectContext.apply")(function* (sourceFile) {
     const ts = yield* service(TypeScriptApi);
@@ -2455,7 +2666,7 @@ var missingEffectContext = createDiagnostic({
 
 // src/diagnostics/missingEffectError.ts
 var missingEffectError = createDiagnostic({
-  name: "effect/missingEffectError",
+  name: "missingEffectError",
   code: 1,
   apply: fn("missingEffectError.apply")(function* (sourceFile) {
     const ts = yield* service(TypeScriptApi);
@@ -2507,7 +2718,7 @@ var missingEffectError = createDiagnostic({
 
 // src/diagnostics/missingStarInYieldEffectGen.ts
 var missingStarInYieldEffectGen = createDiagnostic({
-  name: "effect/missingStarInYieldEffectGen",
+  name: "missingStarInYieldEffectGen",
   code: 4,
   apply: fn("missingStarInYieldEffectGen.apply")(function* (sourceFile) {
     const ts = yield* service(TypeScriptApi);
@@ -2526,7 +2737,7 @@ var missingStarInYieldEffectGen = createDiagnostic({
       if (ts.isYieldExpression(node) && node.expression && node.asteriskToken === void 0) {
         const functionStarNode = ts.findAncestor(
           node,
-          (_) => (ts.isFunctionExpression(_) || ts.isMethodDeclaration(_)) && _.asteriskToken !== void 0
+          (_) => ts.isFunctionExpression(_) || ts.isFunctionDeclaration(_) || ts.isMethodDeclaration(_)
         );
         if (functionStarNode && functionStarNode.parent) {
           const effectGenNode = functionStarNode.parent;
@@ -2580,51 +2791,9 @@ var missingStarInYieldEffectGen = createDiagnostic({
   })
 });
 
-// src/diagnostics/multipleEffectVersions.ts
-var effectVersionsCache = /* @__PURE__ */ new Map();
-var programResolvedCacheSize = /* @__PURE__ */ new Map();
-var multipleEffectVersions = createDiagnostic({
-  name: "effect/multipleEffectVersions",
-  code: 6,
-  apply: fn("multipleEffectVersions.apply")(function* (sourceFile) {
-    const ts = yield* service(TypeScriptApi);
-    const program = yield* service(TypeScriptProgram);
-    const options = yield* service(PluginOptions);
-    const effectDiagnostics = [];
-    if (!options.multipleEffectCheck) return [];
-    if (sourceFile.statements.length < 1) return [];
-    const effectVersions = effectVersionsCache.get(sourceFile.fileName) || {};
-    const newResolvedModuleSize = "resolvedModules" in program && typeof program.resolvedModules === "object" && "size" in program.resolvedModules ? program.resolvedModules.size : 0;
-    const oldResolvedSize = programResolvedCacheSize.get(sourceFile.fileName) || 0;
-    if (newResolvedModuleSize !== oldResolvedSize) {
-      if ("forEachResolvedModule" in program && typeof program.forEachResolvedModule === "function") {
-        program.forEachResolvedModule((_) => {
-          if (_ && _.resolvedModule && _.resolvedModule.packageId && _.resolvedModule.packageId.name === "effect" && !(_.resolvedModule.packageId.version in effectVersions)) {
-            effectVersions[_.resolvedModule.packageId.version] = {
-              resolvedFileName: _.resolvedModule.resolvedFileName
-            };
-          }
-        });
-      }
-      effectVersionsCache.set(sourceFile.fileName, effectVersions);
-      programResolvedCacheSize.set(sourceFile.fileName, newResolvedModuleSize);
-    }
-    if (Object.keys(effectVersions).length > 1) {
-      const versions = Object.keys(effectVersions).map((version) => `version ${version}`);
-      effectDiagnostics.push({
-        node: sourceFile.statements[0],
-        category: ts.DiagnosticCategory.Warning,
-        messageText: `Seems like in this project there are multiple effect versions loaded (${versions.join(", ")}). This may cause unexpected type errors and runtime behaviours. If you are ok with that, you can disable this warning by adding "multipleEffectCheck": false to the Effect LSP options inside your tsconfig.json`,
-        fixes: []
-      });
-    }
-    return effectDiagnostics;
-  })
-});
-
 // src/diagnostics/unnecessaryEffectGen.ts
 var unnecessaryEffectGen = createDiagnostic({
-  name: "effect/unnecessaryEffectGen",
+  name: "unnecessaryEffectGen",
   code: 5,
   apply: fn("unnecessaryEffectGen.apply")(function* (sourceFile) {
     const ts = yield* service(TypeScriptApi);
@@ -2671,7 +2840,7 @@ var unnecessaryEffectGen = createDiagnostic({
 
 // src/diagnostics.ts
 var diagnostics = [
-  multipleEffectVersions,
+  duplicatePackage,
   missingEffectContext,
   missingEffectError,
   floatingEffect,
@@ -2680,9 +2849,7 @@ var diagnostics = [
 ];
 
 // src/quickinfo.ts
-var SymbolDisplayPartEq = make(
-  (fa, fb) => fa.kind === fb.kind && fa.text === fb.text
-);
+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)
 );
@@ -2757,7 +2924,7 @@ function prependEffectTypeArguments(sourceFile, position, quickInfo) {
 
 // src/refactors/asyncAwaitToGen.ts
 var asyncAwaitToGen = createRefactor({
-  name: "effect/asyncAwaitToGen",
+  name: "asyncAwaitToGen",
   description: "Convert to Effect.gen",
   apply: fn("asyncAwaitToGen.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
@@ -2768,9 +2935,7 @@ var asyncAwaitToGen = createRefactor({
         (node2) => ts.isFunctionDeclaration(node2) || ts.isArrowFunction(node2) || ts.isFunctionExpression(node2)
       ),
       filter((node2) => !!node2.body),
-      filter(
-        (node2) => !!(ts.getCombinedModifierFlags(node2) & ts.ModifierFlags.Async)
-      ),
+      filter((node2) => !!(ts.getCombinedModifierFlags(node2) & ts.ModifierFlags.Async)),
       head
     );
     if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
@@ -2788,7 +2953,7 @@ var asyncAwaitToGen = createRefactor({
                 (node2) => pipe(
                   importedEffectModule(node2),
                   option,
-                  map3(isSome2)
+                  map4(isSome2)
                 )
               )
             ),
@@ -2829,7 +2994,7 @@ var asyncAwaitToGen = createRefactor({
 
 // src/refactors/asyncAwaitToGenTryPromise.ts
 var asyncAwaitToGenTryPromise = createRefactor({
-  name: "effect/asyncAwaitToGenTryPromise",
+  name: "asyncAwaitToGenTryPromise",
   description: "Convert to Effect.gen with failures",
   apply: fn("asyncAwaitToGenTryPromise.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
@@ -2840,9 +3005,7 @@ var asyncAwaitToGenTryPromise = createRefactor({
         (node2) => ts.isFunctionDeclaration(node2) || ts.isArrowFunction(node2) || ts.isFunctionExpression(node2)
       ),
       filter((node2) => !!node2.body),
-      filter(
-        (node2) => !!(ts.getCombinedModifierFlags(node2) & ts.ModifierFlags.Async)
-      ),
+      filter((node2) => !!(ts.getCombinedModifierFlags(node2) & ts.ModifierFlags.Async)),
       head
     );
     if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
@@ -2860,7 +3023,7 @@ var asyncAwaitToGenTryPromise = createRefactor({
                 (node2) => pipe(
                   importedEffectModule(node2),
                   option,
-                  map3(isSome2)
+                  map4(isSome2)
                 )
               )
             ),
@@ -2931,7 +3094,7 @@ var asyncAwaitToGenTryPromise = createRefactor({
 
 // src/refactors/effectGenToFn.ts
 var effectGenToFn = createRefactor({
-  name: "effect/effectGenToFn",
+  name: "effectGenToFn",
   description: "Convert to Effect.fn",
   apply: fn("effectGenToFn.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
@@ -2971,7 +3134,7 @@ var effectGenToFn = createRefactor({
     });
     const maybeNode = yield* pipe(
       yield* getAncestorNodesInRange(sourceFile, textRange),
-      map2(parseEffectGenNode),
+      map3(parseEffectGenNode),
       firstSuccessOf,
       option
     );
@@ -3021,7 +3184,7 @@ var effectGenToFn = createRefactor({
 
 // src/refactors/functionToArrow.ts
 var functionToArrow = createRefactor({
-  name: "effect/functionToArrow",
+  name: "functionToArrow",
   description: "Convert to arrow",
   apply: fn("functionToArrow.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
@@ -3106,7 +3269,7 @@ var _findSchemaVariableDeclaration = fn(
     );
     return yield* pipe(
       yield* getAncestorNodesInRange(sourceFile, textRange),
-      map2(findSchema),
+      map3(findSchema),
       firstSuccessOf,
       option
     );
@@ -3189,7 +3352,7 @@ var _createOpaqueTypes = fn("_createOpaqueTypes")(function* (effectSchemaName, i
   return { contextType, encodedType, opaqueType };
 });
 var makeSchemaOpaque = createRefactor({
-  name: "effect/makeSchemaOpaque",
+  name: "makeSchemaOpaque",
   description: "Make Schema opaque",
   apply: fn("makeSchemaOpaque.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
@@ -3267,7 +3430,7 @@ var makeSchemaOpaque = createRefactor({
 
 // src/refactors/makeSchemaOpaqueWithNs.ts
 var makeSchemaOpaqueWithNs = createRefactor({
-  name: "effect/makeSchemaOpaqueWithNs",
+  name: "makeSchemaOpaqueWithNs",
   description: "Make Schema opaque with namespace",
   apply: fn("makeSchemaOpaqueWithNs.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
@@ -3361,7 +3524,7 @@ var makeSchemaOpaqueWithNs = createRefactor({
 
 // src/refactors/pipeableToDatafirst.ts
 var pipeableToDatafirst = createRefactor({
-  name: "effect/pipeableToDatafirst",
+  name: "pipeableToDatafirst",
   description: "Rewrite to datafirst",
   apply: fn("pipeableToDatafirst.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
@@ -3399,7 +3562,7 @@ var pipeableToDatafirst = createRefactor({
       filter(
         (node2) => node2.arguments.length > 0
       ),
-      map2((node2) => {
+      map3((node2) => {
         let newNode2 = node2.arguments[0];
         let didSomething = false;
         for (let i = 1; i < node2.arguments.length; i++) {
@@ -3426,7 +3589,7 @@ var pipeableToDatafirst = createRefactor({
         return didSomething ? some2([node2, newNode2]) : none2();
       }),
       filter(isSome2),
-      map2((_) => _.value),
+      map3((_) => _.value),
       head
     );
     if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
@@ -3444,7 +3607,7 @@ var pipeableToDatafirst = createRefactor({
 
 // src/refactors/removeUnnecessaryEffectGen.ts
 var removeUnnecessaryEffectGen = createRefactor({
-  name: "effect/removeUnnecessaryEffectGen",
+  name: "removeUnnecessaryEffectGen",
   description: "Remove unnecessary Effect.gen",
   apply: fn("removeUnnecessaryEffectGen.apply")(function* (sourceFile, textRange) {
     for (const nodeToReplace of yield* getAncestorNodesInRange(sourceFile, textRange)) {
@@ -3470,7 +3633,7 @@ var removeUnnecessaryEffectGen = createRefactor({
 
 // src/refactors/toggleLazyConst.ts
 var toggleLazyConst = createRefactor({
-  name: "effect/toggleLazyConst",
+  name: "toggleLazyConst",
   description: "Toggle lazy const",
   apply: fn("toggleLazyConst.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
@@ -3510,7 +3673,7 @@ var toggleLazyConst = createRefactor({
 
 // src/refactors/toggleReturnTypeAnnotation.ts
 var toggleReturnTypeAnnotation = createRefactor({
-  name: "effect/toggleReturnTypeAnnotation",
+  name: "toggleReturnTypeAnnotation",
   description: "Toggle return type annotation",
   apply: fn("toggleReturnTypeAnnotation.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
@@ -3560,16 +3723,14 @@ var toggleReturnTypeAnnotation = createRefactor({
 
 // src/refactors/toggleTypeAnnotation.ts
 var toggleTypeAnnotation = createRefactor({
-  name: "effect/toggleTypeAnnotation",
+  name: "toggleTypeAnnotation",
   description: "Toggle type annotation",
   apply: fn("toggleTypeAnnotation.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
     const maybeNode = pipe(
       yield* getAncestorNodesInRange(sourceFile, textRange),
-      filter(
-        (node2) => ts.isVariableDeclaration(node2) || ts.isPropertyDeclaration(node2)
-      ),
+      filter((node2) => ts.isVariableDeclaration(node2) || ts.isPropertyDeclaration(node2)),
       filter((node2) => isNodeInRange(textRange)(node2.name)),
       filter((node2) => !!node2.initializer),
       head
@@ -4079,7 +4240,7 @@ var applyAtNode = fn("SchemaGen.applyAtNode")(
 
 // src/refactors/typeToEffectSchema.ts
 var typeToEffectSchema = createRefactor({
-  name: "effect/typeToEffectSchema",
+  name: "typeToEffectSchema",
   description: "Refactor to Schema",
   apply: fn("typeToEffectSchema.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
@@ -4101,7 +4262,7 @@ var typeToEffectSchema = createRefactor({
 
 // src/refactors/typeToEffectSchemaClass.ts
 var typeToEffectSchemaClass = createRefactor({
-  name: "effect/typeToEffectSchemaClass",
+  name: "typeToEffectSchemaClass",
   description: "Refactor to Schema.Class",
   apply: fn("typeToEffectSchemaClass.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
@@ -4123,7 +4284,7 @@ var typeToEffectSchemaClass = createRefactor({
 
 // src/refactors/wrapWithEffectGen.ts
 var wrapWithEffectGen = createRefactor({
-  name: "effect/wrapWithEffectGen",
+  name: "wrapWithEffectGen",
   description: "Wrap with Effect.gen",
   apply: fn("wrapWithEffectGen.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
@@ -4140,7 +4301,7 @@ var wrapWithEffectGen = createRefactor({
     );
     const maybeNode = yield* pipe(
       yield* getAncestorNodesInRange(sourceFile, textRange),
-      map2(findEffectToWrap),
+      map3(findEffectToWrap),
       firstSuccessOf,
       option
     );
@@ -4174,7 +4335,7 @@ var getEffectModuleIdentifierName = fn("getEffectModuleIdentifierName")(
           (node) => pipe(
             importedEffectModule(node),
             option,
-            map3(isSome2)
+            map4(isSome2)
           )
         )
       ),
@@ -4188,7 +4349,7 @@ var getEffectModuleIdentifierName = fn("getEffectModuleIdentifierName")(
 
 // src/refactors/wrapWithPipe.ts
 var wrapWithPipe = createRefactor({
-  name: "effect/wrapWithPipe",
+  name: "wrapWithPipe",
   description: "Wrap with pipe",
   apply: fn("wrapWithPipe.apply")(function* (sourceFile, textRange) {
     if (textRange.end - textRange.pos === 0) {
@@ -4226,10 +4387,12 @@ var refactors = [
 ];
 
 // src/index.ts
+var LSP_INJECTED_URI = "@effect/language-service/injected";
 var init = (modules) => {
   function create(info) {
     const languageService = info.languageService;
-    const pluginOptions = parsePluginOptions(info.config);
+    if (languageService[LSP_INJECTED_URI]) return languageService;
+    const languageServicePluginOptions = parse(info.config);
     const diagnosticsErrorCodes = diagnostics.map((diagnostic) => diagnostic.code);
     try {
       ;
@@ -4240,28 +4403,38 @@ var init = (modules) => {
     } catch (_) {
     }
     const proxy = /* @__PURE__ */ Object.create(null);
+    proxy[LSP_INJECTED_URI] = true;
     for (const k of Object.keys(languageService)) {
       proxy[k] = (...args) => languageService[k].apply(languageService, args);
     }
+    function runNano(program) {
+      return (fa) => pipe(
+        fa,
+        provideService(TypeScriptProgram, program),
+        provideService(TypeCheckerApi, program.getTypeChecker()),
+        provideService(
+          TypeCheckerApiCache,
+          makeTypeCheckerApiCache()
+        ),
+        provideService(TypeScriptApi, modules.typescript),
+        provideService(
+          LanguageServicePluginOptions,
+          languageServicePluginOptions
+        ),
+        run
+      );
+    }
     const effectCodeFixesForFile = /* @__PURE__ */ new Map();
     proxy.getSemanticDiagnostics = (fileName, ...args) => {
       const applicableDiagnostics = languageService.getSemanticDiagnostics(fileName, ...args);
       const program = languageService.getProgram();
-      if (pluginOptions.diagnostics && program) {
+      if (languageServicePluginOptions.diagnostics && program) {
         effectCodeFixesForFile.delete(fileName);
         const sourceFile = program.getSourceFile(fileName);
         if (sourceFile) {
           return pipe(
             getSemanticDiagnosticsWithCodeFixes(diagnostics, sourceFile),
-            provideService(TypeScriptProgram, program),
-            provideService(TypeCheckerApi, program.getTypeChecker()),
-            provideService(
-              TypeCheckerApiCache,
-              makeTypeCheckerApiCache()
-            ),
-            provideService(TypeScriptApi, modules.typescript),
-            provideService(PluginOptions, pluginOptions),
-            run,
+            runNano(program),
             Either_exports.map(({ codeFixes, diagnostics: diagnostics2 }) => {
               effectCodeFixesForFile.set(fileName, codeFixes);
               return diagnostics2.concat(applicableDiagnostics);
@@ -4330,14 +4503,7 @@ var init = (modules) => {
         if (sourceFile) {
           return pipe(
             getApplicableRefactors(refactors, sourceFile, positionOrRange),
-            provideService(TypeCheckerApi, program.getTypeChecker()),
-            provideService(
-              TypeCheckerApiCache,
-              makeTypeCheckerApiCache()
-            ),
-            provideService(TypeScriptApi, modules.typescript),
-            provideService(PluginOptions, pluginOptions),
-            run,
+            runNano(program),
             Either_exports.map((effectRefactors) => applicableRefactors.concat(effectRefactors)),
             Either_exports.getOrElse(() => applicableRefactors)
           );
@@ -4376,14 +4542,7 @@ var init = (modules) => {
               );
               return { edits };
             }),
-            provideService(TypeCheckerApi, program.getTypeChecker()),
-            provideService(
-              TypeCheckerApiCache,
-              makeTypeCheckerApiCache()
-            ),
-            provideService(TypeScriptApi, modules.typescript),
-            provideService(PluginOptions, pluginOptions),
-            run
+            runNano(program)
           );
           if (Either_exports.isRight(result)) return result.right;
         }
@@ -4400,7 +4559,7 @@ var init = (modules) => {
     };
     proxy.getQuickInfoAtPosition = (fileName, position, ...args) => {
       const quickInfo = languageService.getQuickInfoAtPosition(fileName, position, ...args);
-      if (pluginOptions.quickinfo) {
+      if (languageServicePluginOptions.quickinfo) {
         const dedupedTagsQuickInfo = dedupeJsDocTags(quickInfo);
         const program = languageService.getProgram();
         if (program) {
@@ -4412,11 +4571,7 @@ var init = (modules) => {
                 position,
                 dedupedTagsQuickInfo
               ),
-              provideService(TypeScriptProgram, program),
-              provideService(TypeCheckerApi, program.getTypeChecker()),
-              provideService(TypeScriptApi, modules.typescript),
-              provideService(PluginOptions, pluginOptions),
-              run,
+              runNano(program),
               Either_exports.getOrElse(() => dedupedTagsQuickInfo)
             );
           }
@@ -4433,7 +4588,7 @@ var init = (modules) => {
         formattingSettings,
         ...args
       );
-      if (pluginOptions.completions) {
+      if (languageServicePluginOptions.completions) {
         const program = languageService.getProgram();
         if (program) {
           const sourceFile = program.getSourceFile(fileName);
@@ -4446,15 +4601,7 @@ var init = (modules) => {
                 options,
                 formattingSettings
               ),
-              provideService(TypeScriptProgram, program),
-              provideService(TypeCheckerApi, program.getTypeChecker()),
-              provideService(
-                TypeCheckerApiCache,
-                makeTypeCheckerApiCache()
-              ),
-              provideService(TypeScriptApi, modules.typescript),
-              provideService(PluginOptions, pluginOptions),
-              run,
+              runNano(program),
               Either_exports.map(
                 (effectCompletions) => applicableCompletions ? {
                   ...applicableCompletions,