@effect/language-service 0.10.0 → 0.10.2

package/index.js

@@ -70,8 +70,6 @@ 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) {
@@ -161,13 +159,13 @@ var array = (item) => make((self, that) => {
 });
 
 // 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, {
+var let_ = (map4) => dual(3, (self, name, f) => map4(self, (a) => Object.assign({}, a, {
   [name]: f(a)
 })));
-var bindTo = (map8) => dual(2, (self, name) => map8(self, (a) => ({
+var bindTo = (map4) => dual(2, (self, name) => map4(self, (a) => ({
   [name]: a
 })));
-var bind = (map8, flatMap6) => dual(3, (self, name, f) => flatMap6(self, (a) => map8(f(a), (b) => Object.assign({}, a, {
+var bind = (map4, flatMap4) => dual(3, (self, name, f) => flatMap4(self, (a) => map4(f(a), (b) => Object.assign({}, a, {
   [name]: b
 }))));
 
@@ -194,7 +192,6 @@ 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`;
@@ -385,21 +382,14 @@ var string = (str) => {
   }
   return optimize(h);
 };
-var structureKeys = (o, keys2) => {
+var structureKeys = (o, keys) => {
   let h = 12289;
-  for (let i = 0; i < keys2.length; i++) {
-    h ^= pipe(string(keys2[i]), combine(hash(o[keys2[i]])));
+  for (let i = 0; i < keys.length; i++) {
+    h ^= pipe(string(keys[i]), combine(hash(o[keys[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];
@@ -515,12 +505,6 @@ 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", () => ({
@@ -568,8 +552,6 @@ 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");
@@ -846,1836 +828,161 @@ var andThen = /* @__PURE__ */ dual(2, (self, f) => flatMap(self, (a) => {
 var zipWith = /* @__PURE__ */ dual(3, (self, that, f) => flatMap(self, (r) => map(that, (r2) => f(r, r2))));
 var ap = /* @__PURE__ */ dual(2, (self, that) => zipWith(self, that, (f, a) => f(a)));
 var all = (input) => {
-  if (Symbol.iterator in input) {
-    const out2 = [];
-    for (const e of input) {
-      if (isLeft2(e)) {
-        return e;
-      }
-      out2.push(e.right);
-    }
-    return right2(out2);
-  }
-  const out = {};
-  for (const key of Object.keys(input)) {
-    const e = input[key];
-    if (isLeft2(e)) {
-      return e;
-    }
-    out[key] = e.right;
-  }
-  return right2(out);
-};
-var flip = (self) => isLeft2(self) ? right2(self.left) : left2(self.right);
-var adapter2 = /* @__PURE__ */ adapter();
-var gen = (...args) => {
-  const f = args.length === 1 ? args[0] : args[1].bind(args[0]);
-  const iterator = f(adapter2);
-  let state = iterator.next();
-  if (state.done) {
-    return right2(state.value);
-  } else {
-    let current = state.value;
-    if (isGenKind(current)) {
-      current = current.value;
-    } else {
-      current = yieldWrapGet(current);
-    }
-    if (isLeft2(current)) {
-      return current;
-    }
-    while (!state.done) {
-      state = iterator.next(current.right);
-      if (!state.done) {
-        current = state.value;
-        if (isGenKind(current)) {
-          current = current.value;
-        } else {
-          current = yieldWrapGet(current);
-        }
-        if (isLeft2(current)) {
-          return current;
-        }
-      }
-    }
-    return right2(state.value);
-  }
-};
-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/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 isArray = Array.isArray;
-var isEmptyArray = (self) => self.length === 0;
-var isEmptyReadonlyArray = isEmptyArray;
-var isNonEmptyReadonlyArray = isNonEmptyArray;
-var isOutOfBound = (i, as) => i < 0 || i >= as.length;
-var get = /* @__PURE__ */ dual(2, (self, index) => {
-  const i = Math.floor(index);
-  return isOutOfBound(i, self) ? none2() : some2(self[i]);
-});
-var unsafeGet = /* @__PURE__ */ dual(2, (self, index) => {
-  const i = Math.floor(index);
-  if (isOutOfBound(i, self)) {
-    throw new Error(`Index ${i} out of bounds`);
-  }
-  return self[i];
-});
-var head = /* @__PURE__ */ get(0);
-var headNonEmpty = /* @__PURE__ */ unsafeGet(0);
-var tailNonEmpty = (self) => self.slice(1);
-var reverse = (self) => Array.from(self).reverse();
-var sort = /* @__PURE__ */ dual(2, (self, O) => {
-  const out = Array.from(self);
-  out.sort(O);
-  return out;
-});
-var empty = () => [];
-var map2 = /* @__PURE__ */ dual(2, (self, f) => self.map(f));
-var flatMap2 = /* @__PURE__ */ dual(2, (self, f) => {
-  if (isEmptyReadonlyArray(self)) {
-    return [];
-  }
-  const out = [];
-  for (let i = 0; i < self.length; i++) {
-    const inner = f(self[i], i);
-    for (let j = 0; j < inner.length; j++) {
-      out.push(inner[j]);
-    }
-  }
-  return out;
-});
-var flatten = /* @__PURE__ */ flatMap2(identity);
-var filter = /* @__PURE__ */ dual(2, (self, predicate) => {
-  const as = fromIterable(self);
-  const out = [];
-  for (let i = 0; i < as.length; i++) {
-    if (predicate(as[i], i)) {
-      out.push(as[i]);
-    }
-  }
-  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)) {
-    const out = [headNonEmpty(input)];
-    const rest = tailNonEmpty(input);
-    for (const r of rest) {
-      if (out.every((a) => !isEquivalent(r, a))) {
-        out.push(r);
-      }
-    }
-    return out;
-  }
-  return [];
-});
-
-// 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 dest;
-}
-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]();
-      }
-    }
-  },
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-};
-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 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 hashFragment(shift, h) {
-  return h >>> shift & MASK;
-}
-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();
-      }
-      if (canEditNode(this, edit)) {
-        this.value = v2;
-        return this;
-      }
-      return new _LeafNode(edit, hash2, key, v2);
-    }
-    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 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);
-      }
-    }
-    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 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;
-      }
-      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));
+  if (Symbol.iterator in input) {
+    const out2 = [];
+    for (const e of input) {
+      if (isLeft2(e)) {
+        return e;
+      }
+      out2.push(e.right);
+    }
+    return right2(out2);
   }
-  pipe() {
-    return pipeArguments(this, arguments);
+  const out = {};
+  for (const key of Object.keys(input)) {
+    const e = input[key];
+    if (isLeft2(e)) {
+      return e;
+    }
+    out[key] = e.right;
   }
+  return right2(out);
 };
-var isRequestResolver = (u) => hasProperty(u, RequestResolverTypeId);
-var YieldableError = /* @__PURE__ */ function() {
-  class YieldableError2 extends globalThis.Error {
-    commit() {
-      return fail2(this);
+var flip = (self) => isLeft2(self) ? right2(self.left) : left2(self.right);
+var adapter2 = /* @__PURE__ */ adapter();
+var gen = (...args) => {
+  const f = args.length === 1 ? args[0] : args[1].bind(args[0]);
+  const iterator = f(adapter2);
+  let state = iterator.next();
+  if (state.done) {
+    return right2(state.value);
+  } else {
+    let current = state.value;
+    if (isGenKind(current)) {
+      current = current.value;
+    } else {
+      current = yieldWrapGet(current);
     }
-    toJSON() {
-      return {
-        ...this
-      };
+    if (isLeft2(current)) {
+      return current;
     }
-    [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
-        });
+    while (!state.done) {
+      state = iterator.next(current.right);
+      if (!state.done) {
+        current = state.value;
+        if (isGenKind(current)) {
+          current = current.value;
+        } else {
+          current = yieldWrapGet(current);
+        }
+        if (isLeft2(current)) {
+          return current;
+        }
       }
-      return this;
     }
+    return right2(state.value);
   }
-  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();
 };
+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/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
-        });
-      }
+// 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/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 isArray = Array.isArray;
+var isEmptyArray = (self) => self.length === 0;
+var isEmptyReadonlyArray = isEmptyArray;
+var isNonEmptyReadonlyArray = isNonEmptyArray;
+var isOutOfBound = (i, as) => i < 0 || i >= as.length;
+var get = /* @__PURE__ */ dual(2, (self, index) => {
+  const i = Math.floor(index);
+  return isOutOfBound(i, self) ? none2() : some2(self[i]);
+});
+var unsafeGet = /* @__PURE__ */ dual(2, (self, index) => {
+  const i = Math.floor(index);
+  if (isOutOfBound(i, self)) {
+    throw new Error(`Index ${i} out of bounds`);
+  }
+  return self[i];
+});
+var head = /* @__PURE__ */ get(0);
+var headNonEmpty = /* @__PURE__ */ unsafeGet(0);
+var tailNonEmpty = (self) => self.slice(1);
+var sort = /* @__PURE__ */ dual(2, (self, O) => {
+  const out = Array.from(self);
+  out.sort(O);
+  return out;
+});
+var empty = () => [];
+var map2 = /* @__PURE__ */ dual(2, (self, f) => self.map(f));
+var flatMap2 = /* @__PURE__ */ dual(2, (self, f) => {
+  if (isEmptyReadonlyArray(self)) {
+    return [];
+  }
+  const out = [];
+  for (let i = 0; i < self.length; i++) {
+    const inner = f(self[i], i);
+    for (let j = 0; j < inner.length; j++) {
+      out.push(inner[j]);
     }
-    toJSON() {
-      return {
-        ...this[plainArgsSymbol],
-        ...this
-      };
+  }
+  return out;
+});
+var flatten = /* @__PURE__ */ flatMap2(identity);
+var filter = /* @__PURE__ */ dual(2, (self, predicate) => {
+  const as = fromIterable(self);
+  const out = [];
+  for (let i = 0; i < as.length; i++) {
+    if (predicate(as[i], i)) {
+      out.push(as[i]);
     }
-  };
-}();
-var TaggedError = (tag) => {
-  class Base extends Error2 {
-    _tag = tag;
   }
-  ;
-  Base.prototype.name = tag;
-  return Base;
-};
+  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)) {
+    const out = [headNonEmpty(input)];
+    const rest = tailNonEmpty(input);
+    for (const r of rest) {
+      if (out.every((a) => !isEquivalent(r, a))) {
+        out.push(r);
+      }
+    }
+    return out;
+  }
+  return [];
+});
 
 // src/core/Nano.ts
-var NanoDefectException = class extends TaggedError("NanoDefectException") {
+var NanoDefectException = class {
+  constructor(message) {
+    this.message = message;
+  }
+  _tag = "@effect/language-service/NanoDefectException";
 };
 var NanoTag = class {
   constructor(key) {
@@ -2712,23 +1019,23 @@ var run = (fa) => {
       case "Left":
         return left2(result.left);
       case "Defect":
-        return left2(new NanoDefectException({ message: result.defect }));
+        return left2(new NanoDefectException(result.defect));
       case "Right":
         return right2(result.right);
     }
   } catch (e) {
-    return left2(new NanoDefectException({ message: e }));
+    return left2(new NanoDefectException(e));
   }
 };
 var succeed = (value) => new Nano(() => ({ _tag: "Right", right: value }));
-var fail3 = (value) => new Nano(() => ({ _tag: "Left", left: value }));
+var fail = (value) => new Nano(() => ({ _tag: "Left", left: value }));
 var sync = (value) => new Nano(() => ({ _tag: "Right", right: value() }));
-var flatMap5 = dual(2, (fa, f) => new Nano((ctx) => {
+var flatMap3 = dual(2, (fa, f) => new Nano((ctx) => {
   const result = fa.run(ctx);
   if (result._tag !== "Right") return result;
   return f(result.right).run(ctx);
 }));
-var map7 = dual(2, (fa, f) => new Nano((ctx) => {
+var map3 = dual(2, (fa, f) => new Nano((ctx) => {
   const result = fa.run(ctx);
   if (result._tag !== "Right") return result;
   return { _tag: "Right", right: f(result.right) };
@@ -2809,7 +1116,8 @@ var getAncestorNodesInRange = fn("AST.getAncestorNodesInRange")(function* (sourc
   if (isNone2(nodeAtPosition)) return empty();
   return yield* collectSelfAndAncestorNodesInRange(nodeAtPosition.value, textRange);
 });
-var NodeNotFoundError = class extends TaggedError("@effect/language-service/NodeNotFoundError") {
+var NodeNotFoundError = class {
+  _tag = "@effect/language-service/NodeNotFoundError";
 };
 var findNodeAtPosition = fn("AST.findNodeAtPosition")(function* (sourceFile, position) {
   const ts = yield* service(TypeScriptApi);
@@ -2820,19 +1128,19 @@ var findNodeAtPosition = fn("AST.findNodeAtPosition")(function* (sourceFile, pos
     return void 0;
   }
   const result = find(sourceFile);
-  if (!result) return yield* fail3(new NodeNotFoundError());
+  if (!result) return yield* fail(new NodeNotFoundError());
   return result;
 });
 var getCommentAtPosition = fn("TypeScriptApi.getCommentAtPosition")(function* (sourceFile, pos) {
   const ts = yield* service(TypeScriptApi);
   const token = yield* findNodeAtPosition(sourceFile, pos);
   if (token === void 0 || token.kind === ts.SyntaxKind.JsxText || pos >= token.end - (ts.tokenToString(token.kind) || "").length) {
-    return yield* fail3(new NodeNotFoundError());
+    return yield* fail(new NodeNotFoundError());
   }
   const startPos = token.pos === 0 ? (ts.getShebang(sourceFile.text) || "").length : token.pos;
-  if (startPos === 0) return yield* fail3(new NodeNotFoundError());
+  if (startPos === 0) return yield* fail(new NodeNotFoundError());
   const result = ts.forEachTrailingCommentRange(sourceFile.text, startPos, isCommentInRange, pos) || ts.forEachLeadingCommentRange(sourceFile.text, startPos, isCommentInRange, pos);
-  if (!result) return yield* fail3(new NodeNotFoundError());
+  if (!result) return yield* fail(new NodeNotFoundError());
   return result;
 });
 function isCommentInRange(pos, end, kind, _nl, at) {
@@ -2946,7 +1254,8 @@ var removeReturnTypeAnnotation = fn("AST.removeReturnTypeAnnotation")(function*
     changes.deleteRange(sourceFile, { pos: endNode.end, end: declaration.type.end });
   }
 });
-var ImportModuleIdentifierNotFoundError = class extends TaggedError("@effect/language-service/ImportModuleIdentifierNotFoundError") {
+var ImportModuleIdentifierNotFoundError = class {
+  _tag = "@effect/language-service/ImportModuleIdentifierNotFoundError";
 };
 var findImportedModuleIdentifier = fn("AST.findImportedModuleIdentifier")(
   function* (sourceFile, test) {
@@ -2972,7 +1281,7 @@ var findImportedModuleIdentifier = fn("AST.findImportedModuleIdentifier")(
         }
       }
     }
-    return yield* fail3(new ImportModuleIdentifierNotFoundError());
+    return yield* fail(new ImportModuleIdentifierNotFoundError());
   }
 );
 function findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, packageName, moduleName) {
@@ -3098,7 +1407,8 @@ var parseDataForExtendsClassCompletion = fn(
 });
 
 // src/core/LSP.ts
-var RefactorNotApplicableError = class extends TaggedError("RefactorNotApplicableError") {
+var RefactorNotApplicableError = class {
+  _tag = "@effect/language-service/RefactorNotApplicableError";
 };
 function createRefactor(definition) {
   return definition;
@@ -3110,13 +1420,12 @@ function createCompletion(definition) {
   return definition;
 }
 var PluginOptions = Tag("PluginOptions");
-var SourceFileNotFoundError = class extends TaggedError("SourceFileNotFoundError") {
-};
-var getSemanticDiagnostics = fn("LSP.getSemanticDiagnostics")(function* (diagnostics2, sourceFile) {
+var getSemanticDiagnosticsWithCodeFixes = fn("LSP.getSemanticDiagnostics")(function* (rules, sourceFile) {
   const effectDiagnostics = [];
+  const effectCodeFixes = [];
   const executor = yield* createDiagnosticExecutor(sourceFile);
-  for (const diagnostic of diagnostics2) {
-    const result = yield* option(executor.execute(diagnostic));
+  for (const rule of rules) {
+    const result = yield* option(executor.execute(rule));
     if (isSome2(result)) {
       effectDiagnostics.push(
         ...pipe(
@@ -3127,35 +1436,34 @@ var getSemanticDiagnostics = fn("LSP.getSemanticDiagnostics")(function* (diagnos
             length: _.node.getEnd() - _.node.getStart(sourceFile),
             messageText: _.messageText,
             category: _.category,
-            code: diagnostic.code,
+            code: rule.code,
             source: "effect"
           }))
         )
       );
-    }
-  }
-  return effectDiagnostics;
-});
-var getCodeFixesAtPosition = fn("LSP.getCodeFixesAtPosition")(function* (diagnostics2, sourceFile, start, end, errorCodes) {
-  const runnableDiagnostics = diagnostics2.filter((_) => errorCodes.indexOf(_.code) > -1);
-  const applicableFixes = [];
-  const executor = yield* createDiagnosticExecutor(sourceFile);
-  for (const diagnostic of runnableDiagnostics) {
-    const result = yield* option(executor.execute(diagnostic));
-    if (isSome2(result)) {
-      applicableFixes.push(
+      effectCodeFixes.push(
         ...pipe(
           result.value,
-          filter(
-            (_) => _.node.getStart(sourceFile) === start && _.node.getEnd() === end
+          map2(
+            (_) => map2(
+              _.fixes,
+              (fix) => ({
+                ...fix,
+                code: rule.code,
+                start: _.node.getStart(sourceFile),
+                end: _.node.getEnd()
+              })
+            )
           ),
-          map2((_) => _.fixes),
           flatten
         )
       );
     }
   }
-  return applicableFixes;
+  return {
+    diagnostics: effectDiagnostics,
+    codeFixes: effectCodeFixes
+  };
 });
 var getApplicableRefactors = fn("LSP.getApplicableRefactors")(function* (refactors2, sourceFile, positionOrRange) {
   const textRange = typeof positionOrRange === "number" ? { pos: positionOrRange, end: positionOrRange } : positionOrRange;
@@ -3179,7 +1487,7 @@ var getApplicableRefactors = fn("LSP.getApplicableRefactors")(function* (refacto
 var getEditsForRefactor = fn("LSP.getEditsForRefactor")(function* (refactors2, sourceFile, positionOrRange, refactorName) {
   const refactor = refactors2.find((refactor2) => refactor2.name === refactorName);
   if (!refactor) {
-    return yield* fail3(new RefactorNotApplicableError());
+    return yield* fail(new RefactorNotApplicableError());
   }
   const textRange = typeof positionOrRange === "number" ? { pos: positionOrRange, end: positionOrRange } : positionOrRange;
   return yield* refactor.apply(sourceFile, textRange);
@@ -3249,7 +1557,7 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
       const fixByDisableEntireFile = {
         fixName: rule.name + "_skipFile",
         description: "Disable " + rule.name + " for this file",
-        apply: flatMap5(
+        apply: flatMap3(
           service(ChangeTracker),
           (changeTracker) => sync(
             () => changeTracker.insertText(
@@ -3467,7 +1775,11 @@ var getMissingTypeEntriesInTargetType = fn(
     return result;
   }
 );
-var CannotFindAncestorConvertibleDeclarationError = class extends TaggedError("CannotFindAncestorConvertibleDeclarationError") {
+var CannotFindAncestorConvertibleDeclarationError = class {
+  constructor(node) {
+    this.node = node;
+  }
+  _tag = "@effect/language-service/CannotFindAncestorConvertibleDeclarationError";
 };
 var getAncestorConvertibleDeclaration = fn(
   "TypeCheckerApi.getAncestorConvertibleDeclaration"
@@ -3480,17 +1792,25 @@ var getAncestorConvertibleDeclaration = fn(
     }
     current = current.parent;
   }
-  return yield* fail3(new CannotFindAncestorConvertibleDeclarationError({ node }));
+  return yield* fail(new CannotFindAncestorConvertibleDeclarationError(node));
 });
-var CannotInferReturnTypeFromEmptyBody = class extends TaggedError("CannotInferReturnTypeFromEmptyBody") {
+var CannotInferReturnTypeFromEmptyBody = class {
+  constructor(declaration) {
+    this.declaration = declaration;
+  }
+  _tag = "@effect/language-service/CannotInferReturnTypeFromEmptyBody";
 };
-var CannotInferReturnType = class extends TaggedError("CannotInferReturnType") {
+var CannotInferReturnType = class {
+  constructor(declaration) {
+    this.declaration = declaration;
+  }
+  _tag = "@effect/language-service/CannotInferReturnType";
 };
 var getInferredReturnType = fn("TypeCheckerApi.getInferredReturnType")(function* (declaration) {
   const typeChecker = yield* service(TypeCheckerApi);
   if (!declaration.body) {
-    return yield* fail3(
-      new CannotInferReturnTypeFromEmptyBody({ declaration })
+    return yield* fail(
+      new CannotInferReturnTypeFromEmptyBody(declaration)
     );
   }
   let returnType;
@@ -3514,8 +1834,8 @@ var getInferredReturnType = fn("TypeCheckerApi.getInferredReturnType")(function*
     }
   }
   if (!returnType) {
-    return yield* fail3(
-      new CannotInferReturnType({ declaration })
+    return yield* fail(
+      new CannotInferReturnType(declaration)
     );
   }
   return returnType;
@@ -3607,10 +1927,16 @@ var expectedAndRealType = fn("TypeCheckerApi.expectedAndRealType")(function* (so
 });
 
 // src/utils/TypeParser.ts
-var TypeParserIssue = class extends TaggedError("@effect/language-service/TypeParserIssue") {
+var TypeParserIssue = class {
+  constructor(type, node, message) {
+    this.type = type;
+    this.node = node;
+    this.message = message;
+  }
+  _tag = "@effect/language-service/TypeParserIssue";
 };
 function typeParserIssue(message, type, node) {
-  return fail3(new TypeParserIssue({ type, message, node }));
+  return fail(new TypeParserIssue(type, node, message));
 }
 function covariantTypeArgument(type) {
   const signatures = type.getCallSignatures();
@@ -4007,41 +2333,38 @@ var missingStarInYieldEffectGen = createDiagnostic({
   code: 4,
   apply: fn("missingStarInYieldEffectGen.apply")(function* (sourceFile) {
     const ts = yield* service(TypeScriptApi);
-    const typeChecker = yield* service(TypeCheckerApi);
     const effectDiagnostics = [];
     const brokenGenerators = /* @__PURE__ */ new Set();
     const brokenYields = /* @__PURE__ */ new Set();
     const nodeToVisit = [];
-    const appendNodeToVisit = (functionStarNode) => (node) => {
-      nodeToVisit.push([node, functionStarNode]);
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
       return void 0;
     };
-    ts.forEachChild(sourceFile, appendNodeToVisit(void 0));
+    ts.forEachChild(sourceFile, appendNodeToVisit);
     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 = yield* option(effectType(type, node.expression));
-        if (isSome2(effect)) {
-          brokenGenerators.add(functionStarNode);
-          brokenYields.add(node);
-        }
-      }
-      const effectGenLike = yield* pipe(
-        effectGen(node),
-        orElse3(() => effectFnUntracedGen(node)),
-        orElse3(() => effectFnGen(node)),
-        option
-      );
-      if (isSome2(effectGenLike)) {
-        ts.forEachChild(
-          effectGenLike.value.body,
-          appendNodeToVisit(effectGenLike.value.functionStar)
+      const node = nodeToVisit.shift();
+      ts.forEachChild(node, appendNodeToVisit);
+      if (ts.isYieldExpression(node) && node.expression && node.asteriskToken === void 0) {
+        const functionStarNode = ts.findAncestor(
+          node,
+          (_) => (ts.isFunctionExpression(_) || ts.isMethodDeclaration(_)) && _.asteriskToken !== void 0
         );
-      } else if ((ts.isFunctionExpression(node) || ts.isMethodDeclaration(node)) && node.asteriskToken !== void 0) {
-        ts.forEachChild(node, appendNodeToVisit(void 0));
-      } else {
-        ts.forEachChild(node, appendNodeToVisit(functionStarNode));
+        if (functionStarNode && functionStarNode.parent) {
+          const effectGenNode = functionStarNode.parent;
+          const effectGenLike = yield* pipe(
+            effectGen(effectGenNode),
+            orElse3(() => effectFnUntracedGen(effectGenNode)),
+            orElse3(() => effectFnGen(effectGenNode)),
+            option
+          );
+          if (isSome2(effectGenLike)) {
+            if (effectGenLike.value.functionStar) {
+              brokenGenerators.add(effectGenLike.value.functionStar);
+            }
+            brokenYields.add(node);
+          }
+        }
       }
     }
     brokenGenerators.forEach(
@@ -4096,18 +2419,28 @@ var unnecessaryEffectGen = createDiagnostic({
     while (nodeToVisit.length > 0) {
       const node = nodeToVisit.shift();
       ts.forEachChild(node, appendNodeToVisit);
-      const maybeUnnecessaryGen = yield* pipe(
-        effectGen(node),
-        flatMap5(({ body }) => returnYieldEffectBlock(body)),
-        option
+      const maybeUnnecessaryYield = yield* option(
+        returnYieldEffectBlock(node)
       );
-      if (isSome2(maybeUnnecessaryGen)) {
-        unnecessaryGenerators.set(node, maybeUnnecessaryGen.value);
+      if (isSome2(maybeUnnecessaryYield)) {
+        const functionStarNode = ts.findAncestor(
+          node,
+          (_) => (ts.isFunctionExpression(_) || ts.isMethodDeclaration(_)) && _.asteriskToken !== void 0
+        );
+        if (functionStarNode && functionStarNode.parent) {
+          const effectGenNode = functionStarNode.parent;
+          const maybeUnnecessaryGen = yield* option(
+            effectGen(effectGenNode)
+          );
+          if (isSome2(maybeUnnecessaryGen)) {
+            unnecessaryGenerators.set(maybeUnnecessaryGen.value.node, maybeUnnecessaryYield.value);
+          }
+        }
       }
     }
     unnecessaryGenerators.forEach(
-      (body, node) => effectDiagnostics.push({
-        node,
+      (yieldedResult, effectGenCall) => effectDiagnostics.push({
+        node: effectGenCall,
         category: ts.DiagnosticCategory.Suggestion,
         messageText: `This Effect.gen is useless here because it only contains a single return statement.`,
         fixes: [{
@@ -4117,7 +2450,7 @@ var unnecessaryEffectGen = createDiagnostic({
             const textChanges = yield* service(
               ChangeTracker
             );
-            textChanges.replaceNode(sourceFile, node, body);
+            textChanges.replaceNode(sourceFile, effectGenCall, yieldedResult);
           })
         }]
       })
@@ -4216,7 +2549,7 @@ var asyncAwaitToGen = createRefactor({
       ),
       head
     );
-    if (isNone2(maybeNode)) return yield* fail3(new RefactorNotApplicableError());
+    if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
     const node = maybeNode.value;
     return {
       kind: "refactor.rewrite.effect.asyncAwaitToGen",
@@ -4231,7 +2564,7 @@ var asyncAwaitToGen = createRefactor({
                 (node2) => pipe(
                   importedEffectModule(node2),
                   option,
-                  map7(isSome2)
+                  map3(isSome2)
                 )
               )
             ),
@@ -4288,7 +2621,7 @@ var asyncAwaitToGenTryPromise = createRefactor({
       ),
       head
     );
-    if (isNone2(maybeNode)) return yield* fail3(new RefactorNotApplicableError());
+    if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
     const node = maybeNode.value;
     return {
       kind: "refactor.rewrite.effect.asyncAwaitToGenTryPromise",
@@ -4303,7 +2636,7 @@ var asyncAwaitToGenTryPromise = createRefactor({
                 (node2) => pipe(
                   importedEffectModule(node2),
                   option,
-                  map7(isSome2)
+                  map3(isSome2)
                 )
               )
             ),
@@ -4401,7 +2734,7 @@ var effectGenToFn = createRefactor({
           }
           break;
         }
-        return yield* fail3(new RefactorNotApplicableError());
+        return yield* fail(new RefactorNotApplicableError());
       });
     }
     const maybeNode = yield* pipe(
@@ -4410,7 +2743,7 @@ var effectGenToFn = createRefactor({
       firstSuccessOf,
       option
     );
-    if (isNone2(maybeNode)) return yield* fail3(new RefactorNotApplicableError());
+    if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
     const { effectModule, generatorFunction, nodeToReplace, pipeArgs } = maybeNode.value;
     return {
       kind: "refactor.rewrite.effect.effectGenToFn",
@@ -4467,7 +2800,7 @@ var functionToArrow = createRefactor({
       filter((_) => !!_.name && isNodeInRange(textRange)(_.name)),
       head
     );
-    if (isNone2(maybeNode)) return yield* fail3(new RefactorNotApplicableError());
+    if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
     const node = maybeNode.value;
     return {
       kind: "refactor.rewrite.effect.functionToArrow",
@@ -4580,7 +2913,7 @@ var pipeableToDatafirst = createRefactor({
       map2((_) => _.value),
       head
     );
-    if (isNone2(maybeNode)) return yield* fail3(new RefactorNotApplicableError());
+    if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
     const [node, newNode] = maybeNode.value;
     return {
       kind: "refactor.rewrite.effect.pipeableToDatafirst",
@@ -4601,7 +2934,7 @@ var removeUnnecessaryEffectGen = createRefactor({
     for (const nodeToReplace of yield* getAncestorNodesInRange(sourceFile, textRange)) {
       const maybeNode = yield* pipe(
         effectGen(nodeToReplace),
-        flatMap5(({ body }) => returnYieldEffectBlock(body)),
+        flatMap3(({ body }) => returnYieldEffectBlock(body)),
         option
       );
       if (isNone2(maybeNode)) continue;
@@ -4615,7 +2948,7 @@ var removeUnnecessaryEffectGen = createRefactor({
         })
       };
     }
-    return yield* fail3(new RefactorNotApplicableError());
+    return yield* fail(new RefactorNotApplicableError());
   })
 });
 
@@ -4634,7 +2967,7 @@ var toggleLazyConst = createRefactor({
       ),
       head
     );
-    if (isNone2(maybeNode)) return yield* fail3(new RefactorNotApplicableError());
+    if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
     const node = maybeNode.value;
     return {
       kind: "refactor.rewrite.effect.toggleLazyConst",
@@ -4673,7 +3006,7 @@ var toggleReturnTypeAnnotation = createRefactor({
       ),
       head
     );
-    if (isNone2(maybeNode)) return yield* fail3(new RefactorNotApplicableError());
+    if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
     const node = maybeNode.value;
     if (node.type) {
       return {
@@ -4686,13 +3019,13 @@ var toggleReturnTypeAnnotation = createRefactor({
       };
     }
     const returnType = yield* option(getInferredReturnType(node));
-    if (isNone2(returnType)) return yield* fail3(new RefactorNotApplicableError());
+    if (isNone2(returnType)) return yield* fail(new RefactorNotApplicableError());
     const returnTypeNode = typeChecker.typeToTypeNode(
       returnType.value,
       node,
       ts.NodeBuilderFlags.NoTruncation
     );
-    if (!returnTypeNode) return yield* fail3(new RefactorNotApplicableError());
+    if (!returnTypeNode) return yield* fail(new RefactorNotApplicableError());
     return {
       kind: "refactor.rewrite.effect.toggleReturnTypeAnnotation",
       description: "Toggle return type annotation",
@@ -4725,7 +3058,7 @@ var toggleTypeAnnotation = createRefactor({
       filter((node2) => !!node2.initializer),
       head
     );
-    if (isNone2(maybeNode)) return yield* fail3(new RefactorNotApplicableError());
+    if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
     const node = maybeNode.value;
     return {
       kind: "refactor.rewrite.effect.toggleTypeAnnotation",
@@ -4776,7 +3109,7 @@ var wrapWithPipe = createRefactor({
   description: "Wrap with pipe",
   apply: (sourceFile, textRange) => gen2(function* () {
     if (textRange.end - textRange.pos === 0) {
-      return yield* fail3(new RefactorNotApplicableError());
+      return yield* fail(new RefactorNotApplicableError());
     }
     return {
       kind: "refactor.rewrite.effect.wrapWithPipe",
@@ -4813,10 +3146,6 @@ var init = (modules) => {
       quickinfo: info.config && "quickinfo" in info.config && typeof info.config.quickinfo === "boolean" ? info.config.quickinfo : true,
       completions: info.config && "completions" in info.config && typeof info.config.completions === "boolean" ? info.config.completions : true
     };
-    const proxy = /* @__PURE__ */ Object.create(null);
-    for (const k of Object.keys(languageService)) {
-      proxy[k] = (...args) => languageService[k].apply(languageService, args);
-    }
     const diagnosticsErrorCodes = diagnostics.map((diagnostic) => diagnostic.code);
     try {
       ;
@@ -4826,81 +3155,20 @@ var init = (modules) => {
       });
     } catch (_) {
     }
-    proxy.getSupportedCodeFixes = (...args) => languageService.getSupportedCodeFixes(...args).concat(
-      diagnosticsErrorCodes.map((_) => "" + _)
-    );
-    proxy.getCodeFixesAtPosition = (fileName, start, end, errorCodes, formatOptions, preferences, ...args) => {
-      const applicableCodeFixes = languageService.getCodeFixesAtPosition(
-        fileName,
-        start,
-        end,
-        errorCodes,
-        formatOptions,
-        preferences,
-        ...args
-      );
-      const program = languageService.getProgram();
-      if (program) {
-        const sourceFile = program.getSourceFile(fileName);
-        if (sourceFile) {
-          return pipe(
-            gen2(function* () {
-              const effectCodeFixes = [];
-              const applicableFixes = yield* getCodeFixesAtPosition(
-                diagnostics,
-                sourceFile,
-                start,
-                end,
-                errorCodes
-              );
-              const formatContext = modules.typescript.formatting.getFormatContext(
-                formatOptions,
-                info.languageServiceHost
-              );
-              for (const applicableFix of applicableFixes) {
-                const changes = modules.typescript.textChanges.ChangeTracker.with(
-                  {
-                    formatContext,
-                    host: info.languageServiceHost,
-                    preferences: preferences || {}
-                  },
-                  (changeTracker) => pipe(
-                    applicableFix.apply,
-                    provideService(ChangeTracker, changeTracker),
-                    run
-                  )
-                );
-                effectCodeFixes.push({
-                  fixName: applicableFix.fixName,
-                  description: applicableFix.description,
-                  changes
-                });
-              }
-              return effectCodeFixes;
-            }),
-            provideService(TypeCheckerApi, program.getTypeChecker()),
-            provideService(
-              TypeCheckerApiCache,
-              makeTypeCheckerApiCache()
-            ),
-            provideService(TypeScriptApi, modules.typescript),
-            provideService(PluginOptions, pluginOptions),
-            run,
-            Either_exports.map((effectCodeFixes) => applicableCodeFixes.concat(effectCodeFixes)),
-            Either_exports.getOrElse(() => applicableCodeFixes)
-          );
-        }
-      }
-      return applicableCodeFixes;
-    };
+    const proxy = /* @__PURE__ */ Object.create(null);
+    for (const k of Object.keys(languageService)) {
+      proxy[k] = (...args) => languageService[k].apply(languageService, args);
+    }
+    const effectCodeFixesForFile = /* @__PURE__ */ new Map();
     proxy.getSemanticDiagnostics = (fileName, ...args) => {
       const applicableDiagnostics = languageService.getSemanticDiagnostics(fileName, ...args);
       const program = languageService.getProgram();
       if (pluginOptions.diagnostics && program) {
+        effectCodeFixesForFile.delete(fileName);
         const sourceFile = program.getSourceFile(fileName);
         if (sourceFile) {
           return pipe(
-            getSemanticDiagnostics(diagnostics, sourceFile),
+            getSemanticDiagnosticsWithCodeFixes(diagnostics, sourceFile),
             provideService(TypeCheckerApi, program.getTypeChecker()),
             provideService(
               TypeCheckerApiCache,
@@ -4909,13 +3177,65 @@ var init = (modules) => {
             provideService(TypeScriptApi, modules.typescript),
             provideService(PluginOptions, pluginOptions),
             run,
-            Either_exports.map((effectDiagnostics) => effectDiagnostics.concat(applicableDiagnostics)),
+            Either_exports.map(({ codeFixes, diagnostics: diagnostics2 }) => {
+              effectCodeFixesForFile.set(fileName, codeFixes);
+              return diagnostics2.concat(applicableDiagnostics);
+            }),
             Either_exports.getOrElse(() => applicableDiagnostics)
           );
         }
       }
       return applicableDiagnostics;
     };
+    proxy.getSupportedCodeFixes = (...args) => languageService.getSupportedCodeFixes(...args).concat(
+      diagnosticsErrorCodes.map((_) => "" + _)
+    );
+    proxy.getCodeFixesAtPosition = (fileName, start, end, errorCodes, formatOptions, preferences, ...args) => {
+      const applicableCodeFixes = languageService.getCodeFixesAtPosition(
+        fileName,
+        start,
+        end,
+        errorCodes,
+        formatOptions,
+        preferences,
+        ...args
+      );
+      return pipe(
+        sync(() => {
+          const effectCodeFixes = [];
+          const applicableFixes = (effectCodeFixesForFile.get(fileName) || []).filter(
+            (_) => _.start === start && _.end === end && errorCodes.indexOf(_.code) > -1
+          );
+          const formatContext = modules.typescript.formatting.getFormatContext(
+            formatOptions,
+            info.languageServiceHost
+          );
+          for (const applicableFix of applicableFixes) {
+            const changes = modules.typescript.textChanges.ChangeTracker.with(
+              {
+                formatContext,
+                host: info.languageServiceHost,
+                preferences: preferences || {}
+              },
+              (changeTracker) => pipe(
+                applicableFix.apply,
+                provideService(ChangeTracker, changeTracker),
+                run
+              )
+            );
+            effectCodeFixes.push({
+              fixName: applicableFix.fixName,
+              description: applicableFix.description,
+              changes
+            });
+          }
+          return effectCodeFixes;
+        }),
+        run,
+        Either_exports.map((effectCodeFixes) => applicableCodeFixes.concat(effectCodeFixes)),
+        Either_exports.getOrElse(() => applicableCodeFixes)
+      );
+    };
     proxy.getApplicableRefactors = (...args) => {
       const applicableRefactors = languageService.getApplicableRefactors(...args);
       const [fileName, positionOrRange] = args;