@effect/language-service 0.21.7 → 0.22.0

package/index.js

@@ -1,9 +1,4 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __export = (target, all3) => {
-  for (var name in all3)
-    __defProp(target, name, { get: all3[name], enumerable: true });
-};
 
 // node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Function.js
 var isFunction = (input) => typeof input === "function";
@@ -70,7 +65,6 @@ var dual = function(arity, body) {
 };
 var identity = (a) => a;
 var constant = (value) => () => value;
-var constNull = /* @__PURE__ */ constant(null);
 var constUndefined = /* @__PURE__ */ constant(void 0);
 function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
   switch (arguments.length) {
@@ -102,50 +96,6 @@ function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
   }
 }
 
-// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Either.js
-var Either_exports = {};
-__export(Either_exports, {
-  Do: () => Do,
-  TypeId: () => TypeId3,
-  all: () => all,
-  andThen: () => andThen,
-  ap: () => ap,
-  bind: () => bind2,
-  bindTo: () => bindTo2,
-  filterOrLeft: () => filterOrLeft,
-  flatMap: () => flatMap,
-  flip: () => flip,
-  fromNullable: () => fromNullable,
-  fromOption: () => fromOption2,
-  gen: () => gen,
-  getEquivalence: () => getEquivalence,
-  getLeft: () => getLeft2,
-  getOrElse: () => getOrElse,
-  getOrNull: () => getOrNull,
-  getOrThrow: () => getOrThrow,
-  getOrThrowWith: () => getOrThrowWith,
-  getOrUndefined: () => getOrUndefined,
-  getRight: () => getRight2,
-  isEither: () => isEither2,
-  isLeft: () => isLeft2,
-  isRight: () => isRight2,
-  left: () => left2,
-  let: () => let_2,
-  liftPredicate: () => liftPredicate,
-  map: () => map,
-  mapBoth: () => mapBoth,
-  mapLeft: () => mapLeft,
-  match: () => match,
-  merge: () => merge,
-  orElse: () => orElse,
-  right: () => right2,
-  transposeMapOption: () => transposeMapOption,
-  transposeOption: () => transposeOption,
-  try: () => try_,
-  void: () => void_,
-  zipWith: () => zipWith
-});
-
 // node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Equivalence.js
 var make = (isEquivalent) => (self, that) => self === that || isEquivalent(self, that);
 var array = (item) => make((self, that) => {
@@ -161,17 +111,6 @@ var array = (item) => make((self, that) => {
   return true;
 });
 
-// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/internal/doNotation.js
-var let_ = (map5) => dual(3, (self, name, f) => map5(self, (a) => Object.assign({}, a, {
-  [name]: f(a)
-})));
-var bindTo = (map5) => dual(2, (self, name) => map5(self, (a) => ({
-  [name]: 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.16.5/node_modules/effect/dist/esm/internal/version.js
 var moduleVersion = "3.16.5";
 var getCurrentVersion = () => moduleVersion;
@@ -286,13 +225,6 @@ var SingleShotGen = class _SingleShotGen {
     return new _SingleShotGen(this.self);
   }
 };
-var adapter = () => function() {
-  let x = arguments[0];
-  for (let i = 1; i < arguments.length; i++) {
-    x = arguments[i](x);
-  }
-  return new GenKindImpl(x);
-};
 var MUL_HI = 1481765933 >>> 0;
 var MUL_LO = 1284865837 >>> 0;
 var YieldWrapTypeId = /* @__PURE__ */ Symbol.for("effect/Utils/YieldWrap");
@@ -786,122 +718,14 @@ var right = (right3) => {
   a.right = right3;
   return a;
 };
-var getLeft = (self) => isRight(self) ? none : some(self.left);
-var getRight = (self) => isLeft(self) ? none : some(self.right);
-var fromOption = /* @__PURE__ */ dual(2, (self, onNone) => isNone(self) ? left(onNone()) : right(self.value));
 
 // node_modules/.pnpm/effect@3.16.5/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;
-var try_ = (evaluate) => {
-  if (isFunction2(evaluate)) {
-    try {
-      return right2(evaluate());
-    } catch (e) {
-      return left2(e);
-    }
-  } else {
-    try {
-      return right2(evaluate.try());
-    } catch (e) {
-      return left2(evaluate.catch(e));
-    }
-  }
-};
-var isEither2 = isEither;
 var isLeft2 = isLeft;
 var isRight2 = isRight;
-var getRight2 = getRight;
-var getLeft2 = getLeft;
-var getEquivalence = ({
-  left: left3,
-  right: right3
-}) => make((x, y) => isLeft2(x) ? isLeft2(y) && left3(x.left, y.left) : isRight2(y) && right3(x.right, y.right));
-var mapBoth = /* @__PURE__ */ dual(2, (self, {
-  onLeft,
-  onRight
-}) => isLeft2(self) ? left2(onLeft(self.left)) : right2(onRight(self.right)));
-var mapLeft = /* @__PURE__ */ dual(2, (self, f) => isLeft2(self) ? left2(f(self.left)) : right2(self.right));
 var map = /* @__PURE__ */ dual(2, (self, f) => isRight2(self) ? right2(f(self.right)) : left2(self.left));
-var match = /* @__PURE__ */ dual(2, (self, {
-  onLeft,
-  onRight
-}) => isLeft2(self) ? onLeft(self.left) : onRight(self.right));
-var liftPredicate = /* @__PURE__ */ dual(3, (a, predicate, orLeftWith) => predicate(a) ? right2(a) : left2(orLeftWith(a)));
-var filterOrLeft = /* @__PURE__ */ dual(3, (self, predicate, orLeftWith) => flatMap(self, (r) => predicate(r) ? right2(r) : left2(orLeftWith(r))));
-var merge = /* @__PURE__ */ match({
-  onLeft: identity,
-  onRight: identity
-});
 var getOrElse = /* @__PURE__ */ dual(2, (self, onLeft) => isLeft2(self) ? onLeft(self.left) : self.right);
-var getOrNull = /* @__PURE__ */ getOrElse(constNull);
-var getOrUndefined = /* @__PURE__ */ getOrElse(constUndefined);
-var getOrThrowWith = /* @__PURE__ */ dual(2, (self, onLeft) => {
-  if (isRight2(self)) {
-    return self.right;
-  }
-  throw onLeft(self.left);
-});
-var getOrThrow = /* @__PURE__ */ getOrThrowWith(() => new Error("getOrThrow called on a Left"));
-var orElse = /* @__PURE__ */ dual(2, (self, that) => isLeft2(self) ? that(self.left) : right2(self.right));
-var flatMap = /* @__PURE__ */ dual(2, (self, f) => isLeft2(self) ? left2(self.left) : f(self.right));
-var andThen = /* @__PURE__ */ dual(2, (self, f) => flatMap(self, (a) => {
-  const b = isFunction2(f) ? f(a) : f;
-  return isEither2(b) ? b : right2(b);
-}));
-var zipWith = /* @__PURE__ */ dual(3, (self, that, f) => flatMap(self, (r) => map(that, (r2) => f(r, r2))));
-var ap = /* @__PURE__ */ dual(2, (self, that) => zipWith(self, that, (f, a) => f(a)));
-var all = (input) => {
-  if (Symbol.iterator in input) {
-    const out2 = [];
-    for (const e of input) {
-      if (isLeft2(e)) {
-        return e;
-      }
-      out2.push(e.right);
-    }
-    return right2(out2);
-  }
-  const out = {};
-  for (const key of Object.keys(input)) {
-    const e = input[key];
-    if (isLeft2(e)) {
-      return e;
-    }
-    out[key] = e.right;
-  }
-  return right2(out);
-};
-var flip = (self) => isLeft2(self) ? right2(self.left) : left2(self.right);
-var adapter2 = /* @__PURE__ */ adapter();
-var gen = (...args) => {
-  const f = args.length === 1 ? args[0] : args[1].bind(args[0]);
-  const iterator = f(adapter2);
-  let state = iterator.next();
-  while (!state.done) {
-    const current = isGenKind(state.value) ? state.value.value : yieldWrapGet(state.value);
-    if (isLeft2(current)) {
-      return current;
-    }
-    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.16.5/node_modules/effect/dist/esm/internal/array.js
-var isNonEmptyArray = (self) => self.length > 0;
 
 // node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Order.js
 var make2 = (compare) => (self, that) => self === that ? 0 : compare(self, that);
@@ -911,16 +735,19 @@ var none2 = () => none;
 var some2 = some;
 var isNone2 = isNone;
 var isSome2 = isSome;
-var match2 = /* @__PURE__ */ dual(2, (self, {
+var match = /* @__PURE__ */ dual(2, (self, {
   onNone,
   onSome
 }) => isNone2(self) ? onNone() : onSome(self.value));
 var getOrElse2 = /* @__PURE__ */ dual(2, (self, onNone) => isNone2(self) ? onNone() : self.value);
-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 orElse = /* @__PURE__ */ dual(2, (self, that) => isNone2(self) ? that() : self);
+var fromNullable = (nullableValue) => nullableValue == null ? none2() : some2(nullableValue);
+var getOrUndefined = /* @__PURE__ */ getOrElse2(constUndefined);
 var map2 = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : some2(f(self.value)));
 
+// node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/internal/array.js
+var isNonEmptyArray = (self) => self.length > 0;
+
 // node_modules/.pnpm/effect@3.16.5/node_modules/effect/dist/esm/Array.js
 var fromIterable = (collection) => Array.isArray(collection) ? collection : Array.from(collection);
 var append = /* @__PURE__ */ dual(2, (self, last) => [...self, last]);
@@ -965,7 +792,7 @@ var intersectionWith = (isEquivalent) => {
 var intersection = /* @__PURE__ */ intersectionWith(_equivalence);
 var empty = () => [];
 var map3 = /* @__PURE__ */ dual(2, (self, f) => self.map(f));
-var flatMap2 = /* @__PURE__ */ dual(2, (self, f) => {
+var flatMap = /* @__PURE__ */ dual(2, (self, f) => {
   if (isEmptyReadonlyArray(self)) {
     return [];
   }
@@ -978,7 +805,7 @@ var flatMap2 = /* @__PURE__ */ dual(2, (self, f) => {
   }
   return out;
 });
-var flatten = /* @__PURE__ */ flatMap2(identity);
+var flatten = /* @__PURE__ */ flatMap(identity);
 var filter = /* @__PURE__ */ dual(2, (self, predicate) => {
   const as = fromIterable(self);
   const out = [];
@@ -1076,7 +903,7 @@ var run = (fa) => {
 var succeed = (value) => make3(() => makeInternalSuccess(value));
 var fail = (value) => make3(() => makeInternalFailure(value));
 var sync = (value) => make3(() => makeInternalSuccess(value()));
-var flatMap3 = dual(2, (fa, f) => make3((ctx) => {
+var flatMap2 = dual(2, (fa, f) => make3((ctx) => {
   const result = fa.run(ctx);
   if (result._tag !== "Right") return result;
   return f(result.value).run(ctx);
@@ -1086,12 +913,12 @@ var map4 = dual(2, (fa, f) => make3((ctx) => {
   if (result._tag !== "Right") return result;
   return makeInternalSuccess(f(result.value));
 }));
-var orElse3 = (f) => (fa) => make3((ctx) => {
+var orElse2 = (f) => (fa) => make3((ctx) => {
   const result = fa.run(ctx);
   if (result._tag === "Left") return f(result.value).run(ctx);
   return result;
 });
-var firstSuccessOf = (arr) => arr.slice(1).reduce((arr2, fa) => orElse3(() => fa)(arr2), arr[0]);
+var firstSuccessOf = (arr) => arr.slice(1).reduce((arr2, fa) => orElse2(() => fa)(arr2), arr[0]);
 var service = (tag) => make3(
   (ctx) => tag.key in ctx.value ? ctx.value[tag.key] : makeInternalDefect(`Cannot find service ${tag.key}`)
 );
@@ -1104,7 +931,7 @@ var provideService = (tag, value) => (fa) => make3((ctx) => {
     }
   });
 });
-var gen2 = (...args) => make3((ctx) => {
+var gen = (...args) => make3((ctx) => {
   const iterator = args[0]();
   let state = iterator.next();
   while (!state.done) {
@@ -1142,12 +969,12 @@ var option = (fa) => make3((ctx) => {
   }
 });
 var successUndefined = makeInternalSuccess(void 0);
-var void_2 = make3(() => successUndefined);
+var void_ = make3(() => successUndefined);
 var ignore = (fa) => make3((ctx) => {
   fa.run(ctx);
   return successUndefined;
 });
-var all2 = (...args) => make3((ctx) => {
+var all = (...args) => make3((ctx) => {
   const results = [];
   for (const arg of args) {
     const result = arg.run(ctx);
@@ -1205,6 +1032,20 @@ function parsePackageContentNameAndVersionFromScope(v) {
     packageDirectory: packageJsonScope.packageDirectory
   };
 }
+function makeGetModuleSpecifier(ts) {
+  if (!(hasProperty(ts, "moduleSpecifiers") && hasProperty(ts.moduleSpecifiers, "getModuleSpecifier") && isFunction2(ts.moduleSpecifiers.getModuleSpecifier))) return;
+  const _internal = ts.moduleSpecifiers.getModuleSpecifier;
+  return (compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host, options) => {
+    return _internal(
+      compilerOptions,
+      importingSourceFile,
+      importingSourceFileName,
+      toFileName,
+      host,
+      options
+    );
+  };
+}
 
 // src/core/AST.ts
 function collectSelfAndAncestorNodesInRange(node, textRange) {
@@ -1364,8 +1205,8 @@ var findImportedModuleIdentifier = fn("AST.findImportedModuleIdentifier")(
         }
       } else if (ts.isNamedImports(namedBindings)) {
         for (const importSpecifier of namedBindings.elements) {
-          const importProperty = fromNullable2(importSpecifier.propertyName).pipe(
-            orElse2(() => some2(importSpecifier.name))
+          const importProperty = fromNullable(importSpecifier.propertyName).pipe(
+            orElse(() => some2(importSpecifier.name))
           );
           if (yield* test(importSpecifier.name, statement.moduleSpecifier, importProperty)) {
             return importSpecifier.name;
@@ -1576,7 +1417,8 @@ function parse(config) {
     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()) : []
+    allowedDuplicatedPackages: isObject(config) && hasProperty(config, "allowedDuplicatedPackages") && isArray(config.allowedDuplicatedPackages) && config.allowedDuplicatedPackages.every(isString) ? config.allowedDuplicatedPackages.map((_) => _.toLowerCase()) : [],
+    namespaceImportPackages: isObject(config) && hasProperty(config, "namespaceImportPackages") && isArray(config.namespaceImportPackages) && config.namespaceImportPackages.every(isString) ? config.namespaceImportPackages.map((_) => _.toLowerCase()) : []
   };
 }
 
@@ -1600,40 +1442,9 @@ var getSemanticDiagnosticsWithCodeFixes = fn(
   let effectCodeFixes = [];
   const executor = yield* createDiagnosticExecutor(sourceFile);
   for (const rule of rules) {
-    const result = yield* option(executor.execute(rule));
-    if (isSome2(result)) {
-      effectDiagnostics = effectDiagnostics.concat(
-        pipe(
-          result.value,
-          map3((_) => ({
-            file: sourceFile,
-            start: _.node.getStart(sourceFile),
-            length: _.node.getEnd() - _.node.getStart(sourceFile),
-            messageText: _.messageText,
-            category: _.category,
-            code: rule.code,
-            source: "effect"
-          }))
-        )
-      );
-      effectCodeFixes = effectCodeFixes.concat(
-        pipe(
-          result.value,
-          map3(
-            (_) => map3(
-              _.fixes,
-              (fix) => ({
-                ...fix,
-                code: rule.code,
-                start: _.node.getStart(sourceFile),
-                end: _.node.getEnd()
-              })
-            )
-          ),
-          flatten
-        )
-      );
-    }
+    const { codeFixes, diagnostics: diagnostics2 } = yield* executor.execute(rule);
+    effectDiagnostics = effectDiagnostics.concat(diagnostics2);
+    effectCodeFixes = effectCodeFixes.concat(codeFixes);
   }
   return {
     diagnostics: effectDiagnostics,
@@ -1721,10 +1532,10 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
     const sectionOverrides = {};
     const skippedRules = [];
     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 nextLineCaptureGroup = match3[1];
-      const rulesCaptureGroup = match3[2];
+    let match2;
+    while ((match2 = regex.exec(sourceFile.text)) !== null) {
+      const nextLineCaptureGroup = match2[1];
+      const rulesCaptureGroup = match2[2];
       if (rulesCaptureGroup) {
         const trimmedRuleString = rulesCaptureGroup.trim();
         if (trimmedRuleString) {
@@ -1736,7 +1547,7 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
               if (ruleLevel === "skip-file") skippedRules.push(ruleName);
               const isOverrideNextLine = nextLineCaptureGroup && nextLineCaptureGroup.trim().toLowerCase() === "-next-line";
               if (isOverrideNextLine) {
-                const node = findNodeWithLeadingCommentAtPosition(match3.index);
+                const node = findNodeWithLeadingCommentAtPosition(match2.index);
                 if (node) {
                   lineOverrides[ruleName] = lineOverrides[ruleName] || [];
                   lineOverrides[ruleName].unshift({
@@ -1748,7 +1559,7 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
               } else {
                 sectionOverrides[ruleName] = sectionOverrides[ruleName] || [];
                 sectionOverrides[ruleName].unshift({
-                  pos: match3.index,
+                  pos: match2.index,
                   level: ruleLevel
                 });
               }
@@ -1764,12 +1575,14 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
       suggestion: ts.DiagnosticCategory.Suggestion
     };
     const execute = fn("LSP.ruleExecutor")(function* (rule) {
+      const diagnostics2 = [];
+      const codeFixes = [];
       const ruleNameLowered = rule.name.toLowerCase();
-      if (skippedRules.indexOf(ruleNameLowered) > -1) return [];
+      if (skippedRules.indexOf(ruleNameLowered) > -1) return { diagnostics: diagnostics2, codeFixes };
       const fixByDisableNextLine = (_) => ({
         fixName: rule.name + "_skipNextLine",
         description: "Disable " + rule.name + " for this line",
-        apply: flatMap3(
+        apply: flatMap2(
           service(ChangeTracker),
           (changeTracker) => sync(() => {
             const disableAtNode = findParentStatementForDisableNextLine(_.node);
@@ -1786,7 +1599,7 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
       const fixByDisableEntireFile = {
         fixName: rule.name + "_skipFile",
         description: "Disable " + rule.name + " for this entire file",
-        apply: flatMap3(
+        apply: flatMap2(
           service(ChangeTracker),
           (changeTracker) => sync(
             () => changeTracker.insertText(
@@ -1798,16 +1611,15 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
           )
         )
       };
-      let modifiedDiagnostics = [];
+      const applicableDiagnostics = [];
       yield* rule.apply(sourceFile, (entry) => {
-        modifiedDiagnostics.push({
+        applicableDiagnostics.push({
           ...entry,
           fixes: entry.fixes.concat([fixByDisableNextLine(entry), fixByDisableEntireFile])
         });
       });
-      if (!(ruleNameLowered in pluginOptions.diagnosticSeverity || ruleNameLowered in sectionOverrides || ruleNameLowered in lineOverrides)) return modifiedDiagnostics;
-      for (const emitted of modifiedDiagnostics.slice(0)) {
-        let newLevel = pluginOptions.diagnosticSeverity[ruleNameLowered];
+      for (const emitted of applicableDiagnostics.slice(0)) {
+        let newLevel = pluginOptions.diagnosticSeverity[ruleNameLowered] || rule.severity;
         const lineOverride = (lineOverrides[ruleNameLowered] || []).find(
           (_) => _.pos < emitted.node.getStart(sourceFile) && _.end >= emitted.node.getEnd()
         );
@@ -1819,13 +1631,26 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
           );
           if (sectionOverride) newLevel = sectionOverride.level;
         }
-        if (newLevel === "off") {
-          modifiedDiagnostics = modifiedDiagnostics.filter((_) => _ !== emitted);
-        } else {
-          emitted.category = newLevel && newLevel in levelToDiagnosticCategory ? levelToDiagnosticCategory[newLevel] : emitted.category;
+        if (!(newLevel in levelToDiagnosticCategory)) continue;
+        diagnostics2.push({
+          file: sourceFile,
+          start: emitted.node.getStart(sourceFile),
+          length: emitted.node.getEnd() - emitted.node.getStart(sourceFile),
+          messageText: emitted.messageText,
+          category: levelToDiagnosticCategory[newLevel],
+          code: rule.code,
+          source: "effect"
+        });
+        for (const fix of emitted.fixes) {
+          codeFixes.push({
+            ...fix,
+            code: rule.code,
+            start: emitted.node.getStart(sourceFile),
+            end: emitted.node.getEnd()
+          });
         }
       }
-      return modifiedDiagnostics;
+      return { diagnostics: diagnostics2, codeFixes };
     });
     return { execute };
   }
@@ -1848,7 +1673,7 @@ var contextSelfInClasses = createCompletion({
         "Context"
       )
     );
-    const contextIdentifier = match2(contextName, {
+    const contextIdentifier = match(contextName, {
       onNone: () => "Context",
       onSome: (_) => _.text
     });
@@ -1881,7 +1706,7 @@ var effectDataClasses = createCompletion({
         "Data"
       )
     );
-    const effectDataIdentifier = match2(dataName, {
+    const effectDataIdentifier = match(dataName, {
       onNone: () => "Data",
       onSome: (_) => _.text
     });
@@ -1920,7 +1745,7 @@ var effectSchemaSelfInClasses = createCompletion({
         "Schema"
       )
     );
-    const schemaIdentifier = match2(effectSchemaName, {
+    const schemaIdentifier = match(effectSchemaName, {
       onNone: () => "Schema",
       onSome: (_) => _.text
     });
@@ -1971,7 +1796,7 @@ var effectSelfInClasses = createCompletion({
         "Effect"
       )
     );
-    const effectIdentifier = match2(effectName, {
+    const effectIdentifier = match(effectName, {
       onNone: () => "Effect",
       onSome: (_) => _.text
     });
@@ -2059,7 +1884,7 @@ function make4(ts, typeChecker) {
     return invariantTypeArgument(propertyType);
   };
   const effectVarianceStruct = (type, atLocation) => map4(
-    all2(
+    all(
       varianceStructCovariantType(type, atLocation, "_A"),
       varianceStructCovariantType(type, atLocation, "_E"),
       varianceStructCovariantType(type, atLocation, "_R")
@@ -2067,7 +1892,7 @@ function make4(ts, typeChecker) {
     ([A, E, R]) => ({ A, E, R })
   );
   const layerVarianceStruct = (type, atLocation) => map4(
-    all2(
+    all(
       varianceStructContravariantType(type, atLocation, "_ROut"),
       varianceStructCovariantType(type, atLocation, "_E"),
       varianceStructCovariantType(type, atLocation, "_RIn")
@@ -2343,12 +2168,12 @@ function make4(ts, typeChecker) {
           let replacementNode = succeed(yieldedExpression);
           if (!explicitReturn && !(successType.flags & ts.TypeFlags.VoidLike)) {
             replacementNode = pipe(
-              gen2(function* () {
+              gen(function* () {
                 const effectIdentifier = pipe(
                   yield* option(
                     findImportedModuleIdentifierByPackageAndNameOrBarrel(node.getSourceFile(), "effect", "Effect")
                   ),
-                  match2({
+                  match({
                     onNone: () => "Effect",
                     onSome: (_) => _.text
                   })
@@ -2381,7 +2206,7 @@ function make4(ts, typeChecker) {
     (node) => node
   );
   const effectSchemaVarianceStruct = (type, atLocation) => map4(
-    all2(
+    all(
       varianceStructInvariantType(type, atLocation, "_A"),
       varianceStructInvariantType(type, atLocation, "_I"),
       varianceStructCovariantType(type, atLocation, "_R")
@@ -2413,7 +2238,7 @@ function make4(ts, typeChecker) {
     (type) => type
   );
   const contextTagVarianceStruct = (type, atLocation) => map4(
-    all2(
+    all(
       varianceStructInvariantType(type, atLocation, "_Identifier"),
       varianceStructInvariantType(type, atLocation, "_Service")
     ),
@@ -2530,7 +2355,7 @@ function makeTypeCheckerApiCache() {
     expectedAndRealType: /* @__PURE__ */ new WeakMap()
   };
 }
-var deterministicTypeOrder = gen2(function* () {
+var deterministicTypeOrder = gen(function* () {
   const typeChecker = yield* service(TypeCheckerApi);
   return make2((a, b) => {
     const aName = typeChecker.typeToString(a);
@@ -2773,6 +2598,15 @@ var appendToUniqueTypesMap = fn(
     };
   }
 );
+function makeResolveExternalModuleName(typeChecker) {
+  if (!(hasProperty(typeChecker, "resolveExternalModuleName") && isFunction(typeChecker.resolveExternalModuleName))) {
+    return;
+  }
+  const _internal = typeChecker.resolveExternalModuleName;
+  return (moduleSpecifier) => {
+    return _internal(moduleSpecifier);
+  };
+}
 
 // src/completions/genFunctionStar.ts
 var genFunctionStar = createCompletion({
@@ -2821,7 +2655,7 @@ var rpcMakeClasses = createCompletion({
         "Rpc"
       )
     );
-    const rpcIdentifier = match2(rpcName, {
+    const rpcIdentifier = match(rpcName, {
       onNone: () => "Rpc",
       onSome: (_) => _.text
     });
@@ -2848,14 +2682,208 @@ var completions = [
   effectDataClasses
 ];
 
+// src/completions/middlewareNamespaceImports.ts
+var importablePackagesMetadataCache = /* @__PURE__ */ new Map();
+var makeImportablePackagesMetadata = fn("makeImportablePackagesMetadata")(function* (sourceFile) {
+  const ts = yield* service(TypeScriptApi);
+  const program = yield* service(TypeScriptProgram);
+  const languageServicePluginOptions = yield* service(LanguageServicePluginOptions);
+  const host = program;
+  const namespaceByFileName = /* @__PURE__ */ new Map();
+  const excludedByFileName = /* @__PURE__ */ new Map();
+  const unbarreledModulePathByFileName = /* @__PURE__ */ new Map();
+  for (const packageName of languageServicePluginOptions.namespaceImportPackages) {
+    const barrelModule = ts.resolveModuleName(packageName, sourceFile.fileName, program.getCompilerOptions(), host);
+    if (barrelModule.resolvedModule) {
+      const barrelPath = barrelModule.resolvedModule.resolvedFileName;
+      const barrelSource = program.getSourceFile(barrelPath) || ts.createSourceFile(barrelPath, host.readFile(barrelPath) || "", sourceFile.languageVersion, true);
+      if (barrelSource) {
+        for (const statement of barrelSource.statements) {
+          if (ts.isExportDeclaration(statement)) {
+            const exportClause = statement.exportClause;
+            const moduleSpecifier = statement.moduleSpecifier;
+            if (moduleSpecifier && ts.isStringLiteral(moduleSpecifier)) {
+              const unbarreledModulePathResolved = ts.resolveModuleName(
+                moduleSpecifier.text,
+                barrelSource.fileName,
+                program.getCompilerOptions(),
+                host
+              );
+              if (unbarreledModulePathResolved.resolvedModule) {
+                const unbarreledModulePath = unbarreledModulePathResolved.resolvedModule.resolvedFileName;
+                if (exportClause && ts.isNamespaceExport(exportClause) && ts.isIdentifier(exportClause.name)) {
+                  namespaceByFileName.set(unbarreledModulePath, exportClause.name.text);
+                  const existingUnbarreledModulePath = unbarreledModulePathByFileName.get(barrelSource.fileName) || [];
+                  existingUnbarreledModulePath.push([exportClause.name.text, unbarreledModulePath]);
+                  unbarreledModulePathByFileName.set(barrelSource.fileName, existingUnbarreledModulePath);
+                }
+                if (exportClause && ts.isNamedExports(exportClause)) {
+                  for (const element of exportClause.elements) {
+                    if (!ts.isIdentifier(element.name)) continue;
+                    const methodName = element.name.text;
+                    const excludedMethods = excludedByFileName.get(methodName) || [];
+                    excludedMethods.push(unbarreledModulePath);
+                    excludedByFileName.set(methodName, excludedMethods);
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  return {
+    getImportNamespaceByFileName: (fileName) => namespaceByFileName.get(fileName),
+    isExcludedFromNamespaceImport: (fileName, exportName) => (excludedByFileName.get(exportName) || []).includes(fileName),
+    getUnbarreledModulePath: (fileName, exportName) => unbarreledModulePathByFileName.get(fileName)?.find(([name]) => name === exportName)?.[1]
+  };
+});
+var appendEffectCompletionEntryData = fn("collectNamespaceImports")(
+  function* (sourceFile, applicableCompletions) {
+    const languageServicePluginOptions = yield* service(LanguageServicePluginOptions);
+    if (languageServicePluginOptions.namespaceImportPackages.length === 0) return applicableCompletions;
+    const packagesMetadata = importablePackagesMetadataCache.get(sourceFile.fileName) || (yield* makeImportablePackagesMetadata(sourceFile));
+    importablePackagesMetadataCache.set(sourceFile.fileName, packagesMetadata);
+    if (applicableCompletions) {
+      return {
+        ...applicableCompletions,
+        entries: applicableCompletions.entries.map((entry) => {
+          if (entry.data && entry.data.fileName && !entry.insertText && !entry.filterText && entry.data.exportName && entry.data.moduleSpecifier) {
+            const isExcluded = packagesMetadata.isExcludedFromNamespaceImport(
+              entry.data.fileName,
+              entry.data.exportName
+            );
+            if (isExcluded) return entry;
+            const unbarreledModulePath = packagesMetadata.getUnbarreledModulePath(
+              entry.data.fileName,
+              entry.data.exportName
+            );
+            const namespaceName = packagesMetadata.getImportNamespaceByFileName(
+              unbarreledModulePath || entry.data.fileName
+            );
+            if (namespaceName) {
+              return {
+                ...entry,
+                // insertText: unbarreledModulePath ? namespaceName : namespaceName + "." + entry.name,
+                // filterText: entry.name,
+                data: {
+                  ...entry.data,
+                  effectNamespaceName: namespaceName,
+                  effectUnbarreledModulePath: unbarreledModulePath || "",
+                  effectReplaceSpan: entry.replacementSpan || applicableCompletions.optionalReplacementSpan
+                }
+              };
+            }
+          }
+          return entry;
+        })
+      };
+    }
+    return applicableCompletions;
+  }
+);
+var postprocessCompletionEntryDetails = fn("postprocessCompletionEntryDetails")(
+  function* (sourceFile, data, applicableCompletionEntryDetails, formatOptions, preferences, languageServiceHost) {
+    const languageServicePluginOptions = yield* service(LanguageServicePluginOptions);
+    if (languageServicePluginOptions.namespaceImportPackages.length === 0) return applicableCompletionEntryDetails;
+    const ts = yield* service(TypeScriptApi);
+    const program = yield* service(TypeScriptProgram);
+    const getModuleSpecifier = makeGetModuleSpecifier(ts);
+    if (!getModuleSpecifier) return applicableCompletionEntryDetails;
+    if (!applicableCompletionEntryDetails) return applicableCompletionEntryDetails;
+    if (!data) return applicableCompletionEntryDetails;
+    if (!("effectNamespaceName" in data && "effectUnbarreledModulePath" in data && "effectReplaceSpan" in data)) {
+      return applicableCompletionEntryDetails;
+    }
+    const effectReplaceSpan = data.effectReplaceSpan;
+    const codeActions = applicableCompletionEntryDetails.codeActions;
+    if (codeActions && codeActions.length === 1) {
+      const action = codeActions[0];
+      if (action.changes.length === 1) {
+        const fileTextChanges = action.changes[0];
+        if (fileTextChanges.fileName === sourceFile.fileName && fileTextChanges.textChanges.length === 1) {
+          const change = fileTextChanges.textChanges[0];
+          let hasImportActions = false;
+          if (change.newText.trim().toLowerCase().startsWith("import") && change.newText.indexOf(data.exportName) > -1) {
+            hasImportActions = true;
+          }
+          if (!hasImportActions && change.newText.indexOf(data.exportName) > -1) {
+            const ancestorNodes = yield* getAncestorNodesInRange(sourceFile, {
+              pos: change.span.start,
+              end: change.span.start
+            });
+            const importNodes = ancestorNodes.filter((node) => ts.isImportDeclaration(node));
+            hasImportActions = importNodes.length > 0;
+          }
+          if (!hasImportActions) return applicableCompletionEntryDetails;
+          const formatContext = ts.formatting.getFormatContext(
+            formatOptions || {},
+            languageServiceHost
+          );
+          const changes = ts.textChanges.ChangeTracker.with(
+            {
+              formatContext,
+              host: languageServiceHost,
+              preferences: preferences || {}
+            },
+            (changeTracker) => {
+              const isBarrelRedirect = String(data.effectUnbarreledModulePath).length > 0;
+              const moduleSpecifier = isBarrelRedirect ? getModuleSpecifier(
+                program.getCompilerOptions(),
+                sourceFile,
+                sourceFile.fileName,
+                String(data.effectUnbarreledModulePath),
+                program
+              ) : String(data.moduleSpecifier);
+              ts.insertImports(
+                changeTracker,
+                sourceFile,
+                ts.factory.createImportDeclaration(
+                  void 0,
+                  ts.factory.createImportClause(
+                    false,
+                    void 0,
+                    ts.factory.createNamespaceImport(ts.factory.createIdentifier(String(data.effectNamespaceName)))
+                  ),
+                  ts.factory.createStringLiteral(moduleSpecifier)
+                ),
+                true,
+                preferences || {}
+              );
+              if (!isBarrelRedirect) {
+                changeTracker.insertText(
+                  sourceFile,
+                  effectReplaceSpan.start,
+                  String(data.effectNamespaceName) + "."
+                );
+              }
+            }
+          );
+          return {
+            ...applicableCompletionEntryDetails,
+            codeActions: [
+              {
+                description: "Import * as " + data.effectNamespaceName + " from " + data.effectUnbarreledModulePath,
+                changes
+              }
+            ]
+          };
+        }
+      }
+    }
+    return applicableCompletionEntryDetails;
+  }
+);
+
 // src/diagnostics/duplicatePackage.ts
 var checkedPackagesCache = /* @__PURE__ */ new Map();
 var programResolvedCacheSize = /* @__PURE__ */ new Map();
 var duplicatePackage = createDiagnostic({
   name: "duplicatePackage",
   code: 6,
+  severity: "warning",
   apply: fn("duplicatePackage.apply")(function* (sourceFile, report) {
-    const ts = yield* service(TypeScriptApi);
     const program = yield* service(TypeScriptProgram);
     const options = yield* service(LanguageServicePluginOptions);
     if (sourceFile.statements.length < 1) return;
@@ -2884,7 +2912,6 @@ var duplicatePackage = createDiagnostic({
         const versions = Object.keys(resolvedPackages[packageName]);
         report({
           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]))}.
@@ -2901,6 +2928,7 @@ ${versions.map((version) => `- found ${version} at ${resolvedPackages[packageNam
 var floatingEffect = createDiagnostic({
   name: "floatingEffect",
   code: 3,
+  severity: "error",
   apply: fn("floatingEffect.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
@@ -2927,13 +2955,12 @@ var floatingEffect = createDiagnostic({
       if (isSome2(effect)) {
         const allowedFloatingEffects = yield* pipe(
           typeParser.fiberType(type, node.expression),
-          orElse3(() => typeParser.effectSubtype(type, node.expression)),
+          orElse2(() => typeParser.effectSubtype(type, node.expression)),
           option
         );
         if (isNone2(allowedFloatingEffects)) {
           report({
             node,
-            category: ts.DiagnosticCategory.Error,
             messageText: `Effect must be yielded or assigned to a variable.`,
             fixes: []
           });
@@ -2947,6 +2974,7 @@ var floatingEffect = createDiagnostic({
 var genericEffectServices = createDiagnostic({
   name: "genericEffectServices",
   code: 10,
+  severity: "warning",
   apply: fn("genericEffectServices.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -2976,12 +3004,11 @@ var genericEffectServices = createDiagnostic({
           map4(() => {
             report({
               node: reportAt,
-              category: ts.DiagnosticCategory.Warning,
               messageText: `Effect Services with type parameters are not supported because they cannot be properly discriminated at runtime, which may cause unexpected behavior.`,
               fixes: []
             });
           }),
-          orElse3(() => sync(() => ts.forEachChild(node, appendNodeToVisit))),
+          orElse2(() => sync(() => ts.forEachChild(node, appendNodeToVisit))),
           ignore
         );
       }
@@ -2989,10 +3016,124 @@ var genericEffectServices = createDiagnostic({
   })
 });
 
+// src/diagnostics/importFromBarrel.ts
+var importFromBarrel = createDiagnostic({
+  name: "importFromBarrel",
+  code: 12,
+  severity: "off",
+  apply: fn("importFromBarrel.apply")(function* (sourceFile, report) {
+    const languageServicePluginOptions = yield* service(LanguageServicePluginOptions);
+    if (languageServicePluginOptions.namespaceImportPackages.length === 0) return;
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const program = yield* service(TypeScriptProgram);
+    const isImportedFromBarrelExport = (element, languageServicePluginOptions2) => {
+      const getModuleSpecifier = makeGetModuleSpecifier(ts);
+      const resolveExternalModuleName = makeResolveExternalModuleName(typeChecker);
+      if (!(getModuleSpecifier && resolveExternalModuleName)) return;
+      const importDeclaration = ts.findAncestor(element, (node) => ts.isImportDeclaration(node));
+      if (!importDeclaration) return;
+      if (!ts.isStringLiteral(importDeclaration.moduleSpecifier)) return;
+      const importClause = importDeclaration.importClause;
+      if (!importClause) return;
+      const namedBindings = importClause.namedBindings;
+      if (!namedBindings) return;
+      if (!ts.isNamedImports(namedBindings)) return;
+      const barrelModuleName = importDeclaration.moduleSpecifier.text;
+      if (languageServicePluginOptions2.namespaceImportPackages.indexOf(barrelModuleName.toLowerCase()) === -1) return;
+      const moduleSymbol = resolveExternalModuleName(importDeclaration.moduleSpecifier);
+      if (!moduleSymbol) return;
+      if (!moduleSymbol.exports) return;
+      const sourceFile2 = importDeclaration.getSourceFile();
+      const nodeForSymbol = element.propertyName || element.name;
+      if (!ts.isIdentifier(nodeForSymbol)) return;
+      const importedName = nodeForSymbol.text;
+      const reexportedSymbol = moduleSymbol.exports.get(ts.escapeLeadingUnderscores(importedName));
+      if (!reexportedSymbol) return;
+      if (!(reexportedSymbol.declarations && reexportedSymbol.declarations.length === 1)) return;
+      const namespaceExport = reexportedSymbol.declarations[0];
+      if (!ts.isNamespaceExport(namespaceExport)) return;
+      const exportDeclaration = namespaceExport.parent;
+      if (!ts.isExportDeclaration(exportDeclaration)) return;
+      if (!exportDeclaration.moduleSpecifier) return;
+      const originalModuleSymbol = resolveExternalModuleName(exportDeclaration.moduleSpecifier);
+      if (!originalModuleSymbol) return;
+      if (!originalModuleSymbol.valueDeclaration) return;
+      const originalSourceFile = originalModuleSymbol.valueDeclaration.getSourceFile();
+      const unbarrelledFileName = getModuleSpecifier(
+        program.getCompilerOptions(),
+        sourceFile2,
+        sourceFile2.fileName,
+        originalSourceFile.fileName,
+        program
+      );
+      if (unbarrelledFileName.toLowerCase().indexOf(barrelModuleName.toLowerCase() + "/") === -1) return;
+      return { unbarrelledFileName, importedName, barrelModuleName, importClause, namedBindings, importDeclaration };
+    };
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      const parent = node.parent;
+      if (!(ts.isImportSpecifier(node) && ts.isNamedImports(parent))) {
+        ts.forEachChild(node, appendNodeToVisit);
+        continue;
+      }
+      const result = isImportedFromBarrelExport(node, languageServicePluginOptions);
+      if (!result) continue;
+      const { barrelModuleName, importClause, importDeclaration, importedName, namedBindings, unbarrelledFileName } = result;
+      report({
+        node,
+        messageText: `Importing from barrel module ${barrelModuleName} is not allowed.`,
+        fixes: [
+          {
+            fixName: "replaceWithUnbarrelledImport",
+            description: `Import * as ${importedName} from ${unbarrelledFileName}`,
+            apply: gen(function* () {
+              const changeTracker = yield* service(ChangeTracker);
+              const newImport = ts.factory.createImportDeclaration(
+                void 0,
+                ts.factory.createImportClause(
+                  importClause.isTypeOnly || node.isTypeOnly,
+                  void 0,
+                  ts.factory.createNamespaceImport(ts.factory.createIdentifier(importedName))
+                ),
+                ts.factory.createStringLiteral(unbarrelledFileName)
+              );
+              if (namedBindings.elements.length === 1) {
+                changeTracker.replaceNode(
+                  sourceFile,
+                  importDeclaration,
+                  newImport
+                );
+              } else {
+                changeTracker.insertNodeAfter(sourceFile, importDeclaration, newImport);
+                changeTracker.replaceNode(
+                  sourceFile,
+                  namedBindings,
+                  ts.factory.updateNamedImports(
+                    namedBindings,
+                    namedBindings.elements.filter((e) => e !== node)
+                  )
+                );
+              }
+            })
+          }
+        ]
+      });
+    }
+  })
+});
+
 // src/diagnostics/leakingRequirements.ts
 var leakingRequirements = createDiagnostic({
   name: "leakingRequirements",
   code: 8,
+  severity: "suggestion",
   apply: fn("leakingRequirements.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
@@ -3012,7 +3153,7 @@ var leakingRequirements = createDiagnostic({
             yield* pipe(
               typeParser.effectType(servicePropertyType, atLocation),
               map4((_) => effectContextType = _.R),
-              orElse3(() => {
+              orElse2(() => {
                 const servicePropertyCallSignatures = servicePropertyType.getCallSignatures();
                 if (servicePropertyCallSignatures.length === 1) {
                   return pipe(
@@ -3022,7 +3163,7 @@ var leakingRequirements = createDiagnostic({
                     })
                   );
                 }
-                return void_2;
+                return void_;
               }),
               ignore
             );
@@ -3050,7 +3191,6 @@ var leakingRequirements = createDiagnostic({
       if (requirements.length === 0) return;
       report({
         node,
-        category: ts.DiagnosticCategory.Warning,
         messageText: `This Service is leaking the ${requirements.map((_) => typeChecker.typeToString(_)).join(" | ")} requirement.
 If these requirements cannot be cached and are expected to be provided per method invocation (e.g. HttpServerRequest), you can safely disable this diagnostic for this line through quickfixes.
 More info at https://effect.website/docs/requirements-management/layers/#avoiding-requirement-leakage`,
@@ -3081,13 +3221,13 @@ More info at https://effect.website/docs/requirements-management/layers/#avoidin
       for (const [type, reportAt] of typesToCheck) {
         yield* pipe(
           typeParser.contextTag(type, node),
-          flatMap3(
+          flatMap2(
             ({ Service }) => pipe(
               parseLeakedRequirements(Service, node),
               map4((requirements) => reportLeakingRequirements(reportAt, sort(requirements, typeOrder)))
             )
           ),
-          orElse3(() => sync(() => ts.forEachChild(node, appendNodeToVisit))),
+          orElse2(() => sync(() => ts.forEachChild(node, appendNodeToVisit))),
           ignore
         );
       }
@@ -3099,17 +3239,17 @@ More info at https://effect.website/docs/requirements-management/layers/#avoidin
 var missingEffectContext = createDiagnostic({
   name: "missingEffectContext",
   code: 1,
+  severity: "error",
   apply: fn("missingEffectContext.apply")(function* (sourceFile, report) {
-    const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
     const typeOrder = yield* deterministicTypeOrder;
     const checkForMissingContextTypes = (node, expectedType, valueNode, realType) => pipe(
-      all2(
+      all(
         typeParser.effectType(expectedType, node),
         typeParser.effectType(realType, valueNode)
       ),
-      flatMap3(
+      flatMap2(
         ([expectedEffect, realEffect]) => getMissingTypeEntriesInTargetType(
           realEffect.R,
           expectedEffect.R
@@ -3126,13 +3266,12 @@ var missingEffectContext = createDiagnostic({
           valueNode,
           realType
         ),
-        orElse3(() => succeed([]))
+        orElse2(() => succeed([]))
       );
       if (missingContext.length > 0) {
         report(
           {
             node,
-            category: ts.DiagnosticCategory.Error,
             messageText: `Missing '${sortTypes(missingContext).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect context.`,
             fixes: []
           }
@@ -3146,17 +3285,17 @@ var missingEffectContext = createDiagnostic({
 var missingEffectError = createDiagnostic({
   name: "missingEffectError",
   code: 1,
+  severity: "error",
   apply: fn("missingEffectError.apply")(function* (sourceFile, report) {
-    const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
     const typeOrder = yield* deterministicTypeOrder;
     const checkForMissingErrorTypes = (node, expectedType, valueNode, realType) => pipe(
-      all2(
+      all(
         typeParser.effectType(expectedType, node),
         typeParser.effectType(realType, valueNode)
       ),
-      flatMap3(
+      flatMap2(
         ([expectedEffect, realEffect]) => getMissingTypeEntriesInTargetType(
           realEffect.E,
           expectedEffect.E
@@ -3173,13 +3312,12 @@ var missingEffectError = createDiagnostic({
           valueNode,
           realType
         ),
-        orElse3(() => succeed([]))
+        orElse2(() => succeed([]))
       );
       if (missingContext.length > 0) {
         report(
           {
             node,
-            category: ts.DiagnosticCategory.Error,
             messageText: `Missing '${sortTypes(missingContext).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect errors.`,
             fixes: []
           }
@@ -3193,6 +3331,7 @@ var missingEffectError = createDiagnostic({
 var missingReturnYieldStar = createDiagnostic({
   name: "missingReturnYieldStar",
   code: 7,
+  severity: "error",
   apply: fn("missingReturnYieldStar.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
@@ -3219,15 +3358,15 @@ var missingReturnYieldStar = createDiagnostic({
               const effectGenNode = generatorFunctionOrReturnStatement.parent;
               const effectGenLike = yield* pipe(
                 typeParser.effectGen(effectGenNode),
-                orElse3(() => typeParser.effectFnUntracedGen(effectGenNode)),
-                orElse3(() => typeParser.effectFnGen(effectGenNode)),
+                orElse2(() => typeParser.effectFnUntracedGen(effectGenNode)),
+                orElse2(() => typeParser.effectFnGen(effectGenNode)),
                 option
               );
               if (isSome2(effectGenLike)) {
                 const fix = node.expression ? [{
                   fixName: "missingReturnYieldStar_fix",
                   description: "Add return statement",
-                  apply: gen2(function* () {
+                  apply: gen(function* () {
                     const changeTracker = yield* service(ChangeTracker);
                     changeTracker.replaceNode(
                       sourceFile,
@@ -3240,7 +3379,6 @@ var missingReturnYieldStar = createDiagnostic({
                 }] : [];
                 report({
                   node,
-                  category: ts.DiagnosticCategory.Error,
                   messageText: `Yielded Effect never succeeds, so it is best to use a 'return yield*' instead.`,
                   fixes: fix
                 });
@@ -3257,6 +3395,7 @@ var missingReturnYieldStar = createDiagnostic({
 var missingStarInYieldEffectGen = createDiagnostic({
   name: "missingStarInYieldEffectGen",
   code: 4,
+  severity: "error",
   apply: fn("missingStarInYieldEffectGen.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -3280,8 +3419,8 @@ var missingStarInYieldEffectGen = createDiagnostic({
           const effectGenNode = functionStarNode.parent;
           yield* pipe(
             typeParser.effectGen(effectGenNode),
-            orElse3(() => typeParser.effectFnUntracedGen(effectGenNode)),
-            orElse3(() => typeParser.effectFnGen(effectGenNode)),
+            orElse2(() => typeParser.effectFnUntracedGen(effectGenNode)),
+            orElse2(() => typeParser.effectFnGen(effectGenNode)),
             map4(({ functionStar }) => {
               if (functionStar) {
                 brokenGenerators.add(functionStar);
@@ -3296,7 +3435,6 @@ var missingStarInYieldEffectGen = createDiagnostic({
     brokenGenerators.forEach(
       (node) => report({
         node,
-        category: ts.DiagnosticCategory.Error,
         messageText: `Seems like you used yield instead of yield* inside this Effect.gen.`,
         fixes: []
       })
@@ -3305,7 +3443,7 @@ var missingStarInYieldEffectGen = createDiagnostic({
       const fix = node.expression ? [{
         fixName: "missingStarInYieldEffectGen_fix",
         description: "Replace yield with yield*",
-        apply: gen2(function* () {
+        apply: gen(function* () {
           const changeTracker = yield* service(ChangeTracker);
           changeTracker.replaceNode(
             sourceFile,
@@ -3319,7 +3457,6 @@ var missingStarInYieldEffectGen = createDiagnostic({
       }] : [];
       report({
         node,
-        category: ts.DiagnosticCategory.Error,
         messageText: `When yielding Effects inside Effect.gen, you should use yield* instead of yield.`,
         fixes: fix
       });
@@ -3331,6 +3468,7 @@ var missingStarInYieldEffectGen = createDiagnostic({
 var returnEffectInGen = createDiagnostic({
   name: "returnEffectInGen",
   code: 11,
+  severity: "suggestion",
   apply: fn("returnEffectInGen.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
@@ -3358,13 +3496,13 @@ var returnEffectInGen = createDiagnostic({
             const effectGenNode = generatorOrRegularFunction.parent;
             yield* pipe(
               typeParser.effectGen(effectGenNode),
-              orElse3(() => typeParser.effectFnUntracedGen(effectGenNode)),
-              orElse3(() => typeParser.effectFnGen(effectGenNode)),
+              orElse2(() => typeParser.effectFnUntracedGen(effectGenNode)),
+              orElse2(() => typeParser.effectFnGen(effectGenNode)),
               map4(() => {
                 const fix = node.expression ? [{
                   fixName: "returnEffectInGen_fix",
                   description: "Add yield* statement",
-                  apply: gen2(function* () {
+                  apply: gen(function* () {
                     const changeTracker = yield* service(ChangeTracker);
                     changeTracker.replaceNode(
                       sourceFile,
@@ -3378,7 +3516,6 @@ var returnEffectInGen = createDiagnostic({
                 }] : [];
                 report({
                   node,
-                  category: ts.DiagnosticCategory.Suggestion,
                   messageText: `You are returning an Effect-able type inside a generator function, and will result in nested Effect<Effect<...>>.
 Maybe you wanted to return yield* instead?
 Nested Effect-able types may be intended if you plan to later manually flatten or unwrap this Effect, if so you can safely disable this diagnostic for this line through quickfixes.`,
@@ -3398,6 +3535,7 @@ Nested Effect-able types may be intended if you plan to later manually flatten o
 var unnecessaryEffectGen = createDiagnostic({
   name: "unnecessaryEffectGen",
   code: 5,
+  severity: "suggestion",
   apply: fn("unnecessaryEffectGen.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -3416,12 +3554,11 @@ var unnecessaryEffectGen = createDiagnostic({
           map4(
             ({ replacementNode }) => report({
               node,
-              category: ts.DiagnosticCategory.Suggestion,
               messageText: `This Effect.gen contains a single return statement.`,
               fixes: [{
                 fixName: "unnecessaryEffectGen_fix",
                 description: "Remove the Effect.gen, and keep the body",
-                apply: gen2(function* () {
+                apply: gen(function* () {
                   const textChanges = yield* service(
                     ChangeTracker
                   );
@@ -3441,6 +3578,7 @@ var unnecessaryEffectGen = createDiagnostic({
 var unnecessaryPipe = createDiagnostic({
   name: "unnecessaryPipe",
   code: 9,
+  severity: "suggestion",
   apply: fn("unnecessaryPipe.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -3460,12 +3598,11 @@ var unnecessaryPipe = createDiagnostic({
             if (args.length === 0) {
               report({
                 node,
-                category: ts.DiagnosticCategory.Suggestion,
                 messageText: `This pipe call contains no arguments.`,
                 fixes: [{
                   fixName: "unnecessaryPipe_fix",
                   description: "Remove the pipe call",
-                  apply: gen2(function* () {
+                  apply: gen(function* () {
                     const textChanges = yield* service(
                       ChangeTracker
                     );
@@ -3494,12 +3631,13 @@ var diagnostics = [
   leakingRequirements,
   unnecessaryPipe,
   genericEffectServices,
-  returnEffectInGen
+  returnEffectInGen,
+  importFromBarrel
 ];
 
 // src/goto/effectRpcDefinition.ts
 function effectRpcDefinition(applicableGotoDefinition, sourceFile, position) {
-  return gen2(function* () {
+  return gen(function* () {
     const program = yield* service(TypeScriptProgram);
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
@@ -3619,41 +3757,82 @@ function dedupeJsDocs(quickInfo2) {
 }
 
 // src/quickinfo/effectTypeArgs.ts
-function formatTypeForQuickInfo(channelType, channelName) {
-  return gen2(function* () {
-    const ts = yield* service(TypeScriptApi);
-    const typeChecker = yield* service(TypeCheckerApi);
-    const stringRepresentation = typeChecker.typeToString(
-      channelType,
-      void 0,
-      ts.TypeFormatFlags.NoTruncation
-    );
-    return `type ${channelName} = ${stringRepresentation}`;
-  });
-}
 function effectTypeArgs(sourceFile, position, quickInfo2) {
   return pipe(
-    gen2(function* () {
+    gen(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
-      );
-      if (isNone2(maybeNode)) return quickInfo2;
-      const node = maybeNode.value;
-      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 effectType = yield* typeParser.effectType(
-        typeChecker.getTypeAtLocation(nodeForType),
-        nodeForType
+      function formatTypeForQuickInfo(channelType, channelName) {
+        const stringRepresentation = typeChecker.typeToString(
+          channelType,
+          void 0,
+          ts.TypeFormatFlags.NoTruncation
+        );
+        return `type ${channelName} = ${stringRepresentation}`;
+      }
+      function makeSymbolDisplayParts(title, A, E, R) {
+        return [{
+          kind: "text",
+          text: "```ts\n/* " + title + " */\n" + formatTypeForQuickInfo(A, "Success") + "\n" + formatTypeForQuickInfo(E, "Failure") + "\n" + formatTypeForQuickInfo(R, "Requirements") + "\n```\n"
+        }];
+      }
+      function getNodeForQuickInfo(node2) {
+        if (ts.isNewExpression(node2.parent) && node2.pos === node2.parent.pos) {
+          return node2.parent.expression;
+        }
+        if (ts.isNamedTupleMember(node2.parent) && node2.pos === node2.parent.pos) {
+          return node2.parent;
+        }
+        if (ts.isJsxNamespacedName(node2.parent)) {
+          return node2.parent;
+        }
+        return node2;
+      }
+      function getDataForQuickInfo() {
+        if (!("getTouchingPropertyName" in ts && typeof ts.getTouchingPropertyName === "function")) return;
+        const touchingNode = ts.getTouchingPropertyName(sourceFile, position);
+        if (touchingNode === sourceFile) return;
+        const adjustedNode = getNodeForQuickInfo(touchingNode);
+        if (ts.isToken(adjustedNode) && adjustedNode.kind === ts.SyntaxKind.YieldKeyword) {
+          if (ts.isYieldExpression(adjustedNode.parent) && adjustedNode.parent.asteriskToken && adjustedNode.parent.expression) {
+            return {
+              type: typeChecker.getTypeAtLocation(adjustedNode.parent.expression),
+              atLocation: adjustedNode.parent.expression,
+              node: adjustedNode.parent,
+              shouldTry: true
+            };
+          }
+        }
+        return {
+          type: typeChecker.getTypeAtLocation(adjustedNode),
+          atLocation: adjustedNode,
+          node: adjustedNode,
+          shouldTry: quickInfo2 && ts.displayPartsToString(quickInfo2.displayParts).indexOf("...") > -1
+        };
+      }
+      const data = getDataForQuickInfo();
+      if (!(data && data.shouldTry)) return quickInfo2;
+      const { atLocation, node, type } = data;
+      const effectTypeArgsDocumentation = yield* pipe(
+        typeParser.effectType(
+          type,
+          atLocation
+        ),
+        map4((_) => makeSymbolDisplayParts("Effect Type Parameters", _.A, _.E, _.R)),
+        orElse2(() => {
+          const callSignatues = type.getCallSignatures();
+          if (callSignatues.length !== 1) return succeed([]);
+          const returnType = callSignatues[0].getReturnType();
+          return pipe(
+            typeParser.effectType(
+              returnType,
+              atLocation
+            ),
+            map4((_) => makeSymbolDisplayParts("Returned Effect Type Parameters", _.A, _.E, _.R))
+          );
+        })
       );
-      const effectTypeArgsDocumentation = [{
-        kind: "text",
-        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();
         const end = node.getEnd();
@@ -3675,7 +3854,7 @@ function effectTypeArgs(sourceFile, position, quickInfo2) {
         documentation: effectTypeArgsDocumentation
       };
     }),
-    orElse3(() => succeed(quickInfo2))
+    orElse2(() => succeed(quickInfo2))
   );
 }
 
@@ -3707,7 +3886,7 @@ var GraphNodeCompoundTransform = class {
   _tag = "GraphNodeCompoundTransform";
 };
 function processLayerGraphNode(ctx, node, pipedInGraphNode) {
-  return gen2(function* () {
+  return gen(function* () {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
@@ -3724,7 +3903,7 @@ function processLayerGraphNode(ctx, node, pipedInGraphNode) {
       const maybeLayer = yield* option(typeParser.layerType(type, node));
       if (isSome2(maybeLayer)) {
         const argNodes = yield* option(
-          all2(...node.arguments.map((_) => processLayerGraphNode(ctx, _, void 0)))
+          all(...node.arguments.map((_) => processLayerGraphNode(ctx, _, void 0)))
         );
         if (isSome2(argNodes) && argNodes.value.length === node.arguments.length) {
           const { allIndexes: outTypes } = yield* appendToUniqueTypesMap(
@@ -3768,7 +3947,7 @@ function processLayerGraphNode(ctx, node, pipedInGraphNode) {
             );
             if (ts.isCallExpression(node)) {
               const argNodes = yield* option(
-                all2(...node.arguments.map((_) => processLayerGraphNode(ctx, _, void 0)))
+                all(...node.arguments.map((_) => processLayerGraphNode(ctx, _, void 0)))
               );
               if (isSome2(argNodes) && argNodes.value.length === node.arguments.length) {
                 return new GraphNodeCompoundTransform(
@@ -3843,7 +4022,7 @@ function escapeMermaid(text) {
   return text.replace(/"/mg, "#quot;").replace(/\n/mg, " ");
 }
 function processNodeMermaid(graph, ctx, ctxL) {
-  return gen2(function* () {
+  return gen(function* () {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
     let subgraphDefs = [];
@@ -3896,7 +4075,7 @@ function processNodeMermaid(graph, ctx, ctxL) {
         return subgraphDefs;
       }
       case "GraphNodeCompoundTransform": {
-        const childs = flatten(yield* all2(...graph.args.map((_) => processNodeMermaid(_, ctx, ctxL))));
+        const childs = flatten(yield* all(...graph.args.map((_) => processNodeMermaid(_, ctx, ctxL))));
         let currentEdges = [];
         const connectedNodes = /* @__PURE__ */ new Set();
         for (const requiredServiceKey of graph.rin) {
@@ -3928,7 +4107,7 @@ function processNodeMermaid(graph, ctx, ctxL) {
   });
 }
 function generateMarmaidUri(graph, ctxL) {
-  return gen2(function* () {
+  return gen(function* () {
     const ctx = {
       seenIds: /* @__PURE__ */ new Set()
     };
@@ -3940,7 +4119,7 @@ function generateMarmaidUri(graph, ctxL) {
 }
 function layerInfo(sourceFile, position, quickInfo2) {
   return pipe(
-    gen2(function* () {
+    gen(function* () {
       const ts = yield* service(TypeScriptApi);
       const typeChecker = yield* service(TypeCheckerApi);
       const typeParser = yield* service(TypeParser);
@@ -3965,8 +4144,8 @@ function layerInfo(sourceFile, position, quickInfo2) {
       };
       const layerInfoDisplayParts = yield* pipe(
         processLayerGraphNode(graphCtx, layerNode, void 0),
-        flatMap3(
-          (rootNode) => gen2(function* () {
+        flatMap2(
+          (rootNode) => gen(function* () {
             yield* succeed(void 0);
             const lines = [];
             const appendInfo = (providesNode, type, kindText) => {
@@ -4010,7 +4189,7 @@ function layerInfo(sourceFile, position, quickInfo2) {
             ];
           })
         ),
-        orElse3(
+        orElse2(
           (e) => succeed([{
             kind: "text",
             text: "```\n/** layer graph not created: " + e.message + " */\n```\n"
@@ -4038,13 +4217,13 @@ function layerInfo(sourceFile, position, quickInfo2) {
         documentation: layerInfoDisplayParts
       };
     }),
-    orElse3(() => succeed(quickInfo2))
+    orElse2(() => succeed(quickInfo2))
   );
 }
 
 // src/quickinfo.ts
 function quickInfo(sourceFile, position, quickInfo2) {
-  return gen2(function* () {
+  return gen(function* () {
     const deduped = yield* dedupeJsDocs(quickInfo2);
     const withEffectTypeArgs = yield* effectTypeArgs(sourceFile, position, deduped);
     const withLayerInfo = yield* layerInfo(sourceFile, position, withEffectTypeArgs);
@@ -4075,9 +4254,9 @@ var asyncAwaitToGen = createRefactor({
       kind: "refactor.rewrite.effect.asyncAwaitToGen",
       description: "Rewrite to Effect.gen",
       apply: pipe(
-        gen2(function* () {
+        gen(function* () {
           const changeTracker = yield* service(ChangeTracker);
-          const effectModuleIdentifierName = match2(
+          const effectModuleIdentifierName = match(
             yield* option(
               findImportedModuleIdentifier(
                 sourceFile,
@@ -4146,9 +4325,9 @@ var asyncAwaitToGenTryPromise = createRefactor({
       kind: "refactor.rewrite.effect.asyncAwaitToGenTryPromise",
       description: "Rewrite to Effect.gen with failures",
       apply: pipe(
-        gen2(function* () {
+        gen(function* () {
           const changeTracker = yield* service(ChangeTracker);
-          const effectModuleIdentifierName = match2(
+          const effectModuleIdentifierName = match(
             yield* option(
               findImportedModuleIdentifier(
                 sourceFile,
@@ -4253,7 +4432,7 @@ var effectGenToFn = createRefactor({
         }
         const maybePipe = yield* pipe(
           typeParser.pipeCall(parent),
-          orElse3((e) => parent.parent ? typeParser.pipeCall(parent.parent) : fail(e)),
+          orElse2((e) => parent.parent ? typeParser.pipeCall(parent.parent) : fail(e)),
           option
         );
         if (isSome2(maybePipe) && maybePipe.value.subject === nodeToReplace2) {
@@ -4277,7 +4456,7 @@ var effectGenToFn = createRefactor({
       kind: "refactor.rewrite.effect.effectGenToFn",
       description: "Convert to Effect.fn",
       apply: pipe(
-        gen2(function* () {
+        gen(function* () {
           const changeTracker = yield* service(ChangeTracker);
           const effectFn = nodeToReplace.name && ts.isIdentifier(nodeToReplace.name) ? ts.factory.createCallExpression(
             ts.factory.createPropertyAccessExpression(
@@ -4334,7 +4513,7 @@ var functionToArrow = createRefactor({
       kind: "refactor.rewrite.effect.functionToArrow",
       description: "Convert to arrow",
       apply: pipe(
-        gen2(function* () {
+        gen(function* () {
           const changeTracker = yield* service(ChangeTracker);
           const body = node.body;
           let newBody = ts.factory.createBlock(body.statements);
@@ -4497,9 +4676,9 @@ var makeSchemaOpaque = createRefactor({
       kind: "refactor.rewrite.effect.makeSchemaOpaque",
       description: `Make Schema opaque`,
       apply: pipe(
-        gen2(function* () {
+        gen(function* () {
           const changeTracker = yield* service(ChangeTracker);
-          const effectSchemaName = match2(
+          const effectSchemaName = match(
             yield* option(
               findImportedModuleIdentifierByPackageAndNameOrBarrel(
                 sourceFile,
@@ -4575,9 +4754,9 @@ var makeSchemaOpaqueWithNs = createRefactor({
       kind: "refactor.rewrite.effect.makeSchemaOpaqueWithNs",
       description: `Make Schema opaque with namespace`,
       apply: pipe(
-        gen2(function* () {
+        gen(function* () {
           const changeTracker = yield* service(ChangeTracker);
-          const effectSchemaName = match2(
+          const effectSchemaName = match(
             yield* option(
               findImportedModuleIdentifierByPackageAndNameOrBarrel(
                 sourceFile,
@@ -4731,7 +4910,7 @@ var pipeableToDatafirst = createRefactor({
     return {
       kind: "refactor.rewrite.effect.pipeableToDatafirst",
       description: "Rewrite to datafirst",
-      apply: gen2(function* () {
+      apply: gen(function* () {
         const changeTracker = yield* service(ChangeTracker);
         changeTracker.replaceNode(sourceFile, node, newNode);
       })
@@ -4752,7 +4931,7 @@ var removeUnnecessaryEffectGen = createRefactor({
       return {
         kind: "refactor.rewrite.effect.removeUnnecessaryEffectGen",
         description: "Remove unnecessary Effect.gen",
-        apply: gen2(function* () {
+        apply: gen(function* () {
           const changeTracker = yield* service(ChangeTracker);
           changeTracker.replaceNode(sourceFile, nodeToReplace, yield* replacementNode);
         })
@@ -4782,7 +4961,7 @@ var toggleLazyConst = createRefactor({
     return {
       kind: "refactor.rewrite.effect.toggleLazyConst",
       description: "Toggle lazy const",
-      apply: gen2(function* () {
+      apply: gen(function* () {
         const changeTracker = yield* service(ChangeTracker);
         const initializer = node.initializer;
         if (ts.isArrowFunction(initializer) && initializer.parameters.length === 0) {
@@ -4872,7 +5051,7 @@ var toggleTypeAnnotation = createRefactor({
       kind: "refactor.rewrite.effect.toggleTypeAnnotation",
       description: "Toggle type annotation",
       apply: pipe(
-        gen2(function* () {
+        gen(function* () {
           const changeTracker = yield* service(ChangeTracker);
           if (node.type) {
             changeTracker.deleteRange(sourceFile, { pos: node.name.end, end: node.type.end });
@@ -4880,19 +5059,19 @@ var toggleTypeAnnotation = createRefactor({
           }
           const initializer = node.initializer;
           const initializerType = typeChecker.getTypeAtLocation(initializer);
-          const initializerTypeNode = fromNullable2(typeChecker.typeToTypeNode(
+          const initializerTypeNode = fromNullable(typeChecker.typeToTypeNode(
             initializerType,
             node,
             ts.NodeBuilderFlags.NoTruncation
           )).pipe(
-            orElse2(
-              () => fromNullable2(typeChecker.typeToTypeNode(
+            orElse(
+              () => fromNullable(typeChecker.typeToTypeNode(
                 initializerType,
                 void 0,
                 ts.NodeBuilderFlags.NoTruncation
               ))
             ),
-            getOrUndefined2
+            getOrUndefined
           );
           if (initializerTypeNode) {
             changeTracker.insertNodeAt(
@@ -4954,7 +5133,7 @@ var makeSchemaGenContext = fn("SchemaGen.makeSchemaGenContext")(function* (sourc
     yield* option(
       findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, "effect", "Schema")
     ),
-    match2({
+    match({
       onNone: () => "Schema",
       onSome: (_) => _.text
     })
@@ -5037,7 +5216,7 @@ var parseAllLiterals = fn(
       }
     }
     if (ts.isUnionTypeNode(node)) {
-      return flatten(yield* all2(...node.types.map((_) => parseAllLiterals(_))));
+      return flatten(yield* all(...node.types.map((_) => parseAllLiterals(_))));
     }
     if (ts.isParenthesizedTypeNode(node)) {
       return yield* parseAllLiterals(node.type);
@@ -5050,7 +5229,7 @@ var createUnsupportedNodeComment = (ts, sourceFile, node) => ts.addSyntheticTrai
   ts.SyntaxKind.MultiLineCommentTrivia,
   " Not supported conversion: " + node.getText(sourceFile) + " "
 );
-var processNode = (node, isVirtualTypeNode) => gen2(function* () {
+var processNode = (node, isVirtualTypeNode) => gen(function* () {
   const { createApiCall, createApiPropertyAccess, entityNameToDataTypeName, sourceFile, ts } = yield* service(
     SchemaGenContext
   );
@@ -5084,11 +5263,11 @@ var processNode = (node, isVirtualTypeNode) => gen2(function* () {
   if (ts.isUnionTypeNode(node)) {
     const allLiterals = yield* option(parseAllLiterals(node));
     if (isSome2(allLiterals)) return createApiCall("Literal", allLiterals.value);
-    const members = yield* all2(...node.types.map((_) => processNode(_, isVirtualTypeNode)));
+    const members = yield* all(...node.types.map((_) => processNode(_, isVirtualTypeNode)));
     return createApiCall("Union", members);
   }
   if (ts.isIntersectionTypeNode(node)) {
-    const [firstSchema, ...otherSchemas] = yield* all2(
+    const [firstSchema, ...otherSchemas] = yield* all(
       ...node.types.map((_) => processNode(_, isVirtualTypeNode))
     );
     if (otherSchemas.length === 0) return firstSchema;
@@ -5144,13 +5323,13 @@ var processNode = (node, isVirtualTypeNode) => gen2(function* () {
         case "Option":
         case "Chunk":
         case "Array": {
-          const elements = yield* all2(
+          const elements = yield* all(
             ...node.typeArguments ? node.typeArguments.map((_) => processNode(_, isVirtualTypeNode)) : []
           );
           return createApiCall(parsedName.value, elements);
         }
         case "Record": {
-          const elements = yield* all2(
+          const elements = yield* all(
             ...node.typeArguments ? node.typeArguments.map((_) => processNode(_, isVirtualTypeNode)) : []
           );
           if (elements.length >= 2) {
@@ -5164,7 +5343,7 @@ var processNode = (node, isVirtualTypeNode) => gen2(function* () {
           return createUnsupportedNodeComment(ts, sourceFile, node);
         }
         case "Either": {
-          const elements = yield* all2(
+          const elements = yield* all(
             ...node.typeArguments ? node.typeArguments.map((_) => processNode(_, isVirtualTypeNode)) : []
           );
           if (elements.length >= 2) {
@@ -5363,7 +5542,7 @@ var applyAtNode = fn("SchemaGen.applyAtNode")(
     const changeTracker = yield* service(ChangeTracker);
     const newNode = yield* pipe(
       process(sourceFile, node, preferClass),
-      orElse3(
+      orElse2(
         (error) => succeed(ts.addSyntheticLeadingComment(
           ts.factory.createIdentifier(""),
           ts.SyntaxKind.MultiLineCommentTrivia,
@@ -5447,7 +5626,7 @@ var wrapWithEffectGen = createRefactor({
       option
     );
     if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
-    const effectModuleIdentifier = match2(
+    const effectModuleIdentifier = match(
       yield* option(
         findImportedModuleIdentifier(
           sourceFile,
@@ -5467,7 +5646,7 @@ var wrapWithEffectGen = createRefactor({
       kind: "refactor.rewrite.effect.wrapWithEffectGen",
       description: `Wrap with Effect.gen`,
       apply: pipe(
-        gen2(function* () {
+        gen(function* () {
           const changeTracker = yield* service(ChangeTracker);
           const effectGen = yield* pipe(
             createEffectGenCallExpressionWithBlock(
@@ -5495,7 +5674,7 @@ var wrapWithPipe = createRefactor({
     return {
       kind: "refactor.rewrite.effect.wrapWithPipe",
       description: `Wrap with pipe(...)`,
-      apply: gen2(function* () {
+      apply: gen(function* () {
         const changeTracker = yield* service(ChangeTracker);
         changeTracker.insertText(sourceFile, textRange.pos, "pipe(");
         changeTracker.insertText(sourceFile, textRange.end, ")");
@@ -5578,11 +5757,11 @@ var init = (modules) => {
           return pipe(
             getSemanticDiagnosticsWithCodeFixes(diagnostics, sourceFile),
             runNano(program),
-            Either_exports.map(({ codeFixes, diagnostics: diagnostics2 }) => {
+            map(({ codeFixes, diagnostics: diagnostics2 }) => {
               effectCodeFixesForFile.set(fileName, codeFixes);
               return diagnostics2.concat(applicableDiagnostics);
             }),
-            Either_exports.getOrElse(() => applicableDiagnostics)
+            getOrElse(() => applicableDiagnostics)
           );
         }
       }
@@ -5633,8 +5812,8 @@ var init = (modules) => {
           return effectCodeFixes;
         }),
         run,
-        Either_exports.map((effectCodeFixes) => applicableCodeFixes.concat(effectCodeFixes)),
-        Either_exports.getOrElse(() => applicableCodeFixes)
+        map((effectCodeFixes) => applicableCodeFixes.concat(effectCodeFixes)),
+        getOrElse(() => applicableCodeFixes)
       );
     };
     proxy.getApplicableRefactors = (...args) => {
@@ -5647,8 +5826,8 @@ var init = (modules) => {
           return pipe(
             getApplicableRefactors(refactors, sourceFile, positionOrRange),
             runNano(program),
-            Either_exports.map((effectRefactors) => applicableRefactors.concat(effectRefactors)),
-            Either_exports.getOrElse(() => applicableRefactors)
+            map((effectRefactors) => applicableRefactors.concat(effectRefactors)),
+            getOrElse(() => applicableRefactors)
           );
         }
       }
@@ -5660,7 +5839,7 @@ var init = (modules) => {
         const sourceFile = program.getSourceFile(fileName);
         if (sourceFile) {
           const result = pipe(
-            gen2(function* () {
+            gen(function* () {
               const applicableRefactor = yield* getEditsForRefactor(
                 refactors,
                 sourceFile,
@@ -5687,7 +5866,7 @@ var init = (modules) => {
             }),
             runNano(program)
           );
-          if (Either_exports.isRight(result)) return result.right;
+          if (isRight2(result)) return result.right;
         }
       }
       return languageService.getEditsForRefactor(
@@ -5714,7 +5893,7 @@ var init = (modules) => {
                 applicableQuickInfo
               ),
               runNano(program),
-              Either_exports.getOrElse(() => applicableQuickInfo)
+              getOrElse(() => applicableQuickInfo)
             );
           }
         }
@@ -5735,32 +5914,70 @@ var init = (modules) => {
           const sourceFile = program.getSourceFile(fileName);
           if (sourceFile) {
             return pipe(
-              getCompletionsAtPosition(
-                completions,
-                sourceFile,
-                position,
-                options,
-                formattingSettings
+              appendEffectCompletionEntryData(sourceFile, applicableCompletions),
+              flatMap2(
+                (augmentedCompletions) => pipe(
+                  getCompletionsAtPosition(
+                    completions,
+                    sourceFile,
+                    position,
+                    options,
+                    formattingSettings
+                  ),
+                  map4(
+                    (effectCompletions) => augmentedCompletions ? {
+                      ...augmentedCompletions,
+                      entries: effectCompletions.concat(augmentedCompletions.entries)
+                    } : effectCompletions.length > 0 ? {
+                      entries: effectCompletions,
+                      isGlobalCompletion: false,
+                      isMemberCompletion: false,
+                      isNewIdentifierLocation: false
+                    } : void 0
+                  )
+                )
               ),
               runNano(program),
-              Either_exports.map(
-                (effectCompletions) => applicableCompletions ? {
-                  ...applicableCompletions,
-                  entries: effectCompletions.concat(applicableCompletions.entries)
-                } : effectCompletions.length > 0 ? {
-                  entries: effectCompletions,
-                  isGlobalCompletion: false,
-                  isMemberCompletion: false,
-                  isNewIdentifierLocation: false
-                } : void 0
-              ),
-              Either_exports.getOrElse(() => applicableCompletions)
+              getOrElse(() => applicableCompletions)
             );
           }
         }
       }
       return applicableCompletions;
     };
+    proxy.getCompletionEntryDetails = (fileName, position, entryName, formatOptions, source, preferences, _data, ...args) => {
+      const applicableCompletionEntryDetails = languageService.getCompletionEntryDetails(
+        fileName,
+        position,
+        entryName,
+        formatOptions,
+        source,
+        preferences,
+        _data,
+        ...args
+      );
+      if (languageServicePluginOptions.completions) {
+        const program = languageService.getProgram();
+        if (program) {
+          const sourceFile = program.getSourceFile(fileName);
+          if (sourceFile) {
+            return pipe(
+              postprocessCompletionEntryDetails(
+                sourceFile,
+                _data,
+                applicableCompletionEntryDetails,
+                formatOptions,
+                preferences,
+                info.languageServiceHost
+              ),
+              runNano(program),
+              getOrElse(() => applicableCompletionEntryDetails)
+            );
+          }
+        }
+      }
+      return applicableCompletionEntryDetails;
+    };
     proxy.getDefinitionAndBoundSpan = (fileName, position, ...args) => {
       const applicableDefinition = languageService.getDefinitionAndBoundSpan(fileName, position, ...args);
       if (languageServicePluginOptions.goto) {
@@ -5771,7 +5988,7 @@ var init = (modules) => {
             return pipe(
               goto(applicableDefinition, sourceFile, position),
               runNano(program),
-              Either_exports.getOrElse(() => applicableDefinition)
+              getOrElse(() => applicableDefinition)
             );
           }
         }