@effect/language-service 0.75.0 → 0.76.0

package/transform.js

@@ -24,15 +24,44 @@ __export(transform_exports, {
 });
 module.exports = __toCommonJS(transform_exports);
 
-// ../../node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Function.js
-var isFunction = (input) => typeof input === "function";
+// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Pipeable.js
+var pipeArguments = (self, args3) => {
+  switch (args3.length) {
+    case 0:
+      return self;
+    case 1:
+      return args3[0](self);
+    case 2:
+      return args3[1](args3[0](self));
+    case 3:
+      return args3[2](args3[1](args3[0](self)));
+    case 4:
+      return args3[3](args3[2](args3[1](args3[0](self))));
+    case 5:
+      return args3[4](args3[3](args3[2](args3[1](args3[0](self)))));
+    case 6:
+      return args3[5](args3[4](args3[3](args3[2](args3[1](args3[0](self))))));
+    case 7:
+      return args3[6](args3[5](args3[4](args3[3](args3[2](args3[1](args3[0](self)))))));
+    case 8:
+      return args3[7](args3[6](args3[5](args3[4](args3[3](args3[2](args3[1](args3[0](self))))))));
+    case 9:
+      return args3[8](args3[7](args3[6](args3[5](args3[4](args3[3](args3[2](args3[1](args3[0](self)))))))));
+    default: {
+      let ret = self;
+      for (let i = 0, len = args3.length; i < len; i++) {
+        ret = args3[i](ret);
+      }
+      return ret;
+    }
+  }
+};
+
+// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Function.js
 var dual = function(arity, body) {
   if (typeof arity === "function") {
     return function() {
-      if (arity(arguments)) {
-        return body.apply(this, arguments);
-      }
-      return (self) => body(self, ...arguments);
+      return arity(arguments) ? body.apply(this, arguments) : (self) => body(self, ...arguments);
     };
   }
   switch (arity) {
@@ -57,32 +86,14 @@ var dual = function(arity, body) {
           return body(self, a, b);
         };
       };
-    case 4:
-      return function(a, b, c, d) {
-        if (arguments.length >= 4) {
-          return body(a, b, c, d);
-        }
-        return function(self) {
-          return body(self, a, b, c);
-        };
-      };
-    case 5:
-      return function(a, b, c, d, e) {
-        if (arguments.length >= 5) {
-          return body(a, b, c, d, e);
-        }
-        return function(self) {
-          return body(self, a, b, c, d);
-        };
-      };
     default:
       return function() {
         if (arguments.length >= arity) {
           return body.apply(this, arguments);
         }
-        const args2 = arguments;
+        const args3 = arguments;
         return function(self) {
-          return body(self, ...args2);
+          return body(self, ...args3);
         };
       };
   }
