@effect/language-service 0.7.1 → 0.8.0

package/index.js

@@ -1,4 +1,9 @@
 "use strict";
+var __defProp = Object.defineProperty;
+var __export = (target, all2) => {
+  for (var name in all2)
+    __defProp(target, name, { get: all2[name], enumerable: true });
+};
 
 // node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Function.js
 var isFunction = (input) => typeof input === "function";
@@ -65,6 +70,9 @@ var dual = function(arity, body) {
 };
 var identity = (a) => a;
 var constant = (value) => () => value;
+var constTrue = /* @__PURE__ */ constant(true);
+var constFalse = /* @__PURE__ */ constant(false);
+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) {
@@ -96,6 +104,73 @@ 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
+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,
+  try: () => try_,
+  zipWith: () => zipWith
+});
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Equivalence.js
+var make = (isEquivalent) => (self, that) => self === that || isEquivalent(self, that);
+var array = (item) => make((self, that) => {
+  if (self.length !== that.length) {
+    return false;
+  }
+  for (let i = 0; i < self.length; i++) {
+    const isEq = item(self[i], that[i]);
+    if (!isEq) {
+      return false;
+    }
+  }
+  return true;
+});
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/doNotation.js
+var let_ = (map8) => dual(3, (self, name, f) => map8(self, (a) => Object.assign({}, a, {
+  [name]: f(a)
+})));
+var bindTo = (map8) => dual(2, (self, name) => map8(self, (a) => ({
+  [name]: a
+})));
+var bind = (map8, flatMap5) => dual(3, (self, name, f) => flatMap5(self, (a) => map8(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";
 var getCurrentVersion = () => moduleVersion;
@@ -115,11 +190,11 @@ var globalValue = (id, compute) => {
 };
 
 // node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Predicate.js
-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);
+var isTagged = /* @__PURE__ */ dual(2, (self, tag) => hasProperty(self, "_tag") && self["_tag"] === tag);
 
 // node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/errors.js
 var getBugErrorMessage = (message) => `BUG: ${message} - please report an issue at https://github.com/Effect-TS/effect/issues`;
@@ -310,14 +385,21 @@ var string = (str) => {
   }
   return optimize(h);
 };
-var structureKeys = (o, keys) => {
+var structureKeys = (o, keys2) => {
   let h = 12289;
-  for (let i = 0; i < keys.length; i++) {
-    h ^= pipe(string(keys[i]), combine(hash(o[keys[i]])));
+  for (let i = 0; i < keys2.length; i++) {
+    h ^= pipe(string(keys2[i]), combine(hash(o[keys2[i]])));
   }
   return optimize(h);
 };
 var structure = (o) => structureKeys(o, Object.keys(o));
+var array2 = (arr) => {
+  let h = 6151;
+  for (let i = 0; i < arr.length; i++) {
+    h = pipe(h, combine(hash(arr[i])));
+  }
+  return optimize(h);
+};
 var cached = function() {
   if (arguments.length === 1) {
     const self2 = arguments[0];
@@ -393,21 +475,6 @@ function compareBoth(self, that) {
 }
 var isEqual = (u) => hasProperty(u, symbol2);
 
-// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Equivalence.js
-var make = (isEquivalent) => (self, that) => self === that || isEquivalent(self, that);
-var array = (item) => make((self, that) => {
-  if (self.length !== that.length) {
-    return false;
-  }
-  for (let i = 0; i < self.length; i++) {
-    const isEq = item(self[i], that[i]);
-    if (!isEq) {
-      return false;
-    }
-  }
-  return true;
-});
-
 // node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Inspectable.js
 var NodeInspectSymbol = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
 var toJSON = (x) => {
@@ -448,6 +515,12 @@ var Class = class {
     return format(this.toJSON());
   }
 };
+var stringifyCircular = (obj, whitespace) => {
+  let cache = [];
+  const retVal = JSON.stringify(obj, (_key, value) => typeof value === "object" && value !== null ? cache.includes(value) ? void 0 : cache.push(value) && (redactableState.fiberRefs !== void 0 && isRedactable(value) ? value[symbolRedactable](redactableState.fiberRefs) : value) : value, whitespace);
+  cache = void 0;
+  return retVal;
+};
 var symbolRedactable = /* @__PURE__ */ Symbol.for("effect/Inspectable/Redactable");
 var isRedactable = (u) => typeof u === "object" && u !== null && symbolRedactable in u;
 var redactableState = /* @__PURE__ */ globalValue("effect/Inspectable/redactableState", () => ({
@@ -495,6 +568,8 @@ var pipeArguments = (self, args) => {
 
 // node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/opCodes/effect.js
 var OP_COMMIT = "Commit";
+var OP_FAILURE = "Failure";
+var OP_WITH_RUNTIME = "WithRuntime";
 
 // node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/effectable.js
 var EffectTypeId = /* @__PURE__ */ Symbol.for("effect/Effect");
@@ -641,53 +716,164 @@ var some = (value) => {
   return a;
 };
 
-// node_modules/.pnpm/effect@3.12.5/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/internal/either.js
+var TypeId2 = /* @__PURE__ */ Symbol.for("effect/Either");
+var CommonProto2 = {
+  ...EffectPrototype,
+  [TypeId2]: {
+    _R: (_) => _
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  },
+  toString() {
+    return format(this.toJSON());
+  }
+};
+var RightProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(CommonProto2), {
+  _tag: "Right",
+  _op: "Right",
+  [symbol2](that) {
+    return isEither(that) && isRight(that) && equals(this.right, that.right);
+  },
+  [symbol]() {
+    return combine(hash(this._tag))(hash(this.right));
+  },
+  toJSON() {
+    return {
+      _id: "Either",
+      _tag: this._tag,
+      right: toJSON(this.right)
+    };
+  }
+});
+var LeftProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(CommonProto2), {
+  _tag: "Left",
+  _op: "Left",
+  [symbol2](that) {
+    return isEither(that) && isLeft(that) && equals(this.left, that.left);
+  },
+  [symbol]() {
+    return combine(hash(this._tag))(hash(this.left));
+  },
+  toJSON() {
+    return {
+      _id: "Either",
+      _tag: this._tag,
+      left: toJSON(this.left)
+    };
+  }
+});
+var isEither = (input) => hasProperty(input, TypeId2);
+var isLeft = (ma) => ma._tag === "Left";
+var isRight = (ma) => ma._tag === "Right";
+var left = (left3) => {
+  const a = Object.create(LeftProto);
+  a.left = left3;
+  return a;
+};
+var right = (right3) => {
+  const a = Object.create(RightProto);
+  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.12.5/node_modules/effect/dist/esm/Option.js
-var none2 = () => none;
-var some2 = some;
-var isNone2 = isNone;
-var isSome2 = isSome;
-var getOrElse = /* @__PURE__ */ dual(2, (self, onNone) => isNone2(self) ? onNone() : self.value);
-var orElse = /* @__PURE__ */ dual(2, (self, that) => isNone2(self) ? that() : self);
-var fromNullable = (nullableValue) => nullableValue == null ? none2() : some2(nullableValue);
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Either.js
+var TypeId3 = TypeId2;
+var right2 = right;
+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 map = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : some2(f(self.value)));
-var flatMap = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : f(self.value));
+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 o of input) {
-      if (isNone2(o)) {
-        return none2();
+    for (const e of input) {
+      if (isLeft2(e)) {
+        return e;
       }
-      out2.push(o.value);
+      out2.push(e.right);
     }
-    return some2(out2);
+    return right2(out2);
   }
   const out = {};
   for (const key of Object.keys(input)) {
-    const o = input[key];
-    if (isNone2(o)) {
-      return none2();
+    const e = input[key];
+    if (isLeft2(e)) {
+      return e;
     }
-    out[key] = o.value;
+    out[key] = e.right;
   }
-  return some2(out);
+  return right2(out);
 };
+var flip = (self) => isLeft2(self) ? right2(self.left) : left2(self.right);
 var adapter2 = /* @__PURE__ */ adapter();
 var gen = (...args) => {
-  let f;
-  if (args.length === 1) {
-    f = args[0];
-  } else {
-    f = args[1].bind(args[0]);
-  }
+  const f = args.length === 1 ? args[0] : args[1].bind(args[0]);
   const iterator = f(adapter2);
   let state = iterator.next();
   if (state.done) {
-    return some2(state.value);
+    return right2(state.value);
   } else {
     let current = state.value;
     if (isGenKind(current)) {
@@ -695,11 +881,11 @@ var gen = (...args) => {
     } else {
       current = yieldWrapGet(current);
     }
-    if (isNone2(current)) {
+    if (isLeft2(current)) {
       return current;
     }
     while (!state.done) {
-      state = iterator.next(current.value);
+      state = iterator.next(current.right);
       if (!state.done) {
         current = state.value;
         if (isGenKind(current)) {
@@ -707,230 +893,42 @@ var gen = (...args) => {
         } else {
           current = yieldWrapGet(current);
         }
-        if (isNone2(current)) {
+        if (isLeft2(current)) {
           return current;
         }
       }
     }
-    return some2(state.value);
+    return right2(state.value);
   }
 };
-
-// src/definition.ts
-function createRefactor(definition) {
-  return definition;
-}
-function createDiagnostic(definition) {
-  return definition;
-}
-
-// src/utils/TypeParser.ts
-var covariantTypeArgument = (type) => {
-  const signatures = type.getCallSignatures();
-  if (signatures.length !== 1) return none2();
-  return some2(signatures[0].getReturnType());
-};
-function pipeableType(ts, typeChecker) {
-  return (type, atLocation) => {
-    const pipeSymbol = typeChecker.getPropertyOfType(type, "pipe");
-    if (!pipeSymbol) return none2();
-    const pipeType = typeChecker.getTypeOfSymbolAtLocation(pipeSymbol, atLocation);
-    const signatures = pipeType.getCallSignatures();
-    if (signatures.length === 0) return none2();
-    return some2(type);
-  };
-}
-function varianceStructCovariantType(ts, typeChecker) {
-  return (type, atLocation, propertyName) => gen(function* (_) {
-    const propertySymbol = yield* fromNullable(
-      typeChecker.getPropertyOfType(type, propertyName)
-    );
-    const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
-    return yield* covariantTypeArgument(propertyType);
-  });
-}
-function effectVarianceStruct(ts, typeChecker) {
-  return (type, atLocation) => all({
-    A: varianceStructCovariantType(ts, typeChecker)(type, atLocation, "_A"),
-    E: varianceStructCovariantType(ts, typeChecker)(type, atLocation, "_E"),
-    R: varianceStructCovariantType(ts, typeChecker)(type, atLocation, "_R")
-  });
-}
-function effectType(ts, typeChecker) {
-  return (type, atLocation) => gen(function* (_) {
-    yield* pipeableType(ts, typeChecker)(type, atLocation);
-    for (const propertySymbol of typeChecker.getPropertiesOfType(type)) {
-      const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
-      const varianceArgs = effectVarianceStruct(ts, typeChecker)(
-        propertyType,
-        atLocation
-      );
-      if (isSome2(varianceArgs)) {
-        return yield* varianceArgs;
-      }
-    }
-    return yield* none2();
-  });
-}
-function fiberType(ts, typeChecker) {
-  return (type, atLocation) => gen(function* (_) {
-    const awaitSymbol = yield* fromNullable(
-      typeChecker.getPropertyOfType(type, "await")
-    );
-    const pollSymbol = yield* fromNullable(
-      typeChecker.getPropertyOfType(type, "poll")
-    );
-    if (!awaitSymbol || !pollSymbol) return yield* none2();
-    return effectType(ts, typeChecker)(type, atLocation);
-  });
-}
-function effectSubtype(ts, typeChecker) {
-  return (type, atLocation) => gen(function* (_) {
-    const tagSymbol = yield* fromNullable(
-      typeChecker.getPropertyOfType(type, "_tag")
-    );
-    if (!tagSymbol) return yield* none2();
-    return effectType(ts, typeChecker)(type, atLocation);
-  });
-}
-function importedEffectModule(ts, typeChecker) {
-  return (node) => gen(function* () {
-    const type = typeChecker.getTypeAtLocation(node);
-    const propertySymbol = yield* fromNullable(
-      typeChecker.getPropertyOfType(type, "never")
-    );
-    const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, node);
-    return yield* effectType(ts, typeChecker)(propertyType, node).pipe(
-      map(() => node)
-    );
-  });
-}
-function effectGen(ts, typeChecker) {
-  return (node) => gen(function* () {
-    if (!ts.isCallExpression(node)) return yield* none2();
-    if (node.arguments.length === 0) return yield* none2();
-    const generatorFunction = node.arguments[0];
-    if (!ts.isFunctionExpression(generatorFunction)) return yield* none2();
-    if (generatorFunction.asteriskToken === void 0) return yield* none2();
-    if (!ts.isPropertyAccessExpression(node.expression)) return yield* none2();
-    const propertyAccess = node.expression;
-    if (propertyAccess.name.text !== "gen") return yield* none2();
-    const effectModule = yield* importedEffectModule(ts, typeChecker)(propertyAccess.expression);
-    return {
-      node,
-      effectModule,
-      generatorFunction,
-      body: generatorFunction.body,
-      functionStar: generatorFunction.getFirstToken()
-    };
-  });
-}
-function effectFnUntracedGen(ts, typeChecker) {
-  return (node) => gen(function* () {
-    if (!ts.isCallExpression(node)) return yield* none2();
-    if (node.arguments.length === 0) return yield* none2();
-    const generatorFunction = node.arguments[0];
-    if (!ts.isFunctionExpression(generatorFunction)) return yield* none2();
-    if (generatorFunction.asteriskToken === void 0) return yield* none2();
-    if (!ts.isPropertyAccessExpression(node.expression)) return yield* none2();
-    const propertyAccess = node.expression;
-    if (propertyAccess.name.text !== "fnUntraced") return yield* none2();
-    const effectModule = yield* importedEffectModule(ts, typeChecker)(propertyAccess.expression);
-    return {
-      node,
-      effectModule,
-      generatorFunction,
-      body: generatorFunction.body,
-      functionStar: generatorFunction.getFirstToken()
-    };
-  });
-}
-function effectFnGen(ts, typeChecker) {
-  return (node) => gen(function* () {
-    if (!ts.isCallExpression(node)) return yield* none2();
-    if (node.arguments.length === 0) return yield* none2();
-    const generatorFunction = node.arguments[0];
-    if (!ts.isFunctionExpression(generatorFunction)) return yield* none2();
-    if (generatorFunction.asteriskToken === void 0) return yield* none2();
-    const expressionToTest = ts.isCallExpression(node.expression) ? node.expression.expression : node.expression;
-    if (!ts.isPropertyAccessExpression(expressionToTest)) return yield* none2();
-    const propertyAccess = expressionToTest;
-    if (propertyAccess.name.text !== "fn") return yield* none2();
-    const effectModule = yield* importedEffectModule(ts, typeChecker)(propertyAccess.expression);
-    return {
-      node,
-      generatorFunction,
-      effectModule,
-      body: generatorFunction.body,
-      functionStar: generatorFunction.getFirstToken()
-    };
-  });
-}
-
-// src/diagnostics/floatingEffect.ts
-var floatingEffect = createDiagnostic({
-  code: 3,
-  apply: (ts, program) => (sourceFile) => {
-    const typeChecker = program.getTypeChecker();
-    const effectDiagnostics = [];
-    function isFloatingExpression(node) {
-      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;
-      return true;
-    }
-    const visit = (node) => {
-      if (isFloatingExpression(node)) {
-        const type = typeChecker.getTypeAtLocation(node.expression);
-        const effect = effectType(ts, typeChecker)(type, node.expression);
-        if (isSome2(effect)) {
-          const allowedFloatingEffects = pipe(
-            fiberType(ts, typeChecker)(type, node.expression),
-            orElse(() => effectSubtype(ts, typeChecker)(type, node.expression))
-          );
-          if (isNone2(allowedFloatingEffects)) {
-            effectDiagnostics.push({
-              node,
-              category: ts.DiagnosticCategory.Error,
-              messageText: `Effect must be yielded or assigned to a variable.`
-            });
-          }
-        }
-      }
-      ts.forEachChild(node, visit);
-    };
-    ts.forEachChild(sourceFile, visit);
-    return effectDiagnostics;
-  }
-});
+var Do = /* @__PURE__ */ right2({});
+var bind2 = /* @__PURE__ */ bind(map, flatMap);
+var bindTo2 = /* @__PURE__ */ bindTo(map);
+var let_2 = /* @__PURE__ */ let_(map);
 
 // node_modules/.pnpm/effect@3.12.5/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/Iterable.js
-var findFirst = /* @__PURE__ */ dual(2, (self, f) => {
-  let i = 0;
-  for (const a of self) {
-    const o = f(a, i);
-    if (isBoolean(o)) {
-      if (o) {
-        return some2(a);
-      }
-    } else {
-      if (isSome2(o)) {
-        return o;
-      }
-    }
-    i++;
-  }
-  return none2();
-});
+// node_modules/.pnpm/effect@3.12.5/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
+var none2 = () => none;
+var some2 = some;
+var isNone2 = isNone;
+var isSome2 = isSome;
+var match2 = /* @__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);
 
 // node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Array.js
 var fromIterable = (collection) => Array.isArray(collection) ? collection : Array.from(collection);
 var append = /* @__PURE__ */ dual(2, (self, last) => [...self, last]);
-var appendAll = /* @__PURE__ */ dual(2, (self, that) => fromIterable(self).concat(fromIterable(that)));
 var isArray = Array.isArray;
 var isNonEmptyReadonlyArray = isNonEmptyArray;
 var isOutOfBound = (i, as) => i < 0 || i >= as.length;
@@ -948,7 +946,7 @@ var unsafeGet = /* @__PURE__ */ dual(2, (self, index) => {
 var head = /* @__PURE__ */ get(0);
 var headNonEmpty = /* @__PURE__ */ unsafeGet(0);
 var tailNonEmpty = (self) => self.slice(1);
-var findFirst2 = findFirst;
+var reverse = (self) => Array.from(self).reverse();
 var sort = /* @__PURE__ */ dual(2, (self, O) => {
   const out = Array.from(self);
   out.sort(O);
@@ -966,6 +964,7 @@ var filter = /* @__PURE__ */ dual(2, (self, predicate) => {
   }
   return out;
 });
+var reduce = /* @__PURE__ */ dual(3, (self, b, f) => fromIterable(self).reduce((b2, a, i) => f(b2, a, i), b));
 var dedupeWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => {
   const input = fromIterable(self);
   if (isNonEmptyReadonlyArray(input)) {
@@ -981,241 +980,1855 @@ var dedupeWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => {
   return [];
 });
 
-// src/utils/AST.ts
-function collectSelfAndAncestorNodesInRange(node, textRange) {
-  let result = empty();
-  let parent = node;
-  while (parent) {
-    if (parent.end >= textRange.end) {
-      result = pipe(result, append(parent));
-    }
-    parent = parent.parent;
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Chunk.js
+var TypeId4 = /* @__PURE__ */ Symbol.for("effect/Chunk");
+function copy(src, srcPos, dest, destPos, len) {
+  for (let i = srcPos; i < Math.min(src.length, srcPos + len); i++) {
+    dest[destPos + i - srcPos] = src[i];
   }
-  return result;
-}
-function getAncestorNodesInRange(ts) {
-  return (sourceFile, textRange) => {
-    const precedingToken = ts.findPrecedingToken(textRange.pos, sourceFile);
-    if (!precedingToken) return empty();
-    return collectSelfAndAncestorNodesInRange(precedingToken, textRange);
-  };
+  return dest;
 }
-function findNodeAtPosition(ts, sourceFile, position) {
-  function find(node) {
-    if (position >= node.getStart() && position < node.getEnd()) {
-      return ts.forEachChild(node, find) || node;
+var emptyArray = [];
+var getEquivalence2 = (isEquivalent) => make((self, that) => self.length === that.length && toReadonlyArray(self).every((value, i) => isEquivalent(value, unsafeGet2(that, i))));
+var _equivalence = /* @__PURE__ */ getEquivalence2(equals);
+var ChunkProto = {
+  [TypeId4]: {
+    _A: (_) => _
+  },
+  toString() {
+    return format(this.toJSON());
+  },
+  toJSON() {
+    return {
+      _id: "Chunk",
+      values: toReadonlyArray(this).map(toJSON)
+    };
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  },
+  [symbol2](that) {
+    return isChunk(that) && _equivalence(this, that);
+  },
+  [symbol]() {
+    return cached(this, array2(toReadonlyArray(this)));
+  },
+  [Symbol.iterator]() {
+    switch (this.backing._tag) {
+      case "IArray": {
+        return this.backing.array[Symbol.iterator]();
+      }
+      case "IEmpty": {
+        return emptyArray[Symbol.iterator]();
+      }
+      default: {
+        return toReadonlyArray(this)[Symbol.iterator]();
+      }
     }
-    return void 0;
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
   }
-  return fromNullable(find(sourceFile));
-}
-function collectDescendantsAndAncestorsInRange(ts, sourceFile, textRange) {
-  const nodeAtPosition = findNodeAtPosition(ts, sourceFile, textRange.pos);
-  if (isNone2(nodeAtPosition)) return empty();
-  return collectSelfAndAncestorNodesInRange(nodeAtPosition.value, textRange);
-}
-function getSingleReturnEffectFromEffectGen(ts, typeChecker, node) {
-  const effectGenLike = effectGen(ts, typeChecker)(node);
-  if (isSome2(effectGenLike)) {
-    const body = effectGenLike.value.body;
-    if (body.statements.length === 1 && ts.isReturnStatement(body.statements[0]) && body.statements[0].expression && ts.isYieldExpression(body.statements[0].expression) && body.statements[0].expression.expression) {
-      const nodeToCheck = body.statements[0].expression.expression;
-      const type = typeChecker.getTypeAtLocation(nodeToCheck);
-      const maybeEffect = effectType(ts, typeChecker)(type, nodeToCheck);
-      if (isSome2(maybeEffect)) {
-        return some2(nodeToCheck);
-      }
+};
+var makeChunk = (backing) => {
+  const chunk = Object.create(ChunkProto);
+  chunk.backing = backing;
+  switch (backing._tag) {
+    case "IEmpty": {
+      chunk.length = 0;
+      chunk.depth = 0;
+      chunk.left = chunk;
+      chunk.right = chunk;
+      break;
+    }
+    case "IConcat": {
+      chunk.length = backing.left.length + backing.right.length;
+      chunk.depth = 1 + Math.max(backing.left.depth, backing.right.depth);
+      chunk.left = backing.left;
+      chunk.right = backing.right;
+      break;
+    }
+    case "IArray": {
+      chunk.length = backing.array.length;
+      chunk.depth = 0;
+      chunk.left = _empty;
+      chunk.right = _empty;
+      break;
+    }
+    case "ISingleton": {
+      chunk.length = 1;
+      chunk.depth = 0;
+      chunk.left = _empty;
+      chunk.right = _empty;
+      break;
+    }
+    case "ISlice": {
+      chunk.length = backing.length;
+      chunk.depth = backing.chunk.depth + 1;
+      chunk.left = _empty;
+      chunk.right = _empty;
+      break;
     }
   }
-  return none2();
-}
-function toTextRange(positionOrRange) {
-  return typeof positionOrRange === "number" ? { end: positionOrRange, pos: positionOrRange } : positionOrRange;
+  return chunk;
+};
+var isChunk = (u) => hasProperty(u, TypeId4);
+var _empty = /* @__PURE__ */ makeChunk({
+  _tag: "IEmpty"
+});
+var empty2 = () => _empty;
+var make3 = (...as) => as.length === 1 ? of(as[0]) : unsafeFromNonEmptyArray(as);
+var of = (a) => makeChunk({
+  _tag: "ISingleton",
+  a
+});
+var fromIterable2 = (self) => isChunk(self) ? self : makeChunk({
+  _tag: "IArray",
+  array: fromIterable(self)
+});
+var copyToArray = (self, array3, initial) => {
+  switch (self.backing._tag) {
+    case "IArray": {
+      copy(self.backing.array, 0, array3, initial, self.length);
+      break;
+    }
+    case "IConcat": {
+      copyToArray(self.left, array3, initial);
+      copyToArray(self.right, array3, initial + self.left.length);
+      break;
+    }
+    case "ISingleton": {
+      array3[initial] = self.backing.a;
+      break;
+    }
+    case "ISlice": {
+      let i = 0;
+      let j = initial;
+      while (i < self.length) {
+        array3[j] = unsafeGet2(self, i);
+        i += 1;
+        j += 1;
+      }
+      break;
+    }
+  }
+};
+var toReadonlyArray_ = (self) => {
+  switch (self.backing._tag) {
+    case "IEmpty": {
+      return emptyArray;
+    }
+    case "IArray": {
+      return self.backing.array;
+    }
+    default: {
+      const arr = new Array(self.length);
+      copyToArray(self, arr, 0);
+      self.backing = {
+        _tag: "IArray",
+        array: arr
+      };
+      self.left = _empty;
+      self.right = _empty;
+      self.depth = 0;
+      return arr;
+    }
+  }
+};
+var toReadonlyArray = toReadonlyArray_;
+var reverseChunk = (self) => {
+  switch (self.backing._tag) {
+    case "IEmpty":
+    case "ISingleton":
+      return self;
+    case "IArray": {
+      return makeChunk({
+        _tag: "IArray",
+        array: reverse(self.backing.array)
+      });
+    }
+    case "IConcat": {
+      return makeChunk({
+        _tag: "IConcat",
+        left: reverse2(self.backing.right),
+        right: reverse2(self.backing.left)
+      });
+    }
+    case "ISlice":
+      return unsafeFromArray(reverse(toReadonlyArray(self)));
+  }
+};
+var reverse2 = reverseChunk;
+var unsafeFromArray = (self) => makeChunk({
+  _tag: "IArray",
+  array: self
+});
+var unsafeFromNonEmptyArray = (self) => unsafeFromArray(self);
+var unsafeGet2 = /* @__PURE__ */ dual(2, (self, index) => {
+  switch (self.backing._tag) {
+    case "IEmpty": {
+      throw new Error(`Index out of bounds`);
+    }
+    case "ISingleton": {
+      if (index !== 0) {
+        throw new Error(`Index out of bounds`);
+      }
+      return self.backing.a;
+    }
+    case "IArray": {
+      if (index >= self.length || index < 0) {
+        throw new Error(`Index out of bounds`);
+      }
+      return self.backing.array[index];
+    }
+    case "IConcat": {
+      return index < self.left.length ? unsafeGet2(self.left, index) : unsafeGet2(self.right, index - self.left.length);
+    }
+    case "ISlice": {
+      return unsafeGet2(self.backing.chunk, index + self.backing.offset);
+    }
+  }
+});
+var prepend = /* @__PURE__ */ dual(2, (self, elem) => appendAll(of(elem), self));
+var appendAll = /* @__PURE__ */ dual(2, (self, that) => {
+  if (self.backing._tag === "IEmpty") {
+    return that;
+  }
+  if (that.backing._tag === "IEmpty") {
+    return self;
+  }
+  const diff = that.depth - self.depth;
+  if (Math.abs(diff) <= 1) {
+    return makeChunk({
+      _tag: "IConcat",
+      left: self,
+      right: that
+    });
+  } else if (diff < -1) {
+    if (self.left.depth >= self.right.depth) {
+      const nr = appendAll(self.right, that);
+      return makeChunk({
+        _tag: "IConcat",
+        left: self.left,
+        right: nr
+      });
+    } else {
+      const nrr = appendAll(self.right.right, that);
+      if (nrr.depth === self.depth - 3) {
+        const nr = makeChunk({
+          _tag: "IConcat",
+          left: self.right.left,
+          right: nrr
+        });
+        return makeChunk({
+          _tag: "IConcat",
+          left: self.left,
+          right: nr
+        });
+      } else {
+        const nl = makeChunk({
+          _tag: "IConcat",
+          left: self.left,
+          right: self.right.left
+        });
+        return makeChunk({
+          _tag: "IConcat",
+          left: nl,
+          right: nrr
+        });
+      }
+    }
+  } else {
+    if (that.right.depth >= that.left.depth) {
+      const nl = appendAll(self, that.left);
+      return makeChunk({
+        _tag: "IConcat",
+        left: nl,
+        right: that.right
+      });
+    } else {
+      const nll = appendAll(self, that.left.left);
+      if (nll.depth === that.depth - 3) {
+        const nl = makeChunk({
+          _tag: "IConcat",
+          left: nll,
+          right: that.left.right
+        });
+        return makeChunk({
+          _tag: "IConcat",
+          left: nl,
+          right: that.right
+        });
+      } else {
+        const nr = makeChunk({
+          _tag: "IConcat",
+          left: that.left.right,
+          right: that.right
+        });
+        return makeChunk({
+          _tag: "IConcat",
+          left: nll,
+          right: nr
+        });
+      }
+    }
+  }
+});
+var isEmpty = (self) => self.length === 0;
+var isNonEmpty = (self) => self.length > 0;
+var unsafeHead = (self) => unsafeGet2(self, 0);
+var headNonEmpty2 = unsafeHead;
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/hashMap/config.js
+var SIZE = 5;
+var BUCKET_SIZE = /* @__PURE__ */ Math.pow(2, SIZE);
+var MASK = BUCKET_SIZE - 1;
+var MAX_INDEX_NODE = BUCKET_SIZE / 2;
+var MIN_ARRAY_NODE = BUCKET_SIZE / 4;
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/hashMap/bitwise.js
+function popcount(x) {
+  x -= x >> 1 & 1431655765;
+  x = (x & 858993459) + (x >> 2 & 858993459);
+  x = x + (x >> 4) & 252645135;
+  x += x >> 8;
+  x += x >> 16;
+  return x & 127;
 }
-function isNodeInRange(textRange) {
-  return (node) => node.pos <= textRange.pos && node.end >= textRange.end;
+function hashFragment(shift, h) {
+  return h >>> shift & MASK;
 }
-function transformAsyncAwaitToEffectGen(ts) {
-  return (node, effectModuleName, onAwait) => {
-    function visitor(_) {
-      if (ts.isAwaitExpression(_)) {
-        const expression = ts.visitEachChild(_.expression, visitor, ts.nullTransformationContext);
-        return ts.factory.createYieldExpression(
-          ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
-          onAwait(expression)
-        );
+function toBitmap(x) {
+  return 1 << x;
+}
+function fromBitmap(bitmap, bit) {
+  return popcount(bitmap & bit - 1);
+}
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/stack.js
+var make4 = (value, previous) => ({
+  value,
+  previous
+});
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/hashMap/array.js
+function arrayUpdate(mutate2, at, v, arr) {
+  let out = arr;
+  if (!mutate2) {
+    const len = arr.length;
+    out = new Array(len);
+    for (let i = 0; i < len; ++i) out[i] = arr[i];
+  }
+  out[at] = v;
+  return out;
+}
+function arraySpliceOut(mutate2, at, arr) {
+  const newLen = arr.length - 1;
+  let i = 0;
+  let g = 0;
+  let out = arr;
+  if (mutate2) {
+    i = g = at;
+  } else {
+    out = new Array(newLen);
+    while (i < at) out[g++] = arr[i++];
+  }
+  ;
+  ++i;
+  while (i <= newLen) out[g++] = arr[i++];
+  if (mutate2) {
+    out.length = newLen;
+  }
+  return out;
+}
+function arraySpliceIn(mutate2, at, v, arr) {
+  const len = arr.length;
+  if (mutate2) {
+    let i2 = len;
+    while (i2 >= at) arr[i2--] = arr[i2];
+    arr[at] = v;
+    return arr;
+  }
+  let i = 0, g = 0;
+  const out = new Array(len + 1);
+  while (i < at) out[g++] = arr[i++];
+  out[at] = v;
+  while (i < len) out[++g] = arr[i++];
+  return out;
+}
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/hashMap/node.js
+var EmptyNode = class _EmptyNode {
+  _tag = "EmptyNode";
+  modify(edit, _shift, f, hash2, key, size4) {
+    const v = f(none2());
+    if (isNone2(v)) return new _EmptyNode();
+    ++size4.value;
+    return new LeafNode(edit, hash2, key, v);
+  }
+};
+function isEmptyNode(a) {
+  return isTagged(a, "EmptyNode");
+}
+function isLeafNode(node) {
+  return isEmptyNode(node) || node._tag === "LeafNode" || node._tag === "CollisionNode";
+}
+function canEditNode(node, edit) {
+  return isEmptyNode(node) ? false : edit === node.edit;
+}
+var LeafNode = class _LeafNode {
+  edit;
+  hash;
+  key;
+  value;
+  _tag = "LeafNode";
+  constructor(edit, hash2, key, value) {
+    this.edit = edit;
+    this.hash = hash2;
+    this.key = key;
+    this.value = value;
+  }
+  modify(edit, shift, f, hash2, key, size4) {
+    if (equals(key, this.key)) {
+      const v2 = f(this.value);
+      if (v2 === this.value) return this;
+      else if (isNone2(v2)) {
+        ;
+        --size4.value;
+        return new EmptyNode();
       }
-      return ts.visitEachChild(_, visitor, ts.nullTransformationContext);
+      if (canEditNode(this, edit)) {
+        this.value = v2;
+        return this;
+      }
+      return new _LeafNode(edit, hash2, key, v2);
     }
-    const generatorBody = visitor(node.body);
-    const generator = ts.factory.createFunctionExpression(
-      void 0,
-      ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
-      void 0,
-      [],
-      [],
-      void 0,
-      generatorBody
-      // NOTE(mattia): intended, to use same routine for both ConciseBody and Body
-    );
-    const effectGenCallExp = ts.factory.createCallExpression(
-      ts.factory.createPropertyAccessExpression(
-        ts.factory.createIdentifier(effectModuleName),
-        "gen"
-      ),
-      void 0,
-      [generator]
-    );
-    let currentFlags = ts.getCombinedModifierFlags(node);
-    currentFlags &= ~ts.ModifierFlags.Async;
-    const newModifiers = ts.factory.createModifiersFromModifierFlags(currentFlags);
-    if (ts.isArrowFunction(node)) {
-      return ts.factory.createArrowFunction(
-        newModifiers,
-        node.typeParameters,
-        node.parameters,
-        void 0,
-        node.equalsGreaterThanToken,
-        effectGenCallExp
-      );
+    const v = f(none2());
+    if (isNone2(v)) return this;
+    ++size4.value;
+    return mergeLeaves(edit, shift, this.hash, this, hash2, new _LeafNode(edit, hash2, key, v));
+  }
+};
+var CollisionNode = class _CollisionNode {
+  edit;
+  hash;
+  children;
+  _tag = "CollisionNode";
+  constructor(edit, hash2, children) {
+    this.edit = edit;
+    this.hash = hash2;
+    this.children = children;
+  }
+  modify(edit, shift, f, hash2, key, size4) {
+    if (hash2 === this.hash) {
+      const canEdit = canEditNode(this, edit);
+      const list = this.updateCollisionList(canEdit, edit, this.hash, this.children, f, key, size4);
+      if (list === this.children) return this;
+      return list.length > 1 ? new _CollisionNode(edit, this.hash, list) : list[0];
     }
-    const newBody = ts.factory.createBlock([
-      ts.factory.createReturnStatement(effectGenCallExp)
-    ]);
-    if (ts.isFunctionDeclaration(node)) {
-      return ts.factory.createFunctionDeclaration(
-        newModifiers,
-        node.asteriskToken,
-        node.name,
-        node.typeParameters,
-        node.parameters,
-        void 0,
-        newBody
-      );
+    const v = f(none2());
+    if (isNone2(v)) return this;
+    ++size4.value;
+    return mergeLeaves(edit, shift, this.hash, this, hash2, new LeafNode(edit, hash2, key, v));
+  }
+  updateCollisionList(mutate2, edit, hash2, list, f, key, size4) {
+    const len = list.length;
+    for (let i = 0; i < len; ++i) {
+      const child = list[i];
+      if ("key" in child && equals(key, child.key)) {
+        const value = child.value;
+        const newValue2 = f(value);
+        if (newValue2 === value) return list;
+        if (isNone2(newValue2)) {
+          ;
+          --size4.value;
+          return arraySpliceOut(mutate2, i, list);
+        }
+        return arrayUpdate(mutate2, i, new LeafNode(edit, hash2, key, newValue2), list);
+      }
     }
-    return ts.factory.createFunctionExpression(
-      newModifiers,
-      node.asteriskToken,
-      node.name,
-      node.typeParameters,
-      node.parameters,
-      void 0,
-      newBody
-    );
-  };
+    const newValue = f(none2());
+    if (isNone2(newValue)) return list;
+    ++size4.value;
+    return arrayUpdate(mutate2, len, new LeafNode(edit, hash2, key, newValue), list);
+  }
+};
+var IndexedNode = class _IndexedNode {
+  edit;
+  mask;
+  children;
+  _tag = "IndexedNode";
+  constructor(edit, mask, children) {
+    this.edit = edit;
+    this.mask = mask;
+    this.children = children;
+  }
+  modify(edit, shift, f, hash2, key, size4) {
+    const mask = this.mask;
+    const children = this.children;
+    const frag = hashFragment(shift, hash2);
+    const bit = toBitmap(frag);
+    const indx = fromBitmap(mask, bit);
+    const exists = mask & bit;
+    const canEdit = canEditNode(this, edit);
+    if (!exists) {
+      const _newChild = new EmptyNode().modify(edit, shift + SIZE, f, hash2, key, size4);
+      if (!_newChild) return this;
+      return children.length >= MAX_INDEX_NODE ? expand(edit, frag, _newChild, mask, children) : new _IndexedNode(edit, mask | bit, arraySpliceIn(canEdit, indx, _newChild, children));
+    }
+    const current = children[indx];
+    const child = current.modify(edit, shift + SIZE, f, hash2, key, size4);
+    if (current === child) return this;
+    let bitmap = mask;
+    let newChildren;
+    if (isEmptyNode(child)) {
+      bitmap &= ~bit;
+      if (!bitmap) return new EmptyNode();
+      if (children.length <= 2 && isLeafNode(children[indx ^ 1])) {
+        return children[indx ^ 1];
+      }
+      newChildren = arraySpliceOut(canEdit, indx, children);
+    } else {
+      newChildren = arrayUpdate(canEdit, indx, child, children);
+    }
+    if (canEdit) {
+      this.mask = bitmap;
+      this.children = newChildren;
+      return this;
+    }
+    return new _IndexedNode(edit, bitmap, newChildren);
+  }
+};
+var ArrayNode = class _ArrayNode {
+  edit;
+  size;
+  children;
+  _tag = "ArrayNode";
+  constructor(edit, size4, children) {
+    this.edit = edit;
+    this.size = size4;
+    this.children = children;
+  }
+  modify(edit, shift, f, hash2, key, size4) {
+    let count = this.size;
+    const children = this.children;
+    const frag = hashFragment(shift, hash2);
+    const child = children[frag];
+    const newChild = (child || new EmptyNode()).modify(edit, shift + SIZE, f, hash2, key, size4);
+    if (child === newChild) return this;
+    const canEdit = canEditNode(this, edit);
+    let newChildren;
+    if (isEmptyNode(child) && !isEmptyNode(newChild)) {
+      ;
+      ++count;
+      newChildren = arrayUpdate(canEdit, frag, newChild, children);
+    } else if (!isEmptyNode(child) && isEmptyNode(newChild)) {
+      ;
+      --count;
+      if (count <= MIN_ARRAY_NODE) {
+        return pack(edit, count, frag, children);
+      }
+      newChildren = arrayUpdate(canEdit, frag, new EmptyNode(), children);
+    } else {
+      newChildren = arrayUpdate(canEdit, frag, newChild, children);
+    }
+    if (canEdit) {
+      this.size = count;
+      this.children = newChildren;
+      return this;
+    }
+    return new _ArrayNode(edit, count, newChildren);
+  }
+};
+function pack(edit, count, removed, elements) {
+  const children = new Array(count - 1);
+  let g = 0;
+  let bitmap = 0;
+  for (let i = 0, len = elements.length; i < len; ++i) {
+    if (i !== removed) {
+      const elem = elements[i];
+      if (elem && !isEmptyNode(elem)) {
+        children[g++] = elem;
+        bitmap |= 1 << i;
+      }
+    }
+  }
+  return new IndexedNode(edit, bitmap, children);
 }
-function addReturnTypeAnnotation(ts, changes) {
-  return (sourceFile, declaration, typeNode) => {
-    const closeParen = ts.findChildOfKind(declaration, ts.SyntaxKind.CloseParenToken, sourceFile);
-    const needParens = ts.isArrowFunction(declaration) && closeParen === void 0;
-    const endNode = needParens ? declaration.parameters[0] : closeParen;
-    if (endNode) {
-      if (needParens) {
-        changes.insertNodeBefore(
-          sourceFile,
-          endNode,
-          ts.factory.createToken(ts.SyntaxKind.OpenParenToken)
-        );
-        changes.insertNodeAfter(
-          sourceFile,
-          endNode,
-          ts.factory.createToken(ts.SyntaxKind.CloseParenToken)
-        );
+function expand(edit, frag, child, bitmap, subNodes) {
+  const arr = [];
+  let bit = bitmap;
+  let count = 0;
+  for (let i = 0; bit; ++i) {
+    if (bit & 1) arr[i] = subNodes[count++];
+    bit >>>= 1;
+  }
+  arr[frag] = child;
+  return new ArrayNode(edit, count + 1, arr);
+}
+function mergeLeavesInner(edit, shift, h1, n1, h2, n2) {
+  if (h1 === h2) return new CollisionNode(edit, h1, [n2, n1]);
+  const subH1 = hashFragment(shift, h1);
+  const subH2 = hashFragment(shift, h2);
+  if (subH1 === subH2) {
+    return (child) => new IndexedNode(edit, toBitmap(subH1) | toBitmap(subH2), [child]);
+  } else {
+    const children = subH1 < subH2 ? [n1, n2] : [n2, n1];
+    return new IndexedNode(edit, toBitmap(subH1) | toBitmap(subH2), children);
+  }
+}
+function mergeLeaves(edit, shift, h1, n1, h2, n2) {
+  let stack = void 0;
+  let currentShift = shift;
+  while (true) {
+    const res = mergeLeavesInner(edit, currentShift, h1, n1, h2, n2);
+    if (typeof res === "function") {
+      stack = make4(res, stack);
+      currentShift = currentShift + SIZE;
+    } else {
+      let final = res;
+      while (stack != null) {
+        final = stack.value(final);
+        stack = stack.previous;
       }
-      changes.insertNodeAt(sourceFile, endNode.end, typeNode, { prefix: ": " });
+      return final;
+    }
+  }
+}
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/hashMap.js
+var HashMapSymbolKey = "effect/HashMap";
+var HashMapTypeId = /* @__PURE__ */ Symbol.for(HashMapSymbolKey);
+var HashMapProto = {
+  [HashMapTypeId]: HashMapTypeId,
+  [Symbol.iterator]() {
+    return new HashMapIterator(this, (k, v) => [k, v]);
+  },
+  [symbol]() {
+    let hash2 = hash(HashMapSymbolKey);
+    for (const item of this) {
+      hash2 ^= pipe(hash(item[0]), combine(hash(item[1])));
+    }
+    return cached(this, hash2);
+  },
+  [symbol2](that) {
+    if (isHashMap(that)) {
+      if (that._size !== this._size) {
+        return false;
+      }
+      for (const item of this) {
+        const elem = pipe(that, getHash(item[0], hash(item[0])));
+        if (isNone2(elem)) {
+          return false;
+        } else {
+          if (!equals(item[1], elem.value)) {
+            return false;
+          }
+        }
+      }
+      return true;
+    }
+    return false;
+  },
+  toString() {
+    return format(this.toJSON());
+  },
+  toJSON() {
+    return {
+      _id: "HashMap",
+      values: Array.from(this).map(toJSON)
+    };
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+var makeImpl = (editable, edit, root, size4) => {
+  const map8 = Object.create(HashMapProto);
+  map8._editable = editable;
+  map8._edit = edit;
+  map8._root = root;
+  map8._size = size4;
+  return map8;
+};
+var HashMapIterator = class _HashMapIterator {
+  map;
+  f;
+  v;
+  constructor(map8, f) {
+    this.map = map8;
+    this.f = f;
+    this.v = visitLazy(this.map._root, this.f, void 0);
+  }
+  next() {
+    if (isNone2(this.v)) {
+      return {
+        done: true,
+        value: void 0
+      };
+    }
+    const v0 = this.v.value;
+    this.v = applyCont(v0.cont);
+    return {
+      done: false,
+      value: v0.value
+    };
+  }
+  [Symbol.iterator]() {
+    return new _HashMapIterator(this.map, this.f);
+  }
+};
+var applyCont = (cont) => cont ? visitLazyChildren(cont[0], cont[1], cont[2], cont[3], cont[4]) : none2();
+var visitLazy = (node, f, cont = void 0) => {
+  switch (node._tag) {
+    case "LeafNode": {
+      if (isSome2(node.value)) {
+        return some2({
+          value: f(node.key, node.value.value),
+          cont
+        });
+      }
+      return applyCont(cont);
+    }
+    case "CollisionNode":
+    case "ArrayNode":
+    case "IndexedNode": {
+      const children = node.children;
+      return visitLazyChildren(children.length, children, 0, f, cont);
+    }
+    default: {
+      return applyCont(cont);
+    }
+  }
+};
+var visitLazyChildren = (len, children, i, f, cont) => {
+  while (i < len) {
+    const child = children[i++];
+    if (child && !isEmptyNode(child)) {
+      return visitLazy(child, f, [len, children, i, f, cont]);
+    }
+  }
+  return applyCont(cont);
+};
+var _empty2 = /* @__PURE__ */ makeImpl(false, 0, /* @__PURE__ */ new EmptyNode(), 0);
+var empty3 = () => _empty2;
+var isHashMap = (u) => hasProperty(u, HashMapTypeId);
+var getHash = /* @__PURE__ */ dual(3, (self, key, hash2) => {
+  let node = self._root;
+  let shift = 0;
+  while (true) {
+    switch (node._tag) {
+      case "LeafNode": {
+        return equals(key, node.key) ? node.value : none2();
+      }
+      case "CollisionNode": {
+        if (hash2 === node.hash) {
+          const children = node.children;
+          for (let i = 0, len = children.length; i < len; ++i) {
+            const child = children[i];
+            if ("key" in child && equals(key, child.key)) {
+              return child.value;
+            }
+          }
+        }
+        return none2();
+      }
+      case "IndexedNode": {
+        const frag = hashFragment(shift, hash2);
+        const bit = toBitmap(frag);
+        if (node.mask & bit) {
+          node = node.children[fromBitmap(node.mask, bit)];
+          shift += SIZE;
+          break;
+        }
+        return none2();
+      }
+      case "ArrayNode": {
+        node = node.children[hashFragment(shift, hash2)];
+        if (node) {
+          shift += SIZE;
+          break;
+        }
+        return none2();
+      }
+      default:
+        return none2();
+    }
+  }
+});
+var set = /* @__PURE__ */ dual(3, (self, key, value) => modifyAt(self, key, () => some2(value)));
+var setTree = /* @__PURE__ */ dual(3, (self, newRoot, newSize) => {
+  if (self._editable) {
+    ;
+    self._root = newRoot;
+    self._size = newSize;
+    return self;
+  }
+  return newRoot === self._root ? self : makeImpl(self._editable, self._edit, newRoot, newSize);
+});
+var keys = (self) => new HashMapIterator(self, (key) => key);
+var size = (self) => self._size;
+var beginMutation = (self) => makeImpl(true, self._edit + 1, self._root, self._size);
+var modifyAt = /* @__PURE__ */ dual(3, (self, key, f) => modifyHash(self, key, hash(key), f));
+var modifyHash = /* @__PURE__ */ dual(4, (self, key, hash2, f) => {
+  const size4 = {
+    value: self._size
+  };
+  const newRoot = self._root.modify(self._editable ? self._edit : NaN, 0, f, hash2, key, size4);
+  return pipe(self, setTree(newRoot, size4.value));
+});
+var forEach = /* @__PURE__ */ dual(2, (self, f) => reduce2(self, void 0, (_, value, key) => f(value, key)));
+var reduce2 = /* @__PURE__ */ dual(3, (self, zero, f) => {
+  const root = self._root;
+  if (root._tag === "LeafNode") {
+    return isSome2(root.value) ? f(zero, root.value.value, root.key) : zero;
+  }
+  if (root._tag === "EmptyNode") {
+    return zero;
+  }
+  const toVisit = [root.children];
+  let children;
+  while (children = toVisit.pop()) {
+    for (let i = 0, len = children.length; i < len; ) {
+      const child = children[i++];
+      if (child && !isEmptyNode(child)) {
+        if (child._tag === "LeafNode") {
+          if (isSome2(child.value)) {
+            zero = f(zero, child.value.value, child.key);
+          }
+        } else {
+          toVisit.push(child.children);
+        }
+      }
+    }
+  }
+  return zero;
+});
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/hashSet.js
+var HashSetSymbolKey = "effect/HashSet";
+var HashSetTypeId = /* @__PURE__ */ Symbol.for(HashSetSymbolKey);
+var HashSetProto = {
+  [HashSetTypeId]: HashSetTypeId,
+  [Symbol.iterator]() {
+    return keys(this._keyMap);
+  },
+  [symbol]() {
+    return cached(this, combine(hash(this._keyMap))(hash(HashSetSymbolKey)));
+  },
+  [symbol2](that) {
+    if (isHashSet(that)) {
+      return size(this._keyMap) === size(that._keyMap) && equals(this._keyMap, that._keyMap);
+    }
+    return false;
+  },
+  toString() {
+    return format(this.toJSON());
+  },
+  toJSON() {
+    return {
+      _id: "HashSet",
+      values: Array.from(this).map(toJSON)
+    };
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+var makeImpl2 = (keyMap) => {
+  const set2 = Object.create(HashSetProto);
+  set2._keyMap = keyMap;
+  return set2;
+};
+var isHashSet = (u) => hasProperty(u, HashSetTypeId);
+var _empty3 = /* @__PURE__ */ makeImpl2(/* @__PURE__ */ empty3());
+var empty4 = () => _empty3;
+var size2 = (self) => size(self._keyMap);
+var beginMutation2 = (self) => makeImpl2(beginMutation(self._keyMap));
+var endMutation = (self) => {
+  ;
+  self._keyMap._editable = false;
+  return self;
+};
+var mutate = /* @__PURE__ */ dual(2, (self, f) => {
+  const transient = beginMutation2(self);
+  f(transient);
+  return endMutation(transient);
+});
+var add = /* @__PURE__ */ dual(2, (self, value) => self._keyMap._editable ? (set(value, true)(self._keyMap), self) : makeImpl2(set(value, true)(self._keyMap)));
+var union2 = /* @__PURE__ */ dual(2, (self, that) => mutate(empty4(), (set2) => {
+  forEach2(self, (value) => add(set2, value));
+  for (const value of that) {
+    add(set2, value);
+  }
+}));
+var forEach2 = /* @__PURE__ */ dual(2, (self, f) => forEach(self._keyMap, (_, k) => f(k)));
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/HashSet.js
+var empty5 = empty4;
+var size3 = size2;
+var add2 = add;
+var union3 = union2;
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/opCodes/cause.js
+var OP_DIE = "Die";
+var OP_EMPTY = "Empty";
+var OP_FAIL = "Fail";
+var OP_INTERRUPT = "Interrupt";
+var OP_PARALLEL = "Parallel";
+var OP_SEQUENTIAL = "Sequential";
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/cause.js
+var CauseSymbolKey = "effect/Cause";
+var CauseTypeId = /* @__PURE__ */ Symbol.for(CauseSymbolKey);
+var variance = {
+  /* c8 ignore next */
+  _E: (_) => _
+};
+var proto = {
+  [CauseTypeId]: variance,
+  [symbol]() {
+    return pipe(hash(CauseSymbolKey), combine(hash(flattenCause(this))), cached(this));
+  },
+  [symbol2](that) {
+    return isCause(that) && causeEquals(this, that);
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
+  },
+  toJSON() {
+    switch (this._tag) {
+      case "Empty":
+        return {
+          _id: "Cause",
+          _tag: this._tag
+        };
+      case "Die":
+        return {
+          _id: "Cause",
+          _tag: this._tag,
+          defect: toJSON(this.defect)
+        };
+      case "Interrupt":
+        return {
+          _id: "Cause",
+          _tag: this._tag,
+          fiberId: this.fiberId.toJSON()
+        };
+      case "Fail":
+        return {
+          _id: "Cause",
+          _tag: this._tag,
+          failure: toJSON(this.error)
+        };
+      case "Sequential":
+      case "Parallel":
+        return {
+          _id: "Cause",
+          _tag: this._tag,
+          left: toJSON(this.left),
+          right: toJSON(this.right)
+        };
+    }
+  },
+  toString() {
+    return pretty(this);
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+};
+var fail = (error) => {
+  const o = Object.create(proto);
+  o._tag = OP_FAIL;
+  o.error = error;
+  return o;
+};
+var parallel = (left3, right3) => {
+  const o = Object.create(proto);
+  o._tag = OP_PARALLEL;
+  o.left = left3;
+  o.right = right3;
+  return o;
+};
+var sequential = (left3, right3) => {
+  const o = Object.create(proto);
+  o._tag = OP_SEQUENTIAL;
+  o.left = left3;
+  o.right = right3;
+  return o;
+};
+var isCause = (u) => hasProperty(u, CauseTypeId);
+var isInterruptedOnly = (self) => reduceWithContext(void 0, IsInterruptedOnlyCauseReducer)(self);
+var causeEquals = (left3, right3) => {
+  let leftStack = of(left3);
+  let rightStack = of(right3);
+  while (isNonEmpty(leftStack) && isNonEmpty(rightStack)) {
+    const [leftParallel, leftSequential] = pipe(headNonEmpty2(leftStack), reduce4([empty5(), empty2()], ([parallel2, sequential2], cause) => {
+      const [par, seq] = evaluateCause(cause);
+      return some2([pipe(parallel2, union3(par)), pipe(sequential2, appendAll(seq))]);
+    }));
+    const [rightParallel, rightSequential] = pipe(headNonEmpty2(rightStack), reduce4([empty5(), empty2()], ([parallel2, sequential2], cause) => {
+      const [par, seq] = evaluateCause(cause);
+      return some2([pipe(parallel2, union3(par)), pipe(sequential2, appendAll(seq))]);
+    }));
+    if (!equals(leftParallel, rightParallel)) {
+      return false;
+    }
+    leftStack = leftSequential;
+    rightStack = rightSequential;
+  }
+  return true;
+};
+var flattenCause = (cause) => {
+  return flattenCauseLoop(of(cause), empty2());
+};
+var flattenCauseLoop = (causes, flattened) => {
+  while (1) {
+    const [parallel2, sequential2] = pipe(causes, reduce([empty5(), empty2()], ([parallel3, sequential3], cause) => {
+      const [par, seq] = evaluateCause(cause);
+      return [pipe(parallel3, union3(par)), pipe(sequential3, appendAll(seq))];
+    }));
+    const updated = size3(parallel2) > 0 ? pipe(flattened, prepend(parallel2)) : flattened;
+    if (isEmpty(sequential2)) {
+      return reverse2(updated);
+    }
+    causes = sequential2;
+    flattened = updated;
+  }
+  throw new Error(getBugErrorMessage("Cause.flattenCauseLoop"));
+};
+var evaluateCause = (self) => {
+  let cause = self;
+  const stack = [];
+  let _parallel = empty5();
+  let _sequential = empty2();
+  while (cause !== void 0) {
+    switch (cause._tag) {
+      case OP_EMPTY: {
+        if (stack.length === 0) {
+          return [_parallel, _sequential];
+        }
+        cause = stack.pop();
+        break;
+      }
+      case OP_FAIL: {
+        _parallel = add2(_parallel, make3(cause._tag, cause.error));
+        if (stack.length === 0) {
+          return [_parallel, _sequential];
+        }
+        cause = stack.pop();
+        break;
+      }
+      case OP_DIE: {
+        _parallel = add2(_parallel, make3(cause._tag, cause.defect));
+        if (stack.length === 0) {
+          return [_parallel, _sequential];
+        }
+        cause = stack.pop();
+        break;
+      }
+      case OP_INTERRUPT: {
+        _parallel = add2(_parallel, make3(cause._tag, cause.fiberId));
+        if (stack.length === 0) {
+          return [_parallel, _sequential];
+        }
+        cause = stack.pop();
+        break;
+      }
+      case OP_SEQUENTIAL: {
+        switch (cause.left._tag) {
+          case OP_EMPTY: {
+            cause = cause.right;
+            break;
+          }
+          case OP_SEQUENTIAL: {
+            cause = sequential(cause.left.left, sequential(cause.left.right, cause.right));
+            break;
+          }
+          case OP_PARALLEL: {
+            cause = parallel(sequential(cause.left.left, cause.right), sequential(cause.left.right, cause.right));
+            break;
+          }
+          default: {
+            _sequential = prepend(_sequential, cause.right);
+            cause = cause.left;
+            break;
+          }
+        }
+        break;
+      }
+      case OP_PARALLEL: {
+        stack.push(cause.right);
+        cause = cause.left;
+        break;
+      }
+    }
+  }
+  throw new Error(getBugErrorMessage("Cause.evaluateCauseLoop"));
+};
+var IsInterruptedOnlyCauseReducer = {
+  emptyCase: constTrue,
+  failCase: constFalse,
+  dieCase: constFalse,
+  interruptCase: constTrue,
+  sequentialCase: (_, left3, right3) => left3 && right3,
+  parallelCase: (_, left3, right3) => left3 && right3
+};
+var OP_SEQUENTIAL_CASE = "SequentialCase";
+var OP_PARALLEL_CASE = "ParallelCase";
+var reduce4 = /* @__PURE__ */ dual(3, (self, zero, pf) => {
+  let accumulator = zero;
+  let cause = self;
+  const causes = [];
+  while (cause !== void 0) {
+    const option2 = pf(accumulator, cause);
+    accumulator = isSome2(option2) ? option2.value : accumulator;
+    switch (cause._tag) {
+      case OP_SEQUENTIAL: {
+        causes.push(cause.right);
+        cause = cause.left;
+        break;
+      }
+      case OP_PARALLEL: {
+        causes.push(cause.right);
+        cause = cause.left;
+        break;
+      }
+      default: {
+        cause = void 0;
+        break;
+      }
+    }
+    if (cause === void 0 && causes.length > 0) {
+      cause = causes.pop();
+    }
+  }
+  return accumulator;
+});
+var reduceWithContext = /* @__PURE__ */ dual(3, (self, context, reducer) => {
+  const input = [self];
+  const output = [];
+  while (input.length > 0) {
+    const cause = input.pop();
+    switch (cause._tag) {
+      case OP_EMPTY: {
+        output.push(right2(reducer.emptyCase(context)));
+        break;
+      }
+      case OP_FAIL: {
+        output.push(right2(reducer.failCase(context, cause.error)));
+        break;
+      }
+      case OP_DIE: {
+        output.push(right2(reducer.dieCase(context, cause.defect)));
+        break;
+      }
+      case OP_INTERRUPT: {
+        output.push(right2(reducer.interruptCase(context, cause.fiberId)));
+        break;
+      }
+      case OP_SEQUENTIAL: {
+        input.push(cause.right);
+        input.push(cause.left);
+        output.push(left2({
+          _tag: OP_SEQUENTIAL_CASE
+        }));
+        break;
+      }
+      case OP_PARALLEL: {
+        input.push(cause.right);
+        input.push(cause.left);
+        output.push(left2({
+          _tag: OP_PARALLEL_CASE
+        }));
+        break;
+      }
+    }
+  }
+  const accumulator = [];
+  while (output.length > 0) {
+    const either = output.pop();
+    switch (either._tag) {
+      case "Left": {
+        switch (either.left._tag) {
+          case OP_SEQUENTIAL_CASE: {
+            const left3 = accumulator.pop();
+            const right3 = accumulator.pop();
+            const value = reducer.sequentialCase(context, left3, right3);
+            accumulator.push(value);
+            break;
+          }
+          case OP_PARALLEL_CASE: {
+            const left3 = accumulator.pop();
+            const right3 = accumulator.pop();
+            const value = reducer.parallelCase(context, left3, right3);
+            accumulator.push(value);
+            break;
+          }
+        }
+        break;
+      }
+      case "Right": {
+        accumulator.push(either.right);
+        break;
+      }
+    }
+  }
+  if (accumulator.length === 0) {
+    throw new Error("BUG: Cause.reduceWithContext - please report an issue at https://github.com/Effect-TS/effect/issues");
+  }
+  return accumulator.pop();
+});
+var pretty = (cause, options) => {
+  if (isInterruptedOnly(cause)) {
+    return "All fibers interrupted without errors.";
+  }
+  return prettyErrors(cause).map(function(e) {
+    if (options?.renderErrorCause !== true || e.cause === void 0) {
+      return e.stack;
+    }
+    return `${e.stack} {
+${renderErrorCause(e.cause, "  ")}
+}`;
+  }).join("\n");
+};
+var renderErrorCause = (cause, prefix) => {
+  const lines = cause.stack.split("\n");
+  let stack = `${prefix}[cause]: ${lines[0]}`;
+  for (let i = 1, len = lines.length; i < len; i++) {
+    stack += `
+${prefix}${lines[i]}`;
+  }
+  if (cause.cause) {
+    stack += ` {
+${renderErrorCause(cause.cause, `${prefix}  `)}
+${prefix}}`;
+  }
+  return stack;
+};
+var PrettyError = class _PrettyError extends globalThis.Error {
+  span = void 0;
+  constructor(originalError) {
+    const originalErrorIsObject = typeof originalError === "object" && originalError !== null;
+    const prevLimit = Error.stackTraceLimit;
+    Error.stackTraceLimit = 1;
+    super(prettyErrorMessage(originalError), originalErrorIsObject && "cause" in originalError && typeof originalError.cause !== "undefined" ? {
+      cause: new _PrettyError(originalError.cause)
+    } : void 0);
+    if (this.message === "") {
+      this.message = "An error has occurred";
+    }
+    Error.stackTraceLimit = prevLimit;
+    this.name = originalError instanceof Error ? originalError.name : "Error";
+    if (originalErrorIsObject) {
+      if (spanSymbol in originalError) {
+        this.span = originalError[spanSymbol];
+      }
+      Object.keys(originalError).forEach((key) => {
+        if (!(key in this)) {
+          this[key] = originalError[key];
+        }
+      });
+    }
+    this.stack = prettyErrorStack(`${this.name}: ${this.message}`, originalError instanceof Error && originalError.stack ? originalError.stack : "", this.span);
+  }
+};
+var prettyErrorMessage = (u) => {
+  if (typeof u === "string") {
+    return u;
+  }
+  if (typeof u === "object" && u !== null && u instanceof Error) {
+    return u.message;
+  }
+  try {
+    if (hasProperty(u, "toString") && isFunction2(u["toString"]) && u["toString"] !== Object.prototype.toString && u["toString"] !== globalThis.Array.prototype.toString) {
+      return u["toString"]();
+    }
+  } catch {
+  }
+  return stringifyCircular(u);
+};
+var locationRegex = /\((.*)\)/g;
+var spanToTrace = /* @__PURE__ */ globalValue("effect/Tracer/spanToTrace", () => /* @__PURE__ */ new WeakMap());
+var prettyErrorStack = (message, stack, span) => {
+  const out = [message];
+  const lines = stack.startsWith(message) ? stack.slice(message.length).split("\n") : stack.split("\n");
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i].includes("Generator.next")) {
+      break;
+    }
+    if (lines[i].includes("effect_internal_function")) {
+      out.pop();
+      break;
+    }
+    out.push(lines[i].replace(/at .*effect_instruction_i.*\((.*)\)/, "at $1").replace(/EffectPrimitive\.\w+/, "<anonymous>"));
+  }
+  if (span) {
+    let current = span;
+    let i = 0;
+    while (current && current._tag === "Span" && i < 10) {
+      const stackFn = spanToTrace.get(current);
+      if (typeof stackFn === "function") {
+        const stack2 = stackFn();
+        if (typeof stack2 === "string") {
+          const locationMatchAll = stack2.matchAll(locationRegex);
+          let match3 = false;
+          for (const [, location] of locationMatchAll) {
+            match3 = true;
+            out.push(`    at ${current.name} (${location})`);
+          }
+          if (!match3) {
+            out.push(`    at ${current.name} (${stack2.replace(/^at /, "")})`);
+          }
+        } else {
+          out.push(`    at ${current.name}`);
+        }
+      } else {
+        out.push(`    at ${current.name}`);
+      }
+      current = getOrUndefined2(current.parent);
+      i++;
+    }
+  }
+  return out.join("\n");
+};
+var spanSymbol = /* @__PURE__ */ Symbol.for("effect/SpanAnnotation");
+var prettyErrors = (cause) => reduceWithContext(cause, void 0, {
+  emptyCase: () => [],
+  dieCase: (_, unknownError) => {
+    return [new PrettyError(unknownError)];
+  },
+  failCase: (_, error) => {
+    return [new PrettyError(error)];
+  },
+  interruptCase: () => [],
+  parallelCase: (_, l, r) => [...l, ...r],
+  sequentialCase: (_, l, r) => [...l, ...r]
+});
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/singleShotGen.js
+var SingleShotGen2 = class _SingleShotGen {
+  self;
+  called = false;
+  constructor(self) {
+    this.self = self;
+  }
+  next(a) {
+    return this.called ? {
+      value: a,
+      done: true
+    } : (this.called = true, {
+      value: this.self,
+      done: false
+    });
+  }
+  return(a) {
+    return {
+      value: a,
+      done: true
+    };
+  }
+  throw(e) {
+    throw e;
+  }
+  [Symbol.iterator]() {
+    return new _SingleShotGen(this.self);
+  }
+};
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/core.js
+var EffectTypeId2 = /* @__PURE__ */ Symbol.for("effect/Effect");
+var EffectPrimitive = class {
+  _op;
+  effect_instruction_i0 = void 0;
+  effect_instruction_i1 = void 0;
+  effect_instruction_i2 = void 0;
+  trace = void 0;
+  [EffectTypeId2] = effectVariance;
+  constructor(_op) {
+    this._op = _op;
+  }
+  [symbol2](that) {
+    return this === that;
+  }
+  [symbol]() {
+    return cached(this, random(this));
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+  toJSON() {
+    return {
+      _id: "Effect",
+      _op: this._op,
+      effect_instruction_i0: toJSON(this.effect_instruction_i0),
+      effect_instruction_i1: toJSON(this.effect_instruction_i1),
+      effect_instruction_i2: toJSON(this.effect_instruction_i2)
+    };
+  }
+  toString() {
+    return format(this.toJSON());
+  }
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+  [Symbol.iterator]() {
+    return new SingleShotGen2(new YieldWrap(this));
+  }
+};
+var EffectPrimitiveFailure = class {
+  _op;
+  effect_instruction_i0 = void 0;
+  effect_instruction_i1 = void 0;
+  effect_instruction_i2 = void 0;
+  trace = void 0;
+  [EffectTypeId2] = effectVariance;
+  constructor(_op) {
+    this._op = _op;
+    this._tag = _op;
+  }
+  [symbol2](that) {
+    return exitIsExit(that) && that._op === "Failure" && // @ts-expect-error
+    equals(this.effect_instruction_i0, that.effect_instruction_i0);
+  }
+  [symbol]() {
+    return pipe(
+      // @ts-expect-error
+      string(this._tag),
+      // @ts-expect-error
+      combine(hash(this.effect_instruction_i0)),
+      cached(this)
+    );
+  }
+  get cause() {
+    return this.effect_instruction_i0;
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+  toJSON() {
+    return {
+      _id: "Exit",
+      _tag: this._op,
+      cause: this.cause.toJSON()
+    };
+  }
+  toString() {
+    return format(this.toJSON());
+  }
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+  [Symbol.iterator]() {
+    return new SingleShotGen2(new YieldWrap(this));
+  }
+};
+var EffectPrimitiveSuccess = class {
+  _op;
+  effect_instruction_i0 = void 0;
+  effect_instruction_i1 = void 0;
+  effect_instruction_i2 = void 0;
+  trace = void 0;
+  [EffectTypeId2] = effectVariance;
+  constructor(_op) {
+    this._op = _op;
+    this._tag = _op;
+  }
+  [symbol2](that) {
+    return exitIsExit(that) && that._op === "Success" && // @ts-expect-error
+    equals(this.effect_instruction_i0, that.effect_instruction_i0);
+  }
+  [symbol]() {
+    return pipe(
+      // @ts-expect-error
+      string(this._tag),
+      // @ts-expect-error
+      combine(hash(this.effect_instruction_i0)),
+      cached(this)
+    );
+  }
+  get value() {
+    return this.effect_instruction_i0;
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+  toJSON() {
+    return {
+      _id: "Exit",
+      _tag: this._op,
+      value: toJSON(this.value)
+    };
+  }
+  toString() {
+    return format(this.toJSON());
+  }
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+  [Symbol.iterator]() {
+    return new SingleShotGen2(new YieldWrap(this));
+  }
+};
+var isEffect = (u) => hasProperty(u, EffectTypeId2);
+var withFiberRuntime = (withRuntime) => {
+  const effect = new EffectPrimitive(OP_WITH_RUNTIME);
+  effect.effect_instruction_i0 = withRuntime;
+  return effect;
+};
+var spanSymbol2 = /* @__PURE__ */ Symbol.for("effect/SpanAnnotation");
+var originalSymbol = /* @__PURE__ */ Symbol.for("effect/OriginalAnnotation");
+var capture = (obj, span) => {
+  if (isSome2(span)) {
+    return new Proxy(obj, {
+      has(target, p) {
+        return p === spanSymbol2 || p === originalSymbol || p in target;
+      },
+      get(target, p) {
+        if (p === spanSymbol2) {
+          return span.value;
+        }
+        if (p === originalSymbol) {
+          return obj;
+        }
+        return target[p];
+      }
+    });
+  }
+  return obj;
+};
+var fail2 = (error) => isObject(error) && !(spanSymbol2 in error) ? withFiberRuntime((fiber) => failCause(fail(capture(error, currentSpanFromFiber(fiber))))) : failCause(fail(error));
+var failCause = (cause) => {
+  const effect = new EffectPrimitiveFailure(OP_FAILURE);
+  effect.effect_instruction_i0 = cause;
+  return effect;
+};
+var logLevelAll = {
+  _tag: "All",
+  syslog: 0,
+  label: "ALL",
+  ordinal: Number.MIN_SAFE_INTEGER,
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+var logLevelNone = {
+  _tag: "None",
+  syslog: 7,
+  label: "OFF",
+  ordinal: Number.MAX_SAFE_INTEGER,
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+var RequestResolverSymbolKey = "effect/RequestResolver";
+var RequestResolverTypeId = /* @__PURE__ */ Symbol.for(RequestResolverSymbolKey);
+var requestResolverVariance = {
+  /* c8 ignore next */
+  _A: (_) => _,
+  /* c8 ignore next */
+  _R: (_) => _
+};
+var RequestResolverImpl = class _RequestResolverImpl {
+  runAll;
+  target;
+  [RequestResolverTypeId] = requestResolverVariance;
+  constructor(runAll, target) {
+    this.runAll = runAll;
+    this.target = target;
+  }
+  [symbol]() {
+    return cached(this, this.target ? hash(this.target) : random(this));
+  }
+  [symbol2](that) {
+    return this.target ? isRequestResolver(that) && equals(this.target, that.target) : this === that;
+  }
+  identified(...ids) {
+    return new _RequestResolverImpl(this.runAll, fromIterable2(ids));
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+var isRequestResolver = (u) => hasProperty(u, RequestResolverTypeId);
+var YieldableError = /* @__PURE__ */ function() {
+  class YieldableError2 extends globalThis.Error {
+    commit() {
+      return fail2(this);
     }
-  };
-}
-function removeReturnTypeAnnotation(ts, changes) {
-  return (sourceFile, declaration) => {
-    const closeParen = ts.findChildOfKind(declaration, ts.SyntaxKind.CloseParenToken, sourceFile);
-    const needParens = ts.isArrowFunction(declaration) && closeParen === void 0;
-    const endNode = needParens ? declaration.parameters[0] : closeParen;
-    if (endNode && declaration.type) {
-      changes.deleteRange(sourceFile, { pos: endNode.end, end: declaration.type.end });
+    toJSON() {
+      return {
+        ...this
+      };
     }
-  };
-}
-function findImportedModuleIdentifier(ts) {
-  return (test) => (sourceFile) => {
-    for (const statement of sourceFile.statements) {
-      if (!ts.isImportDeclaration(statement)) continue;
-      const importClause = statement.importClause;
-      if (!importClause) continue;
-      const namedBindings = importClause.namedBindings;
-      if (!namedBindings) continue;
-      if (ts.isNamespaceImport(namedBindings)) {
-        if (test(namedBindings.name)) return some2(namedBindings.name);
-      } else if (ts.isNamedImports(namedBindings)) {
-        for (const importSpecifier of namedBindings.elements) {
-          if (test(importSpecifier.name)) return some2(importSpecifier.name);
-        }
+    [NodeInspectSymbol]() {
+      if (this.toString !== globalThis.Error.prototype.toString) {
+        return this.stack ? `${this.toString()}
+${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
+      } else if ("Bun" in globalThis) {
+        return pretty(fail(this), {
+          renderErrorCause: true
+        });
       }
+      return this;
     }
-    return none2();
-  };
-}
-function simplifyTypeNode(ts) {
-  function collectCallable(typeNode) {
-    if (ts.isParenthesizedTypeNode(typeNode)) return collectCallable(typeNode.type);
-    if (ts.isFunctionTypeNode(typeNode)) {
-      return some2([
-        ts.factory.createCallSignature(typeNode.typeParameters, typeNode.parameters, typeNode.type)
-      ]);
-    }
-    if (ts.isTypeLiteralNode(typeNode)) {
-      const allCallSignatures = typeNode.members.every(ts.isCallSignatureDeclaration);
-      if (allCallSignatures) {
-        return some2(typeNode.members);
+  }
+  Object.assign(YieldableError2.prototype, StructuralCommitPrototype);
+  return YieldableError2;
+}();
+var makeException = (proto2, tag) => {
+  class Base extends YieldableError {
+    _tag = tag;
+  }
+  Object.assign(Base.prototype, proto2);
+  Base.prototype.name = tag;
+  return Base;
+};
+var RuntimeExceptionTypeId = /* @__PURE__ */ Symbol.for("effect/Cause/errors/RuntimeException");
+var RuntimeException = /* @__PURE__ */ makeException({
+  [RuntimeExceptionTypeId]: RuntimeExceptionTypeId
+}, "RuntimeException");
+var InterruptedExceptionTypeId = /* @__PURE__ */ Symbol.for("effect/Cause/errors/InterruptedException");
+var InterruptedException = /* @__PURE__ */ makeException({
+  [InterruptedExceptionTypeId]: InterruptedExceptionTypeId
+}, "InterruptedException");
+var IllegalArgumentExceptionTypeId = /* @__PURE__ */ Symbol.for("effect/Cause/errors/IllegalArgument");
+var IllegalArgumentException = /* @__PURE__ */ makeException({
+  [IllegalArgumentExceptionTypeId]: IllegalArgumentExceptionTypeId
+}, "IllegalArgumentException");
+var NoSuchElementExceptionTypeId = /* @__PURE__ */ Symbol.for("effect/Cause/errors/NoSuchElement");
+var NoSuchElementException = /* @__PURE__ */ makeException({
+  [NoSuchElementExceptionTypeId]: NoSuchElementExceptionTypeId
+}, "NoSuchElementException");
+var InvalidPubSubCapacityExceptionTypeId = /* @__PURE__ */ Symbol.for("effect/Cause/errors/InvalidPubSubCapacityException");
+var InvalidPubSubCapacityException = /* @__PURE__ */ makeException({
+  [InvalidPubSubCapacityExceptionTypeId]: InvalidPubSubCapacityExceptionTypeId
+}, "InvalidPubSubCapacityException");
+var ExceededCapacityExceptionTypeId = /* @__PURE__ */ Symbol.for("effect/Cause/errors/ExceededCapacityException");
+var ExceededCapacityException = /* @__PURE__ */ makeException({
+  [ExceededCapacityExceptionTypeId]: ExceededCapacityExceptionTypeId
+}, "ExceededCapacityException");
+var TimeoutExceptionTypeId = /* @__PURE__ */ Symbol.for("effect/Cause/errors/Timeout");
+var TimeoutException = /* @__PURE__ */ makeException({
+  [TimeoutExceptionTypeId]: TimeoutExceptionTypeId
+}, "TimeoutException");
+var exitIsExit = (u) => isEffect(u) && "_tag" in u && (u._tag === "Success" || u._tag === "Failure");
+var currentSpanFromFiber = (fiber) => {
+  const span = fiber.currentSpan;
+  return span !== void 0 && span._tag === "Span" ? some2(span) : none2();
+};
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Data.js
+var Error2 = /* @__PURE__ */ function() {
+  const plainArgsSymbol = /* @__PURE__ */ Symbol.for("effect/Data/Error/plainArgs");
+  return class Base extends YieldableError {
+    constructor(args) {
+      super(args?.message, args?.cause ? {
+        cause: args.cause
+      } : void 0);
+      if (args) {
+        Object.assign(this, args);
+        Object.defineProperty(this, plainArgsSymbol, {
+          value: args,
+          enumerable: false
+        });
       }
     }
-    if (ts.isIntersectionTypeNode(typeNode)) {
-      const members = typeNode.types.map(collectCallable);
-      if (members.every(isSome2)) {
-        return some2(members.map((_) => isSome2(_) ? _.value : []).flat());
-      }
+    toJSON() {
+      return {
+        ...this[plainArgsSymbol],
+        ...this
+      };
     }
-    return none2();
+  };
+}();
+var TaggedError = (tag) => {
+  class Base extends Error2 {
+    _tag = tag;
   }
-  return (typeNode) => {
-    const callSignatures = collectCallable(typeNode);
-    if (isSome2(callSignatures) && callSignatures.value.length > 1) {
-      return ts.factory.createTypeLiteralNode(callSignatures.value);
+  ;
+  Base.prototype.name = tag;
+  return Base;
+};
+
+// src/core/Nano.ts
+var NanoInterruptedException = class extends TaggedError("NanoInterruptedException") {
+};
+var NanoDefectException = class extends TaggedError("NanoDefectException") {
+};
+var NanoTag = class {
+  constructor(key) {
+    this.key = key;
+  }
+};
+var Tag = (identifier) => new NanoTag(identifier);
+var contextEmpty = { value: {} };
+var contextAdd = (context, tag, value) => ({
+  ...context,
+  value: {
+    ...context.value,
+    [tag.key]: value
+  }
+});
+var contextGet = (context, tag) => {
+  if (tag.key in context.value) {
+    return some2(context.value[tag.key]);
+  }
+  return none2();
+};
+var Nano = class {
+  constructor(run2) {
+    this.run = run2;
+  }
+  [Symbol.iterator]() {
+    return new SingleShotGen(new YieldWrap(this));
+  }
+};
+var run = (fa) => pipe(
+  try_({
+    try: () => fa.run(contextEmpty),
+    catch: (error) => new NanoDefectException({ value: error })
+  }),
+  flatMap((_) => _),
+  flatMap((_) => _)
+);
+var succeed = (value) => new Nano(() => right2(right2(value)));
+var fail3 = (value) => new Nano(() => right2(left2(value)));
+var sync = (value) => new Nano(() => right2(right2(value())));
+var flatMap4 = dual(2, (fa, f) => new Nano((ctx) => {
+  const result = fa.run(ctx);
+  if (isLeft2(result)) return result;
+  if (isLeft2(result.right)) return result;
+  return f(result.right.right).run(ctx);
+}));
+var map7 = dual(2, (fa, f) => new Nano((ctx) => {
+  const result = fa.run(ctx);
+  if (isLeft2(result)) return result;
+  if (isLeft2(result.right)) return result;
+  return right2(right2(f(result.right.right)));
+}));
+var orElse3 = (f) => (fa) => new Nano((ctx) => {
+  const result = fa.run(ctx);
+  if (isLeft2(result)) return result;
+  if (isLeft2(result.right)) return f().run(ctx);
+  return result;
+});
+var firstSuccessOf = (arr) => reduce(arr.slice(1), arr[0], (arr2, fa) => orElse3(() => fa)(arr2));
+var service = (tag) => new Nano(
+  (ctx) => contextGet(ctx, tag).pipe(match2({
+    onNone: () => left2(new NanoDefectException({ value: `Cannot find service ${tag.key}` })),
+    onSome: (value) => right2(right2(value))
+  }))
+);
+var provideService = (tag, value) => (fa) => new Nano((ctx) => {
+  return fa.run(contextAdd(ctx, tag, value));
+});
+var gen2 = (...args) => new Nano((ctx) => {
+  const iterator = args[0]();
+  let state = iterator.next();
+  while (!state.done) {
+    const current = isGenKind(state.value) ? state.value.value : yieldWrapGet(state.value);
+    const result = current.run(ctx);
+    if (isLeft2(result)) {
+      return result;
     }
-    return typeNode;
-  };
+    const inner = result.right;
+    if (isLeft2(inner)) {
+      return result;
+    }
+    state = iterator.next(inner.right);
+  }
+  return right2(right2(state.value));
+});
+var option = (fa) => new Nano((ctx) => {
+  return match(fa.run(ctx), {
+    onLeft: (cause) => left2(cause),
+    onRight: match({
+      onLeft: () => right2(right2(none2())),
+      onRight: (value) => right2(right2(some2(value)))
+    })
+  });
+});
+
+// src/core/LSP.ts
+var RefactorNotApplicableError = class extends TaggedError("RefactorNotApplicableError") {
+};
+function createRefactor(definition) {
+  return definition;
 }
-function isPipeCall(ts) {
-  return (node) => {
-    if (!ts.isCallExpression(node)) return false;
-    const expression = node.expression;
-    if (!ts.isIdentifier(expression)) return false;
-    if (expression.text !== "pipe") return false;
-    return true;
-  };
+function createDiagnostic(definition) {
+  return definition;
 }
-function asDataFirstExpression(ts, checker) {
-  return (node, self) => {
-    if (!ts.isCallExpression(node)) return none2();
-    const signature = checker.getResolvedSignature(node);
-    if (!signature) return none2();
-    const callSignatures = checker.getTypeAtLocation(node.expression).getCallSignatures();
-    for (let i = 0; i < callSignatures.length; i++) {
-      const callSignature = callSignatures[i];
-      if (callSignature.parameters.length === node.arguments.length + 1) {
-        return some2(
-          ts.factory.createCallExpression(
-            node.expression,
-            [],
-            [self].concat(node.arguments)
-          )
-        );
+var PluginOptions = Tag("PluginOptions");
+var SourceFileNotFoundError = class extends TaggedError("SourceFileNotFoundError") {
+};
+function getSemanticDiagnostics(diagnostics2, sourceFile) {
+  return gen2(function* () {
+    const effectDiagnostics = [];
+    for (const diagnostic of diagnostics2) {
+      const result = yield* option(diagnostic.apply(sourceFile));
+      if (isSome2(result)) {
+        effectDiagnostics.push(...result.value.map((_) => ({
+          file: sourceFile,
+          start: _.node.getStart(sourceFile),
+          length: _.node.getEnd() - _.node.getStart(sourceFile),
+          messageText: _.messageText,
+          category: _.category,
+          code: diagnostic.code,
+          source: "effect"
+        })));
       }
     }
-    return none2();
-  };
+    return effectDiagnostics;
+  });
+}
+function getApplicableRefactors(refactors2, sourceFile, positionOrRange) {
+  return gen2(function* () {
+    const textRange = typeof positionOrRange === "number" ? { pos: positionOrRange, end: positionOrRange } : positionOrRange;
+    const effectRefactors = [];
+    for (const refactor of refactors2) {
+      const result = yield* option(refactor.apply(sourceFile, textRange));
+      if (isSome2(result)) {
+        effectRefactors.push({
+          name: refactor.name,
+          description: refactor.description,
+          actions: [{
+            name: refactor.name,
+            description: result.value.description,
+            kind: result.value.kind
+          }]
+        });
+      }
+    }
+    return effectRefactors;
+  });
+}
+function getEditsForRefactor(refactors2, sourceFile, positionOrRange, refactorName) {
+  return gen2(function* () {
+    const refactor = refactors2.find((refactor2) => refactor2.name === refactorName);
+    if (!refactor) {
+      return yield* fail3(new RefactorNotApplicableError());
+    }
+    const textRange = typeof positionOrRange === "number" ? { pos: positionOrRange, end: positionOrRange } : positionOrRange;
+    return yield* refactor.apply(sourceFile, textRange);
+  });
 }
-function deterministicTypeOrder(ts, typeChecker) {
+
+// src/utils/TypeScriptApi.ts
+var TypeScriptApi = Tag("TypeScriptApi");
+var ChangeTracker = Tag("ChangeTracker");
+
+// src/utils/TypeCheckerApi.ts
+var TypeCheckerApi = Tag("TypeChecker");
+var deterministicTypeOrder = gen2(function* () {
+  const typeChecker = yield* service(TypeCheckerApi);
   return make2((a, b) => {
     const aName = typeChecker.typeToString(a);
     const bName = typeChecker.typeToString(b);
@@ -1223,40 +2836,10 @@ function deterministicTypeOrder(ts, typeChecker) {
     if (aName > bName) return 1;
     return 0;
   });
-}
-function tryPreserveDeclarationSemantics(ts) {
-  return (nodeToReplace, node) => {
-    if (!ts.isExpression(node)) return node;
-    if (ts.isFunctionDeclaration(nodeToReplace)) {
-      if (!nodeToReplace.name) return node;
-      return ts.factory.createVariableStatement(
-        nodeToReplace.modifiers,
-        ts.factory.createVariableDeclarationList(
-          [ts.factory.createVariableDeclaration(
-            nodeToReplace.name,
-            void 0,
-            void 0,
-            node
-          )],
-          ts.NodeFlags.Const
-        )
-      );
-    } else if (ts.isMethodDeclaration(nodeToReplace)) {
-      return ts.factory.createPropertyDeclaration(
-        nodeToReplace.modifiers,
-        nodeToReplace.name,
-        void 0,
-        void 0,
-        node
-      );
-    }
-    return node;
-  };
-}
-
-// src/utils/TypeCheckerApi.ts
-function getMissingTypeEntriesInTargetType(ts, typeChecker) {
-  return (realType, expectedType) => {
+});
+function getMissingTypeEntriesInTargetType(realType, expectedType) {
+  return gen2(function* () {
+    const typeChecker = yield* service(TypeCheckerApi);
     const result = [];
     const toTest = [realType];
     while (toTest.length > 0) {
@@ -1272,28 +2855,34 @@ function getMissingTypeEntriesInTargetType(ts, typeChecker) {
       }
     }
     return result;
-  };
+  });
 }
-function getInferredReturnType(ts, typeChecker) {
-  function isConvertibleDeclaration(node) {
-    switch (node.kind) {
-      case ts.SyntaxKind.FunctionDeclaration:
-      case ts.SyntaxKind.FunctionExpression:
-      case ts.SyntaxKind.ArrowFunction:
-      case ts.SyntaxKind.MethodDeclaration:
-        return true;
-      default:
-        return false;
-    }
-  }
-  return (node) => {
-    let declaration = node;
-    while (declaration && !isConvertibleDeclaration(declaration)) {
-      declaration = declaration.parent;
+var CannotFindAncestorConvertibleDeclarationError = class extends TaggedError("CannotFindAncestorConvertibleDeclarationError") {
+};
+function getAncestorConvertibleDeclaration(node) {
+  return gen2(function* () {
+    const ts = yield* service(TypeScriptApi);
+    let current = node;
+    while (current) {
+      if (ts.isFunctionDeclaration(current) || ts.isFunctionExpression(current) || ts.isArrowFunction(current) || ts.isMethodDeclaration(current)) {
+        return current;
+      }
+      current = current.parent;
     }
-    if (!isConvertibleDeclaration(declaration)) return none2();
-    if (!declaration || !declaration.body) {
-      return none2();
+    return yield* fail3(new CannotFindAncestorConvertibleDeclarationError({ node }));
+  });
+}
+var CannotInferReturnTypeFromEmptyBody = class extends TaggedError("CannotInferReturnTypeFromEmptyBody") {
+};
+var CannotInferReturnType = class extends TaggedError("CannotInferReturnType") {
+};
+function getInferredReturnType(declaration) {
+  return gen2(function* () {
+    const typeChecker = yield* service(TypeCheckerApi);
+    if (!declaration.body) {
+      return yield* fail3(
+        new CannotInferReturnTypeFromEmptyBody({ declaration })
+      );
     }
     let returnType;
     if (typeChecker.isImplementationOfOverload(declaration)) {
@@ -1309,20 +2898,24 @@ function getInferredReturnType(ts, typeChecker) {
       if (signature) {
         const typePredicate = typeChecker.getTypePredicateOfSignature(signature);
         if (typePredicate && typePredicate.type) {
-          return some2(typePredicate.type);
+          return typePredicate.type;
         } else {
           returnType = typeChecker.getReturnTypeOfSignature(signature);
         }
       }
     }
     if (!returnType) {
-      return none2();
+      return yield* fail3(
+        new CannotInferReturnType({ declaration })
+      );
     }
-    return some2(returnType);
-  };
+    return returnType;
+  });
 }
-function expectedAndRealType(ts, typeChecker) {
-  return (node) => {
+function expectedAndRealType(node) {
+  return gen2(function* () {
+    const typeChecker = yield* service(TypeCheckerApi);
+    const ts = yield* service(TypeScriptApi);
     if (ts.isVariableDeclaration(node) && node.initializer) {
       const expectedType = typeChecker.getTypeAtLocation(node.name);
       const realType = typeChecker.getTypeAtLocation(node.initializer);
@@ -1354,57 +2947,383 @@ function expectedAndRealType(ts, typeChecker) {
         }
       }
     }
-    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
-      const expectedType = typeChecker.getTypeAtLocation(node.left);
-      const realType = typeChecker.getTypeAtLocation(node.right);
-      return [[node.left, expectedType, node.right, realType]];
+    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+      const expectedType = typeChecker.getTypeAtLocation(node.left);
+      const realType = typeChecker.getTypeAtLocation(node.right);
+      return [[node.left, expectedType, node.right, realType]];
+    }
+    if (ts.isReturnStatement(node) && node.expression) {
+      const parentDeclaration = yield* option(getAncestorConvertibleDeclaration(node));
+      if (isSome2(parentDeclaration)) {
+        const expectedType = yield* option(getInferredReturnType(parentDeclaration.value));
+        const realType = typeChecker.getTypeAtLocation(node.expression);
+        if (isSome2(expectedType)) return [[node, expectedType.value, node, realType]];
+      }
+    }
+    if (ts.isArrowFunction(node) && ts.isExpression(node.body)) {
+      const body = node.body;
+      const expectedType = typeChecker.getContextualType(body);
+      const realType = typeChecker.getTypeAtLocation(body);
+      if (expectedType) return [[body, expectedType, body, realType]];
+    }
+    if (ts.isSatisfiesExpression(node)) {
+      const expectedType = typeChecker.getTypeAtLocation(node.type);
+      const realType = typeChecker.getTypeAtLocation(node.expression);
+      return [[node.expression, expectedType, node.expression, realType]];
+    }
+    return [];
+  });
+}
+
+// src/utils/TypeParser.ts
+var TypeParserIssue = class extends TaggedError("@effect/language-service/TypeParserIssue") {
+};
+function typeParserIssue(message, type, node) {
+  return fail3(new TypeParserIssue({ type, message, node }));
+}
+function covariantTypeArgument(type) {
+  const signatures = type.getCallSignatures();
+  if (signatures.length !== 1) {
+    return typeParserIssue("Covariant type has no call signature", type);
+  }
+  return succeed(signatures[0].getReturnType());
+}
+function pipeableType(type, atLocation) {
+  return gen2(function* () {
+    const typeChecker = yield* service(TypeCheckerApi);
+    const pipeSymbol = typeChecker.getPropertyOfType(type, "pipe");
+    if (!pipeSymbol) {
+      return yield* typeParserIssue("Type has no 'pipe' property", type, atLocation);
+    }
+    const pipeType = typeChecker.getTypeOfSymbolAtLocation(pipeSymbol, atLocation);
+    const signatures = pipeType.getCallSignatures();
+    if (signatures.length === 0) {
+      return yield* typeParserIssue("'pipe' property is not callable", type, atLocation);
+    }
+    return type;
+  });
+}
+function varianceStructCovariantType(type, atLocation, propertyName) {
+  return gen2(function* () {
+    const typeChecker = yield* service(TypeCheckerApi);
+    const propertySymbol = typeChecker.getPropertyOfType(type, propertyName);
+    if (!propertySymbol) {
+      return yield* typeParserIssue(`Type has no '${propertyName}' property`, type, atLocation);
+    }
+    const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
+    return yield* covariantTypeArgument(propertyType);
+  });
+}
+function effectVarianceStruct(type, atLocation) {
+  return gen2(function* () {
+    return {
+      A: yield* varianceStructCovariantType(type, atLocation, "_A"),
+      E: yield* varianceStructCovariantType(type, atLocation, "_E"),
+      R: yield* varianceStructCovariantType(type, atLocation, "_R")
+    };
+  });
+}
+function effectType(type, atLocation) {
+  return gen2(function* () {
+    const typeChecker = yield* service(TypeCheckerApi);
+    yield* pipeableType(type, atLocation);
+    for (const propertySymbol of typeChecker.getPropertiesOfType(type)) {
+      const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
+      const varianceArgs = yield* option(effectVarianceStruct(
+        propertyType,
+        atLocation
+      ));
+      if (isSome2(varianceArgs)) {
+        return varianceArgs.value;
+      }
+    }
+    return yield* typeParserIssue("Type has no effect variance struct", type, atLocation);
+  });
+}
+function fiberType(type, atLocation) {
+  return gen2(function* () {
+    const typeChecker = yield* service(TypeCheckerApi);
+    const awaitSymbol = typeChecker.getPropertyOfType(type, "await");
+    const pollSymbol = typeChecker.getPropertyOfType(type, "poll");
+    if (!awaitSymbol || !pollSymbol) {
+      return yield* typeParserIssue(
+        "Type is not a fiber because it does not have 'await' or 'poll' property",
+        type,
+        atLocation
+      );
+    }
+    return yield* effectType(type, atLocation);
+  });
+}
+function effectSubtype(type, atLocation) {
+  return gen2(function* () {
+    const typeChecker = yield* service(TypeCheckerApi);
+    const tagSymbol = typeChecker.getPropertyOfType(type, "_tag");
+    if (!tagSymbol) {
+      return yield* typeParserIssue(
+        "Type is not a subtype of effect because it does not have '_tag' property",
+        type,
+        atLocation
+      );
+    }
+    return yield* effectType(type, atLocation);
+  });
+}
+function importedEffectModule(node) {
+  return gen2(function* () {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const type = typeChecker.getTypeAtLocation(node);
+    const propertySymbol = typeChecker.getPropertyOfType(type, "never");
+    if (!propertySymbol) {
+      return yield* typeParserIssue("Type has no 'never' property", type, node);
+    }
+    if (!ts.isExpression(node)) {
+      return yield* typeParserIssue("Node is not an expression", type, node);
+    }
+    const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, node);
+    yield* effectType(propertyType, node);
+    return node;
+  });
+}
+function effectGen(node) {
+  return gen2(function* () {
+    const ts = yield* service(TypeScriptApi);
+    if (!ts.isCallExpression(node)) {
+      return yield* typeParserIssue("Node is not a call expression", void 0, node);
+    }
+    if (node.arguments.length === 0) {
+      return yield* typeParserIssue("Node has no arguments", void 0, node);
+    }
+    const generatorFunction = node.arguments[0];
+    if (!ts.isFunctionExpression(generatorFunction)) {
+      return yield* typeParserIssue("Node is not a function expression", void 0, node);
+    }
+    if (generatorFunction.asteriskToken === void 0) {
+      return yield* typeParserIssue("Node is not a generator function", void 0, node);
+    }
+    if (!ts.isPropertyAccessExpression(node.expression)) {
+      return yield* typeParserIssue("Node is not a property access expression", void 0, node);
+    }
+    const propertyAccess = node.expression;
+    if (propertyAccess.name.text !== "gen") {
+      return yield* typeParserIssue("Call expression name is not 'gen'", void 0, node);
+    }
+    const effectModule = yield* importedEffectModule(propertyAccess.expression);
+    return {
+      node,
+      effectModule,
+      generatorFunction,
+      body: generatorFunction.body,
+      functionStar: generatorFunction.getFirstToken()
+    };
+  });
+}
+function effectFnUntracedGen(node) {
+  return gen2(function* () {
+    const ts = yield* service(TypeScriptApi);
+    if (!ts.isCallExpression(node)) {
+      return yield* typeParserIssue("Node is not a call expression", void 0, node);
+    }
+    if (node.arguments.length === 0) {
+      return yield* typeParserIssue("Node has no arguments", void 0, node);
+    }
+    const generatorFunction = node.arguments[0];
+    if (!ts.isFunctionExpression(generatorFunction)) {
+      return yield* typeParserIssue("Node is not a function expression", void 0, node);
+    }
+    if (generatorFunction.asteriskToken === void 0) {
+      return yield* typeParserIssue(
+        "Node is not a generator function",
+        void 0,
+        node
+      );
+    }
+    if (!ts.isPropertyAccessExpression(node.expression)) {
+      return yield* typeParserIssue(
+        "Node is not a property access expression",
+        void 0,
+        node
+      );
+    }
+    const propertyAccess = node.expression;
+    if (propertyAccess.name.text !== "fnUntraced") {
+      return yield* typeParserIssue(
+        "Call expression name is not 'fnUntraced'",
+        void 0,
+        node
+      );
+    }
+    const effectModule = yield* importedEffectModule(propertyAccess.expression);
+    return {
+      node,
+      effectModule,
+      generatorFunction,
+      body: generatorFunction.body,
+      functionStar: generatorFunction.getFirstToken()
+    };
+  });
+}
+function effectFnGen(node) {
+  return gen2(function* () {
+    const ts = yield* service(TypeScriptApi);
+    if (!ts.isCallExpression(node)) {
+      return yield* typeParserIssue("Node is not a call expression", void 0, node);
+    }
+    if (node.arguments.length === 0) {
+      return yield* typeParserIssue("Node has no arguments", void 0, node);
     }
-    if (ts.isReturnStatement(node) && node.expression) {
-      const expectedType = getOrUndefined(getInferredReturnType(ts, typeChecker)(node));
-      const realType = typeChecker.getTypeAtLocation(node.expression);
-      if (expectedType) return [[node, expectedType, node, realType]];
+    const generatorFunction = node.arguments[0];
+    if (!ts.isFunctionExpression(generatorFunction)) {
+      return yield* typeParserIssue(
+        "Node is not a function expression",
+        void 0,
+        node
+      );
     }
-    if (ts.isArrowFunction(node) && ts.isExpression(node.body)) {
-      const body = node.body;
-      const expectedType = typeChecker.getContextualType(body);
-      const realType = typeChecker.getTypeAtLocation(body);
-      if (expectedType) return [[body, expectedType, body, realType]];
+    if (generatorFunction.asteriskToken === void 0) {
+      return yield* typeParserIssue(
+        "Node is not a generator function",
+        void 0,
+        node
+      );
     }
-    if (ts.isSatisfiesExpression(node)) {
-      const expectedType = typeChecker.getTypeAtLocation(node.type);
-      const realType = typeChecker.getTypeAtLocation(node.expression);
-      return [[node.expression, expectedType, node.expression, realType]];
+    const expressionToTest = ts.isCallExpression(node.expression) ? node.expression.expression : node.expression;
+    if (!ts.isPropertyAccessExpression(expressionToTest)) {
+      return yield* typeParserIssue(
+        "Node is not a property access expression",
+        void 0,
+        node
+      );
     }
-    return [];
-  };
+    const propertyAccess = expressionToTest;
+    if (propertyAccess.name.text !== "fn") {
+      return yield* typeParserIssue(
+        "Call expression name is not 'fn'",
+        void 0,
+        node
+      );
+    }
+    const effectModule = yield* importedEffectModule(propertyAccess.expression);
+    return {
+      node,
+      generatorFunction,
+      effectModule,
+      body: generatorFunction.body,
+      functionStar: generatorFunction.getFirstToken()
+    };
+  });
+}
+function returnYieldEffectBlock(body) {
+  return gen2(function* () {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    if (!ts.isBlock(body)) return yield* typeParserIssue("Node is not a block", void 0, body);
+    if (body.statements.length === 1 && ts.isReturnStatement(body.statements[0]) && body.statements[0].expression && ts.isYieldExpression(body.statements[0].expression) && body.statements[0].expression.expression) {
+      const nodeToCheck = body.statements[0].expression.expression;
+      const type = typeChecker.getTypeAtLocation(nodeToCheck);
+      yield* effectType(type, nodeToCheck);
+      return nodeToCheck;
+    }
+    return yield* typeParserIssue(
+      "Node is not a return statement with a yield expression",
+      void 0,
+      body
+    );
+  });
 }
 
+// src/diagnostics/floatingEffect.ts
+var floatingEffect = createDiagnostic({
+  name: "effect/floatingEffect",
+  code: 3,
+  apply: (sourceFile) => gen2(function* () {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    function isFloatingExpression(node) {
+      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;
+      return true;
+    }
+    const effectDiagnostics = [];
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts.forEachChild(node, appendNodeToVisit);
+      if (!isFloatingExpression(node)) continue;
+      const type = typeChecker.getTypeAtLocation(node.expression);
+      const effect = yield* option(effectType(type, node.expression));
+      if (isSome2(effect)) {
+        const allowedFloatingEffects = yield* pipe(
+          fiberType(type, node.expression),
+          orElse3(() => effectSubtype(type, node.expression)),
+          option
+        );
+        if (isNone2(allowedFloatingEffects)) {
+          effectDiagnostics.push({
+            node,
+            category: ts.DiagnosticCategory.Error,
+            messageText: `Effect must be yielded or assigned to a variable.`
+          });
+        }
+      }
+    }
+    return effectDiagnostics;
+  })
+});
+
 // src/diagnostics/missingEffectContext.ts
 var missingEffectContext = createDiagnostic({
+  name: "effect/missingEffectContext",
   code: 1,
-  apply: (ts, program) => (sourceFile) => {
-    const typeChecker = program.getTypeChecker();
-    const effectDiagnostics = [];
-    const sortTypes = sort(deterministicTypeOrder(ts, typeChecker));
-    const visit = (node) => {
-      const entries = expectedAndRealType(ts, typeChecker)(node);
-      for (const [node2, expectedType, valueNode, realType] of entries) {
-        const expectedEffect = effectType(ts, typeChecker)(
+  apply: (sourceFile) => gen2(function* () {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeOrder = yield* deterministicTypeOrder;
+    function checkForMissingContextTypes(node, expectedType, valueNode, realType) {
+      return gen2(function* () {
+        const expectedEffect = yield* effectType(
           expectedType,
-          node2
+          node
         );
-        if (isNone2(expectedEffect)) continue;
-        const realEffect = effectType(ts, typeChecker)(
+        const realEffect = yield* effectType(
           realType,
           valueNode
         );
-        if (isNone2(realEffect)) continue;
-        const missingContext = getMissingTypeEntriesInTargetType(
-          ts,
-          typeChecker
-        )(
-          realEffect.value.R,
-          expectedEffect.value.R
+        return yield* getMissingTypeEntriesInTargetType(
+          realEffect.R,
+          expectedEffect.R
+        );
+      });
+    }
+    const effectDiagnostics = [];
+    const sortTypes = sort(typeOrder);
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts.forEachChild(node, appendNodeToVisit);
+      const entries = yield* expectedAndRealType(node);
+      for (const [node2, expectedType, valueNode, realType] of entries) {
+        const missingContext = yield* pipe(
+          checkForMissingContextTypes(
+            node2,
+            expectedType,
+            valueNode,
+            realType
+          ),
+          orElse3(() => succeed([]))
         );
         if (missingContext.length > 0) {
           effectDiagnostics.push(
@@ -1416,88 +3335,115 @@ var missingEffectContext = createDiagnostic({
           );
         }
       }
-      ts.forEachChild(node, visit);
-    };
-    ts.forEachChild(sourceFile, visit);
+    }
     return effectDiagnostics;
-  }
+  })
 });
 
 // src/diagnostics/missingEffectError.ts
 var missingEffectError = createDiagnostic({
-  code: 2,
-  apply: (ts, program) => (sourceFile) => {
-    const typeChecker = program.getTypeChecker();
-    const effectDiagnostics = [];
-    const sortTypes = sort(deterministicTypeOrder(ts, typeChecker));
-    const visit = (node) => {
-      const entries = expectedAndRealType(ts, typeChecker)(node);
-      for (const [node2, expectedType, valueNode, realType] of entries) {
-        const expectedEffect = effectType(ts, typeChecker)(
+  name: "effect/missingEffectError",
+  code: 1,
+  apply: (sourceFile) => gen2(function* () {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeOrder = yield* deterministicTypeOrder;
+    function checkForMissingErrorTypes(node, expectedType, valueNode, realType) {
+      return gen2(function* () {
+        const expectedEffect = yield* effectType(
           expectedType,
-          node2
+          node
         );
-        if (isNone2(expectedEffect)) continue;
-        const realEffect = effectType(ts, typeChecker)(
+        const realEffect = yield* effectType(
           realType,
           valueNode
         );
-        if (isNone2(realEffect)) continue;
-        const missingErrorTypes = getMissingTypeEntriesInTargetType(
-          ts,
-          typeChecker
-        )(
-          realEffect.value.E,
-          expectedEffect.value.E
+        return yield* getMissingTypeEntriesInTargetType(
+          realEffect.E,
+          expectedEffect.E
+        );
+      });
+    }
+    const effectDiagnostics = [];
+    const sortTypes = sort(typeOrder);
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts.forEachChild(node, appendNodeToVisit);
+      const entries = yield* expectedAndRealType(node);
+      for (const [node2, expectedType, valueNode, realType] of entries) {
+        const missingContext = yield* pipe(
+          checkForMissingErrorTypes(
+            node2,
+            expectedType,
+            valueNode,
+            realType
+          ),
+          orElse3(() => succeed([]))
         );
-        if (missingErrorTypes.length > 0) {
+        if (missingContext.length > 0) {
           effectDiagnostics.push(
             {
               node: node2,
               category: ts.DiagnosticCategory.Error,
-              messageText: `Missing '${sortTypes(missingErrorTypes).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect errors.`
+              messageText: `Missing '${sortTypes(missingContext).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect errors.`
             }
           );
         }
       }
-      ts.forEachChild(node, visit);
-    };
-    ts.forEachChild(sourceFile, visit);
+    }
     return effectDiagnostics;
-  }
+  })
 });
 
 // src/diagnostics/missingStarInYieldEffectGen.ts
 var missingStarInYieldEffectGen = createDiagnostic({
+  name: "effect/missingStarInYieldEffectGen",
   code: 4,
-  apply: (ts, program) => (sourceFile) => {
-    const typeChecker = program.getTypeChecker();
+  apply: (sourceFile) => gen2(function* () {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
     const effectDiagnostics = [];
     const brokenGenerators = /* @__PURE__ */ new Set();
     const brokenYields = /* @__PURE__ */ new Set();
-    const visit = (functionStarNode) => (node) => {
+    const nodeToVisit = [];
+    const appendNodeToVisit = (functionStarNode) => (node) => {
+      nodeToVisit.push([node, functionStarNode]);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit(void 0));
+    while (nodeToVisit.length > 0) {
+      const [node, functionStarNode] = nodeToVisit.shift();
       if (functionStarNode && ts.isYieldExpression(node) && node.expression && node.asteriskToken === void 0) {
         const type = typeChecker.getTypeAtLocation(node.expression);
-        const effect = effectType(ts, typeChecker)(type, node.expression);
+        const effect = yield* option(effectType(type, node.expression));
         if (isSome2(effect)) {
           brokenGenerators.add(functionStarNode);
           brokenYields.add(node);
         }
       }
-      const effectGenLike = pipe(
-        effectGen(ts, typeChecker)(node),
-        orElse(() => effectFnUntracedGen(ts, typeChecker)(node)),
-        orElse(() => effectFnGen(ts, typeChecker)(node))
+      const effectGenLike = yield* pipe(
+        effectGen(node),
+        orElse3(() => effectFnUntracedGen(node)),
+        orElse3(() => effectFnGen(node)),
+        option
       );
       if (isSome2(effectGenLike)) {
-        ts.forEachChild(effectGenLike.value.body, visit(effectGenLike.value.functionStar));
+        ts.forEachChild(
+          effectGenLike.value.body,
+          appendNodeToVisit(effectGenLike.value.functionStar)
+        );
       } else if ((ts.isFunctionExpression(node) || ts.isMethodDeclaration(node)) && node.asteriskToken !== void 0) {
-        ts.forEachChild(node, visit(void 0));
+        ts.forEachChild(node, appendNodeToVisit(void 0));
       } else {
-        ts.forEachChild(node, visit(functionStarNode));
+        ts.forEachChild(node, appendNodeToVisit(functionStarNode));
       }
-    };
-    ts.forEachChild(sourceFile, visit(void 0));
+    }
     brokenGenerators.forEach(
       (node) => effectDiagnostics.push({
         node,
@@ -1513,23 +3459,35 @@ var missingStarInYieldEffectGen = createDiagnostic({
       })
     );
     return effectDiagnostics;
-  }
+  })
 });
 
 // src/diagnostics/unnecessaryEffectGen.ts
 var unnecessaryEffectGen = createDiagnostic({
+  name: "effect/unnecessaryEffectGen",
   code: 5,
-  apply: (ts, program) => (sourceFile) => {
-    const typeChecker = program.getTypeChecker();
+  apply: (sourceFile) => gen2(function* () {
+    const ts = yield* service(TypeScriptApi);
     const effectDiagnostics = [];
     const brokenGenerators = /* @__PURE__ */ new Set();
-    const visit = (node) => {
-      if (isSome2(getSingleReturnEffectFromEffectGen(ts, typeChecker, node))) {
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts.forEachChild(node, appendNodeToVisit);
+      const maybeUnnecessaryGen = yield* pipe(
+        effectGen(node),
+        flatMap4(({ body }) => returnYieldEffectBlock(body)),
+        option
+      );
+      if (isSome2(maybeUnnecessaryGen)) {
         brokenGenerators.add(node);
       }
-      ts.forEachChild(node, visit);
-    };
-    ts.forEachChild(sourceFile, visit);
+    }
     brokenGenerators.forEach(
       (node) => effectDiagnostics.push({
         node,
@@ -1538,17 +3496,258 @@ var unnecessaryEffectGen = createDiagnostic({
       })
     );
     return effectDiagnostics;
-  }
+  })
 });
 
 // src/diagnostics.ts
-var diagnostics = {
+var diagnostics = [
   missingEffectContext,
   missingEffectError,
   floatingEffect,
   missingStarInYieldEffectGen,
   unnecessaryEffectGen
+];
+
+// src/utils/AST.ts
+function collectSelfAndAncestorNodesInRange(node, textRange) {
+  return sync(() => {
+    let result = empty();
+    let parent = node;
+    while (parent) {
+      if (parent.end >= textRange.end) {
+        result = pipe(result, append(parent));
+      }
+      parent = parent.parent;
+    }
+    return result;
+  });
+}
+function getAncestorNodesInRange(sourceFile, textRange) {
+  return gen2(function* () {
+    const ts = yield* service(TypeScriptApi);
+    const precedingToken = ts.findPrecedingToken(textRange.pos, sourceFile);
+    if (!precedingToken) return empty();
+    return yield* collectSelfAndAncestorNodesInRange(precedingToken, textRange);
+  });
+}
+var NodeNotFoundError = class extends TaggedError("@effect/language-service/NodeNotFoundError") {
+};
+function findNodeAtPosition(sourceFile, position) {
+  return gen2(function* () {
+    const ts = yield* service(TypeScriptApi);
+    function find(node) {
+      if (position >= node.getStart() && position < node.getEnd()) {
+        return ts.forEachChild(node, find) || node;
+      }
+      return void 0;
+    }
+    const result = find(sourceFile);
+    if (!result) return yield* fail3(new NodeNotFoundError());
+    return result;
+  });
+}
+function collectDescendantsAndAncestorsInRange(sourceFile, textRange) {
+  return gen2(function* () {
+    const nodeAtPosition = yield* option(findNodeAtPosition(sourceFile, textRange.pos));
+    if (isNone2(nodeAtPosition)) return empty();
+    return yield* collectSelfAndAncestorNodesInRange(nodeAtPosition.value, textRange);
+  });
+}
+function toTextRange(positionOrRange) {
+  return typeof positionOrRange === "number" ? { end: positionOrRange, pos: positionOrRange } : positionOrRange;
+}
+function isNodeInRange(textRange) {
+  return (node) => node.pos <= textRange.pos && node.end >= textRange.end;
+}
+function transformAsyncAwaitToEffectGen(node, effectModuleName, onAwait) {
+  return gen2(function* () {
+    const ts = yield* service(TypeScriptApi);
+    function visitor(_) {
+      if (ts.isAwaitExpression(_)) {
+        const expression = ts.visitEachChild(_.expression, visitor, ts.nullTransformationContext);
+        return ts.factory.createYieldExpression(
+          ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+          onAwait(expression)
+        );
+      }
+      return ts.visitEachChild(_, visitor, ts.nullTransformationContext);
+    }
+    const generatorBody = visitor(node.body);
+    const generator = ts.factory.createFunctionExpression(
+      void 0,
+      ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+      void 0,
+      [],
+      [],
+      void 0,
+      generatorBody
+      // NOTE(mattia): intended, to use same routine for both ConciseBody and Body
+    );
+    const effectGenCallExp = ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(
+        ts.factory.createIdentifier(effectModuleName),
+        "gen"
+      ),
+      void 0,
+      [generator]
+    );
+    let currentFlags = ts.getCombinedModifierFlags(node);
+    currentFlags &= ~ts.ModifierFlags.Async;
+    const newModifiers = ts.factory.createModifiersFromModifierFlags(currentFlags);
+    if (ts.isArrowFunction(node)) {
+      return ts.factory.createArrowFunction(
+        newModifiers,
+        node.typeParameters,
+        node.parameters,
+        void 0,
+        node.equalsGreaterThanToken,
+        effectGenCallExp
+      );
+    }
+    const newBody = ts.factory.createBlock([
+      ts.factory.createReturnStatement(effectGenCallExp)
+    ]);
+    if (ts.isFunctionDeclaration(node)) {
+      return ts.factory.createFunctionDeclaration(
+        newModifiers,
+        node.asteriskToken,
+        node.name,
+        node.typeParameters,
+        node.parameters,
+        void 0,
+        newBody
+      );
+    }
+    return ts.factory.createFunctionExpression(
+      newModifiers,
+      node.asteriskToken,
+      node.name,
+      node.typeParameters,
+      node.parameters,
+      void 0,
+      newBody
+    );
+  });
+}
+function addReturnTypeAnnotation(sourceFile, declaration, typeNode) {
+  return gen2(function* () {
+    const ts = yield* service(TypeScriptApi);
+    const changes = yield* service(ChangeTracker);
+    const closeParen = ts.findChildOfKind(declaration, ts.SyntaxKind.CloseParenToken, sourceFile);
+    const needParens = ts.isArrowFunction(declaration) && closeParen === void 0;
+    const endNode = needParens ? declaration.parameters[0] : closeParen;
+    if (endNode) {
+      if (needParens) {
+        changes.insertNodeBefore(
+          sourceFile,
+          endNode,
+          ts.factory.createToken(ts.SyntaxKind.OpenParenToken)
+        );
+        changes.insertNodeAfter(
+          sourceFile,
+          endNode,
+          ts.factory.createToken(ts.SyntaxKind.CloseParenToken)
+        );
+      }
+      changes.insertNodeAt(sourceFile, endNode.end, typeNode, { prefix: ": " });
+    }
+  });
+}
+function removeReturnTypeAnnotation(sourceFile, declaration) {
+  return gen2(function* () {
+    const ts = yield* service(TypeScriptApi);
+    const changes = yield* service(ChangeTracker);
+    const closeParen = ts.findChildOfKind(declaration, ts.SyntaxKind.CloseParenToken, sourceFile);
+    const needParens = ts.isArrowFunction(declaration) && closeParen === void 0;
+    const endNode = needParens ? declaration.parameters[0] : closeParen;
+    if (endNode && declaration.type) {
+      changes.deleteRange(sourceFile, { pos: endNode.end, end: declaration.type.end });
+    }
+  });
+}
+var ImportModuleIdentifierNotFoundError = class extends TaggedError("@effect/language-service/ImportModuleIdentifierNotFoundError") {
 };
+function findImportedModuleIdentifier(sourceFile, test) {
+  return gen2(function* () {
+    const ts = yield* service(TypeScriptApi);
+    for (const statement of sourceFile.statements) {
+      if (!ts.isImportDeclaration(statement)) continue;
+      const importClause = statement.importClause;
+      if (!importClause) continue;
+      const namedBindings = importClause.namedBindings;
+      if (!namedBindings) continue;
+      if (ts.isNamespaceImport(namedBindings)) {
+        if (yield* test(namedBindings.name)) return namedBindings.name;
+      } else if (ts.isNamedImports(namedBindings)) {
+        for (const importSpecifier of namedBindings.elements) {
+          if (yield* test(importSpecifier.name)) return importSpecifier.name;
+        }
+      }
+    }
+    return yield* fail3(new ImportModuleIdentifierNotFoundError());
+  });
+}
+function simplifyTypeNode(typeNode) {
+  function collectCallable(ts, typeNode2) {
+    if (ts.isParenthesizedTypeNode(typeNode2)) return collectCallable(ts, typeNode2.type);
+    if (ts.isFunctionTypeNode(typeNode2)) {
+      return some2([
+        ts.factory.createCallSignature(typeNode2.typeParameters, typeNode2.parameters, typeNode2.type)
+      ]);
+    }
+    if (ts.isTypeLiteralNode(typeNode2)) {
+      const allCallSignatures = typeNode2.members.every(ts.isCallSignatureDeclaration);
+      if (allCallSignatures) {
+        return some2(typeNode2.members);
+      }
+    }
+    if (ts.isIntersectionTypeNode(typeNode2)) {
+      const members = typeNode2.types.map((node) => collectCallable(ts, node));
+      if (members.every(isSome2)) {
+        return some2(members.map((_) => isSome2(_) ? _.value : []).flat());
+      }
+    }
+    return none2();
+  }
+  return gen2(function* () {
+    const ts = yield* service(TypeScriptApi);
+    const callSignatures = collectCallable(ts, typeNode);
+    if (isSome2(callSignatures) && callSignatures.value.length > 1) {
+      return ts.factory.createTypeLiteralNode(callSignatures.value);
+    }
+    return typeNode;
+  });
+}
+function tryPreserveDeclarationSemantics(nodeToReplace, node) {
+  return gen2(function* () {
+    const ts = yield* service(TypeScriptApi);
+    if (!ts.isExpression(node)) return node;
+    if (ts.isFunctionDeclaration(nodeToReplace)) {
+      if (!nodeToReplace.name) return node;
+      return ts.factory.createVariableStatement(
+        nodeToReplace.modifiers,
+        ts.factory.createVariableDeclarationList(
+          [ts.factory.createVariableDeclaration(
+            nodeToReplace.name,
+            void 0,
+            void 0,
+            node
+          )],
+          ts.NodeFlags.Const
+        )
+      );
+    } else if (ts.isMethodDeclaration(nodeToReplace)) {
+      return ts.factory.createPropertyDeclaration(
+        nodeToReplace.modifiers,
+        nodeToReplace.name,
+        void 0,
+        void 0,
+        node
+      );
+    }
+    return node;
+  });
+}
 
 // src/quickinfo.ts
 var SymbolDisplayPartEq = make(
@@ -1566,231 +3765,273 @@ function dedupeJsDocTags(quickInfo) {
   }
   return quickInfo;
 }
-function formatTypeForQuickInfo(ts, typeChecker) {
-  return (channelType, channelName) => {
+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 prependEffectTypeArguments(ts, program) {
-  return (sourceFileName, position, quickInfo) => {
-    const sourceFile = program.getSourceFile(sourceFileName);
-    if (!sourceFile) return quickInfo;
-    const hasTruncationHappened = ts.displayPartsToString(quickInfo.displayParts).indexOf("...") > -1;
-    if (!hasTruncationHappened) return quickInfo;
-    const typeChecker = program.getTypeChecker();
-    const effectTypeArgsDocumentation = pipe(
-      getAncestorNodesInRange(ts)(sourceFile, toTextRange(position)),
-      head,
-      flatMap(
-        (_) => effectType(ts, typeChecker)(typeChecker.getTypeAtLocation(_), _)
-      ),
-      map((_) => [{
+function prependEffectTypeArguments(sourceFile, position, quickInfo) {
+  return pipe(
+    gen2(function* () {
+      const ts = yield* service(TypeScriptApi);
+      const typeChecker = yield* service(TypeCheckerApi);
+      const hasTruncationHappened = ts.displayPartsToString(quickInfo.displayParts).indexOf("...") > -1;
+      if (!hasTruncationHappened) return quickInfo;
+      const maybeNode = pipe(
+        yield* getAncestorNodesInRange(sourceFile, toTextRange(position)),
+        head
+      );
+      if (isNone2(maybeNode)) return quickInfo;
+      const effectType2 = yield* effectType(
+        typeChecker.getTypeAtLocation(maybeNode.value),
+        maybeNode.value
+      );
+      const effectTypeArgsDocumentation = [{
         kind: "text",
-        text: "```ts\n/* Effect Type Parameters */\n" + formatTypeForQuickInfo(ts, typeChecker)(_.A, "Success") + "\n" + formatTypeForQuickInfo(ts, typeChecker)(_.E, "Failure") + "\n" + formatTypeForQuickInfo(ts, typeChecker)(_.R, "Requirements") + "\n```\n"
-      }]),
-      getOrElse(() => [])
-    );
-    if (quickInfo.documentation) {
+        text: "```ts\n/* Effect Type Parameters */\n" + (yield* formatTypeForQuickInfo(effectType2.A, "Success")) + "\n" + (yield* formatTypeForQuickInfo(effectType2.E, "Failure")) + "\n" + (yield* formatTypeForQuickInfo(effectType2.R, "Requirements")) + "\n```\n"
+      }];
+      if (quickInfo.documentation) {
+        return {
+          ...quickInfo,
+          documentation: effectTypeArgsDocumentation.concat(quickInfo.documentation)
+        };
+      }
       return {
         ...quickInfo,
-        documentation: effectTypeArgsDocumentation.concat(quickInfo.documentation)
+        documentation: effectTypeArgsDocumentation
       };
-    }
-    return {
-      ...quickInfo,
-      documentation: effectTypeArgsDocumentation
-    };
-  };
+    }),
+    orElse3(() => succeed(quickInfo))
+  );
 }
 
 // src/refactors/asyncAwaitToGen.ts
 var asyncAwaitToGen = createRefactor({
   name: "effect/asyncAwaitToGen",
   description: "Convert to Effect.gen",
-  apply: (ts, program) => (sourceFile, textRange) => pipe(
-    getAncestorNodesInRange(ts)(sourceFile, textRange),
-    filter(
-      (node) => ts.isFunctionDeclaration(node) || ts.isArrowFunction(node) || ts.isFunctionExpression(node)
-    ),
-    filter((node) => !!node.body),
-    filter(
-      (node) => !!(ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Async)
-    ),
-    head,
-    map((node) => ({
+  apply: (sourceFile, textRange) => gen2(function* () {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const maybeNode = pipe(
+      yield* getAncestorNodesInRange(sourceFile, textRange),
+      filter(
+        (node2) => ts.isFunctionDeclaration(node2) || ts.isArrowFunction(node2) || ts.isFunctionExpression(node2)
+      ),
+      filter((node2) => !!node2.body),
+      filter(
+        (node2) => !!(ts.getCombinedModifierFlags(node2) & ts.ModifierFlags.Async)
+      ),
+      head
+    );
+    if (isNone2(maybeNode)) return yield* fail3(new RefactorNotApplicableError());
+    const node = maybeNode.value;
+    return {
       kind: "refactor.rewrite.effect.asyncAwaitToGen",
       description: "Rewrite to Effect.gen",
-      apply: (changeTracker) => {
-        const isImportedEffectModule = importedEffectModule(
-          ts,
-          program.getTypeChecker()
-        );
-        const effectModuleIdentifierName = pipe(
-          findImportedModuleIdentifier(ts)(
-            (node2) => isSome2(isImportedEffectModule(node2))
-          )(sourceFile),
-          map((node2) => node2.text),
-          getOrElse(() => "Effect")
-        );
-        const newDeclaration = transformAsyncAwaitToEffectGen(
-          ts
-        )(
-          node,
-          effectModuleIdentifierName,
-          (expression) => ts.factory.createCallExpression(
-            ts.factory.createPropertyAccessExpression(
-              ts.factory.createIdentifier(effectModuleIdentifierName),
-              "promise"
-            ),
-            void 0,
-            [
-              ts.factory.createArrowFunction(
-                void 0,
-                void 0,
-                [],
-                void 0,
-                void 0,
-                expression
+      apply: pipe(
+        gen2(function* () {
+          const changeTracker = yield* service(ChangeTracker);
+          const effectModuleIdentifierName = match2(
+            yield* option(
+              findImportedModuleIdentifier(
+                sourceFile,
+                (node2) => pipe(
+                  importedEffectModule(node2),
+                  option,
+                  map7(isSome2)
+                )
               )
-            ]
-          )
-        );
-        changeTracker.replaceNode(sourceFile, node, newDeclaration);
-      }
-    }))
-  )
+            ),
+            {
+              onNone: () => "Effect",
+              onSome: (node2) => node2.text
+            }
+          );
+          const newDeclaration = yield* transformAsyncAwaitToEffectGen(
+            node,
+            effectModuleIdentifierName,
+            (expression) => ts.factory.createCallExpression(
+              ts.factory.createPropertyAccessExpression(
+                ts.factory.createIdentifier(effectModuleIdentifierName),
+                "promise"
+              ),
+              void 0,
+              [
+                ts.factory.createArrowFunction(
+                  void 0,
+                  void 0,
+                  [],
+                  void 0,
+                  void 0,
+                  expression
+                )
+              ]
+            )
+          );
+          changeTracker.replaceNode(sourceFile, node, newDeclaration);
+        }),
+        provideService(TypeScriptApi, ts),
+        provideService(TypeCheckerApi, typeChecker)
+      )
+    };
+  })
 });
 
 // src/refactors/asyncAwaitToGenTryPromise.ts
 var asyncAwaitToGenTryPromise = createRefactor({
   name: "effect/asyncAwaitToGenTryPromise",
   description: "Convert to Effect.gen with failures",
-  apply: (ts, program) => (sourceFile, textRange) => pipe(
-    getAncestorNodesInRange(ts)(sourceFile, textRange),
-    filter(
-      (node) => ts.isFunctionDeclaration(node) || ts.isArrowFunction(node) || ts.isFunctionExpression(node)
-    ),
-    filter((node) => !!node.body),
-    filter(
-      (node) => !!(ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Async)
-    ),
-    head,
-    map((node) => ({
+  apply: (sourceFile, textRange) => gen2(function* () {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const maybeNode = pipe(
+      yield* getAncestorNodesInRange(sourceFile, textRange),
+      filter(
+        (node2) => ts.isFunctionDeclaration(node2) || ts.isArrowFunction(node2) || ts.isFunctionExpression(node2)
+      ),
+      filter((node2) => !!node2.body),
+      filter(
+        (node2) => !!(ts.getCombinedModifierFlags(node2) & ts.ModifierFlags.Async)
+      ),
+      head
+    );
+    if (isNone2(maybeNode)) return yield* fail3(new RefactorNotApplicableError());
+    const node = maybeNode.value;
+    return {
       kind: "refactor.rewrite.effect.asyncAwaitToGenTryPromise",
       description: "Rewrite to Effect.gen with failures",
-      apply: (changeTracker) => {
-        const isImportedEffectModule = importedEffectModule(
-          ts,
-          program.getTypeChecker()
-        );
-        const effectModuleIdentifierName = pipe(
-          findImportedModuleIdentifier(ts)(
-            (node2) => isSome2(isImportedEffectModule(node2))
-          )(sourceFile),
-          map((node2) => node2.text),
-          getOrElse(() => "Effect")
-        );
-        let errorCount = 0;
-        function createErrorADT() {
-          errorCount++;
-          return ts.factory.createObjectLiteralExpression([
-            ts.factory.createPropertyAssignment(
-              "_tag",
-              ts.factory.createAsExpression(
-                ts.factory.createStringLiteral("Error" + errorCount),
-                ts.factory.createTypeReferenceNode("const")
+      apply: pipe(
+        gen2(function* () {
+          const changeTracker = yield* service(ChangeTracker);
+          const effectModuleIdentifierName = match2(
+            yield* option(
+              findImportedModuleIdentifier(
+                sourceFile,
+                (node2) => pipe(
+                  importedEffectModule(node2),
+                  option,
+                  map7(isSome2)
+                )
               )
             ),
-            ts.factory.createShorthandPropertyAssignment("error")
-          ]);
-        }
-        const newDeclaration = transformAsyncAwaitToEffectGen(
-          ts
-        )(
-          node,
-          effectModuleIdentifierName,
-          (expression) => ts.factory.createCallExpression(
-            ts.factory.createPropertyAccessExpression(
-              ts.factory.createIdentifier(effectModuleIdentifierName),
-              "tryPromise"
-            ),
-            void 0,
-            [
-              ts.factory.createObjectLiteralExpression([
-                ts.factory.createPropertyAssignment(
-                  ts.factory.createIdentifier("try"),
-                  ts.factory.createArrowFunction(
-                    void 0,
-                    void 0,
-                    [],
-                    void 0,
-                    void 0,
-                    expression
-                  )
-                ),
-                ts.factory.createPropertyAssignment(
-                  ts.factory.createIdentifier("catch"),
-                  ts.factory.createArrowFunction(
-                    void 0,
-                    void 0,
-                    [ts.factory.createParameterDeclaration(void 0, void 0, "error")],
-                    void 0,
-                    void 0,
-                    createErrorADT()
-                  )
+            {
+              onNone: () => "Effect",
+              onSome: (node2) => node2.text
+            }
+          );
+          let errorCount = 0;
+          function createErrorADT() {
+            errorCount++;
+            return ts.factory.createObjectLiteralExpression([
+              ts.factory.createPropertyAssignment(
+                "_tag",
+                ts.factory.createAsExpression(
+                  ts.factory.createStringLiteral("Error" + errorCount),
+                  ts.factory.createTypeReferenceNode("const")
                 )
-              ])
-            ]
-          )
-        );
-        changeTracker.replaceNode(sourceFile, node, newDeclaration);
-      }
-    }))
-  )
+              ),
+              ts.factory.createShorthandPropertyAssignment("error")
+            ]);
+          }
+          const newDeclaration = yield* transformAsyncAwaitToEffectGen(
+            node,
+            effectModuleIdentifierName,
+            (expression) => ts.factory.createCallExpression(
+              ts.factory.createPropertyAccessExpression(
+                ts.factory.createIdentifier(effectModuleIdentifierName),
+                "tryPromise"
+              ),
+              void 0,
+              [
+                ts.factory.createObjectLiteralExpression([
+                  ts.factory.createPropertyAssignment(
+                    ts.factory.createIdentifier("try"),
+                    ts.factory.createArrowFunction(
+                      void 0,
+                      void 0,
+                      [],
+                      void 0,
+                      void 0,
+                      expression
+                    )
+                  ),
+                  ts.factory.createPropertyAssignment(
+                    ts.factory.createIdentifier("catch"),
+                    ts.factory.createArrowFunction(
+                      void 0,
+                      void 0,
+                      [ts.factory.createParameterDeclaration(void 0, void 0, "error")],
+                      void 0,
+                      void 0,
+                      createErrorADT()
+                    )
+                  )
+                ])
+              ]
+            )
+          );
+          changeTracker.replaceNode(sourceFile, node, newDeclaration);
+        }),
+        provideService(TypeScriptApi, ts),
+        provideService(TypeCheckerApi, typeChecker)
+      )
+    };
+  })
 });
 
 // src/refactors/effectGenToFn.ts
 var effectGenToFn = createRefactor({
   name: "effect/effectGenToFn",
   description: "Convert to Effect.fn",
-  apply: (ts, program) => (sourceFile, textRange) => pipe(
-    getAncestorNodesInRange(ts)(sourceFile, textRange),
-    findFirst2(
-      (node) => gen(function* () {
-        const effectGen2 = yield* effectGen(ts, program.getTypeChecker())(node);
-        let pipeArgs = ts.factory.createNodeArray([]);
-        let nodeToReplace = node.parent;
+  apply: (sourceFile, textRange) => gen2(function* () {
+    const ts = yield* service(TypeScriptApi);
+    function parseEffectGenNode(node) {
+      return gen2(function* () {
+        const effectGen2 = yield* effectGen(node);
+        let pipeArgs2 = ts.factory.createNodeArray([]);
+        let nodeToReplace2 = node.parent;
         if (ts.isPropertyAccessExpression(node.parent) && node.parent.name.text === "pipe" && ts.isCallExpression(node.parent.parent)) {
-          pipeArgs = node.parent.parent.arguments;
-          nodeToReplace = node.parent.parent.parent;
+          pipeArgs2 = node.parent.parent.arguments;
+          nodeToReplace2 = node.parent.parent.parent;
         }
-        while (nodeToReplace) {
-          if (ts.isArrowFunction(nodeToReplace) || ts.isFunctionDeclaration(nodeToReplace) || ts.isMethodDeclaration(nodeToReplace)) {
-            return { ...effectGen2, pipeArgs, nodeToReplace };
+        while (nodeToReplace2) {
+          if (ts.isArrowFunction(nodeToReplace2) || ts.isFunctionDeclaration(nodeToReplace2) || ts.isMethodDeclaration(nodeToReplace2)) {
+            return { ...effectGen2, pipeArgs: pipeArgs2, nodeToReplace: nodeToReplace2 };
           }
-          if (ts.isConciseBody(nodeToReplace) || ts.isReturnStatement(nodeToReplace)) {
-            nodeToReplace = nodeToReplace.parent;
+          if (ts.isConciseBody(nodeToReplace2) || ts.isReturnStatement(nodeToReplace2)) {
+            nodeToReplace2 = nodeToReplace2.parent;
             continue;
           }
-          if (ts.isBlock(nodeToReplace) && nodeToReplace.statements.length === 1) {
-            nodeToReplace = nodeToReplace.parent;
+          if (ts.isBlock(nodeToReplace2) && nodeToReplace2.statements.length === 1) {
+            nodeToReplace2 = nodeToReplace2.parent;
             continue;
           }
           break;
         }
-        return yield* none2();
-      })
-    ),
-    map(
-      ({ effectModule, generatorFunction, nodeToReplace, pipeArgs }) => ({
-        kind: "refactor.rewrite.effect.effectGenToFn",
-        description: "Convert to Effect.fn",
-        apply: (changeTracker) => {
+        return yield* fail3(new RefactorNotApplicableError());
+      });
+    }
+    const maybeNode = yield* pipe(
+      yield* getAncestorNodesInRange(sourceFile, textRange),
+      map2(parseEffectGenNode),
+      firstSuccessOf,
+      option
+    );
+    if (isNone2(maybeNode)) return yield* fail3(new RefactorNotApplicableError());
+    const { effectModule, generatorFunction, nodeToReplace, pipeArgs } = maybeNode.value;
+    return {
+      kind: "refactor.rewrite.effect.effectGenToFn",
+      description: "Convert to Effect.fn",
+      apply: pipe(
+        gen2(function* () {
+          const changeTracker = yield* service(ChangeTracker);
           const effectFn = nodeToReplace.name && ts.isIdentifier(nodeToReplace.name) ? ts.factory.createCallExpression(
             ts.factory.createPropertyAccessExpression(
               effectModule,
@@ -1818,37 +4059,36 @@ var effectGenToFn = createRefactor({
           changeTracker.replaceNode(
             sourceFile,
             nodeToReplace,
-            tryPreserveDeclarationSemantics(ts)(nodeToReplace, effectFnCallWithGenerator)
+            yield* tryPreserveDeclarationSemantics(nodeToReplace, effectFnCallWithGenerator)
           );
-        }
-      })
-    )
-  )
+        }),
+        provideService(TypeScriptApi, ts)
+      )
+    };
+  })
 });
 
 // src/refactors/functionToArrow.ts
 var functionToArrow = createRefactor({
   name: "effect/functionToArrow",
   description: "Convert to arrow",
-  apply: (ts) => (sourceFile, textRange) => pipe(
-    pipe(
-      getAncestorNodesInRange(ts)(sourceFile, textRange),
-      filter(ts.isFunctionDeclaration)
-    ),
-    appendAll(
-      pipe(
-        getAncestorNodesInRange(ts)(sourceFile, textRange),
-        filter(ts.isMethodDeclaration)
-      )
-    ),
-    filter((node) => !!node.body),
-    filter((node) => !!node.name && isNodeInRange(textRange)(node.name)),
-    head,
-    map(
-      (node) => ({
-        kind: "refactor.rewrite.effect.functionToArrow",
-        description: "Convert to arrow",
-        apply: (changeTracker) => {
+  apply: (sourceFile, textRange) => gen2(function* () {
+    const ts = yield* service(TypeScriptApi);
+    const maybeNode = pipe(
+      yield* getAncestorNodesInRange(sourceFile, textRange),
+      filter((_) => ts.isFunctionDeclaration(_) || ts.isMethodDeclaration(_)),
+      filter((_) => !!_.body),
+      filter((_) => !!_.name && isNodeInRange(textRange)(_.name)),
+      head
+    );
+    if (isNone2(maybeNode)) return yield* fail3(new RefactorNotApplicableError());
+    const node = maybeNode.value;
+    return {
+      kind: "refactor.rewrite.effect.functionToArrow",
+      description: "Convert to arrow",
+      apply: pipe(
+        gen2(function* () {
+          const changeTracker = yield* service(ChangeTracker);
           const body = node.body;
           let newBody = ts.factory.createBlock(body.statements);
           if (body.statements.length === 1) {
@@ -1869,269 +4109,306 @@ var functionToArrow = createRefactor({
             ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
             newBody
           );
-          let constFlags = ts.getCombinedModifierFlags(node);
-          constFlags &= ~arrowFlags;
-          const constModifiers = ts.factory.createModifiersFromModifierFlags(constFlags);
-          let newDeclaration = node;
-          if (ts.isMethodDeclaration(node)) {
-            newDeclaration = ts.factory.createPropertyDeclaration(
-              constModifiers,
-              node.name,
-              void 0,
-              void 0,
-              arrowFunction
-            );
-          } else if (ts.isFunctionDeclaration(node)) {
-            newDeclaration = ts.factory.createVariableStatement(
-              constModifiers,
-              ts.factory.createVariableDeclarationList(
-                [
-                  ts.factory.createVariableDeclaration(
-                    node.name,
-                    void 0,
-                    void 0,
-                    arrowFunction
-                  )
-                ],
-                ts.NodeFlags.Const
-              )
-            );
-          }
-          changeTracker.replaceNode(sourceFile, node, newDeclaration);
-        }
-      })
-    )
-  )
+          const newDeclaration = yield* tryPreserveDeclarationSemantics(
+            node,
+            arrowFunction
+          );
+          changeTracker.replaceNode(sourceFile, node, newDeclaration, {
+            leadingTriviaOption: ts.textChanges.LeadingTriviaOption.IncludeAll,
+            trailingTriviaOption: ts.textChanges.TrailingTriviaOption.Exclude
+          });
+        }),
+        provideService(TypeScriptApi, ts)
+      )
+    };
+  })
 });
 
 // src/refactors/pipeableToDatafirst.ts
 var pipeableToDatafirst = createRefactor({
   name: "effect/pipeableToDatafirst",
   description: "Rewrite to datafirst",
-  apply: (ts, program) => (sourceFile, textRange) => pipe(
-    getAncestorNodesInRange(ts)(sourceFile, textRange),
-    filter(isPipeCall(ts)),
-    filter((node) => isNodeInRange(textRange)(node.expression)),
-    filter(
-      (node) => node.arguments.length > 0
-    ),
-    map2((node) => {
-      let newNode = node.arguments[0];
-      let didSomething = false;
-      for (let i = 1; i < node.arguments.length; i++) {
-        const arg = node.arguments[i];
-        const a = asDataFirstExpression(ts, program.getTypeChecker())(arg, newNode);
-        if (isSome2(a)) {
-          newNode = a.value;
-          didSomething = true;
-        } else {
-          if (isPipeCall(ts)(newNode)) {
-            newNode = ts.factory.createCallExpression(
-              ts.factory.createIdentifier("pipe"),
+  apply: (sourceFile, textRange) => gen2(function* () {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    function isPipeCall(node2) {
+      if (!ts.isCallExpression(node2)) return false;
+      const expression = node2.expression;
+      if (!ts.isIdentifier(expression)) return false;
+      if (expression.text !== "pipe") return false;
+      return true;
+    }
+    function asDataFirstExpression(node2, self) {
+      if (!ts.isCallExpression(node2)) return none2();
+      const signature = typeChecker.getResolvedSignature(node2);
+      if (!signature) return none2();
+      const callSignatures = typeChecker.getTypeAtLocation(node2.expression).getCallSignatures();
+      for (let i = 0; i < callSignatures.length; i++) {
+        const callSignature = callSignatures[i];
+        if (callSignature.parameters.length === node2.arguments.length + 1) {
+          return some2(
+            ts.factory.createCallExpression(
+              node2.expression,
               [],
-              newNode.arguments.concat([arg])
-            );
+              [self].concat(node2.arguments)
+            )
+          );
+        }
+      }
+      return none2();
+    }
+    const maybeNode = pipe(
+      yield* getAncestorNodesInRange(sourceFile, textRange),
+      filter(isPipeCall),
+      filter((node2) => isNodeInRange(textRange)(node2.expression)),
+      filter(
+        (node2) => node2.arguments.length > 0
+      ),
+      map2((node2) => {
+        let newNode2 = node2.arguments[0];
+        let didSomething = false;
+        for (let i = 1; i < node2.arguments.length; i++) {
+          const arg = node2.arguments[i];
+          const a = asDataFirstExpression(arg, newNode2);
+          if (isSome2(a)) {
+            newNode2 = a.value;
+            didSomething = true;
           } else {
-            newNode = ts.factory.createCallExpression(ts.factory.createIdentifier("pipe"), [], [
-              newNode,
-              arg
-            ]);
+            if (isPipeCall(newNode2)) {
+              newNode2 = ts.factory.createCallExpression(
+                ts.factory.createIdentifier("pipe"),
+                [],
+                newNode2.arguments.concat([arg])
+              );
+            } else {
+              newNode2 = ts.factory.createCallExpression(ts.factory.createIdentifier("pipe"), [], [
+                newNode2,
+                arg
+              ]);
+            }
           }
         }
-      }
-      return didSomething ? some2([node, newNode]) : none2();
-    }),
-    filter(isSome2),
-    map2((_) => _.value),
-    head,
-    map(([node, newNode]) => ({
+        return didSomething ? some2([node2, newNode2]) : none2();
+      }),
+      filter(isSome2),
+      map2((_) => _.value),
+      head
+    );
+    if (isNone2(maybeNode)) return yield* fail3(new RefactorNotApplicableError());
+    const [node, newNode] = maybeNode.value;
+    return {
       kind: "refactor.rewrite.effect.pipeableToDatafirst",
       description: "Rewrite to datafirst",
-      apply: (changeTracker) => {
+      apply: gen2(function* () {
+        const changeTracker = yield* service(ChangeTracker);
         changeTracker.replaceNode(sourceFile, node, newNode);
-      }
-    }))
-  )
+      })
+    };
+  })
 });
 
 // src/refactors/removeUnnecessaryEffectGen.ts
 var removeUnnecessaryEffectGen = createRefactor({
   name: "effect/removeUnnecessaryEffectGen",
   description: "Remove unnecessary Effect.gen",
-  apply: (ts, program) => (sourceFile, textRange) => {
-    const typeChecker = program.getTypeChecker();
-    return pipe(
-      collectDescendantsAndAncestorsInRange(ts, sourceFile, textRange),
-      findFirst2(
-        (node) => gen(function* () {
-          const returnedYieldedEffect = yield* getSingleReturnEffectFromEffectGen(
-            ts,
-            typeChecker,
-            node
-          );
-          return { nodeToReplace: node, returnedYieldedEffect };
-        })
-      ),
-      map((a) => ({
+  apply: (sourceFile, textRange) => gen2(function* () {
+    for (const nodeToReplace of yield* collectDescendantsAndAncestorsInRange(
+      sourceFile,
+      textRange
+    )) {
+      const maybeNode = yield* pipe(
+        effectGen(nodeToReplace),
+        flatMap4(({ body }) => returnYieldEffectBlock(body)),
+        option
+      );
+      if (isNone2(maybeNode)) continue;
+      const returnedYieldedEffect = maybeNode.value;
+      return {
         kind: "refactor.rewrite.effect.removeUnnecessaryEffectGen",
         description: "Remove unnecessary Effect.gen",
-        apply: (changeTracker) => {
-          changeTracker.replaceNode(sourceFile, a.nodeToReplace, a.returnedYieldedEffect);
-        }
-      }))
-    );
-  }
+        apply: gen2(function* () {
+          const changeTracker = yield* service(ChangeTracker);
+          changeTracker.replaceNode(sourceFile, nodeToReplace, returnedYieldedEffect);
+        })
+      };
+    }
+    return yield* fail3(new RefactorNotApplicableError());
+  })
 });
 
 // src/refactors/toggleLazyConst.ts
 var toggleLazyConst = createRefactor({
   name: "effect/toggleLazyConst",
   description: "Toggle type annotation",
-  apply: (ts) => (sourceFile, textRange) => pipe(
-    getAncestorNodesInRange(ts)(sourceFile, textRange),
-    filter(ts.isVariableDeclaration),
-    filter((node) => isNodeInRange(textRange)(node.name)),
-    filter(
-      (node) => !!node.initializer && !(ts.isArrowFunction(node.initializer) && ts.isBlock(node.initializer.body))
-    ),
-    head,
-    map(
-      (node) => ({
-        kind: "refactor.rewrite.effect.toggleLazyConst",
-        description: "Toggle lazy const",
-        apply: (changeTracker) => {
-          const initializer = node.initializer;
-          if (ts.isArrowFunction(initializer) && initializer.parameters.length === 0) {
-            changeTracker.deleteRange(sourceFile, {
-              pos: initializer.body.end,
-              end: initializer.end
-            });
-            changeTracker.deleteRange(sourceFile, {
-              pos: initializer.pos,
-              end: initializer.body.pos
-            });
-            return;
-          }
-          changeTracker.insertText(sourceFile, initializer.pos, " () =>");
+  apply: (sourceFile, textRange) => gen2(function* () {
+    const ts = yield* service(TypeScriptApi);
+    const maybeNode = pipe(
+      yield* getAncestorNodesInRange(sourceFile, textRange),
+      filter(ts.isVariableDeclaration),
+      filter((node2) => isNodeInRange(textRange)(node2.name)),
+      filter(
+        (node2) => !!node2.initializer && !(ts.isArrowFunction(node2.initializer) && ts.isBlock(node2.initializer.body))
+      ),
+      head
+    );
+    if (isNone2(maybeNode)) return yield* fail3(new RefactorNotApplicableError());
+    const node = maybeNode.value;
+    return {
+      kind: "refactor.rewrite.effect.toggleLazyConst",
+      description: "Toggle lazy const",
+      apply: gen2(function* () {
+        const changeTracker = yield* service(ChangeTracker);
+        const initializer = node.initializer;
+        if (ts.isArrowFunction(initializer) && initializer.parameters.length === 0) {
+          changeTracker.deleteRange(sourceFile, {
+            pos: initializer.body.end,
+            end: initializer.end
+          });
+          changeTracker.deleteRange(sourceFile, {
+            pos: initializer.pos,
+            end: initializer.body.pos
+          });
+          return;
         }
+        changeTracker.insertText(sourceFile, initializer.pos, " () =>");
       })
-    )
-  )
+    };
+  })
 });
 
 // src/refactors/toggleReturnTypeAnnotation.ts
 var toggleReturnTypeAnnotation = createRefactor({
   name: "effect/toggleReturnTypeAnnotation",
   description: "Toggle return type annotation",
-  apply: (ts, program) => (sourceFile, textRange) => {
-    return gen(function* () {
-      const typeChecker = program.getTypeChecker();
-      const node = yield* pipe(
-        getAncestorNodesInRange(ts)(sourceFile, textRange),
-        filter(
-          (node2) => ts.isFunctionDeclaration(node2) || ts.isFunctionExpression(node2) || ts.isArrowFunction(node2) || ts.isMethodDeclaration(node2)
-        ),
-        head
-      );
-      if (node.type) {
-        return {
-          kind: "refactor.rewrite.effect.toggleReturnTypeAnnotation",
-          description: "Toggle return type annotation",
-          apply: (changeTracker) => removeReturnTypeAnnotation(ts, changeTracker)(sourceFile, node)
-        };
-      }
-      const returnType = yield* getInferredReturnType(ts, typeChecker)(node);
-      const returnTypeNode = yield* fromNullable(
-        typeChecker.typeToTypeNode(returnType, node, ts.NodeBuilderFlags.NoTruncation)
-      );
+  apply: (sourceFile, textRange) => gen2(function* () {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const maybeNode = pipe(
+      yield* getAncestorNodesInRange(sourceFile, textRange),
+      filter(
+        (node2) => ts.isFunctionDeclaration(node2) || ts.isFunctionExpression(node2) || ts.isArrowFunction(node2) || ts.isMethodDeclaration(node2)
+      ),
+      head
+    );
+    if (isNone2(maybeNode)) return yield* fail3(new RefactorNotApplicableError());
+    const node = maybeNode.value;
+    if (node.type) {
       return {
         kind: "refactor.rewrite.effect.toggleReturnTypeAnnotation",
         description: "Toggle return type annotation",
-        apply: (changeTracker) => {
-          addReturnTypeAnnotation(ts, changeTracker)(
-            sourceFile,
-            node,
-            simplifyTypeNode(ts)(returnTypeNode)
-          );
-        }
+        apply: pipe(
+          removeReturnTypeAnnotation(sourceFile, node),
+          provideService(TypeScriptApi, ts)
+        )
       };
-    });
-  }
+    }
+    const returnType = yield* option(getInferredReturnType(node));
+    if (isNone2(returnType)) return yield* fail3(new RefactorNotApplicableError());
+    const returnTypeNode = typeChecker.typeToTypeNode(
+      returnType.value,
+      node,
+      ts.NodeBuilderFlags.NoTruncation
+    );
+    if (!returnTypeNode) return yield* fail3(new RefactorNotApplicableError());
+    return {
+      kind: "refactor.rewrite.effect.toggleReturnTypeAnnotation",
+      description: "Toggle return type annotation",
+      apply: pipe(
+        addReturnTypeAnnotation(
+          sourceFile,
+          node,
+          yield* simplifyTypeNode(returnTypeNode)
+        ),
+        provideService(TypeCheckerApi, typeChecker),
+        provideService(TypeScriptApi, ts)
+      )
+    };
+  })
 });
 
 // src/refactors/toggleTypeAnnotation.ts
 var toggleTypeAnnotation = createRefactor({
   name: "effect/toggleTypeAnnotation",
   description: "Toggle type annotation",
-  apply: (ts, program) => (sourceFile, textRange) => pipe(
-    getAncestorNodesInRange(ts)(sourceFile, textRange),
-    filter(
-      (node) => ts.isVariableDeclaration(node) || ts.isPropertyDeclaration(node)
-    ),
-    filter((node) => isNodeInRange(textRange)(node.name)),
-    filter((node) => !!node.initializer),
-    head,
-    map(
-      (node) => ({
-        kind: "refactor.rewrite.effect.toggleTypeAnnotation",
-        description: "Toggle type annotation",
-        apply: (changeTracker) => {
-          const typeChecker = program.getTypeChecker();
+  apply: (sourceFile, textRange) => gen2(function* () {
+    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) => isNodeInRange(textRange)(node2.name)),
+      filter((node2) => !!node2.initializer),
+      head
+    );
+    if (isNone2(maybeNode)) return yield* fail3(new RefactorNotApplicableError());
+    const node = maybeNode.value;
+    return {
+      kind: "refactor.rewrite.effect.toggleTypeAnnotation",
+      description: "Toggle type annotation",
+      apply: pipe(
+        gen2(function* () {
+          const changeTracker = yield* service(ChangeTracker);
           if (node.type) {
             changeTracker.deleteRange(sourceFile, { pos: node.name.end, end: node.type.end });
             return;
           }
           const initializer = node.initializer;
           const initializerType = typeChecker.getTypeAtLocation(initializer);
-          const initializerTypeNode = fromNullable(typeChecker.typeToTypeNode(
+          const initializerTypeNode = fromNullable2(typeChecker.typeToTypeNode(
             initializerType,
             node,
             ts.NodeBuilderFlags.NoTruncation
           )).pipe(
-            orElse(
-              () => fromNullable(typeChecker.typeToTypeNode(
+            orElse2(
+              () => fromNullable2(typeChecker.typeToTypeNode(
                 initializerType,
                 void 0,
                 ts.NodeBuilderFlags.NoTruncation
               ))
             ),
-            getOrUndefined
+            getOrUndefined2
           );
           if (initializerTypeNode) {
             changeTracker.insertNodeAt(
               sourceFile,
               node.name.end,
-              simplifyTypeNode(ts)(initializerTypeNode),
+              yield* simplifyTypeNode(initializerTypeNode),
               {
                 prefix: ": "
               }
             );
           }
-        }
-      })
-    )
-  )
+        }),
+        provideService(TypeScriptApi, ts)
+      )
+    };
+  })
 });
 
 // src/refactors/wrapWithPipe.ts
 var wrapWithPipe = createRefactor({
   name: "effect/wrapWithPipe",
   description: "Wrap with pipe",
-  apply: () => (sourceFile, textRange) => {
-    if (textRange.end - textRange.pos === 0) return none2();
-    return some2({
+  apply: (sourceFile, textRange) => gen2(function* () {
+    if (textRange.end - textRange.pos === 0) {
+      return yield* fail3(new RefactorNotApplicableError());
+    }
+    return {
       kind: "refactor.rewrite.effect.wrapWithPipe",
       description: `Wrap with pipe(...)`,
-      apply: (changeTracker) => {
+      apply: gen2(function* () {
+        const changeTracker = yield* service(ChangeTracker);
         changeTracker.insertText(sourceFile, textRange.pos, "pipe(");
         changeTracker.insertText(sourceFile, textRange.end, ")");
-      }
-    });
-  }
+      })
+    };
+  })
 });
 
 // src/refactors.ts
-var refactors = {
+var refactors = [
   asyncAwaitToGen,
   asyncAwaitToGenTryPromise,
   functionToArrow,
@@ -2142,11 +4419,10 @@ var refactors = {
   toggleTypeAnnotation,
   wrapWithPipe,
   effectGenToFn
-};
+];
 
 // src/index.ts
 var init = (modules) => {
-  const ts = modules.typescript;
   function create(info) {
     const languageService = info.languageService;
     const pluginOptions = {
@@ -2161,35 +4437,18 @@ var init = (modules) => {
       const applicableDiagnostics = languageService.getSemanticDiagnostics(fileName, ...args);
       const program = languageService.getProgram();
       if (pluginOptions.diagnostics && program) {
-        const effectDiagnostics = pipe(
-          fromNullable(program.getSourceFile(fileName)),
-          map(
-            (sourceFile) => pipe(
-              Object.values(diagnostics).map(
-                (diagnostic) => pipe(
-                  diagnostic.apply(modules.typescript, program, pluginOptions)(
-                    sourceFile,
-                    applicableDiagnostics
-                  ).map((_) => ({
-                    file: sourceFile,
-                    start: _.node.getStart(sourceFile),
-                    length: _.node.getEnd() - _.node.getStart(sourceFile),
-                    messageText: _.messageText,
-                    category: _.category,
-                    code: diagnostic.code,
-                    source: "effect"
-                  }))
-                )
-              ),
-              (_) => _.reduce(
-                (arr, maybeRefactor) => arr.concat(maybeRefactor),
-                []
-              )
-            )
-          ),
-          getOrElse(() => [])
-        );
-        return effectDiagnostics.concat(applicableDiagnostics);
+        const sourceFile = program.getSourceFile(fileName);
+        if (sourceFile) {
+          return pipe(
+            getSemanticDiagnostics(diagnostics, sourceFile),
+            provideService(TypeScriptApi, modules.typescript),
+            provideService(TypeCheckerApi, program.getTypeChecker()),
+            provideService(PluginOptions, pluginOptions),
+            run,
+            Either_exports.map((effectDiagnostics) => effectDiagnostics.concat(applicableDiagnostics)),
+            Either_exports.getOrElse(() => applicableDiagnostics)
+          );
+        }
       }
       return applicableDiagnostics;
     };
@@ -2198,78 +4457,58 @@ var init = (modules) => {
       const [fileName, positionOrRange] = args;
       const program = languageService.getProgram();
       if (program) {
-        const textRange = toTextRange(positionOrRange);
-        const effectRefactors = pipe(
-          fromNullable(program.getSourceFile(fileName)),
-          map(
-            (sourceFile) => pipe(
-              Object.values(refactors).map(
-                (refactor) => pipe(
-                  refactor.apply(modules.typescript, program, pluginOptions)(
-                    sourceFile,
-                    textRange
-                  ),
-                  map((_) => ({
-                    name: refactor.name,
-                    description: refactor.description,
-                    actions: [{
-                      name: refactor.name,
-                      description: _.description,
-                      kind: _.kind
-                    }]
-                  }))
-                )
-              ),
-              (_) => _.reduce(
-                (arr, maybeRefactor) => arr.concat(isSome2(maybeRefactor) ? [maybeRefactor.value] : []),
-                []
-              )
-            )
-          ),
-          getOrElse(() => [])
-        );
-        info.project.projectService.logger.info(
-          "[@effect/language-service] possible refactors are " + JSON.stringify(effectRefactors)
-        );
-        return applicableRefactors.concat(effectRefactors);
+        const sourceFile = program.getSourceFile(fileName);
+        if (sourceFile) {
+          return pipe(
+            getApplicableRefactors(refactors, sourceFile, positionOrRange),
+            provideService(TypeScriptApi, modules.typescript),
+            provideService(TypeCheckerApi, program.getTypeChecker()),
+            provideService(PluginOptions, pluginOptions),
+            run,
+            Either_exports.map((effectRefactors) => applicableRefactors.concat(effectRefactors)),
+            Either_exports.getOrElse(() => applicableRefactors)
+          );
+        }
       }
       return applicableRefactors;
     };
     proxy.getEditsForRefactor = (fileName, formatOptions, positionOrRange, refactorName, actionName, preferences, ...args) => {
       const program = languageService.getProgram();
       if (program) {
-        for (const refactor of Object.values(refactors)) {
-          if (refactor.name === refactorName) {
-            const textRange = toTextRange(positionOrRange);
-            const possibleRefactor = pipe(
-              fromNullable(program.getSourceFile(fileName)),
-              flatMap(
-                (sourceFile) => refactor.apply(modules.typescript, program, pluginOptions)(
-                  sourceFile,
-                  textRange
+        const sourceFile = program.getSourceFile(fileName);
+        if (sourceFile) {
+          const result = pipe(
+            gen2(function* () {
+              const applicableRefactor = yield* getEditsForRefactor(
+                refactors,
+                sourceFile,
+                positionOrRange,
+                refactorName
+              );
+              const formatContext = modules.typescript.formatting.getFormatContext(
+                formatOptions,
+                info.languageServiceHost
+              );
+              const edits = modules.typescript.textChanges.ChangeTracker.with(
+                {
+                  formatContext,
+                  host: info.languageServiceHost,
+                  preferences: preferences || {}
+                },
+                (changeTracker) => pipe(
+                  applicableRefactor.apply,
+                  provideService(ChangeTracker, changeTracker),
+                  run
                 )
-              )
-            );
-            if (isNone2(possibleRefactor)) {
-              info.project.projectService.logger.info(
-                "[@effect/language-service] requested refactor " + refactorName + " is not applicable"
               );
-              return { edits: [] };
-            }
-            const formatContext = ts.formatting.getFormatContext(
-              formatOptions,
-              info.languageServiceHost
-            );
-            const edits = ts.textChanges.ChangeTracker.with(
-              {
-                formatContext,
-                host: info.languageServiceHost,
-                preferences: preferences || {}
-              },
-              (changeTracker) => possibleRefactor.value.apply(changeTracker)
-            );
-            return { edits };
-          }
+              return { edits };
+            }),
+            provideService(TypeScriptApi, modules.typescript),
+            provideService(TypeCheckerApi, program.getTypeChecker()),
+            provideService(PluginOptions, pluginOptions),
+            run
+          );
+          if (Either_exports.isRight(result)) return result.right;
         }
       }
       return languageService.getEditsForRefactor(
@@ -2288,7 +4527,20 @@ var init = (modules) => {
         const dedupedTagsQuickInfo = dedupeJsDocTags(quickInfo);
         const program = languageService.getProgram();
         if (program) {
-          return prependEffectTypeArguments(ts, program)(fileName, position, dedupedTagsQuickInfo);
+          const sourceFile = program.getSourceFile(fileName);
+          if (sourceFile) {
+            return pipe(
+              prependEffectTypeArguments(
+                sourceFile,
+                position,
+                dedupedTagsQuickInfo
+              ),
+              provideService(TypeScriptApi, modules.typescript),
+              provideService(TypeCheckerApi, program.getTypeChecker()),
+              run,
+              Either_exports.getOrElse(() => dedupedTagsQuickInfo)
+            );
+          }
         }
         return dedupedTagsQuickInfo;
       }