@@ -90,189 +101,57 @@ var dual = function(arity, body) {
 var identity = (a) => a;
 var constant = (value) => () => value;
 var constUndefined = /* @__PURE__ */ constant(void 0);
-function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
-  switch (arguments.length) {
-    case 1:
-      return a;
-    case 2:
-      return ab(a);
-    case 3:
-      return bc(ab(a));
-    case 4:
-      return cd(bc(ab(a)));
-    case 5:
-      return de(cd(bc(ab(a))));
-    case 6:
-      return ef(de(cd(bc(ab(a)))));
-    case 7:
-      return fg(ef(de(cd(bc(ab(a))))));
-    case 8:
-      return gh(fg(ef(de(cd(bc(ab(a)))))));
-    case 9:
-      return hi(gh(fg(ef(de(cd(bc(ab(a))))))));
-    default: {
-      let ret = arguments[0];
-      for (let i = 1; i < arguments.length; i++) {
-        ret = arguments[i](ret);
-      }
-      return ret;
-    }
-  }
+function pipe(a, ...args3) {
+  return pipeArguments(a, args3);
 }
 
-// ../../node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/GlobalValue.js
-var globalStoreId = `effect/GlobalValue`;
-var globalStore;
-var globalValue = (id, compute) => {
-  if (!globalStore) {
-    globalThis[globalStoreId] ??= /* @__PURE__ */ new Map();
-    globalStore = globalThis[globalStoreId];
-  }
-  if (!globalStore.has(id)) {
-    globalStore.set(id, compute());
-  }
-  return globalStore.get(id);
+// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/internal/equal.js
+var getAllObjectKeys = (obj) => {
+  const keys2 = new Set(Reflect.ownKeys(obj));
+  if (obj.constructor === Object) return keys2;
+  if (obj instanceof Error) {
+    keys2.delete("stack");
+  }
+  const proto = Object.getPrototypeOf(obj);
+  let current = proto;
+  while (current !== null && current !== Object.prototype) {
+    const ownKeys = Reflect.ownKeys(current);
+    for (let i = 0; i < ownKeys.length; i++) {
+      keys2.add(ownKeys[i]);
+    }
+    current = Object.getPrototypeOf(current);
+  }
+  if (keys2.has("constructor") && typeof obj.constructor === "function" && proto === obj.constructor.prototype) {
+    keys2.delete("constructor");
+  }
+  return keys2;
 };
+var byReferenceInstances = /* @__PURE__ */ new WeakSet();
 
-// ../../node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Predicate.js
-var isString = (input) => typeof input === "string";
-var isNumber = (input) => typeof input === "number";
-var isBoolean = (input) => typeof input === "boolean";
-var isFunction2 = isFunction;
-var isRecordOrArray = (input) => typeof input === "object" && input !== null;
-var isObject = (input) => isRecordOrArray(input) || isFunction2(input);
-var hasProperty = /* @__PURE__ */ dual(2, (self, property) => isObject(self) && property in self);
-var isRecord = (input) => isRecordOrArray(input) && !Array.isArray(input);
-
-// ../../node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Utils.js
-var GenKindTypeId = /* @__PURE__ */ Symbol.for("effect/Gen/GenKind");
-var GenKindImpl = class {
-  value;
-  constructor(value) {
-    this.value = value;
-  }
-  /**
-   * @since 2.0.0
-   */
-  get _F() {
-    return identity;
-  }
-  /**
-   * @since 2.0.0
-   */
-  get _R() {
-    return (_) => _;
-  }
-  /**
-   * @since 2.0.0
-   */
-  get _O() {
-    return (_) => _;
-  }
-  /**
-   * @since 2.0.0
-   */
-  get _E() {
-    return (_) => _;
-  }
-  /**
-   * @since 2.0.0
-   */
-  [GenKindTypeId] = GenKindTypeId;
-  /**
-   * @since 2.0.0
-   */
-  [Symbol.iterator]() {
-    return new SingleShotGen(this);
-  }
-};
-var SingleShotGen = class _SingleShotGen {
-  self;
-  called = false;
-  constructor(self) {
-    this.self = self;
-  }
-  /**
-   * @since 2.0.0
-   */
-  next(a) {
-    return this.called ? {
-      value: a,
-      done: true
-    } : (this.called = true, {
-      value: this.self,
-      done: false
-    });
-  }
-  /**
-   * @since 2.0.0
-   */
-  return(a) {
-    return {
-      value: a,
-      done: true
-    };
-  }
-  /**
-   * @since 2.0.0
-   */
-  throw(e) {
-    throw e;
-  }
-  /**
-   * @since 2.0.0
-   */
-  [Symbol.iterator]() {
-    return new _SingleShotGen(this.self);
-  }
-};
-var MUL_HI = 1481765933 >>> 0;
-var MUL_LO = 1284865837 >>> 0;
-var YieldWrapTypeId = /* @__PURE__ */ Symbol.for("effect/Utils/YieldWrap");
-var YieldWrap = class {
-  /**
-   * @since 3.0.6
-   */
-  #value;
-  constructor(value) {
-    this.#value = value;
-  }
-  /**
-   * @since 3.0.6
-   */
-  [YieldWrapTypeId]() {
-    return this.#value;
-  }
-};
-var structuralRegionState = /* @__PURE__ */ globalValue("effect/Utils/isStructuralRegion", () => ({
-  enabled: false,
-  tester: void 0
-}));
-var standard = {
-  effect_internal_function: (body) => {
-    return body();
-  }
-};
-var forced = {
-  effect_internal_function: (body) => {
-    try {
-      return body();
-    } finally {
-    }
-  }
-};
-var isNotOptimizedAway = /* @__PURE__ */ standard.effect_internal_function(() => new Error().stack)?.includes("effect_internal_function") === true;
-var internalCall = isNotOptimizedAway ? standard.effect_internal_function : forced.effect_internal_function;
-var genConstructor = function* () {
-}.constructor;
+// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Predicate.js
+function isString(input) {
+  return typeof input === "string";
+}
+function isNumber(input) {
+  return typeof input === "number";
+}
+function isBoolean(input) {
+  return typeof input === "boolean";
+}
+function isFunction(input) {
+  return typeof input === "function";
+}
+function isObject(input) {
+  return typeof input === "object" && input !== null && !Array.isArray(input);
+}
+function isObjectKeyword(input) {
+  return typeof input === "object" && input !== null || isFunction(input);
+}
+var hasProperty = /* @__PURE__ */ dual(2, (self, property) => isObjectKeyword(self) && property in self);
 
-// ../../node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Hash.js
-var randomHashCache = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/Hash/randomHashCache"), () => /* @__PURE__ */ new WeakMap());
-var symbol = /* @__PURE__ */ Symbol.for("effect/Hash");
+// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Hash.js
+var symbol = "~effect/interfaces/Hash";
 var hash = (self) => {
-  if (structuralRegionState.enabled === true) {
-    return 0;
-  }
   switch (typeof self) {
     case "number":
       return number(self);
@@ -291,16 +170,32 @@ var hash = (self) => {
       if (self === null) {
         return string("null");
       } else if (self instanceof Date) {
-        if (Number.isNaN(self.getTime())) {
-          return string("Invalid Date");
-        }
-        return hash(self.toISOString());
-      } else if (self instanceof URL) {
-        return hash(self.href);
-      } else if (isHash(self)) {
-        return self[symbol]();
+        return string(self.toISOString());
+      } else if (self instanceof RegExp) {
+        return string(self.toString());
       } else {
-        return random(self);
+        if (byReferenceInstances.has(self)) {
+          return random(self);
+        }
+        if (hashCache.has(self)) {
+          return hashCache.get(self);
+        }
+        const h = withVisitedTracking(self, () => {
+          if (isHash(self)) {
+            return self[symbol]();
+          } else if (typeof self === "function") {
+            return random(self);
+          } else if (Array.isArray(self)) {
+            return array(self);
+          } else if (self instanceof Map) {
+            return hashMap(self);
+          } else if (self instanceof Set) {
+            return hashSet(self);
+          }
+          return structure(self);
+        });
+        hashCache.set(self, h);
+        return h;
       }
     }
     default:
@@ -313,12 +208,18 @@ var random = (self) => {
   }
   return randomHashCache.get(self);
 };
-var combine = (b) => (self) => self * 53 ^ b;
+var combine = /* @__PURE__ */ dual(2, (self, b) => self * 53 ^ b);
 var optimize = (n) => n & 3221225471 | n >>> 1 & 1073741824;
 var isHash = (u) => hasProperty(u, symbol);
 var number = (n) => {
-  if (n !== n || n === Infinity) {
-    return 0;
+  if (n !== n) {
+    return string("NaN");
+  }
+  if (n === Infinity) {
+    return string("Infinity");
+  }
+  if (n === -Infinity) {
+    return string("-Infinity");
   }
   let h = n | 0;
   if (h !== n) {
@@ -338,38 +239,37 @@ var string = (str) => {
 };
 var structureKeys = (o, keys2) => {
   let h = 12289;
-  for (let i = 0; i < keys2.length; i++) {
-    h ^= pipe(string(keys2[i]), combine(hash(o[keys2[i]])));
+  for (const key of keys2) {
+    h ^= combine(hash(key), hash(o[key]));
   }
   return optimize(h);
 };
-var structure = (o) => structureKeys(o, Object.keys(o));
-var cached = function() {
-  if (arguments.length === 1) {
-    const self2 = arguments[0];
-    return function(hash3) {
-      Object.defineProperty(self2, symbol, {
-        value() {
-          return hash3;
-        },
-        enumerable: false
-      });
-      return hash3;
-    };
+var structure = (o) => structureKeys(o, getAllObjectKeys(o));
+var iterableWith = (seed, f) => (iter) => {
+  let h = seed;
+  for (const element of iter) {
+    h ^= f(element);
   }
-  const self = arguments[0];
-  const hash2 = arguments[1];
-  Object.defineProperty(self, symbol, {
-    value() {
-      return hash2;
-    },
-    enumerable: false
-  });
-  return hash2;
+  return optimize(h);
 };
+var array = /* @__PURE__ */ iterableWith(6151, hash);
+var hashMap = /* @__PURE__ */ iterableWith(/* @__PURE__ */ string("Map"), ([k, v]) => combine(hash(k), hash(v)));
+var hashSet = /* @__PURE__ */ iterableWith(/* @__PURE__ */ string("Set"), hash);
+var randomHashCache = /* @__PURE__ */ new WeakMap();
+var hashCache = /* @__PURE__ */ new WeakMap();
+var visitedObjects = /* @__PURE__ */ new WeakSet();
+function withVisitedTracking(obj, fn2) {
+  if (visitedObjects.has(obj)) {
+    return string("[Circular]");
+  }
+  visitedObjects.add(obj);
+  const result = fn2();
+  visitedObjects.delete(obj);
+  return result;
+}
 
-// ../../node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Equal.js
-var symbol2 = /* @__PURE__ */ Symbol.for("effect/Equal");
+// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Equal.js
+var symbol2 = "~effect/interfaces/Equal";
 function equals() {
   if (arguments.length === 1) {
     return (self) => compareBoth(self, arguments[0]);
@@ -377,71 +277,274 @@ function equals() {
   return compareBoth(arguments[0], arguments[1]);
 }
 function compareBoth(self, that) {
-  if (self === that) {
-    return true;
-  }
+  if (self === that) return true;
+  if (self == null || that == null) return false;
   const selfType = typeof self;
   if (selfType !== typeof that) {
     return false;
   }
-  if (selfType === "object" || selfType === "function") {
-    if (self !== null && that !== null) {
-      if (isEqual(self) && isEqual(that)) {
-        if (hash(self) === hash(that) && self[symbol2](that)) {
-          return true;
-        } else {
-          return structuralRegionState.enabled && structuralRegionState.tester ? structuralRegionState.tester(self, that) : false;
-        }
-      } else if (self instanceof Date && that instanceof Date) {
-        const t1 = self.getTime();
-        const t2 = that.getTime();
-        return t1 === t2 || Number.isNaN(t1) && Number.isNaN(t2);
-      } else if (self instanceof URL && that instanceof URL) {
-        return self.href === that.href;
-      }
-    }
-    if (structuralRegionState.enabled) {
-      if (Array.isArray(self) && Array.isArray(that)) {
-        return self.length === that.length && self.every((v, i) => compareBoth(v, that[i]));
-      }
-      if (Object.getPrototypeOf(self) === Object.prototype && Object.getPrototypeOf(self) === Object.prototype) {
-        const keysSelf = Object.keys(self);
-        const keysThat = Object.keys(that);
-        if (keysSelf.length === keysThat.length) {
-          for (const key of keysSelf) {
-            if (!(key in that && compareBoth(self[key], that[key]))) {
-              return structuralRegionState.tester ? structuralRegionState.tester(self, that) : false;
-            }
-          }
-          return true;
-        }
+  if (selfType === "number" && self !== self && that !== that) {
+    return true;
+  }
+  if (selfType !== "object" && selfType !== "function") {
+    return false;
+  }
+  if (byReferenceInstances.has(self) || byReferenceInstances.has(that)) {
+    return false;
+  }
+  return withCache(self, that, compareObjects);
+}
+function withVisitedTracking2(self, that, fn2) {
+  const hasLeft = visitedLeft.has(self);
+  const hasRight = visitedRight.has(that);
+  if (hasLeft && hasRight) {
+    return true;
+  }
+  if (hasLeft || hasRight) {
+    return false;
+  }
+  visitedLeft.add(self);
+  visitedRight.add(that);
+  const result = fn2();
+  visitedLeft.delete(self);
+  visitedRight.delete(that);
+  return result;
+}
+var visitedLeft = /* @__PURE__ */ new WeakSet();
+var visitedRight = /* @__PURE__ */ new WeakSet();
+function compareObjects(self, that) {
+  if (hash(self) !== hash(that)) {
+    return false;
+  } else if (self instanceof Date) {
+    if (!(that instanceof Date)) return false;
+    return self.toISOString() === that.toISOString();
+  } else if (self instanceof RegExp) {
+    if (!(that instanceof RegExp)) return false;
+    return self.toString() === that.toString();
+  }
+  const selfIsEqual = isEqual(self);
+  const thatIsEqual = isEqual(that);
+  if (selfIsEqual !== thatIsEqual) return false;
+  const bothEquals = selfIsEqual && thatIsEqual;
+  if (typeof self === "function" && !bothEquals) {
+    return false;
+  }
+  return withVisitedTracking2(self, that, () => {
+    if (bothEquals) {
+      return self[symbol2](that);
+    } else if (Array.isArray(self)) {
+      if (!Array.isArray(that) || self.length !== that.length) {
+        return false;
       }
-      return structuralRegionState.tester ? structuralRegionState.tester(self, that) : false;
+      return compareArrays(self, that);
+    } else if (self instanceof Map) {
+      if (!(that instanceof Map) || self.size !== that.size) {
+        return false;
+      }
+      return compareMaps(self, that);
+    } else if (self instanceof Set) {
+      if (!(that instanceof Set) || self.size !== that.size) {
+        return false;
+      }
+      return compareSets(self, that);
+    }
+    return compareRecords(self, that);
+  });
+}
+function withCache(self, that, f) {
+  let selfMap = equalityCache.get(self);
+  if (!selfMap) {
+    selfMap = /* @__PURE__ */ new WeakMap();
+    equalityCache.set(self, selfMap);
+  } else if (selfMap.has(that)) {
+    return selfMap.get(that);
+  }
+  const result = f(self, that);
+  selfMap.set(that, result);
+  let thatMap = equalityCache.get(that);
+  if (!thatMap) {
+    thatMap = /* @__PURE__ */ new WeakMap();
+    equalityCache.set(that, thatMap);
+  }
+  thatMap.set(self, result);
+  return result;
+}
+var equalityCache = /* @__PURE__ */ new WeakMap();
+function compareArrays(self, that) {
+  for (let i = 0; i < self.length; i++) {
+    if (!compareBoth(self[i], that[i])) {
+      return false;
     }
   }
-  return structuralRegionState.enabled && structuralRegionState.tester ? structuralRegionState.tester(self, that) : false;
+  return true;
 }
+function compareRecords(self, that) {
+  const selfKeys = getAllObjectKeys(self);
+  const thatKeys = getAllObjectKeys(that);
+  if (selfKeys.size !== thatKeys.size) {
+    return false;
+  }
+  for (const key of selfKeys) {
+    if (!thatKeys.has(key) || !compareBoth(self[key], that[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+function makeCompareMap(keyEquivalence, valueEquivalence) {
+  return function compareMaps2(self, that) {
+    for (const [selfKey, selfValue] of self) {
+      let found = false;
+      for (const [thatKey, thatValue] of that) {
+        if (keyEquivalence(selfKey, thatKey) && valueEquivalence(selfValue, thatValue)) {
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        return false;
+      }
+    }
+    return true;
+  };
+}
+var compareMaps = /* @__PURE__ */ makeCompareMap(compareBoth, compareBoth);
+function makeCompareSet(equivalence) {
+  return function compareSets2(self, that) {
+    for (const selfValue of self) {
+      let found = false;
+      for (const thatValue of that) {
+        if (equivalence(selfValue, thatValue)) {
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        return false;
+      }
+    }
+    return true;
+  };
+}
+var compareSets = /* @__PURE__ */ makeCompareSet(compareBoth);
 var isEqual = (u) => hasProperty(u, symbol2);
-var equivalence = () => equals;
+var asEquivalence = () => equals;
+
+// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Redactable.js
+var symbolRedactable = /* @__PURE__ */ Symbol.for("~effect/Inspectable/redactable");
+var isRedactable = (u) => hasProperty(u, symbolRedactable);
+function redact(u) {
+  if (isRedactable(u)) return getRedacted(u);
+  return u;
+}
+function getRedacted(redactable) {
+  return redactable[symbolRedactable](globalThis[currentFiberTypeId]?.services ?? emptyServiceMap);
+}
+var currentFiberTypeId = "~effect/Fiber/currentFiber";
+var emptyServiceMap = {
+  "~effect/ServiceMap": {},
+  mapUnsafe: /* @__PURE__ */ new Map(),
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
 
-// ../../node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Inspectable.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Formatter.js
+function format(input, options) {
+  const space = options?.space ?? 0;
+  const seen = /* @__PURE__ */ new WeakSet();
+  const gap = !space ? "" : typeof space === "number" ? " ".repeat(space) : space;
+  const ind = (d) => gap.repeat(d);
+  const wrap = (v, body) => {
+    const ctor = v?.constructor;
+    return ctor && ctor !== Object.prototype.constructor && ctor.name ? `${ctor.name}(${body})` : body;
+  };
+  const ownKeys = (o) => {
+    try {
+      return Reflect.ownKeys(o);
+    } catch {
+      return ["[ownKeys threw]"];
+    }
+  };
+  function recur(v, d = 0) {
+    if (Array.isArray(v)) {
+      if (seen.has(v)) return CIRCULAR;
+      seen.add(v);
+      if (!gap || v.length <= 1) return `[${v.map((x) => recur(x, d)).join(",")}]`;
+      const inner = v.map((x) => recur(x, d + 1)).join(",\n" + ind(d + 1));
+      return `[
+${ind(d + 1)}${inner}
+${ind(d)}]`;
+    }
+    if (v instanceof Date) return formatDate(v);
+    if (!options?.ignoreToString && hasProperty(v, "toString") && typeof v["toString"] === "function" && v["toString"] !== Object.prototype.toString && v["toString"] !== Array.prototype.toString) {
+      const s = safeToString(v);
+      if (v instanceof Error && v.cause) {
+        return `${s} (cause: ${recur(v.cause, d)})`;
+      }
+      return s;
+    }
+    if (typeof v === "string") return JSON.stringify(v);
+    if (typeof v === "number" || v == null || typeof v === "boolean" || typeof v === "symbol") return String(v);
+    if (typeof v === "bigint") return String(v) + "n";
+    if (typeof v === "object" || typeof v === "function") {
+      if (seen.has(v)) return CIRCULAR;
+      seen.add(v);
+      if (symbolRedactable in v) return format(getRedacted(v));
+      if (Symbol.iterator in v) {
+        return `${v.constructor.name}(${recur(Array.from(v), d)})`;
+      }
+      const keys2 = ownKeys(v);
+      if (!gap || keys2.length <= 1) {
+        const body2 = `{${keys2.map((k) => `${formatPropertyKey(k)}:${recur(v[k], d)}`).join(",")}}`;
+        return wrap(v, body2);
+      }
+      const body = `{
+${keys2.map((k) => `${ind(d + 1)}${formatPropertyKey(k)}: ${recur(v[k], d + 1)}`).join(",\n")}
+${ind(d)}}`;
+      return wrap(v, body);
+    }
+    return String(v);
+  }
+  return recur(input, 0);
+}
+var CIRCULAR = "[Circular]";
+function formatPropertyKey(name) {
+  return typeof name === "string" ? JSON.stringify(name) : String(name);
+}
+function formatDate(date) {
+  try {
+    return date.toISOString();
+  } catch {
+    return "Invalid Date";
+  }
+}
+function safeToString(input) {
+  try {
+    const s = input.toString();
+    return typeof s === "string" ? s : String(s);
+  } catch {
+    return "[toString threw]";
+  }
+}
+
+// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Inspectable.js
 var NodeInspectSymbol = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
-var toJSON = (x) => {
+var toJson = (input) => {
   try {
-    if (hasProperty(x, "toJSON") && isFunction2(x["toJSON"]) && x["toJSON"].length === 0) {
-      return x.toJSON();
-    } else if (Array.isArray(x)) {
-      return x.map(toJSON);
+    if (hasProperty(input, "toJSON") && isFunction(input["toJSON"]) && input["toJSON"].length === 0) {
+      return input.toJSON();
+    } else if (Array.isArray(input)) {
+      return input.map(toJson);
     }
   } catch {
-    return {};
+    return "[toJSON threw]";
   }
-  return redact(x);
+  return redact(input);
 };
-var format = (x) => JSON.stringify(x, null, 2);
 var BaseProto = {
   toJSON() {
-    return toJSON(this);
+    return toJson(this);
   },
   [NodeInspectSymbol]() {
     return this.toJSON();
@@ -451,171 +554,447 @@ var BaseProto = {
   }
 };
 var Class = class {
+  /**
+   * Node.js custom inspection method.
+   *
+   * @since 2.0.0
+   */
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+  /**
+   * Returns a formatted string representation of this object.
+   *
+   * @since 2.0.0
+   */
+  toString() {
+    return format(this.toJSON());
+  }
+};
+
+// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Utils.js
+var GenKindTypeId = "~effect/Utils/GenKind";
+var GenKindImpl = class {
+  value;
+  constructor(value) {
+    this.value = value;
+  }
+  get _F() {
+    return identity;
+  }
+  get _R() {
+    return (_) => _;
+  }
+  get _O() {
+    return (_) => _;
+  }
+  get _E() {
+    return (_) => _;
+  }
+  [GenKindTypeId] = GenKindTypeId;
+  [Symbol.iterator]() {
+    return new SingleShotGen(this);
+  }
+};
+var SingleShotGen = class _SingleShotGen {
+  called = false;
+  self;
+  constructor(self) {
+    this.self = self;
+  }
+  /**
+   * @since 2.0.0
+   */
+  next(a) {
+    return this.called ? {
+      value: a,
+      done: true
+    } : (this.called = true, {
+      value: this.self,
+      done: false
+    });
+  }
   /**
    * @since 2.0.0
    */
+  [Symbol.iterator]() {
+    return new _SingleShotGen(this.self);
+  }
+};
+var InternalTypeId = "~effect/Effect/internal";
+var standard = {
+  [InternalTypeId]: (body) => {
+    return body();
+  }
+};
+var forced = {
+  [InternalTypeId]: (body) => {
+    try {
+      return body();
+    } finally {
+    }
+  }
+};
+var isNotOptimizedAway = /* @__PURE__ */ standard[InternalTypeId](() => new Error().stack)?.includes(InternalTypeId) === true;
+var internalCall = isNotOptimizedAway ? standard[InternalTypeId] : forced[InternalTypeId];
+var genConstructor = function* () {
+}.constructor;
+
+// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/internal/core.js
+var EffectTypeId = `~effect/Effect`;
+var ExitTypeId = `~effect/Exit`;
+var effectVariance = {
+  _A: identity,
+  _E: identity,
+  _R: identity
+};
+var identifier = `${EffectTypeId}/identifier`;
+var args = `${EffectTypeId}/args`;
+var evaluate = `${EffectTypeId}/evaluate`;
+var contA = `${EffectTypeId}/successCont`;
+var contE = `${EffectTypeId}/failureCont`;
+var contAll = `${EffectTypeId}/ensureCont`;
+var PipeInspectableProto = {
+  pipe() {
+    return pipeArguments(this, arguments);
+  },
+  toJSON() {
+    return {
+      ...this
+    };
+  },
+  toString() {
+    return format(this.toJSON(), {
+      ignoreToString: true,
+      space: 2
+    });
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+};
+var StructuralProto = {
+  [symbol]() {
+    return structureKeys(this, Object.keys(this));
+  },
+  [symbol2](that) {
+    const selfKeys = Object.keys(this);
+    const thatKeys = Object.keys(that);
+    if (selfKeys.length !== thatKeys.length) return false;
+    for (let i = 0; i < selfKeys.length; i++) {
+      if (selfKeys[i] !== thatKeys[i] && !equals(this[selfKeys[i]], that[selfKeys[i]])) {
+        return false;
+      }
+    }
+    return true;
+  }
+};
+var YieldableProto = {
+  [Symbol.iterator]() {
+    return new SingleShotGen(this);
+  }
+};
+var YieldableErrorProto = {
+  ...YieldableProto,
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+var EffectProto = {
+  [EffectTypeId]: effectVariance,
+  ...PipeInspectableProto,
+  [Symbol.iterator]() {
+    return new SingleShotGen(this);
+  },
+  asEffect() {
+    return this;
+  },
+  toJSON() {
+    return {
+      _id: "Effect",
+      op: this[identifier],
+      ...args in this ? {
+        args: this[args]
+      } : void 0
+    };
+  }
+};
+var isExit = (u) => hasProperty(u, ExitTypeId);
+var CauseTypeId = "~effect/Cause";
+var CauseReasonTypeId = "~effect/Cause/Reason";
+var isCause = (self) => hasProperty(self, CauseTypeId);
+var CauseImpl = class {
+  [CauseTypeId];
+  reasons;
+  constructor(failures) {
+    this[CauseTypeId] = CauseTypeId;
+    this.reasons = failures;
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+  toJSON() {
+    return {
+      _id: "Cause",
+      failures: this.reasons.map((f) => f.toJSON())
+    };
+  }
+  toString() {
+    return `Cause(${format(this.reasons)})`;
+  }
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+  [symbol2](that) {
+    return isCause(that) && this.reasons.length === that.reasons.length && this.reasons.every((e, i) => equals(e, that.reasons[i]));
+  }
+  [symbol]() {
+    return array(this.reasons);
+  }
+};
+var annotationsMap = /* @__PURE__ */ new WeakMap();
+var ReasonBase = class {
+  [CauseReasonTypeId];
+  annotations;
+  _tag;
+  constructor(_tag, annotations, originalError) {
+    this[CauseReasonTypeId] = CauseReasonTypeId;
+    this._tag = _tag;
+    if (annotations !== constEmptyAnnotations && typeof originalError === "object" && originalError !== null && annotations.size > 0) {
+      const prevAnnotations = annotationsMap.get(originalError);
+      if (prevAnnotations) {
+        annotations = new Map([...prevAnnotations, ...annotations]);
+      }
+      annotationsMap.set(originalError, annotations);
+    }
+    this.annotations = annotations;
+  }
+  annotate(annotations, options) {
+    if (annotations.mapUnsafe.size === 0) return this;
+    const newAnnotations = new Map(this.annotations);
+    annotations.mapUnsafe.forEach((value, key) => {
+      if (options?.overwrite !== true && newAnnotations.has(key)) return;
+      newAnnotations.set(key, value);
+    });
+    const self = Object.assign(Object.create(Object.getPrototypeOf(this)), this);
+    self.annotations = newAnnotations;
+    return self;
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+  toString() {
+    return format(this);
+  }
   [NodeInspectSymbol]() {
-    return this.toJSON();
+    return this.toString();
+  }
+};
+var constEmptyAnnotations = /* @__PURE__ */ new Map();
+var Fail = class extends ReasonBase {
+  error;
+  constructor(error, annotations = constEmptyAnnotations) {
+    super("Fail", annotations, error);
+    this.error = error;
   }
-  /**
-   * @since 2.0.0
-   */
   toString() {
-    return format(this.toJSON());
+    return `Fail(${format(this.error)})`;
   }
-};
-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", () => ({
-  fiberRefs: void 0
-}));
-var redact = (u) => {
-  if (isRedactable(u) && redactableState.fiberRefs !== void 0) {
-    return u[symbolRedactable](redactableState.fiberRefs);
+  toJSON() {
+    return {
+      _tag: "Fail",
+      error: this.error
+    };
   }
-  return u;
-};
-
-// ../../node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Pipeable.js
-var pipeArguments = (self, args2) => {
-  switch (args2.length) {
-    case 0:
-      return self;
-    case 1:
-      return args2[0](self);
-    case 2:
-      return args2[1](args2[0](self));
-    case 3:
-      return args2[2](args2[1](args2[0](self)));
-    case 4:
-      return args2[3](args2[2](args2[1](args2[0](self))));
-    case 5:
-      return args2[4](args2[3](args2[2](args2[1](args2[0](self)))));
-    case 6:
-      return args2[5](args2[4](args2[3](args2[2](args2[1](args2[0](self))))));
-    case 7:
-      return args2[6](args2[5](args2[4](args2[3](args2[2](args2[1](args2[0](self)))))));
-    case 8:
-      return args2[7](args2[6](args2[5](args2[4](args2[3](args2[2](args2[1](args2[0](self))))))));
-    case 9:
-      return args2[8](args2[7](args2[6](args2[5](args2[4](args2[3](args2[2](args2[1](args2[0](self)))))))));
-    default: {
-      let ret = self;
-      for (let i = 0, len = args2.length; i < len; i++) {
-        ret = args2[i](ret);
-      }
-      return ret;
-    }
+  [symbol2](that) {
+    return isFailReason(that) && equals(this.error, that.error) && equals(this.annotations, that.annotations);
+  }
+  [symbol]() {
+    return combine(string(this._tag))(combine(hash(this.error))(hash(this.annotations)));
   }
 };
-
-// ../../node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/internal/opCodes/effect.js
-var OP_COMMIT = "Commit";
-
-// ../../node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/internal/version.js
-var moduleVersion = "3.19.14";
-var getCurrentVersion = () => moduleVersion;
-
-// ../../node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/internal/effectable.js
-var EffectTypeId = /* @__PURE__ */ Symbol.for("effect/Effect");
-var StreamTypeId = /* @__PURE__ */ Symbol.for("effect/Stream");
-var SinkTypeId = /* @__PURE__ */ Symbol.for("effect/Sink");
-var ChannelTypeId = /* @__PURE__ */ Symbol.for("effect/Channel");
-var effectVariance = {
-  /* c8 ignore next */
-  _R: (_) => _,
-  /* c8 ignore next */
-  _E: (_) => _,
-  /* c8 ignore next */
-  _A: (_) => _,
-  _V: /* @__PURE__ */ getCurrentVersion()
+var causeFail = (error) => new CauseImpl([new Fail(error)]);
+var Die = class extends ReasonBase {
+  defect;
+  constructor(defect, annotations = constEmptyAnnotations) {
+    super("Die", annotations, defect);
+    this.defect = defect;
+  }
+  toString() {
+    return `Die(${format(this.defect)})`;
+  }
+  toJSON() {
+    return {
+      _tag: "Die",
+      defect: this.defect
+    };
+  }
+  [symbol2](that) {
+    return isDieReason(that) && equals(this.defect, that.defect) && equals(this.annotations, that.annotations);
+  }
+  [symbol]() {
+    return combine(string(this._tag))(combine(hash(this.defect))(hash(this.annotations)));
+  }
 };
-var sinkVariance = {
-  /* c8 ignore next */
-  _A: (_) => _,
-  /* c8 ignore next */
-  _In: (_) => _,
-  /* c8 ignore next */
-  _L: (_) => _,
-  /* c8 ignore next */
-  _E: (_) => _,
-  /* c8 ignore next */
-  _R: (_) => _
+var causeDie = (defect) => new CauseImpl([new Die(defect)]);
+var causeAnnotate = /* @__PURE__ */ dual((args3) => isCause(args3[0]), (self, annotations, options) => {
+  if (annotations.mapUnsafe.size === 0) return self;
+  return new CauseImpl(self.reasons.map((f) => f.annotate(annotations, options)));
+});
+var isFailReason = (self) => self._tag === "Fail";
+var isDieReason = (self) => self._tag === "Die";
+function defaultEvaluate(_fiber) {
+  return exitDie(`Effect.evaluate: Not implemented`);
+}
+var makePrimitiveProto = (options) => ({
+  ...EffectProto,
+  [identifier]: options.op,
+  [evaluate]: options[evaluate] ?? defaultEvaluate,
+  [contA]: options[contA],
+  [contE]: options[contE],
+  [contAll]: options[contAll]
+});
+var makePrimitive = (options) => {
+  const Proto = makePrimitiveProto(options);
+  return function() {
+    const self = Object.create(Proto);
+    self[args] = options.single === false ? arguments : arguments[0];
+    return self;
+  };
 };
-var channelVariance = {
-  /* c8 ignore next */
-  _Env: (_) => _,
-  /* c8 ignore next */
-  _InErr: (_) => _,
-  /* c8 ignore next */
-  _InElem: (_) => _,
-  /* c8 ignore next */
-  _InDone: (_) => _,
-  /* c8 ignore next */
-  _OutErr: (_) => _,
-  /* c8 ignore next */
-  _OutElem: (_) => _,
-  /* c8 ignore next */
-  _OutDone: (_) => _
+var makeExit = (options) => {
+  const Proto = {
+    ...makePrimitiveProto(options),
+    [ExitTypeId]: ExitTypeId,
+    _tag: options.op,
+    get [options.prop]() {
+      return this[args];
+    },
+    toString() {
+      return `${options.op}(${format(this[args])})`;
+    },
+    toJSON() {
+      return {
+        _id: "Exit",
+        _tag: options.op,
+        [options.prop]: this[args]
+      };
+    },
+    [symbol2](that) {
+      return isExit(that) && that._tag === this._tag && equals(this[args], that[args]);
+    },
+    [symbol]() {
+      return combine(string(options.op), hash(this[args]));
+    }
+  };
+  return function(value) {
+    const self = Object.create(Proto);
+    self[args] = value;
+    return self;
+  };
 };
-var EffectPrototype = {
-  [EffectTypeId]: effectVariance,
-  [StreamTypeId]: effectVariance,
-  [SinkTypeId]: sinkVariance,
-  [ChannelTypeId]: channelVariance,
-  [symbol2](that) {
-    return this === that;
-  },
-  [symbol]() {
-    return cached(this, random(this));
-  },
-  [Symbol.iterator]() {
-    return new SingleShotGen(new YieldWrap(this));
-  },
-  pipe() {
-    return pipeArguments(this, arguments);
+var exitSucceed = /* @__PURE__ */ makeExit({
+  op: "Success",
+  prop: "value",
+  [evaluate](fiber) {
+    const cont = fiber.getCont(contA);
+    return cont ? cont[contA](this[args], fiber, this) : fiber.yieldWith(this);
   }
+});
+var StackTraceKey = {
+  key: "effect/Cause/StackTrace"
 };
-var StructuralPrototype = {
-  [symbol]() {
-    return cached(this, structure(this));
-  },
-  [symbol2](that) {
-    const selfKeys = Object.keys(this);
-    const thatKeys = Object.keys(that);
-    if (selfKeys.length !== thatKeys.length) {
-      return false;
+var exitFailCause = /* @__PURE__ */ makeExit({
+  op: "Failure",
+  prop: "cause",
+  [evaluate](fiber) {
+    let cause = this[args];
+    let annotated = false;
+    if (fiber.currentStackFrame) {
+      cause = causeAnnotate(cause, {
+        mapUnsafe: /* @__PURE__ */ new Map([[StackTraceKey.key, fiber.currentStackFrame]])
+      });
+      annotated = true;
     }
-    for (const key of selfKeys) {
-      if (!(key in that && equals(this[key], that[key]))) {
-        return false;
-      }
+    let cont = fiber.getCont(contE);
+    while (fiber.interruptible && fiber._interruptedCause && cont) {
+      cont = fiber.getCont(contE);
     }
-    return true;
+    return cont ? cont[contE](cause, fiber, annotated ? void 0 : this) : fiber.yieldWith(annotated ? this : exitFailCause(cause));
   }
+});
+var exitFail = (e) => exitFailCause(causeFail(e));
+var exitDie = (defect) => exitFailCause(causeDie(defect));
+var withFiber = /* @__PURE__ */ makePrimitive({
+  op: "WithFiber",
+  [evaluate](fiber) {
+    return this[args](fiber);
+  }
+});
+var YieldableError = /* @__PURE__ */ (function() {
+  class YieldableError2 extends globalThis.Error {
+    asEffect() {
+      return exitFail(this);
+    }
+  }
+  Object.assign(YieldableError2.prototype, YieldableErrorProto);
+  return YieldableError2;
+})();
+var Error2 = /* @__PURE__ */ (function() {
+  const plainArgsSymbol = /* @__PURE__ */ Symbol.for("effect/Data/Error/plainArgs");
+  return class Base extends YieldableError {
+    constructor(args3) {
+      super(args3?.message, args3?.cause ? {
+        cause: args3.cause
+      } : void 0);
+      if (args3) {
+        Object.assign(this, args3);
+        Object.defineProperty(this, plainArgsSymbol, {
+          value: args3,
+          enumerable: false
+        });
+      }
+    }
+    toJSON() {
+      return {
+        ...this[plainArgsSymbol],
+        ...this
+      };
+    }
+  };
+})();
+var TaggedError = (tag) => {
+  class Base extends Error2 {
+    _tag = tag;
+  }
+  ;
+  Base.prototype.name = tag;
+  return Base;
 };
-var CommitPrototype = {
-  ...EffectPrototype,
-  _op: OP_COMMIT
+var NoSuchElementErrorTypeId = "~effect/Cause/NoSuchElementError";
+var NoSuchElementError = class extends (/* @__PURE__ */ TaggedError("NoSuchElementError")) {
+  [NoSuchElementErrorTypeId] = NoSuchElementErrorTypeId;
+  constructor(message) {
+    super({
+      message
+    });
+  }
 };
-var StructuralCommitPrototype = {
-  ...CommitPrototype,
-  ...StructuralPrototype
+var DoneTypeId = "~effect/Cause/Done";
+var DoneVoid = {
+  [DoneTypeId]: DoneTypeId,
+  _tag: "Done",
+  value: void 0
 };
 
-// ../../node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/internal/option.js
-var TypeId = /* @__PURE__ */ Symbol.for("effect/Option");
+// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/internal/option.js
+var TypeId = "~effect/data/Option";
 var CommonProto = {
-  ...EffectPrototype,
   [TypeId]: {
     _A: (_) => _
   },
-  [NodeInspectSymbol]() {
-    return this.toJSON();
-  },
-  toString() {
-    return format(this.toJSON());
-  }
+  ...PipeInspectableProto,
+  ...YieldableProto
 };
 var SomeProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(CommonProto), {
   _tag: "Some",
@@ -624,14 +1003,20 @@ var SomeProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(Comm
     return isOption(that) && isSome(that) && equals(this.value, that.value);
   },
   [symbol]() {
-    return cached(this, combine(hash(this._tag))(hash(this.value)));
+    return combine(hash(this._tag))(hash(this.value));
+  },
+  toString() {
+    return `some(${format(this.value)})`;
   },
   toJSON() {
     return {
       _id: "Option",
       _tag: this._tag,
-      value: toJSON(this.value)
+      value: toJson(this.value)
     };
+  },
+  asEffect() {
+    return exitSucceed(this.value);
   }
 });
 var NoneHash = /* @__PURE__ */ hash("None");
@@ -644,11 +1029,17 @@ var NoneProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(Comm
   [symbol]() {
     return NoneHash;
   },
+  toString() {
+    return `none()`;
+  },
   toJSON() {
     return {
       _id: "Option",
       _tag: this._tag
     };
+  },
+  asEffect() {
+    return exitFail(new NoSuchElementError());
   }
 });
 var isOption = (input) => hasProperty(input, TypeId);
@@ -661,94 +1052,113 @@ var some = (value) => {
   return a;
 };
 
-// ../../node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/internal/either.js
-var TypeId2 = /* @__PURE__ */ Symbol.for("effect/Either");
+// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/internal/result.js
+var TypeId2 = "~effect/data/Result";
 var CommonProto2 = {
-  ...EffectPrototype,
   [TypeId2]: {
-    _R: (_) => _
-  },
-  [NodeInspectSymbol]() {
-    return this.toJSON();
+    /* v8 ignore next 2 */
+    _A: (_) => _,
+    _E: (_) => _
   },
-  toString() {
-    return format(this.toJSON());
-  }
+  ...PipeInspectableProto,
+  ...YieldableProto
 };
-var RightProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(CommonProto2), {
-  _tag: "Right",
-  _op: "Right",
+var SuccessProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(CommonProto2), {
+  _tag: "Success",
+  _op: "Success",
   [symbol2](that) {
-    return isEither(that) && isRight(that) && equals(this.right, that.right);
+    return isResult(that) && isSuccess(that) && equals(this.success, that.success);
   },
   [symbol]() {
-    return combine(hash(this._tag))(hash(this.right));
+    return combine(hash(this._tag))(hash(this.success));
+  },
+  toString() {
+    return `success(${format(this.success)})`;
   },
   toJSON() {
     return {
-      _id: "Either",
+      _id: "Result",
       _tag: this._tag,
-      right: toJSON(this.right)
+      value: toJson(this.success)
     };
+  },
+  asEffect() {
+    return exitSucceed(this.success);
   }
 });
-var LeftProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(CommonProto2), {
-  _tag: "Left",
-  _op: "Left",
+var FailureProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(CommonProto2), {
+  _tag: "Failure",
+  _op: "Failure",
   [symbol2](that) {
-    return isEither(that) && isLeft(that) && equals(this.left, that.left);
+    return isResult(that) && isFailure(that) && equals(this.failure, that.failure);
   },
   [symbol]() {
-    return combine(hash(this._tag))(hash(this.left));
+    return combine(hash(this._tag))(hash(this.failure));
+  },
+  toString() {
+    return `failure(${format(this.failure)})`;
   },
   toJSON() {
     return {
-      _id: "Either",
+      _id: "Result",
       _tag: this._tag,
-      left: toJSON(this.left)
+      failure: toJson(this.failure)
     };
+  },
+  asEffect() {
+    return exitFail(this.failure);
   }
 });
-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;
+var isResult = (input) => hasProperty(input, TypeId2);
+var isFailure = (result) => result._tag === "Failure";
+var isSuccess = (result) => result._tag === "Success";
+var fail = (failure) => {
+  const a = Object.create(FailureProto);
+  a.failure = failure;
   return a;
 };
-var right = (right3) => {
-  const a = Object.create(RightProto);
-  a.right = right3;
+var succeed = (success) => {
+  const a = Object.create(SuccessProto);
+  a.success = success;
   return a;
 };
 
-// ../../node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Either.js
-var right2 = right;
-var left2 = left;
-var isLeft2 = isLeft;
-var isRight2 = isRight;
-var map = /* @__PURE__ */ dual(2, (self, f) => isRight2(self) ? right2(f(self.right)) : left2(self.left));
-var getOrElse = /* @__PURE__ */ dual(2, (self, onLeft) => isLeft2(self) ? onLeft(self.left) : self.right);
-
-// ../../node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/internal/array.js
-var isNonEmptyArray = (self) => self.length > 0;
-
-// ../../node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Order.js
-var make = (compare) => (self, that) => self === that ? 0 : compare(self, that);
-var string2 = /* @__PURE__ */ make((self, that) => self < that ? -1 : 1);
+// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Order.js
+function make(compare) {
+  return (self, that) => self === that ? 0 : compare(self, that);
+}
+var String2 = /* @__PURE__ */ make((self, that) => self < that ? -1 : 1);
 
-// ../../node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Option.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Option.js
 var none2 = () => none;
 var some2 = some;
 var isNone2 = isNone;
 var isSome2 = isSome;
-var getOrElse2 = /* @__PURE__ */ dual(2, (self, onNone) => isNone2(self) ? onNone() : self.value);
+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);
-var getOrUndefined = /* @__PURE__ */ getOrElse2(constUndefined);
+var fromNullishOr = (a) => a == null ? none2() : some2(a);
+var getOrUndefined = /* @__PURE__ */ getOrElse(constUndefined);
+
+// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Result.js
+var succeed2 = succeed;
+var fail2 = fail;
+var isFailure2 = isFailure;
+var isSuccess2 = isSuccess;
+var map = /* @__PURE__ */ dual(2, (self, f) => isSuccess2(self) ? succeed2(f(self.success)) : fail2(self.failure));
+var getOrElse2 = /* @__PURE__ */ dual(2, (self, onFailure) => isFailure2(self) ? onFailure(self.failure) : self.success);
+
+// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Filter.js
+var apply = (filter2, input, ...args3) => {
+  const result = filter2(input, ...args3);
+  if (result === true) return succeed2(input);
+  if (result === false) return fail2(input);
+  return result;
+};
 
-// ../../node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Record.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/internal/array.js
+var isArrayNonEmpty = (self) => self.length > 0;
+
+// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Record.js
 var map2 = /* @__PURE__ */ dual(2, (self, f) => {
   const out = {
     ...self
@@ -760,31 +1170,34 @@ var map2 = /* @__PURE__ */ dual(2, (self, f) => {
 });
 var keys = (self) => Object.keys(self);
 
-// ../../node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Array.js
-var fromIterable = (collection) => Array.isArray(collection) ? collection : Array.from(collection);
+// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Array.js
+var Array2 = globalThis.Array;
+var fromIterable = (collection) => Array2.isArray(collection) ? collection : Array2.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 isEmptyArray = (self) => self.length === 0;
-var isEmptyReadonlyArray = isEmptyArray;
-var isNonEmptyReadonlyArray = isNonEmptyArray;
-var isOutOfBounds = (i, as) => i < 0 || i >= as.length;
+var isArray = Array2.isArray;
+var isArrayEmpty = (self) => self.length === 0;
+var isReadonlyArrayEmpty = isArrayEmpty;
+var isReadonlyArrayNonEmpty = isArrayNonEmpty;
+function isOutOfBounds(i, as) {
+  return i < 0 || i >= as.length;
+}
 var get = /* @__PURE__ */ dual(2, (self, index) => {
   const i = Math.floor(index);
   return isOutOfBounds(i, self) ? none2() : some2(self[i]);
 });
-var unsafeGet = /* @__PURE__ */ dual(2, (self, index) => {
+var getUnsafe = /* @__PURE__ */ dual(2, (self, index) => {
   const i = Math.floor(index);
   if (isOutOfBounds(i, self)) {
-    throw new Error(`Index ${i} out of bounds`);
+    throw new Error(`Index out of bounds: ${i}`);
   }
   return self[i];
 });
 var head = /* @__PURE__ */ get(0);
-var headNonEmpty = /* @__PURE__ */ unsafeGet(0);
+var headNonEmpty = /* @__PURE__ */ getUnsafe(0);
 var tailNonEmpty = (self) => self.slice(1);
 var sort = /* @__PURE__ */ dual(2, (self, O) => {
-  const out = Array.from(self);
+  const out = Array2.from(self);
   out.sort(O);
   return out;
 });
@@ -796,19 +1209,18 @@ var containsWith = (isEquivalent) => dual(2, (self, a) => {
   }
   return false;
 });
-var _equivalence = /* @__PURE__ */ equivalence();
 var intersectionWith = (isEquivalent) => {
   const has = containsWith(isEquivalent);
   return dual(2, (self, that) => {
-    const bs = fromIterable(that);
-    return fromIterable(self).filter((a) => has(bs, a));
+    const thatArray = fromIterable(that);
+    return fromIterable(self).filter((a) => has(thatArray, a));
   });
 };
-var intersection = /* @__PURE__ */ intersectionWith(_equivalence);
+var intersection = /* @__PURE__ */ intersectionWith(/* @__PURE__ */ asEquivalence());
 var empty = () => [];
 var map3 = /* @__PURE__ */ dual(2, (self, f) => self.map(f));
 var flatMap = /* @__PURE__ */ dual(2, (self, f) => {
-  if (isEmptyReadonlyArray(self)) {
+  if (isReadonlyArrayEmpty(self)) {
     return [];
   }
   const out = [];
@@ -821,19 +1233,20 @@ var flatMap = /* @__PURE__ */ dual(2, (self, f) => {
   return out;
 });
 var flatten = /* @__PURE__ */ flatMap(identity);
-var filter = /* @__PURE__ */ dual(2, (self, predicate) => {
+var filter = /* @__PURE__ */ dual(2, (self, f) => {
   const as = fromIterable(self);
   const out = [];
   for (let i = 0; i < as.length; i++) {
-    if (predicate(as[i], i)) {
-      out.push(as[i]);
+    const result = apply(f, as[i], i);
+    if (!isFailure2(result)) {
+      out.push(result.success);
     }
   }
   return out;
 });
 var dedupeWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => {
   const input = fromIterable(self);
-  if (isNonEmptyReadonlyArray(input)) {
+  if (isReadonlyArrayNonEmpty(input)) {
     const out = [headNonEmpty(input)];
     const rest = tailNonEmpty(input);
     for (const r of rest) {
@@ -845,16 +1258,17 @@ var dedupeWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => {
   }
   return [];
 });
-var dedupe = (self) => dedupeWith(self, equivalence());
+var dedupe = (self) => dedupeWith(self, asEquivalence());
 var join = /* @__PURE__ */ dual(2, (self, sep) => fromIterable(self).join(sep));
 
 // src/core/Nano.ts
+var debugPerformance = false;
 var NanoTag = class {
   constructor(key) {
     this.key = key;
   }
 };
-var Tag = (identifier) => new NanoTag(identifier);
+var Tag = (identifier2) => new NanoTag(identifier2);
 var SingleShotGen2 = class _SingleShotGen {
   called = false;
   self;
@@ -880,12 +1294,12 @@ var SingleShotGen2 = class _SingleShotGen {
     return new _SingleShotGen(this.self);
   }
 };
-var evaluate = /* @__PURE__ */ Symbol.for("Nano.evaluate");
-var contA = /* @__PURE__ */ Symbol.for("Nano.contA");
-var contE = /* @__PURE__ */ Symbol.for("Nano.contE");
-var contAll = /* @__PURE__ */ Symbol.for("Nano.contAll");
+var evaluate2 = /* @__PURE__ */ Symbol.for("Nano.evaluate");
+var contA2 = /* @__PURE__ */ Symbol.for("Nano.contA");
+var contE2 = /* @__PURE__ */ Symbol.for("Nano.contE");
+var contAll2 = /* @__PURE__ */ Symbol.for("Nano.contAll");
 var NanoYield = /* @__PURE__ */ Symbol.for("Nano.yield");
-var args = /* @__PURE__ */ Symbol.for("Nano.args");
+var args2 = /* @__PURE__ */ Symbol.for("Nano.args");
 var NanoDefectException = class {
   constructor(message, lastSpan) {
     this.message = message;
@@ -902,43 +1316,43 @@ var SucceedProto = {
   ...PrimitiveProto,
   _tag: "Success",
   get value() {
-    return this[args];
+    return this[args2];
   },
-  [evaluate](fiber) {
-    const cont = fiber.getCont(contA);
-    return cont ? cont[contA](this[args], fiber) : fiber.yieldWith(this);
+  [evaluate2](fiber) {
+    const cont = fiber.getCont(contA2);
+    return cont ? cont[contA2](this[args2], fiber) : fiber.yieldWith(this);
   }
 };
-var succeed = (value) => {
+var succeed3 = (value) => {
   const nano = Object.create(SucceedProto);
-  nano[args] = value;
+  nano[args2] = value;
   return nano;
 };
-var FailureProto = {
+var FailureProto2 = {
   ...PrimitiveProto,
   _tag: "Failure",
   get value() {
-    return this[args];
+    return this[args2];
   },
-  [evaluate](fiber) {
-    const cont = fiber.getCont(contE);
-    return cont ? cont[contE](this[args], fiber) : fiber.yieldWith(this);
+  [evaluate2](fiber) {
+    const cont = fiber.getCont(contE2);
+    return cont ? cont[contE2](this[args2], fiber) : fiber.yieldWith(this);
   }
 };
-var fail = (error) => {
-  const nano = Object.create(FailureProto);
-  nano[args] = error;
+var fail3 = (error) => {
+  const nano = Object.create(FailureProto2);
+  nano[args2] = error;
   return nano;
 };
 var SuspendProto = {
   ...PrimitiveProto,
-  [evaluate]() {
-    return this[args]();
+  [evaluate2]() {
+    return this[args2]();
   }
 };
 var suspend = (fn2) => {
   const nano = Object.create(SuspendProto);
-  nano[args] = fn2;
+  nano[args2] = fn2;
   return nano;
 };
 var NanoFiber = class {
@@ -946,12 +1360,11 @@ var NanoFiber = class {
   _yielded = void 0;
   _services = {};
   _cache = {};
-  _perf = false;
   _lastSpan = "";
   runLoop(nano) {
     let current = nano;
     while (true) {
-      current = current[evaluate](this);
+      current = current[evaluate2](this);
       if (current === NanoYield) {
         return this._yielded;
       }
@@ -961,7 +1374,7 @@ var NanoFiber = class {
     while (true) {
       const op = this._stack.pop();
       if (!op) return void 0;
-      const cont = op[contAll] && op[contAll](this);
+      const cont = op[contAll2] && op[contAll2](this);
       if (cont) return { [symbol3]: cont };
       if (op[symbol3]) return op;
     }
@@ -975,9 +1388,9 @@ var timings = {};
 var timingsCount = {};
 var WithSpanProto = {
   ...PrimitiveProto,
-  [evaluate](fiber) {
-    const [fa, name] = this[args];
-    if (!fiber._perf) return fa;
+  [evaluate2](fiber) {
+    const [fa, name] = this[args2];
+    if (!debugPerformance) return fa;
     const previousSpan = fiber._lastSpan;
     fiber._lastSpan = name;
     const start = performance.now();
@@ -987,20 +1400,20 @@ var WithSpanProto = {
         const end = performance.now();
         timings[name] = (timings[name] || 0) + (end - start);
         fiber._lastSpan = previousSpan;
-        return succeed(_);
+        return succeed3(_);
       },
       onFailure: (_) => {
         const end = performance.now();
         timings[name] = (timings[name] || 0) + (end - start);
         fiber._lastSpan = previousSpan;
-        return fail(_);
+        return fail3(_);
       }
     });
   }
 };
 var withSpan = (name) => (fa) => {
   const nano = Object.create(WithSpanProto);
-  nano[args] = [fa, name];
+  nano[args2] = [fa, name];
   return nano;
 };
 var run = (nano) => {
@@ -1008,86 +1421,86 @@ var run = (nano) => {
   try {
     const result = fiber.runLoop(nano);
     if (result._tag === "Success") {
-      return right2(result.value);
+      return succeed2(result.value);
     }
-    return left2(result.value);
+    return fail2(result.value);
   } catch (e) {
-    return left2(new NanoDefectException(e, fiber._lastSpan));
+    return fail2(new NanoDefectException(e, fiber._lastSpan));
   }
 };
 var OnSuccessProto = {
   ...PrimitiveProto,
-  [evaluate](fiber) {
+  [evaluate2](fiber) {
     fiber._stack.push(this);
-    return this[args];
+    return this[args2];
   }
 };
 var flatMap2 = dual(2, (fa, f) => {
   const nano = Object.create(OnSuccessProto);
-  nano[args] = fa;
-  nano[contA] = f;
+  nano[args2] = fa;
+  nano[contA2] = f;
   return nano;
 });
-var map4 = dual(2, (fa, f) => flatMap2(fa, (_) => succeed(f(_))));
+var map4 = dual(2, (fa, f) => flatMap2(fa, (_) => succeed3(f(_))));
 var SyncProto = {
   ...PrimitiveProto,
-  [evaluate](fiber) {
-    const value = this[args]();
-    const cont = fiber.getCont(contA);
-    return cont ? cont[contA](value, fiber) : fiber.yieldWith(succeed(value));
+  [evaluate2](fiber) {
+    const value = this[args2]();
+    const cont = fiber.getCont(contA2);
+    return cont ? cont[contA2](value, fiber) : fiber.yieldWith(succeed3(value));
   }
 };
 var sync = (f) => {
   const nano = Object.create(SyncProto);
-  nano[args] = f;
+  nano[args2] = f;
   return nano;
 };
-var void_ = succeed(void 0);
+var void_ = succeed3(void 0);
 var FromIteratorProto = {
   ...PrimitiveProto,
-  [contA](value, fiber) {
-    const state = this[args][0].next(value);
-    if (state.done) return succeed(state.value);
+  [contA2](value, fiber) {
+    const state = this[args2][0].next(value);
+    if (state.done) return succeed3(state.value);
     fiber._stack.push(this);
     return state.value;
   },
-  [evaluate](fiber) {
-    return this[contA](this[args][1], fiber);
+  [evaluate2](fiber) {
+    return this[contA2](this[args2][1], fiber);
   }
 };
 var unsafeFromIterator = (iterator, initial) => {
   const nano = Object.create(FromIteratorProto);
-  nano[args] = [iterator, initial];
+  nano[args2] = [iterator, initial];
   return nano;
 };
-var gen = (...args2) => suspend(() => unsafeFromIterator(args2[0]()));
-var fn = (_) => (body) => (...args2) => withSpan(_)(suspend(() => unsafeFromIterator(body(...args2))));
+var gen = (...args3) => suspend(() => unsafeFromIterator(args3[0]()));
+var fn = (_) => (body) => (...args3) => withSpan(_)(suspend(() => unsafeFromIterator(body(...args3))));
 var MatchProto = {
   ...PrimitiveProto,
-  [evaluate](fiber) {
+  [evaluate2](fiber) {
     fiber._stack.push(this);
-    return this[args];
+    return this[args2];
   }
 };
 var match = (fa, opts) => {
   const nano = Object.create(MatchProto);
-  nano[args] = fa;
-  nano[contA] = opts.onSuccess;
-  nano[contE] = opts.onFailure;
+  nano[args2] = fa;
+  nano[contA2] = opts.onSuccess;
+  nano[contE2] = opts.onFailure;
   return nano;
 };
 var orElse2 = (f) => (fa) => {
   const nano = Object.create(MatchProto);
-  nano[args] = fa;
-  nano[contE] = (_) => _ instanceof NanoDefectException ? fail(_) : f(_);
+  nano[args2] = fa;
+  nano[contE2] = (_) => _ instanceof NanoDefectException ? fail3(_) : f(_);
   return nano;
 };
 var firstSuccessOf = (arr) => arr.slice(1).reduce((arr2, fa) => orElse2(() => fa)(arr2), arr[0]);
 var ProvideServiceProto = {
   ...PrimitiveProto,
-  [evaluate](fiber) {
+  [evaluate2](fiber) {
     const prevServices = fiber._services;
-    const [fa, tag, value] = this[args];
+    const [fa, tag, value] = this[args2];
     fiber._services = {
       ...fiber._services,
       [tag.key]: value
@@ -1095,54 +1508,54 @@ var ProvideServiceProto = {
     return match(fa, {
       onSuccess: (_) => {
         fiber._services = prevServices;
-        return succeed(_);
+        return succeed3(_);
       },
       onFailure: (_) => {
         fiber._services = prevServices;
-        return fail(_);
+        return fail3(_);
       }
     });
   }
 };
 var provideService = (tag, value) => (fa) => {
   const nano = Object.create(ProvideServiceProto);
-  nano[args] = [fa, tag, value];
+  nano[args2] = [fa, tag, value];
   return nano;
 };
 var ServiceProto = {
   ...PrimitiveProto,
-  [evaluate](fiber) {
-    const tag = this[args];
+  [evaluate2](fiber) {
+    const tag = this[args2];
     if (tag.key in fiber._services) {
       const value = fiber._services[tag.key];
-      const cont2 = fiber.getCont(contA);
-      return cont2 ? cont2[contA](value, fiber) : fiber.yieldWith(succeed(value));
+      const cont2 = fiber.getCont(contA2);
+      return cont2 ? cont2[contA2](value, fiber) : fiber.yieldWith(succeed3(value));
     }
-    const cont = fiber.getCont(contE);
-    return cont ? cont[contE](tag, fiber) : fiber.yieldWith(fail(new NanoDefectException(`Service ${tag.key} not found`, fiber._lastSpan)));
+    const cont = fiber.getCont(contE2);
+    return cont ? cont[contE2](tag, fiber) : fiber.yieldWith(fail3(new NanoDefectException(`Service ${tag.key} not found`, fiber._lastSpan)));
   }
 };
 var service = (tag) => {
   const nano = Object.create(ServiceProto);
-  nano[args] = tag;
+  nano[args2] = tag;
   return nano;
 };
 var CachedProto = {
   ...PrimitiveProto,
-  [evaluate](fiber) {
-    const [fa, type, key] = this[args];
+  [evaluate2](fiber) {
+    const [fa, type, key] = this[args2];
     const cache = fiber._cache[type] || /* @__PURE__ */ new WeakMap();
     fiber._cache[type] = cache;
-    const cached2 = cache.get(key);
-    if (cached2) return cached2;
+    const cached = cache.get(key);
+    if (cached) return cached;
     return match(fa, {
       onSuccess: (_) => {
-        cache.set(key, succeed(_));
-        return succeed(_);
+        cache.set(key, succeed3(_));
+        return succeed3(_);
       },
       onFailure: (_) => {
-        cache.set(key, fail(_));
-        return fail(_);
+        cache.set(key, fail3(_));
+        return fail3(_);
       }
     });
   }
@@ -1150,35 +1563,35 @@ var CachedProto = {
 function cachedBy(fa, type, lookupKey) {
   return (...p) => {
     const nano = Object.create(CachedProto);
-    nano[args] = [fa(...p), type, lookupKey(...p)];
+    nano[args2] = [fa(...p), type, lookupKey(...p)];
     return nano;
   };
 }
 var option = (fa) => {
   const nano = Object.create(MatchProto);
-  nano[args] = fa;
-  nano[contA] = (_) => succeed(some2(_));
-  nano[contE] = (_) => _ instanceof NanoDefectException ? fail(_) : succeed(none2());
+  nano[args2] = fa;
+  nano[contA2] = (_) => succeed3(some2(_));
+  nano[contE2] = (_) => _ instanceof NanoDefectException ? fail3(_) : succeed3(none2());
   return nano;
 };
 var orUndefined = (fa) => {
   const nano = Object.create(MatchProto);
-  nano[args] = fa;
-  nano[contA] = (_) => succeed(_);
-  nano[contE] = (_) => _ instanceof NanoDefectException ? fail(_) : succeed(void 0);
+  nano[args2] = fa;
+  nano[contA2] = (_) => succeed3(_);
+  nano[contE2] = (_) => _ instanceof NanoDefectException ? fail3(_) : succeed3(void 0);
   return nano;
 };
 var ignore = (fa) => {
   const nano = Object.create(MatchProto);
-  nano[args] = fa;
-  nano[contA] = (_) => void_;
-  nano[contE] = (_) => _ instanceof NanoDefectException ? fail(_) : void_;
+  nano[args2] = fa;
+  nano[contA2] = (_) => void_;
+  nano[contE2] = (_) => _ instanceof NanoDefectException ? fail3(_) : void_;
   return nano;
 };
 var all = fn("all")(
-  function* (...args2) {
+  function* (...args3) {
     const results = [];
-    for (const fa of args2) {
+    for (const fa of args3) {
       const result = yield* fa;
       results.push(result);
     }
@@ -1192,7 +1605,7 @@ function isValidSeverityLevel(value) {
   return value === "off" || value === "error" || value === "warning" || value === "message" || value === "suggestion";
 }
 function parseDiagnosticSeverity(config) {
-  if (!isRecord(config)) return {};
+  if (!isObject(config)) return {};
   return Object.fromEntries(
     pipe(
       Object.entries(config),
@@ -1255,7 +1668,7 @@ function parse(config) {
   return {
     refactors: isObject(config) && hasProperty(config, "refactors") && isBoolean(config.refactors) ? config.refactors : defaults.refactors,
     diagnostics: isObject(config) && hasProperty(config, "diagnostics") && isBoolean(config.diagnostics) ? config.diagnostics : defaults.diagnostics,
-    diagnosticSeverity: isObject(config) && hasProperty(config, "diagnosticSeverity") && isRecord(config.diagnosticSeverity) ? parseDiagnosticSeverity(config.diagnosticSeverity) : defaults.diagnosticSeverity,
+    diagnosticSeverity: isObject(config) && hasProperty(config, "diagnosticSeverity") && isObject(config.diagnosticSeverity) ? parseDiagnosticSeverity(config.diagnosticSeverity) : defaults.diagnosticSeverity,
     diagnosticsName: isObject(config) && hasProperty(config, "diagnosticsName") && isBoolean(config.diagnosticsName) ? config.diagnosticsName : defaults.diagnosticsName,
     missingDiagnosticNextLine: isObject(config) && hasProperty(config, "missingDiagnosticNextLine") && isString(config.missingDiagnosticNextLine) && isValidSeverityLevel(config.missingDiagnosticNextLine) ? config.missingDiagnosticNextLine : defaults.missingDiagnosticNextLine,
     includeSuggestionsInTsc: isObject(config) && hasProperty(config, "includeSuggestionsInTsc") && isBoolean(config.includeSuggestionsInTsc) ? config.includeSuggestionsInTsc : defaults.includeSuggestionsInTsc,
@@ -1270,7 +1683,7 @@ function parse(config) {
     allowedDuplicatedPackages: isObject(config) && hasProperty(config, "allowedDuplicatedPackages") && isArray(config.allowedDuplicatedPackages) && config.allowedDuplicatedPackages.every(isString) ? config.allowedDuplicatedPackages.map((_) => _.toLowerCase()) : defaults.allowedDuplicatedPackages,
     namespaceImportPackages: isObject(config) && hasProperty(config, "namespaceImportPackages") && isArray(config.namespaceImportPackages) && config.namespaceImportPackages.every(isString) ? config.namespaceImportPackages.map((_) => _.toLowerCase()) : defaults.namespaceImportPackages,
     barrelImportPackages: isObject(config) && hasProperty(config, "barrelImportPackages") && isArray(config.barrelImportPackages) && config.barrelImportPackages.every(isString) ? config.barrelImportPackages.map((_) => _.toLowerCase()) : defaults.barrelImportPackages,
-    importAliases: isObject(config) && hasProperty(config, "importAliases") && isRecord(config.importAliases) ? map2(config.importAliases, (value) => String(value)) : defaults.importAliases,
+    importAliases: isObject(config) && hasProperty(config, "importAliases") && isObject(config.importAliases) ? map2(config.importAliases, (value) => String(value)) : defaults.importAliases,
     topLevelNamedReexports: isObject(config) && hasProperty(config, "topLevelNamedReexports") && isString(config.topLevelNamedReexports) && ["ignore", "follow"].includes(config.topLevelNamedReexports.toLowerCase()) ? config.topLevelNamedReexports.toLowerCase() : defaults.topLevelNamedReexports,
     renames: isObject(config) && hasProperty(config, "renames") && isBoolean(config.renames) ? config.renames : defaults.renames,
     noExternal: isObject(config) && hasProperty(config, "noExternal") && isBoolean(config.noExternal) ? config.noExternal : defaults.noExternal,
@@ -1289,9 +1702,9 @@ var TypeScriptProgram = Tag("TypeScriptProgram");
 var ChangeTracker = Tag("ChangeTracker");
 function getPackageJsonInfoCache(program) {
   try {
-    if (hasProperty(program, "getModuleResolutionCache") && isFunction2(program.getModuleResolutionCache)) {
+    if (hasProperty(program, "getModuleResolutionCache") && isFunction(program.getModuleResolutionCache)) {
       const moduleResolutionCache = program.getModuleResolutionCache();
-      if (hasProperty(moduleResolutionCache, "getPackageJsonInfoCache") && isFunction2(moduleResolutionCache.getPackageJsonInfoCache)) {
+      if (hasProperty(moduleResolutionCache, "getPackageJsonInfoCache") && isFunction(moduleResolutionCache.getPackageJsonInfoCache)) {
         return moduleResolutionCache.getPackageJsonInfoCache();
       }
     }
@@ -1302,7 +1715,7 @@ function getPackageJsonInfoCache(program) {
 }
 function getDirectoryPath(ts, path) {
   try {
-    if (hasProperty(ts, "getDirectoryPath") && isFunction2(ts.getDirectoryPath)) {
+    if (hasProperty(ts, "getDirectoryPath") && isFunction(ts.getDirectoryPath)) {
       return ts.getDirectoryPath(path);
     }
     return path;
@@ -1311,7 +1724,7 @@ function getDirectoryPath(ts, path) {
   }
 }
 function makeGetModuleSpecifier(ts) {
-  if (!(hasProperty(ts, "moduleSpecifiers") && hasProperty(ts.moduleSpecifiers, "getModuleSpecifier") && isFunction2(ts.moduleSpecifiers.getModuleSpecifier))) return;
+  if (!(hasProperty(ts, "moduleSpecifiers") && hasProperty(ts.moduleSpecifiers, "getModuleSpecifier") && isFunction(ts.moduleSpecifiers.getModuleSpecifier))) return;
   const _internal = ts.moduleSpecifiers.getModuleSpecifier;
   return (compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host, options) => {
     return _internal(
@@ -1325,14 +1738,14 @@ function makeGetModuleSpecifier(ts) {
   };
 }
 function makeGetTemporaryModuleResolutionState(ts) {
-  if (hasProperty(ts, "getTemporaryModuleResolutionState") && isFunction2(ts.getTemporaryModuleResolutionState)) {
+  if (hasProperty(ts, "getTemporaryModuleResolutionState") && isFunction(ts.getTemporaryModuleResolutionState)) {
     const _internal = ts.getTemporaryModuleResolutionState;
     return (cache, program, compilerOptions) => _internal(cache, program, compilerOptions);
   }
   return void 0;
 }
 function makeGetPackageScopeForPath(ts) {
-  if (hasProperty(ts, "getPackageScopeForPath") && isFunction2(ts.getPackageScopeForPath)) {
+  if (hasProperty(ts, "getPackageScopeForPath") && isFunction(ts.getPackageScopeForPath)) {
     const _internal = ts.getPackageScopeForPath;
     return (path, state) => _internal(path, state);
   }
@@ -1590,7 +2003,7 @@ function makeTypeScriptUtils(ts) {
         }
       } else if (ts.isNamedImports(namedBindings)) {
         for (const importSpecifier of namedBindings.elements) {
-          const importProperty = fromNullable(importSpecifier.propertyName).pipe(
+          const importProperty = fromNullishOr(importSpecifier.propertyName).pipe(
             orElse(() => some2(importSpecifier.name))
           );
           if (test(importSpecifier.name, statement.moduleSpecifier, importProperty)) {
@@ -1920,14 +2333,44 @@ var getApplicableRefactors = fn("LSP.getApplicableRefactors")(function* (refacto
   }
   return effectRefactors;
 });
+function codeFixNameToFullyQualifiedName(name) {
+  return `@effect/language-service/codefixes/${name}`;
+}
+var codeFixesToApplicableRefactor = fn("LSP.codeFixesToApplicableRefactor")(function* (codeFixes, sourceFile, positionOrRange) {
+  const effectRefactors = [];
+  const range = typeof positionOrRange === "number" ? { pos: positionOrRange, end: positionOrRange } : positionOrRange;
+  const inRangeCodeFixes = codeFixes.filter((_) => _.start <= range.pos && _.end >= range.end);
+  for (const codeFix of inRangeCodeFixes) {
+    effectRefactors.push({
+      name: codeFixNameToFullyQualifiedName(codeFix.fixName),
+      description: "Quick Fix: " + codeFix.description,
+      actions: [{
+        name: codeFixNameToFullyQualifiedName(codeFix.fixName),
+        description: "Quick Fix: " + codeFix.description,
+        kind: "refactor.rewrite.codeFixEffect." + codeFix.fixName
+      }]
+    });
+  }
+  return effectRefactors;
+});
 var getEditsForRefactor = fn("LSP.getEditsForRefactor")(function* (refactors, sourceFile, positionOrRange, refactorName) {
   const refactor = refactors.find((refactor2) => refactorNameToFullyQualifiedName(refactor2.name) === refactorName);
   if (!refactor) {
-    return yield* fail(new RefactorNotApplicableError());
+    return yield* fail3(new RefactorNotApplicableError());
   }
   const textRange = typeof positionOrRange === "number" ? { pos: positionOrRange, end: positionOrRange } : positionOrRange;
   return yield* refactor.apply(sourceFile, textRange);
 });
+var getEditsForCodeFixes = fn("LSP.getEditsForCodeFixes")(function* (codeFixes, positionOrRange, refactorName) {
+  const textRange = typeof positionOrRange === "number" ? { pos: positionOrRange, end: positionOrRange } : positionOrRange;
+  const fixToRun = codeFixes.find(
+    (_) => codeFixNameToFullyQualifiedName(_.fixName) === refactorName && _.start <= textRange.pos && _.end >= textRange.end
+  );
+  if (!fixToRun) {
+    return yield* fail3(new RefactorNotApplicableError());
+  }
+  return fixToRun;
+});
 var getCompletionsAtPosition = fn("LSP.getCompletionsAtPosition")(function* (completions, sourceFile, position, options, formatCodeSettings) {
   let effectCompletions = [];
   for (const completion of completions) {
@@ -2011,7 +2454,7 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
       message: ts.DiagnosticCategory.Message,
       suggestion: ts.DiagnosticCategory.Suggestion
     };
-    const execute = (rule) => gen(function* () {
+    const execute = fn("LSP.execute")(function* (rule) {
       const diagnostics2 = [];
       const codeFixes = [];
       const ruleNameLowered = rule.name.toLowerCase();
@@ -2179,7 +2622,7 @@ var getEditsForCodegen = fn("LSP.getEditsForCodegen")(function* (codegens2, sour
     (codegen2) => codegen2.range.pos <= textRange.pos && codegen2.range.end >= textRange.end
   );
   if (inRangeCodegens.length !== 1) {
-    return yield* fail(new CodegenNotApplicableError("zero or multiple codegens in range"));
+    return yield* fail3(new CodegenNotApplicableError("zero or multiple codegens in range"));
   }
   const { codegen, range } = inRangeCodegens[0];
   const edit = yield* codegen.apply(sourceFile, range);
@@ -2378,8 +2821,8 @@ function makeTypeCheckerUtils(ts, typeChecker, tsUtils) {
   };
   const expectedAndRealTypeCache = /* @__PURE__ */ new WeakMap();
   const expectedAndRealType = (sourceFile) => {
-    const cached2 = expectedAndRealTypeCache.get(sourceFile);
-    if (cached2) return cached2;
+    const cached = expectedAndRealTypeCache.get(sourceFile);
+    if (cached) return cached;
     const result = [];
     const nodeToVisit = [sourceFile];
     const appendNodeToVisit = (node) => {
@@ -2596,7 +3039,7 @@ var nanoLayer3 = (fa) => gen(function* () {
 });
 var TypeParserIssue = class _TypeParserIssue {
   _tag = "@effect/language-service/TypeParserIssue";
-  static issue = fail(new _TypeParserIssue());
+  static issue = fail3(new _TypeParserIssue());
 };
 function typeParserIssue(_message, _type, _node) {
   return TypeParserIssue.issue;
@@ -2792,21 +3235,30 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     if (signatures.length !== 1) {
       return typeParserIssue("Covariant type has no call signature", type);
     }
-    return succeed(typeChecker.getReturnTypeOfSignature(signatures[0]));
+    if (signatures[0].typeParameters && signatures[0].typeParameters.length > 0) {
+      return typeParserIssue("Invariant type should not have type parameters", type);
+    }
+    return succeed3(typeChecker.getReturnTypeOfSignature(signatures[0]));
   }
   function contravariantTypeArgument(type) {
     const signatures = typeChecker.getSignaturesOfType(type, ts.SignatureKind.Call);
     if (signatures.length !== 1) {
       return typeParserIssue("Contravariant type has no call signature", type);
     }
-    return succeed(typeCheckerUtils.getTypeParameterAtPosition(signatures[0], 0));
+    if (signatures[0].typeParameters && signatures[0].typeParameters.length > 0) {
+      return typeParserIssue("Invariant type should not have type parameters", type);
+    }
+    return succeed3(typeCheckerUtils.getTypeParameterAtPosition(signatures[0], 0));
   }
   function invariantTypeArgument(type) {
     const signatures = typeChecker.getSignaturesOfType(type, ts.SignatureKind.Call);
     if (signatures.length !== 1) {
       return typeParserIssue("Invariant type has no call signature", type);
     }
-    return succeed(typeChecker.getReturnTypeOfSignature(signatures[0]));
+    if (signatures[0].typeParameters && signatures[0].typeParameters.length > 0) {
+      return typeParserIssue("Invariant type should not have type parameters", type);
+    }
+    return succeed3(typeChecker.getReturnTypeOfSignature(signatures[0]));
   }
   const pipeableType = cachedBy(
     function(type, atLocation) {
@@ -2819,7 +3271,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
       if (signatures.length === 0) {
         return typeParserIssue("'pipe' property is not callable", type, atLocation);
       }
-      return succeed(type);
+      return succeed3(type);
     },
     "TypeParser.pipeableType",
     (type) => type
@@ -3283,7 +3735,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
           const type = typeCheckerUtils.getTypeAtLocation(yieldedExpression);
           if (!type) continue;
           const { A: successType } = yield* effectType(type, yieldedExpression);
-          let replacementNode = succeed(yieldedExpression);
+          let replacementNode = succeed3(yieldedExpression);
           if (!explicitReturn && !(successType.flags & ts.TypeFlags.VoidLike)) {
             replacementNode = pipe(
               gen(function* () {
@@ -3494,15 +3946,15 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
               if (node.arguments.length === 0) {
                 return typeParserIssue("Node is not a pipe call", void 0, node);
               }
-              const [subject, ...args2] = node.arguments;
-              return succeed({
+              const [subject, ...args3] = node.arguments;
+              return succeed3({
                 node,
                 subject,
-                args: args2,
+                args: args3,
                 kind: "pipe"
               });
             }
-            return succeed({
+            return succeed3({
               node,
               subject: baseExpression,
               args: Array.from(node.arguments),
@@ -3512,8 +3964,8 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
         );
       }
       if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && ts.idText(node.expression) === "pipe" && node.arguments.length > 0) {
-        const [subject, ...args2] = node.arguments;
-        return succeed({ node, subject, args: args2, kind: "pipe" });
+        const [subject, ...args3] = node.arguments;
+        return succeed3({ node, subject, args: args3, kind: "pipe" });
       }
       return typeParserIssue("Node is not a pipe call", void 0, node);
     },
@@ -3528,7 +3980,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
       if (node.arguments.length !== 1) {
         return typeParserIssue("Node must have exactly one argument", void 0, node);
       }
-      return succeed({
+      return succeed3({
         node,
         callee: node.expression,
         subject: node.arguments[0]
@@ -3590,7 +4042,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
           if (!callbackParameterType) {
             continue;
           }
-          return succeed({
+          return succeed3({
             type: callbackParameterType
           });
         }
@@ -4002,9 +4454,9 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
                     let accessors2 = void 0;
                     let dependencies = void 0;
                     if (wholeCall.arguments.length >= 2) {
-                      const args2 = wholeCall.arguments[1];
-                      if (ts.isObjectLiteralExpression(args2)) {
-                        for (const property of args2.properties) {
+                      const args3 = wholeCall.arguments[1];
+                      if (ts.isObjectLiteralExpression(args3)) {
+                        for (const property of args3.properties) {
                           if (ts.isPropertyAssignment(property) && property.name && ts.isIdentifier(property.name) && ts.idText(property.name) === "accessors" && property.initializer && property.initializer.kind === ts.SyntaxKind.TrueKeyword) {
                             accessors2 = true;
                           }
@@ -4209,7 +4661,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
       const body = node.body;
       const returnType = node.type;
       if (ts.isArrowFunction(node) && !ts.isBlock(body)) {
-        return succeed({
+        return succeed3({
           node,
           body,
           expression: body,
@@ -4227,7 +4679,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
         if (!stmt.expression) {
           return typeParserIssue("Return statement must have an expression", void 0, node);
         }
-        return succeed({
+        return succeed3({
           node,
           body,
           expression: stmt.expression,
@@ -4252,7 +4704,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
       if (body.statements.length !== 0) {
         return typeParserIssue("Block must have zero statements", void 0, node);
       }
-      return succeed({
+      return succeed3({
         node,
         body,
         returnType
@@ -4693,32 +5145,38 @@ var catchAllToMapError = createDiagnostic({
       return void 0;
     };
     const getEffectFailCallInfo = (body) => {
-      return gen(function* () {
-        if (ts.isCallExpression(body)) {
-          const isFailCall = yield* pipe(
-            typeParser.isNodeReferenceToEffectModuleApi("fail")(body.expression),
-            orUndefined
-          );
-          if (isFailCall && body.arguments.length >= 1) {
-            return { failCall: body, failArg: body.arguments[0] };
-          }
-        }
-        if (ts.isBlock(body)) {
-          const statements = body.statements;
-          if (statements.length === 1) {
-            const stmt = statements[0];
-            if (ts.isReturnStatement(stmt) && stmt.expression && ts.isCallExpression(stmt.expression)) {
-              const isFailCall = yield* pipe(
-                typeParser.isNodeReferenceToEffectModuleApi("fail")(stmt.expression.expression),
-                orUndefined
-              );
-              if (isFailCall && stmt.expression.arguments.length >= 1) {
-                return { failCall: stmt.expression, failArg: stmt.expression.arguments[0] };
-              }
+      if (ts.isCallExpression(body)) {
+        return pipe(
+          typeParser.isNodeReferenceToEffectModuleApi("fail")(body.expression),
+          orUndefined,
+          map4((isFailCall) => {
+            if (isFailCall && body.arguments.length >= 1) {
+              return { failCall: body, failArg: body.arguments[0] };
             }
+            return void 0;
+          })
+        );
+      }
+      if (ts.isBlock(body)) {
+        const statements = body.statements;
+        if (statements.length === 1) {
+          const stmt = statements[0];
+          if (ts.isReturnStatement(stmt) && stmt.expression && ts.isCallExpression(stmt.expression)) {
+            const callExpr = stmt.expression;
+            return pipe(
+              typeParser.isNodeReferenceToEffectModuleApi("fail")(callExpr.expression),
+              orUndefined,
+              map4((isFailCall) => {
+                if (isFailCall && callExpr.arguments.length >= 1) {
+                  return { failCall: callExpr, failArg: callExpr.arguments[0] };
+                }
+                return void 0;
+              })
+            );
           }
         }
-      });
+      }
+      return void_;
     };
     const flows = yield* typeParser.pipingFlows(true)(sourceFile);
     for (const flow2 of flows) {
@@ -4943,10 +5401,10 @@ var getOrMakeKeyBuilder = fn("getOrMakeKeyBuilder")(function* (sourceFile) {
   keyBuilderCache.set(sourceFile.fileName, keyBuilder);
   return keyBuilder;
 });
-function createString(sourceFile, identifier, kind) {
+function createString(sourceFile, identifier2, kind) {
   return map4(
     getOrMakeKeyBuilder(sourceFile),
-    (identifierBuilder) => identifierBuilder.createString(identifier, kind)
+    (identifierBuilder) => identifierBuilder.createString(identifier2, kind)
   );
 }
 
@@ -4963,20 +5421,21 @@ var deterministicKeys = createDiagnostic({
     const typeScriptUtils = yield* service(TypeScriptUtils);
     const options = yield* service(LanguageServicePluginOptions);
     const parseExtendsCustom = cachedBy(
-      fn("parseExtendsCustom")(function* (classDeclaration) {
+      (classDeclaration) => {
         if (!options.extendedKeyDetection) {
-          return yield* typeParserIssue("Extended key detection is disabled", void 0, classDeclaration);
+          return TypeParserIssue.issue;
         }
         if (!classDeclaration.name) {
-          return yield* typeParserIssue("Class has no name", void 0, classDeclaration);
+          return TypeParserIssue.issue;
         }
         if (!ts.isIdentifier(classDeclaration.name)) {
-          return yield* typeParserIssue("Class name is not an identifier", void 0, classDeclaration);
+          return TypeParserIssue.issue;
         }
         const heritageClauses = classDeclaration.heritageClauses;
         if (!heritageClauses) {
-          return yield* typeParserIssue("Class has no heritage clauses", void 0, classDeclaration);
+          return TypeParserIssue.issue;
         }
+        const className = classDeclaration.name;
         const nodeToVisit2 = [...classDeclaration.heritageClauses];
         const appendNodeToVisit2 = (node) => {
           nodeToVisit2.push(node);
@@ -4997,7 +5456,7 @@ var deterministicKeys = createDiagnostic({
                     const parameterSourceFile = typeScriptUtils.getSourceFileOfNode(declaration);
                     const paramText = parameterSourceFile.text.substring(declaration.pos, declaration.end);
                     if (paramText.toLowerCase().includes("@effect-identifier")) {
-                      return { className: classDeclaration.name, keyStringLiteral: arg, target: "custom" };
+                      return succeed3({ className, keyStringLiteral: arg, target: "custom" });
                     }
                   }
                 }
@@ -5006,12 +5465,8 @@ var deterministicKeys = createDiagnostic({
           }
           ts.forEachChild(node, appendNodeToVisit2);
         }
-        return yield* typeParserIssue(
-          "Class does not extend any custom pattern",
-          void 0,
-          classDeclaration
-        );
-      }),
+        return TypeParserIssue.issue;
+      },
       "deterministicKeys.parseExtendsCustom",
       (classDeclaration) => classDeclaration
     );
@@ -5290,25 +5745,27 @@ var effectFnOpportunity = createDiagnostic({
       }
       return false;
     };
-    const tryExtractWithSpanExpression = (expr) => gen(function* () {
+    const tryExtractWithSpanExpression = fn("effectFnOpportunity.tryExtractWithSpanExpression")(function* (expr) {
       if (!ts.isCallExpression(expr)) return void 0;
       const callee = expr.expression;
       const isWithSpan = yield* pipe(
         typeParser.isNodeReferenceToEffectModuleApi("withSpan")(callee),
         map4(() => true),
-        orElse2(() => succeed(false))
+        orElse2(() => succeed3(false))
       );
       if (!isWithSpan) return void 0;
       if (expr.arguments.length === 0) return void 0;
       return expr.arguments[0];
     });
-    const tryParseGenOpportunity = (fnNode) => gen(function* () {
+    const tryParseGenOpportunity = fn(
+      "effectFnOpportunity.tryParseGenOpportunity"
+    )(function* (fnNode) {
       const bodyExpression = getBodyExpression(fnNode);
       if (!bodyExpression) return yield* TypeParserIssue.issue;
       const { pipeArguments: pipeArguments2, subject } = yield* pipe(
         typeParser.pipeCall(bodyExpression),
-        map4(({ args: args2, subject: subject2 }) => ({ subject: subject2, pipeArguments: args2 })),
-        orElse2(() => succeed({ subject: bodyExpression, pipeArguments: [] }))
+        map4(({ args: args3, subject: subject2 }) => ({ subject: subject2, pipeArguments: args3 })),
+        orElse2(() => succeed3({ subject: bodyExpression, pipeArguments: [] }))
       );
       const { effectModule, generatorFunction } = yield* typeParser.effectGen(subject);
       const effectModuleName = ts.isIdentifier(effectModule) ? ts.idText(effectModule) : sourceEffectModuleName;
@@ -5325,75 +5782,80 @@ var effectFnOpportunity = createDiagnostic({
     const isInsideEffectFn = (fnNode) => {
       const parent = fnNode.parent;
       if (!parent || !ts.isCallExpression(parent)) {
-        return succeed(false);
+        return succeed3(false);
       }
       if (parent.arguments[0] !== fnNode) {
-        return succeed(false);
+        return succeed3(false);
       }
       return pipe(
         typeParser.effectFn(parent),
         orElse2(() => typeParser.effectFnGen(parent)),
         orElse2(() => typeParser.effectFnUntracedGen(parent)),
         map4(() => true),
-        orElse2(() => succeed(false))
+        orElse2(() => succeed3(false))
       );
     };
-    const parseEffectFnOpportunityTarget = (node) => gen(function* () {
+    const parseEffectFnOpportunityTargetGen = fn("effectFnOpportunity.parseEffectFnOpportunityTarget")(
+      function* (node, returnType, traceName, nameIdentifier) {
+        if (yield* isInsideEffectFn(node)) {
+          return yield* TypeParserIssue.issue;
+        }
+        const unionMembers = typeCheckerUtils.unrollUnionMembers(returnType);
+        yield* all(...unionMembers.map((member) => typeParser.strictEffectType(member, node)));
+        const opportunity = yield* pipe(
+          tryParseGenOpportunity(node),
+          orElse2(() => {
+            if (ts.isArrowFunction(node) && !ts.isBlock(node.body)) {
+              return TypeParserIssue.issue;
+            }
+            const body = ts.isArrowFunction(node) ? node.body : node.body;
+            if (!body || !ts.isBlock(body) || body.statements.length <= 5) {
+              return TypeParserIssue.issue;
+            }
+            return succeed3({
+              effectModuleName: sourceEffectModuleName,
+              pipeArguments: [],
+              generatorFunction: void 0,
+              explicitTraceExpression: void 0
+            });
+          })
+        );
+        return {
+          node,
+          nameIdentifier,
+          effectModuleName: opportunity.effectModuleName,
+          inferredTraceName: traceName,
+          explicitTraceExpression: opportunity.explicitTraceExpression,
+          pipeArguments: opportunity.pipeArguments,
+          generatorFunction: opportunity.generatorFunction,
+          hasParamsInPipeArgs: areParametersReferencedIn(node, opportunity.pipeArguments)
+        };
+      }
+    );
+    const parseEffectFnOpportunityTarget = (node) => {
       if (!ts.isFunctionExpression(node) && !ts.isArrowFunction(node) && !ts.isFunctionDeclaration(node)) {
-        return yield* TypeParserIssue.issue;
+        return TypeParserIssue.issue;
       }
       if ((ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node)) && node.asteriskToken) {
-        return yield* TypeParserIssue.issue;
+        return TypeParserIssue.issue;
       }
       if (ts.isFunctionExpression(node) && node.name) {
-        return yield* TypeParserIssue.issue;
+        return TypeParserIssue.issue;
       }
       if (node.type) {
-        return yield* TypeParserIssue.issue;
-      }
-      if (yield* isInsideEffectFn(node)) {
-        return yield* TypeParserIssue.issue;
+        return TypeParserIssue.issue;
       }
       const functionType = typeChecker.getTypeAtLocation(node);
-      if (!functionType) return yield* TypeParserIssue.issue;
+      if (!functionType) return TypeParserIssue.issue;
       const callSignatures = typeChecker.getSignaturesOfType(functionType, ts.SignatureKind.Call);
-      if (callSignatures.length !== 1) return yield* TypeParserIssue.issue;
+      if (callSignatures.length !== 1) return TypeParserIssue.issue;
       const signature = callSignatures[0];
       const returnType = typeChecker.getReturnTypeOfSignature(signature);
-      const unionMembers = typeCheckerUtils.unrollUnionMembers(returnType);
-      yield* all(...unionMembers.map((member) => typeParser.strictEffectType(member, node)));
       const nameIdentifier = getNameIdentifier(node);
       const traceName = nameIdentifier ? ts.isIdentifier(nameIdentifier) ? ts.idText(nameIdentifier) : nameIdentifier.text : void 0;
-      if (!traceName) return yield* TypeParserIssue.issue;
-      const opportunity = yield* pipe(
-        tryParseGenOpportunity(node),
-        orElse2(() => {
-          if (ts.isArrowFunction(node) && !ts.isBlock(node.body)) {
-            return TypeParserIssue.issue;
-          }
-          const body = ts.isArrowFunction(node) ? node.body : node.body;
-          if (!body || !ts.isBlock(body) || body.statements.length <= 5) {
-            return TypeParserIssue.issue;
-          }
-          return succeed({
-            effectModuleName: sourceEffectModuleName,
-            pipeArguments: [],
-            generatorFunction: void 0,
-            explicitTraceExpression: void 0
-          });
-        })
-      );
-      return {
-        node,
-        nameIdentifier,
-        effectModuleName: opportunity.effectModuleName,
-        inferredTraceName: traceName,
-        explicitTraceExpression: opportunity.explicitTraceExpression,
-        pipeArguments: opportunity.pipeArguments,
-        generatorFunction: opportunity.generatorFunction,
-        hasParamsInPipeArgs: areParametersReferencedIn(node, opportunity.pipeArguments)
-      };
-    });
+      if (!traceName) return TypeParserIssue.issue;
+      return parseEffectFnOpportunityTargetGen(node, returnType, traceName, nameIdentifier);
+    };
     const getFunctionBodyBlock = (node) => {
       if (ts.isArrowFunction(node)) {
         if (ts.isBlock(node.body)) {
@@ -5549,7 +6011,7 @@ var effectFnOpportunity = createDiagnostic({
         }).join(", ");
         const fnSignature = `function*${typeParamNames}(${paramNames}) { ... }`;
         const pipeArgsForWithSpan = pipeArguments2.slice(0, -1);
-        const pipeArgsSuffix = (args2) => args2.length > 0 ? ", ...pipeTransformations" : "";
+        const pipeArgsSuffix = (args3) => args3.length > 0 ? ", ...pipeTransformations" : "";
         switch (firstFix.fixName) {
           case "effectFnOpportunity_toEffectFnWithSpan": {
             const traceName = explicitTraceExpression ? sourceFile.text.slice(explicitTraceExpression.pos, explicitTraceExpression.end).trim() : void 0;
@@ -5634,7 +6096,7 @@ var effectInVoidSuccess = createDiagnostic({
         );
         return { voidedEffect };
       }
-      return yield* fail(typeParserIssue("expectedEffect success is not void"));
+      return yield* TypeParserIssue.issue;
     });
     const entries = typeCheckerUtils.expectedAndRealType(sourceFile);
     for (const [node, expectedType, valueNode, realType] of entries) {
@@ -5695,7 +6157,7 @@ var effectMapVoid = createDiagnostic({
               () => pipe(
                 typeParser.lazyExpression(callback),
                 flatMap2(
-                  (lazy) => tsUtils.isVoidExpression(lazy.expression) ? succeed(lazy) : typeParserIssue("Expression is not void")
+                  (lazy) => tsUtils.isVoidExpression(lazy.expression) ? succeed3(lazy) : typeParserIssue("Expression is not void")
                 )
               )
             ),
@@ -6356,11 +6818,11 @@ var leakingRequirements = createDiagnostic({
                 memory,
                 effectContextType,
                 (type) => {
-                  if (type.flags & ts.TypeFlags.Never) return succeed(true);
+                  if (type.flags & ts.TypeFlags.Never) return succeed3(true);
                   return pipe(
                     typeParser.scopeType(type, atLocation),
                     map4(() => true),
-                    orElse2(() => succeed(false))
+                    orElse2(() => succeed3(false))
                   );
                 }
               );
@@ -6775,7 +7237,7 @@ var missingEffectError = createDiagnostic({
                 map3((_) => _.literal),
                 filter((_) => ts.isLiteralExpression(_)),
                 map3((_) => _.text),
-                sort(string2),
+                sort(String2),
                 map3(
                   (_) => ts.factory.createPropertyAssignment(
                     ts.factory.createIdentifier(_),
@@ -6868,7 +7330,7 @@ var missingEffectServiceDependency = createDiagnostic({
               );
               if (layerResult) {
                 const servicesMemory = /* @__PURE__ */ new Map();
-                const excludeNever = (type) => succeed((type.flags & ts.TypeFlags.Never) !== 0);
+                const excludeNever = (type) => succeed3((type.flags & ts.TypeFlags.Never) !== 0);
                 const { allIndexes: requiredIndexes } = yield* typeCheckerUtils.appendToUniqueTypesMap(
                   servicesMemory,
                   layerResult.RIn,
@@ -7384,13 +7846,13 @@ var generate = fn("writeTagClassAccessors.generate")(function* (sourceFile, serv
         atLocation2,
         ts.NodeBuilderFlags.NoTruncation
       );
-      if (!successType) return fail("error generating success type");
+      if (!successType) return fail3("error generating success type");
       const failureType = typeChecker.typeToTypeNode(
         returnedEffect.E,
         atLocation2,
         ts.NodeBuilderFlags.NoTruncation
       );
-      if (!failureType) return fail("error generating failure type");
+      if (!failureType) return fail3("error generating failure type");
       const typeNode = ts.factory.createTypeReferenceNode(
         ts.factory.createQualifiedName(
           ts.factory.createIdentifier(effectIdentifier),
@@ -7398,7 +7860,7 @@ var generate = fn("writeTagClassAccessors.generate")(function* (sourceFile, serv
         ),
         [successType, failureType, contextType]
       );
-      return succeed(typeNode);
+      return succeed3(typeNode);
     }),
     orElse2(
       () => pipe(
@@ -7409,8 +7871,8 @@ var generate = fn("writeTagClassAccessors.generate")(function* (sourceFile, serv
             atLocation2,
             ts.NodeBuilderFlags.NoTruncation
           );
-          if (!successType) return fail("error generating success type");
-          return succeed(ts.factory.createTypeReferenceNode(
+          if (!successType) return fail3("error generating success type");
+          return succeed3(ts.factory.createTypeReferenceNode(
             ts.factory.createQualifiedName(
               ts.factory.createIdentifier(effectIdentifier),
               ts.factory.createIdentifier("Effect")
@@ -7431,7 +7893,7 @@ var generate = fn("writeTagClassAccessors.generate")(function* (sourceFile, serv
     ),
     orElse2(() => {
       const successType = typeChecker.typeToTypeNode(type, atLocation2, ts.NodeBuilderFlags.NoTruncation);
-      if (!successType) return fail("error generating success type");
+      if (!successType) return fail3("error generating success type");
       const typeNode = ts.factory.createTypeReferenceNode(
         ts.factory.createQualifiedName(
           ts.factory.createIdentifier(effectIdentifier),
@@ -7443,28 +7905,30 @@ var generate = fn("writeTagClassAccessors.generate")(function* (sourceFile, serv
           ts.factory.createTypeReferenceNode(ts.idText(className2))
         ]
       );
-      return succeed(typeNode);
+      return succeed3(typeNode);
     })
   );
-  const proxySignature = (signature, atLocation2, className2) => gen(function* () {
-    const signatureDeclaration = typeChecker.signatureToSignatureDeclaration(
-      signature,
-      ts.SyntaxKind.FunctionType,
-      atLocation2,
-      ts.NodeBuilderFlags.NoTruncation
-    );
-    if (!signatureDeclaration) return yield* fail("error generating signature");
-    const returnType = yield* generateReturnType(
-      typeChecker.getReturnTypeOfSignature(signature),
-      atLocation2,
-      className2
-    );
-    return ts.factory.createFunctionTypeNode(
-      signatureDeclaration.typeParameters,
-      signatureDeclaration.parameters,
-      returnType
-    );
-  });
+  const proxySignature = fn("writeTagClassAccessors.proxySignature")(
+    function* (signature, atLocation2, className2) {
+      const signatureDeclaration = typeChecker.signatureToSignatureDeclaration(
+        signature,
+        ts.SyntaxKind.FunctionType,
+        atLocation2,
+        ts.NodeBuilderFlags.NoTruncation
+      );
+      if (!signatureDeclaration) return yield* fail3("error generating signature");
+      const returnType = yield* generateReturnType(
+        typeChecker.getReturnTypeOfSignature(signature),
+        atLocation2,
+        className2
+      );
+      return ts.factory.createFunctionTypeNode(
+        signatureDeclaration.typeParameters,
+        signatureDeclaration.parameters,
+        returnType
+      );
+    }
+  );
   for (const { property, propertyType } of involvedMembers) {
     const callSignatures = [];
     let propertyDeclaration = void 0;
@@ -7501,21 +7965,21 @@ var parse2 = fn("writeTagClassAccessors.parse")(function* (node) {
   const typeChecker = yield* service(TypeCheckerApi);
   const typeParser = yield* service(TypeParser);
   const typeCheckerUtils = yield* service(TypeCheckerUtils);
-  if (typeParser.supportedEffect() === "v4") return yield* fail("not applicable to Effect v4");
-  if (!ts.isClassDeclaration(node)) return yield* fail("not a class declaration");
+  if (typeParser.supportedEffect() === "v4") return yield* fail3("not applicable to Effect v4");
+  if (!ts.isClassDeclaration(node)) return yield* fail3("not a class declaration");
   const { Service, accessors: accessors2, className, kind } = yield* pipe(
     map4(typeParser.extendsEffectService(node), (_) => ({ kind: "effectService", ..._ })),
     orElse2(
       () => map4(typeParser.extendsEffectTag(node), (_) => ({ kind: "effectTag", accessors: true, ..._ }))
     ),
-    orElse2(() => fail("not a class extending Effect.Service call"))
+    orElse2(() => fail3("not a class extending Effect.Service call"))
   );
-  if (accessors2 !== true) return yield* fail("accessors are not enabled in the Effect.Service call");
+  if (accessors2 !== true) return yield* fail3("accessors are not enabled in the Effect.Service call");
   const involvedMembers = [];
   const nonPrimitiveServices = typeCheckerUtils.unrollUnionMembers(Service).filter(
     (_) => !(_.flags & ts.TypeFlags.Number || _.flags & ts.TypeFlags.String || _.flags & ts.TypeFlags.Boolean || _.flags & ts.TypeFlags.Literal)
   );
-  if (nonPrimitiveServices.length === 0) return yield* fail("Service type is a primitive type");
+  if (nonPrimitiveServices.length === 0) return yield* fail3("Service type is a primitive type");
   for (const serviceShape of nonPrimitiveServices) {
     for (const property of typeChecker.getPropertiesOfType(serviceShape)) {
       const propertyType = typeChecker.getTypeOfSymbolAtLocation(property, node);
@@ -7556,7 +8020,7 @@ var writeTagClassAccessors = createRefactor({
     const parentNodes = tsUtils.getAncestorNodesInRange(sourceFile, textRange);
     return yield* pipe(
       firstSuccessOf(parentNodes.map(parseNode)),
-      orElse2(() => fail(new RefactorNotApplicableError()))
+      orElse2(() => fail3(new RefactorNotApplicableError()))
     );
   })
 });
@@ -7571,7 +8035,7 @@ var accessors = createCodegen({
     const typeParser = yield* service(TypeParser);
     const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const nodeAndCommentRange = tsUtils.findNodeWithLeadingCommentAtPosition(sourceFile, textRange.pos);
-    if (!nodeAndCommentRange) return yield* fail(new CodegenNotApplicableError("no node and comment range"));
+    if (!nodeAndCommentRange) return yield* fail3(new CodegenNotApplicableError("no node and comment range"));
     return yield* pipe(
       parse2(nodeAndCommentRange.node),
       map4(
@@ -7588,7 +8052,7 @@ var accessors = createCodegen({
           )
         })
       ),
-      orElse2((cause) => fail(new CodegenNotApplicableError(cause)))
+      orElse2((cause) => fail3(new CodegenNotApplicableError(cause)))
     );
   })
 });
@@ -7601,7 +8065,7 @@ var annotate = createCodegen({
     const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeCheckerUtils = yield* service(TypeCheckerUtils);
-    const parse3 = (node) => gen(function* () {
+    const parse3 = fn("annotate.parse")(function* (node) {
       let variableDeclarations = [];
       const result = [];
       if (ts.isVariableStatement(node)) {
@@ -7612,14 +8076,14 @@ var annotate = createCodegen({
         variableDeclarations = [...variableDeclarations, node];
       }
       if (variableDeclarations.length === 0) {
-        return yield* fail(new CodegenNotApplicableError("not a variable declaration"));
+        return yield* fail3(new CodegenNotApplicableError("not a variable declaration"));
       }
       for (const variableDeclaration of variableDeclarations) {
         if (!variableDeclaration.initializer) continue;
         const initializerType = typeCheckerUtils.getTypeAtLocation(variableDeclaration.initializer);
         if (!initializerType) continue;
         const enclosingNode = ts.findAncestor(variableDeclaration, (_) => tsUtils.isDeclarationKind(_.kind)) || sourceFile;
-        const initializerTypeNode = fromNullable(typeCheckerUtils.typeToSimplifiedTypeNode(
+        const initializerTypeNode = fromNullishOr(typeCheckerUtils.typeToSimplifiedTypeNode(
           initializerType,
           enclosingNode,
           ts.NodeBuilderFlags.NoTruncation | ts.NodeBuilderFlags.IgnoreErrors
@@ -7632,7 +8096,7 @@ var annotate = createCodegen({
         result.push({ variableDeclaration, initializerTypeNode, hash: hash3 });
       }
       if (result.length === 0) {
-        return yield* fail(new CodegenNotApplicableError("no variable declarations with initializers"));
+        return yield* fail3(new CodegenNotApplicableError("no variable declarations with initializers"));
       }
       const hash2 = cyrb53(result.map((_) => _.hash).join("/"));
       return {
@@ -7641,7 +8105,7 @@ var annotate = createCodegen({
       };
     });
     const nodeAndCommentRange = tsUtils.findNodeWithLeadingCommentAtPosition(sourceFile, textRange.pos);
-    if (!nodeAndCommentRange) return yield* fail(new CodegenNotApplicableError("no node and comment range"));
+    if (!nodeAndCommentRange) return yield* fail3(new CodegenNotApplicableError("no node and comment range"));
     return yield* pipe(
       parse3(nodeAndCommentRange.node),
       map4(
@@ -7702,13 +8166,13 @@ var makeStructuralSchemaGenContext = fn("StructuralSchemaGen.makeContext")(
         ts.factory.createIdentifier(effectSchemaIdentifier),
         apiName
       ),
-      createApiCall: (apiName, args2) => ts.factory.createCallExpression(
+      createApiCall: (apiName, args3) => ts.factory.createCallExpression(
         ts.factory.createPropertyAccessExpression(
           ts.factory.createIdentifier(effectSchemaIdentifier),
           apiName
         ),
         [],
-        args2
+        args3
       ),
       hoistedSchemas: /* @__PURE__ */ new Map(),
       typeToStatementIndex: /* @__PURE__ */ new Map(),
@@ -7758,7 +8222,7 @@ var processType = fn(
       StructuralSchemaGenContext
     );
     if (processingContext.depth >= processingContext.maxDepth) {
-      return yield* fail(new UnsupportedTypeError(type, "Maximum depth exceeded"));
+      return yield* fail3(new UnsupportedTypeError(type, "Maximum depth exceeded"));
     }
     let hoistName = fromIterable(nameToType.entries()).find(([_, existingType]) => existingType === type)?.[0];
     if (!hoistName && type && type.symbol && type.symbol.declarations && type.symbol.declarations.length === 1) {
@@ -7872,7 +8336,7 @@ var processTypeImpl = fn(
       const objectType = type;
       return yield* processObjectType(objectType, context);
     }
-    return yield* fail(
+    return yield* fail3(
       new UnsupportedTypeError(
         type,
         `Type with flags ${type.flags} is not supported`
@@ -7952,7 +8416,7 @@ var processArrayType = fn(
     const { createApiCall, typeChecker, typeCheckerUtils } = yield* service(StructuralSchemaGenContext);
     const typeArgs = typeChecker.getTypeArguments(type);
     if (typeArgs.length === 0) {
-      return yield* fail(new UnsupportedTypeError(type, "Array type has no type arguments"));
+      return yield* fail3(new UnsupportedTypeError(type, "Array type has no type arguments"));
     }
     const elementSchema = yield* processType(typeArgs[0], context);
     const expr = createApiCall("Array", [elementSchema]);
@@ -8028,7 +8492,7 @@ var processObjectType = fn(
       );
     }
     const indexInfos = typeChecker.getIndexInfosOfType(type);
-    const args2 = [
+    const args3 = [
       ts.factory.createObjectLiteralExpression(propertyAssignments, propertyAssignments.length > 0)
     ];
     const records = [];
@@ -8043,7 +8507,7 @@ var processObjectType = fn(
       if (records.length > 0) {
         return [
           createApiCall("StructWithRest", [
-            createApiCall("Struct", args2),
+            createApiCall("Struct", args3),
             ts.factory.createArrayLiteralExpression(
               records.map(({ key, value }) => createApiCall("Record", [key, value]))
             )
@@ -8075,7 +8539,7 @@ var processObjectType = fn(
                     [ts.factory.createStringLiteral(context.hoistName)]
                   ),
                   [],
-                  args2
+                  args3
                 ),
                 []
               )
@@ -8088,14 +8552,14 @@ var processObjectType = fn(
       return [ctx.hoistedSchemas.get(type)(), true];
     }
     for (const { key, value } of records) {
-      args2.push(
+      args3.push(
         ts.factory.createObjectLiteralExpression([
           ts.factory.createPropertyAssignment("key", key),
           ts.factory.createPropertyAssignment("value", value)
         ])
       );
     }
-    return [createApiCall("Struct", args2), propertyAssignments.length === 0];
+    return [createApiCall("Struct", args3), propertyAssignments.length === 0];
   }
 );
 var findNodeToProcess = fn("StructuralSchemaGen.findNodeToProcess")(
@@ -8182,7 +8646,7 @@ var process = fn("StructuralSchemaGen.process")(
           ([name, type]) => pipe(
             processType(type, createProcessingContext(typeParser.supportedEffect())),
             orElse2(
-              (error) => succeed(ts.addSyntheticLeadingComment(
+              (error) => succeed3(ts.addSyntheticLeadingComment(
                 ts.factory.createIdentifier(""),
                 ts.SyntaxKind.MultiLineCommentTrivia,
                 " " + String(error) + " ",
@@ -8255,10 +8719,10 @@ var process = fn("StructuralSchemaGen.process")(
   }
 );
 var applyAtNode = fn("StructuralSchemaGen.applyAtNode")(
-  function* (sourceFile, node, identifier, type, isExported) {
+  function* (sourceFile, node, identifier2, type, isExported) {
     const changeTracker = yield* service(ChangeTracker);
     const ts = yield* service(TypeScriptApi);
-    const ctx = yield* process(sourceFile, node, /* @__PURE__ */ new Map([[ts.idText(identifier), type]]), isExported, false);
+    const ctx = yield* process(sourceFile, node, /* @__PURE__ */ new Map([[ts.idText(identifier2), type]]), isExported, false);
     for (const statement of ctx.schemaStatements) {
       changeTracker.insertNodeAt(sourceFile, node.pos, statement, { prefix: "\n", suffix: "\n" });
     }
@@ -8277,13 +8741,13 @@ var typeToSchema = createCodegen({
     const program = yield* service(TypeScriptProgram);
     const inThisFile = yield* getCodegensForSourceFile([typeToSchema], sourceFile);
     if (inThisFile.length > 1) {
-      return yield* fail(
+      return yield* fail3(
         new CodegenNotApplicableError("the typeToSchema codegen can be used only once per file")
       );
     }
-    const parse3 = (node) => gen(function* () {
+    const parse3 = fn("typeToSchema.parse")(function* (node) {
       if (!ts.isTypeAliasDeclaration(node)) {
-        return yield* fail(
+        return yield* fail3(
           new CodegenNotApplicableError(
             "this codegen is applicable only to a type alias where each object member is a schema to generate. e.g. `type ToGenerate = { UserSchema: User, TodoSchema: Todo}`"
           )
@@ -8291,7 +8755,7 @@ var typeToSchema = createCodegen({
       }
       const type = typeCheckerUtils.getTypeAtLocation(node.name);
       if (!type) {
-        return yield* fail(
+        return yield* fail3(
           new CodegenNotApplicableError(
             "error getting the type to process"
           )
@@ -8324,7 +8788,7 @@ var typeToSchema = createCodegen({
     });
     const nodeAndCommentRange = tsUtils.findNodeWithLeadingCommentAtPosition(sourceFile, textRange.pos);
     if (!nodeAndCommentRange) {
-      return yield* fail(new CodegenNotApplicableError("no node and comment range affected"));
+      return yield* fail3(new CodegenNotApplicableError("no node and comment range affected"));
     }
     return yield* pipe(
       parse3(nodeAndCommentRange.node),
@@ -8460,7 +8924,7 @@ var overriddenSchemaConstructor = createDiagnostic({
               const isSchema = yield* pipe(
                 typeParser.effectSchemaType(typeAtLocation, type.expression),
                 map4(() => true),
-                orElse2(() => succeed(false))
+                orElse2(() => succeed3(false))
               );
               if (isSchema) {
                 extendsSchema = true;
@@ -8558,73 +9022,99 @@ var preferSchemaOverJson = createDiagnostic({
   apply: fn("preferSchemaOverJson.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
-    const parseJsonMethod = (node) => gen(function* () {
-      if (!ts.isCallExpression(node)) return yield* fail("node is not a call expression");
-      const expression = node.expression;
-      if (!ts.isPropertyAccessExpression(expression)) return yield* fail("expression is not a property access");
-      const objectExpr = expression.expression;
-      const methodName = ts.idText(expression.name);
-      if (!ts.isIdentifier(objectExpr) || ts.idText(objectExpr) !== "JSON") {
-        return yield* fail("object is not JSON");
+    const isJsonCall = (node) => ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression) && ts.idText(node.expression.expression) === "JSON" && (ts.idText(node.expression.name) === "parse" || ts.idText(node.expression.name) === "stringify");
+    const findEnclosingEffectTry = (jsonCall) => {
+      const parent = jsonCall.parent;
+      let lazy;
+      if (ts.isArrowFunction(parent) && parent.body === jsonCall && parent.parameters.length === 0 && (!parent.typeParameters || parent.typeParameters.length === 0)) {
+        lazy = parent;
+      }
+      if (!lazy && ts.isReturnStatement(parent) && parent.expression === jsonCall) {
+        const block = parent.parent;
+        if (ts.isBlock(block) && block.statements.length === 1) {
+          const fn2 = block.parent;
+          if ((ts.isArrowFunction(fn2) || ts.isFunctionExpression(fn2)) && fn2.parameters.length === 0 && (!fn2.typeParameters || fn2.typeParameters.length === 0)) {
+            lazy = fn2;
+          }
+        }
       }
-      if (methodName !== "parse" && methodName !== "stringify") {
-        return yield* fail("method is not parse or stringify");
+      if (!lazy) return void 0;
+      const lazyParent = lazy.parent;
+      if (ts.isCallExpression(lazyParent) && lazyParent.arguments.length > 0 && lazyParent.arguments[0] === lazy) {
+        return lazyParent;
       }
-      return { node, methodName };
-    });
-    const effectTrySimple = (node) => gen(function* () {
-      if (!ts.isCallExpression(node)) return yield* fail("node is not a call expression");
+      if (ts.isPropertyAssignment(lazyParent) && ts.isIdentifier(lazyParent.name) && ts.idText(lazyParent.name) === "try") {
+        const objLiteral = lazyParent.parent;
+        if (ts.isObjectLiteralExpression(objLiteral)) {
+          const callExpr = objLiteral.parent;
+          if (ts.isCallExpression(callExpr) && callExpr.arguments.length > 0 && callExpr.arguments[0] === objLiteral) {
+            return callExpr;
+          }
+        }
+      }
+      return void 0;
+    };
+    const jsonCalls = [];
+    const collectJsonCalls = (node) => {
+      if (isJsonCall(node)) {
+        jsonCalls.push(node);
+      }
+      ts.forEachChild(node, collectJsonCalls);
+    };
+    ts.forEachChild(sourceFile, collectJsonCalls);
+    if (jsonCalls.length === 0) return;
+    const effectTrySimple = fn("preferSchemaOverJson.effectTrySimple")(function* (node) {
       yield* typeParser.isNodeReferenceToEffectModuleApi("try")(node.expression);
-      if (node.arguments.length === 0) return yield* fail("Effect.try has no arguments");
+      if (node.arguments.length === 0) return yield* TypeParserIssue.issue;
       const lazyFn = yield* typeParser.lazyExpression(node.arguments[0]);
-      const jsonMethod = yield* parseJsonMethod(lazyFn.expression);
-      return { node: jsonMethod.node, methodName: jsonMethod.methodName };
+      if (!isJsonCall(lazyFn.expression)) return yield* TypeParserIssue.issue;
+      return lazyFn.expression;
     });
-    const effectTryObject = (node) => gen(function* () {
-      if (!ts.isCallExpression(node)) return yield* fail("node is not a call expression");
+    const effectTryObject = fn("preferSchemaOverJson.effectTryObject")(function* (node) {
       yield* typeParser.isNodeReferenceToEffectModuleApi("try")(node.expression);
-      if (node.arguments.length === 0) return yield* fail("Effect.try has no arguments");
+      if (node.arguments.length === 0) return yield* TypeParserIssue.issue;
       const arg = node.arguments[0];
-      if (!ts.isObjectLiteralExpression(arg)) return yield* fail("argument is not an object literal");
+      if (!ts.isObjectLiteralExpression(arg)) return yield* TypeParserIssue.issue;
       const tryProp = arg.properties.find(
         (p) => ts.isPropertyAssignment(p) && ts.isIdentifier(p.name) && ts.idText(p.name) === "try"
       );
-      if (!tryProp) return yield* fail("object has no 'try' property");
+      if (!tryProp) return yield* TypeParserIssue.issue;
       const lazyFn = yield* typeParser.lazyExpression(tryProp.initializer);
-      const jsonMethod = yield* parseJsonMethod(lazyFn.expression);
-      return { node: jsonMethod.node, methodName: jsonMethod.methodName };
+      if (!isJsonCall(lazyFn.expression)) return yield* TypeParserIssue.issue;
+      return lazyFn.expression;
     });
-    const jsonMethodInEffectGen = (node) => gen(function* () {
-      const jsonMethod = yield* parseJsonMethod(node);
-      const { effectGen, scopeNode } = yield* typeParser.findEnclosingScopes(node);
-      if (!effectGen || effectGen.body.statements.length === 0) {
-        return yield* fail("not inside an Effect generator");
+    const jsonMethodInEffectGen = fn("preferSchemaOverJson.jsonMethodInEffectGen")(
+      function* (jsonCall) {
+        const { effectGen, scopeNode } = yield* typeParser.findEnclosingScopes(jsonCall);
+        if (!effectGen || effectGen.body.statements.length === 0) {
+          return yield* TypeParserIssue.issue;
+        }
+        if (scopeNode && scopeNode !== effectGen.generatorFunction) {
+          return yield* TypeParserIssue.issue;
+        }
+        return jsonCall;
       }
-      if (scopeNode && scopeNode !== effectGen.generatorFunction) {
-        return yield* fail("inside a nested function scope");
+    );
+    for (const jsonCall of jsonCalls) {
+      const effectTryCall = findEnclosingEffectTry(jsonCall);
+      let match2;
+      if (effectTryCall) {
+        match2 = yield* pipe(
+          firstSuccessOf([
+            effectTrySimple(effectTryCall),
+            effectTryObject(effectTryCall)
+          ]),
+          option
+        );
+      } else {
+        match2 = yield* pipe(
+          jsonMethodInEffectGen(jsonCall),
+          option
+        );
       }
-      return { node: jsonMethod.node, methodName: jsonMethod.methodName };
-    });
-    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 match2 = yield* pipe(
-        firstSuccessOf([
-          effectTrySimple(node),
-          effectTryObject(node),
-          jsonMethodInEffectGen(node)
-        ]),
-        option
-      );
       if (isSome2(match2)) {
         report({
-          location: match2.value.node,
+          location: match2.value,
           messageText: "Consider using Effect Schema for JSON operations instead of JSON.parse/JSON.stringify",
           fixes: []
         });
@@ -9041,11 +9531,11 @@ var schemaUnionOfLiterals = createDiagnostic({
           orElse2(() => void_)
         );
         if (isSchemaUnionCall) {
-          const args2 = fromIterable(node.arguments);
-          if (args2.length >= 2) {
-            const allAreCallExpressions = args2.every((arg) => ts.isCallExpression(arg));
+          const args3 = fromIterable(node.arguments);
+          if (args3.length >= 2) {
+            const allAreCallExpressions = args3.every((arg) => ts.isCallExpression(arg));
             if (allAreCallExpressions) {
-              const literalChecks = args2.map((arg) => {
+              const literalChecks = args3.map((arg) => {
                 const callArg = arg;
                 return pipe(
                   typeParser.isNodeReferenceToEffectSchemaModuleApi("Literal")(callArg.expression),
@@ -9268,19 +9758,24 @@ var strictEffectProvide = createDiagnostic({
     const ts = yield* service(TypeScriptApi);
     const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const typeParser = yield* service(TypeParser);
-    const parseEffectProvideWithLayer = (node) => gen(function* () {
+    const parseEffectProvideWithLayerGen = fn("strictEffectProvide.parseEffectProvideWithLayer")(
+      function* (node) {
+        yield* typeParser.isNodeReferenceToEffectModuleApi("provide")(node.expression);
+        return yield* firstSuccessOf(
+          node.arguments.map((arg) => {
+            const argType = typeCheckerUtils.getTypeAtLocation(arg);
+            if (!argType) return typeParserIssue("Could not get argument type");
+            return typeParser.layerType(argType, arg);
+          })
+        );
+      }
+    );
+    const parseEffectProvideWithLayer = (node) => {
       if (!ts.isCallExpression(node) || node.arguments.length === 0) {
-        return yield* typeParserIssue("Not an Effect.provide call");
-      }
-      yield* typeParser.isNodeReferenceToEffectModuleApi("provide")(node.expression);
-      return yield* firstSuccessOf(
-        node.arguments.map((arg) => {
-          const argType = typeCheckerUtils.getTypeAtLocation(arg);
-          if (!argType) return typeParserIssue("Could not get argument type");
-          return typeParser.layerType(argType, arg);
-        })
-      );
-    });
+        return TypeParserIssue.issue;
+      }
+      return parseEffectProvideWithLayerGen(node);
+    };
     const nodeToVisit = [];
     const appendNodeToVisit = (node) => {
       nodeToVisit.push(node);
@@ -9546,8 +10041,8 @@ var unnecessaryPipe = createDiagnostic({
       if (ts.isCallExpression(node)) {
         yield* pipe(
           typeParser.pipeCall(node),
-          map4(({ args: args2, subject }) => {
-            if (args2.length === 0) {
+          map4(({ args: args3, subject }) => {
+            if (args3.length === 0) {
               report({
                 location: node,
                 messageText: `This pipe call contains no arguments.`,
@@ -9666,7 +10161,7 @@ var unsupportedServiceAccessors = createDiagnostic({
       if (ts.isClassDeclaration(node)) {
         const parseResult = yield* pipe(
           parse2(node),
-          orElse2(() => succeed(null))
+          orElse2(() => succeed3(null))
         );
         if (parseResult && parseResult.involvedMembers.length > 0) {
           const existingStaticMembers = /* @__PURE__ */ new Set();
@@ -9778,7 +10273,7 @@ function transform_default(program, pluginConfig, { addDiagnostic, ts: tsInstanc
             (_2) => _2.category === tsInstance.DiagnosticCategory.Error || _2.category === tsInstance.DiagnosticCategory.Warning
           )
         ),
-        getOrElse(() => []),
+        getOrElse2(() => []),
         map3(addDiagnostic)
       );
       return sourceFile;