@effect/language-service 0.1.0 → 0.3.0

package/index.cjs

@@ -1,6 +1,6 @@
 "use strict";
 
-// node_modules/.pnpm/effect@2.0.0-next.59/node_modules/effect/dist/esm/Function.js
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Function.js
 var isFunction = (input) => typeof input === "function";
 var dual = function(arity, body) {
   if (typeof arity === "function") {
@@ -94,32 +94,36 @@ function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
   }
 }
 
-// node_modules/.pnpm/effect@2.0.0-next.59/node_modules/effect/dist/esm/internal/version.js
-var moduleVersion = "2.0.0-next.59";
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/version.js
+var moduleVersion = "3.12.5";
+var getCurrentVersion = () => moduleVersion;
 
-// node_modules/.pnpm/effect@2.0.0-next.59/node_modules/effect/dist/esm/GlobalValue.js
-var globalStoreId = /* @__PURE__ */ Symbol.for(`effect/GlobalValue/globalStoreId/${moduleVersion}`);
-if (!(globalStoreId in globalThis)) {
-  ;
-  globalThis[globalStoreId] = /* @__PURE__ */ new Map();
-}
-var globalStore = globalThis[globalStoreId];
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/GlobalValue.js
+var globalStoreId = `effect/GlobalValue/globalStoreId/${/* @__PURE__ */ getCurrentVersion()}`;
+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@2.0.0-next.59/node_modules/effect/dist/esm/Predicate.js
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Predicate.js
 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 isNullable = (input) => input === null || input === void 0;
 
-// node_modules/.pnpm/effect@2.0.0-next.59/node_modules/effect/dist/esm/Utils.js
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/errors.js
+var getBugErrorMessage = (message) => `BUG: ${message} - please report an issue at https://github.com/Effect-TS/effect/issues`;
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Utils.js
 var GenKindTypeId = /* @__PURE__ */ Symbol.for("effect/Gen/GenKind");
+var isGenKind = (u) => isObject(u) && GenKindTypeId in u;
 var GenKindImpl = class {
   value;
   constructor(value) {
@@ -200,139 +204,51 @@ var SingleShotGen = class _SingleShotGen {
     return new _SingleShotGen(this.self);
   }
 };
-var defaultIncHi = 335903614;
-var defaultIncLo = 4150755663;
+var adapter = () => function() {
+  let x = arguments[0];
+  for (let i = 1; i < arguments.length; i++) {
+    x = arguments[i](x);
+  }
+  return new GenKindImpl(x);
+};
 var MUL_HI = 1481765933 >>> 0;
 var MUL_LO = 1284865837 >>> 0;
-var BIT_53 = 9007199254740992;
-var BIT_27 = 134217728;
-var PCGRandom = class {
-  _state;
-  constructor(seedHi, seedLo, incHi, incLo) {
-    if (isNullable(seedLo) && isNullable(seedHi)) {
-      seedLo = Math.random() * 4294967295 >>> 0;
-      seedHi = 0;
-    } else if (isNullable(seedLo)) {
-      seedLo = seedHi;
-      seedHi = 0;
-    }
-    if (isNullable(incLo) && isNullable(incHi)) {
-      incLo = this._state ? this._state[3] : defaultIncLo;
-      incHi = this._state ? this._state[2] : defaultIncHi;
-    } else if (isNullable(incLo)) {
-      incLo = incHi;
-      incHi = 0;
-    }
-    this._state = new Int32Array([0, 0, incHi >>> 0, ((incLo || 0) | 1) >>> 0]);
-    this._next();
-    add64(this._state, this._state[0], this._state[1], seedHi >>> 0, seedLo >>> 0);
-    this._next();
-    return this;
-  }
+var YieldWrapTypeId = /* @__PURE__ */ Symbol.for("effect/Utils/YieldWrap");
+var YieldWrap = class {
   /**
-   * Returns a copy of the internal state of this random number generator as a
-   * JavaScript Array.
-   *
-   * @category getters
-   * @since 2.0.0
-   */
-  getState() {
-    return [this._state[0], this._state[1], this._state[2], this._state[3]];
-  }
-  /**
-   * Restore state previously retrieved using `getState()`.
-   *
-   * @since 2.0.0
-   */
-  setState(state) {
-    this._state[0] = state[0];
-    this._state[1] = state[1];
-    this._state[2] = state[2];
-    this._state[3] = state[3] | 1;
-  }
-  /**
-   * Get a uniformly distributed 32 bit integer between [0, max).
-   *
-   * @category getter
-   * @since 2.0.0
+   * @since 3.0.6
    */
-  integer(max) {
-    if (!max) {
-      return this._next();
-    }
-    max = max >>> 0;
-    if ((max & max - 1) === 0) {
-      return this._next() & max - 1;
-    }
-    let num = 0;
-    const skew = (-max >>> 0) % max >>> 0;
-    for (num = this._next(); num < skew; num = this._next()) {
-    }
-    return num % max;
+  #value;
+  constructor(value) {
+    this.#value = value;
   }
   /**
-   * Get a uniformly distributed IEEE-754 double between 0.0 and 1.0, with
-   * 53 bits of precision (every bit of the mantissa is randomized).
-   *
-   * @category getters
-   * @since 2.0.0
+   * @since 3.0.6
    */
-  number() {
-    const hi = (this._next() & 67108863) * 1;
-    const lo = (this._next() & 134217727) * 1;
-    return (hi * BIT_27 + lo) / BIT_53;
-  }
-  /** @internal */
-  _next() {
-    const oldHi = this._state[0] >>> 0;
-    const oldLo = this._state[1] >>> 0;
-    mul64(this._state, oldHi, oldLo, MUL_HI, MUL_LO);
-    add64(this._state, this._state[0], this._state[1], this._state[2], this._state[3]);
-    let xsHi = oldHi >>> 18;
-    let xsLo = (oldLo >>> 18 | oldHi << 14) >>> 0;
-    xsHi = (xsHi ^ oldHi) >>> 0;
-    xsLo = (xsLo ^ oldLo) >>> 0;
-    const xorshifted = (xsLo >>> 27 | xsHi << 5) >>> 0;
-    const rot = oldHi >>> 27;
-    const rot2 = (-rot >>> 0 & 31) >>> 0;
-    return (xorshifted >>> rot | xorshifted << rot2) >>> 0;
+  [YieldWrapTypeId]() {
+    return this.#value;
   }
 };
-function mul64(out, aHi, aLo, bHi, bLo) {
-  let c1 = (aLo >>> 16) * (bLo & 65535) >>> 0;
-  let c0 = (aLo & 65535) * (bLo >>> 16) >>> 0;
-  let lo = (aLo & 65535) * (bLo & 65535) >>> 0;
-  let hi = (aLo >>> 16) * (bLo >>> 16) + ((c0 >>> 16) + (c1 >>> 16)) >>> 0;
-  c0 = c0 << 16 >>> 0;
-  lo = lo + c0 >>> 0;
-  if (lo >>> 0 < c0 >>> 0) {
-    hi = hi + 1 >>> 0;
-  }
-  c1 = c1 << 16 >>> 0;
-  lo = lo + c1 >>> 0;
-  if (lo >>> 0 < c1 >>> 0) {
-    hi = hi + 1 >>> 0;
-  }
-  hi = hi + Math.imul(aLo, bHi) >>> 0;
-  hi = hi + Math.imul(aHi, bLo) >>> 0;
-  out[0] = hi;
-  out[1] = lo;
-}
-function add64(out, aHi, aLo, bHi, bLo) {
-  let hi = aHi + bHi >>> 0;
-  const lo = aLo + bLo >>> 0;
-  if (lo >>> 0 < aLo >>> 0) {
-    hi = hi + 1 | 0;
+function yieldWrapGet(self) {
+  if (typeof self === "object" && self !== null && YieldWrapTypeId in self) {
+    return self[YieldWrapTypeId]();
   }
-  out[0] = hi;
-  out[1] = lo;
+  throw new Error(getBugErrorMessage("yieldWrapGet"));
 }
+var structuralRegionState = /* @__PURE__ */ globalValue("effect/Utils/isStructuralRegion", () => ({
+  enabled: false,
+  tester: void 0
+}));
+var genConstructor = function* () {
+}.constructor;
 
-// node_modules/.pnpm/effect@2.0.0-next.59/node_modules/effect/dist/esm/Hash.js
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Hash.js
 var randomHashCache = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/Hash/randomHashCache"), () => /* @__PURE__ */ new WeakMap());
-var pcgr = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/Hash/pcgr"), () => new PCGRandom());
 var symbol = /* @__PURE__ */ Symbol.for("effect/Hash");
 var hash = (self) => {
+  if (structuralRegionState.enabled === true) {
+    return 0;
+  }
   switch (typeof self) {
     case "number":
       return number(self);
@@ -350,8 +266,9 @@ var hash = (self) => {
     case "object": {
       if (self === null) {
         return string("null");
-      }
-      if (isHash(self)) {
+      } else if (self instanceof Date) {
+        return hash(self.toISOString());
+      } else if (isHash(self)) {
         return self[symbol]();
       } else {
         return random(self);
@@ -363,7 +280,7 @@ var hash = (self) => {
 };
 var random = (self) => {
   if (!randomHashCache.has(self)) {
-    randomHashCache.set(self, number(pcgr.integer(Number.MAX_SAFE_INTEGER)));
+    randomHashCache.set(self, number(Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)));
   }
   return randomHashCache.get(self);
 };
@@ -381,7 +298,7 @@ var number = (n) => {
   while (n > 4294967295) {
     h ^= n /= 4294967295;
   }
-  return optimize(n);
+  return optimize(h);
 };
 var string = (str) => {
   let h = 5381, i = str.length;
@@ -398,8 +315,31 @@ var structureKeys = (o, keys) => {
   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;
+    };
+  }
+  const self = arguments[0];
+  const hash2 = arguments[1];
+  Object.defineProperty(self, symbol, {
+    value() {
+      return hash2;
+    },
+    enumerable: false
+  });
+  return hash2;
+};
 
-// node_modules/.pnpm/effect@2.0.0-next.59/node_modules/effect/dist/esm/Equal.js
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Equal.js
 var symbol2 = /* @__PURE__ */ Symbol.for("effect/Equal");
 function equals() {
   if (arguments.length === 1) {
@@ -415,30 +355,113 @@ function compareBoth(self, that) {
   if (selfType !== typeof that) {
     return false;
   }
-  if ((selfType === "object" || selfType === "function") && self !== null && that !== null) {
-    if (isEqual(self) && isEqual(that)) {
-      return hash(self) === hash(that) && self[symbol2](that);
+  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) {
+        return self.toISOString() === that.toISOString();
+      }
+    }
+    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;
+        }
+      }
+      return structuralRegionState.tester ? structuralRegionState.tester(self, that) : false;
     }
   }
-  return false;
+  return structuralRegionState.enabled && structuralRegionState.tester ? structuralRegionState.tester(self, that) : false;
 }
 var isEqual = (u) => hasProperty(u, symbol2);
 
-// node_modules/.pnpm/effect@2.0.0-next.59/node_modules/effect/dist/esm/Inspectable.js
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Equivalence.js
+var make = (isEquivalent) => (self, that) => self === that || isEquivalent(self, that);
+var array = (item) => make((self, that) => {
+  if (self.length !== that.length) {
+    return false;
+  }
+  for (let i = 0; i < self.length; i++) {
+    const isEq = item(self[i], that[i]);
+    if (!isEq) {
+      return false;
+    }
+  }
+  return true;
+});
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Inspectable.js
 var NodeInspectSymbol = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
 var toJSON = (x) => {
-  if (hasProperty(x, "toJSON") && isFunction2(x["toJSON"]) && x["toJSON"].length === 0) {
-    return x.toJSON();
-  } else if (Array.isArray(x)) {
-    return x.map(toJSON);
+  try {
+    if (hasProperty(x, "toJSON") && isFunction2(x["toJSON"]) && x["toJSON"].length === 0) {
+      return x.toJSON();
+    } else if (Array.isArray(x)) {
+      return x.map(toJSON);
+    }
+  } catch (_) {
+    return {};
   }
-  return x;
+  return redact(x);
 };
 var format = (x) => JSON.stringify(x, null, 2);
+var BaseProto = {
+  toJSON() {
+    return toJSON(this);
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  },
+  toString() {
+    return format(this.toJSON());
+  }
+};
+var Class = class {
+  /**
+   * @since 2.0.0
+   */
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+  /**
+   * @since 2.0.0
+   */
+  toString() {
+    return format(this.toJSON());
+  }
+};
+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);
+  }
+  return u;
+};
 
-// node_modules/.pnpm/effect@2.0.0-next.59/node_modules/effect/dist/esm/Pipeable.js
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Pipeable.js
 var pipeArguments = (self, args) => {
   switch (args.length) {
+    case 0:
+      return self;
     case 1:
       return args[0](self);
     case 2:
@@ -467,10 +490,10 @@ var pipeArguments = (self, args) => {
   }
 };
 
-// node_modules/.pnpm/effect@2.0.0-next.59/node_modules/effect/dist/esm/internal/opCodes/effect.js
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/opCodes/effect.js
 var OP_COMMIT = "Commit";
 
-// node_modules/.pnpm/effect@2.0.0-next.59/node_modules/effect/dist/esm/internal/effectable.js
+// node_modules/.pnpm/effect@3.12.5/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");
@@ -482,19 +505,19 @@ var effectVariance = {
   _E: (_) => _,
   /* c8 ignore next */
   _A: (_) => _,
-  _V: moduleVersion
+  _V: /* @__PURE__ */ getCurrentVersion()
 };
 var sinkVariance = {
   /* c8 ignore next */
-  _R: (_) => _,
-  /* c8 ignore next */
-  _E: (_) => _,
+  _A: (_) => _,
   /* c8 ignore next */
   _In: (_) => _,
   /* c8 ignore next */
   _L: (_) => _,
   /* c8 ignore next */
-  _Z: (_) => _
+  _E: (_) => _,
+  /* c8 ignore next */
+  _R: (_) => _
 };
 var channelVariance = {
   /* c8 ignore next */
@@ -521,7 +544,10 @@ var EffectPrototype = {
     return this === that;
   },
   [symbol]() {
-    return random(this);
+    return cached(this, random(this));
+  },
+  [Symbol.iterator]() {
+    return new SingleShotGen(new YieldWrap(this));
   },
   pipe() {
     return pipeArguments(this, arguments);
@@ -529,7 +555,7 @@ var EffectPrototype = {
 };
 var StructuralPrototype = {
   [symbol]() {
-    return structure(this);
+    return cached(this, structure(this));
   },
   [symbol2](that) {
     const selfKeys = Object.keys(this);
@@ -554,7 +580,7 @@ var StructuralCommitPrototype = {
   ...StructuralPrototype
 };
 
-// node_modules/.pnpm/effect@2.0.0-next.59/node_modules/effect/dist/esm/internal/option.js
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/option.js
 var TypeId = /* @__PURE__ */ Symbol.for("effect/Option");
 var CommonProto = {
   ...EffectPrototype,
@@ -572,10 +598,10 @@ var SomeProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(Comm
   _tag: "Some",
   _op: "Some",
   [symbol2](that) {
-    return isOption(that) && isSome(that) && equals(that.value, this.value);
+    return isOption(that) && isSome(that) && equals(this.value, that.value);
   },
   [symbol]() {
-    return combine(hash(this._tag))(hash(this.value));
+    return cached(this, combine(hash(this._tag))(hash(this.value)));
   },
   toJSON() {
     return {
@@ -585,6 +611,7 @@ var SomeProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(Comm
     };
   }
 });
+var NoneHash = /* @__PURE__ */ hash("None");
 var NoneProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(CommonProto), {
   _tag: "None",
   _op: "None",
@@ -592,7 +619,7 @@ var NoneProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(Comm
     return isOption(that) && isNone(that);
   },
   [symbol]() {
-    return combine(hash(this._tag));
+    return NoneHash;
   },
   toJSON() {
     return {
@@ -611,7 +638,10 @@ var some = (value) => {
   return a;
 };
 
-// node_modules/.pnpm/effect@2.0.0-next.59/node_modules/effect/dist/esm/Option.js
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Order.js
+var make2 = (compare) => (self, that) => self === that ? 0 : compare(self, that);
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Option.js
 var none2 = () => none;
 var some2 = some;
 var isNone2 = isNone;
@@ -621,17 +651,273 @@ var orElse = /* @__PURE__ */ dual(2, (self, that) => isNone2(self) ? that() : se
 var fromNullable = (nullableValue) => nullableValue == null ? none2() : some2(nullableValue);
 var map = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : some2(f(self.value)));
 var flatMap = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : f(self.value));
+var all = (input) => {
+  if (Symbol.iterator in input) {
+    const out2 = [];
+    for (const o of input) {
+      if (isNone2(o)) {
+        return none2();
+      }
+      out2.push(o.value);
+    }
+    return some2(out2);
+  }
+  const out = {};
+  for (const key of Object.keys(input)) {
+    const o = input[key];
+    if (isNone2(o)) {
+      return none2();
+    }
+    out[key] = o.value;
+  }
+  return some2(out);
+};
+var adapter2 = /* @__PURE__ */ adapter();
+var gen = (...args) => {
+  let f;
+  if (args.length === 1) {
+    f = args[0];
+  } else {
+    f = args[1].bind(args[0]);
+  }
+  const iterator = f(adapter2);
+  let state = iterator.next();
+  if (state.done) {
+    return some2(state.value);
+  } else {
+    let current = state.value;
+    if (isGenKind(current)) {
+      current = current.value;
+    } else {
+      current = yieldWrapGet(current);
+    }
+    if (isNone2(current)) {
+      return current;
+    }
+    while (!state.done) {
+      state = iterator.next(current.value);
+      if (!state.done) {
+        current = state.value;
+        if (isGenKind(current)) {
+          current = current.value;
+        } else {
+          current = yieldWrapGet(current);
+        }
+        if (isNone2(current)) {
+          return current;
+        }
+      }
+    }
+    return some2(state.value);
+  }
+};
+
+// src/definition.ts
+function createRefactor(definition) {
+  return definition;
+}
+function createDiagnostic(definition) {
+  return definition;
+}
 
-// node_modules/.pnpm/effect@2.0.0-next.59/node_modules/effect/dist/esm/ReadonlyArray.js
+// src/utils/TypeParser.ts
+var covariantTypeArgument = (type) => {
+  const signatures = type.getCallSignatures();
+  if (signatures.length !== 1)
+    return none2();
+  return some2(signatures[0].getReturnType());
+};
+function pipeableType(ts, typeChecker) {
+  return (type, atLocation) => {
+    const pipeSymbol = typeChecker.getPropertyOfType(type, "pipe");
+    if (!pipeSymbol)
+      return none2();
+    const pipeType = typeChecker.getTypeOfSymbolAtLocation(pipeSymbol, atLocation);
+    const signatures = pipeType.getCallSignatures();
+    if (signatures.length === 0)
+      return none2();
+    return some2(type);
+  };
+}
+function varianceStructCovariant(ts, typeChecker) {
+  return (type, atLocation, propertyName) => gen(function* (_) {
+    const propertySymbol = yield* fromNullable(
+      typeChecker.getPropertyOfType(type, propertyName)
+    );
+    const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
+    return yield* covariantTypeArgument(propertyType);
+  });
+}
+function effectVarianceStruct(ts, typeChecker) {
+  return (type, atLocation) => all({
+    A: varianceStructCovariant(ts, typeChecker)(type, atLocation, "_A"),
+    E: varianceStructCovariant(ts, typeChecker)(type, atLocation, "_E"),
+    R: varianceStructCovariant(ts, typeChecker)(type, atLocation, "_R")
+  });
+}
+function effectTypeArguments(ts, typeChecker) {
+  return (type, atLocation) => gen(function* (_) {
+    yield* pipeableType(ts, typeChecker)(type, atLocation);
+    for (const propertySymbol of typeChecker.getPropertiesOfType(type)) {
+      const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
+      const varianceArgs = effectVarianceStruct(ts, typeChecker)(
+        propertyType,
+        atLocation
+      );
+      if (isSome2(varianceArgs)) {
+        return yield* varianceArgs;
+      }
+    }
+    return yield* none2();
+  });
+}
+function importedEffectModule(ts, typeChecker) {
+  return (node) => gen(function* () {
+    const type = typeChecker.getTypeAtLocation(node);
+    const propertySymbol = yield* fromNullable(
+      typeChecker.getPropertyOfType(type, "never")
+    );
+    const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, node);
+    return yield* effectTypeArguments(ts, typeChecker)(propertyType, node).pipe(
+      map(() => node)
+    );
+  });
+}
+function effectGen(ts, typeChecker) {
+  return (node) => gen(function* () {
+    if (!ts.isCallExpression(node))
+      return yield* none2();
+    if (node.arguments.length === 0)
+      return yield* none2();
+    const generatorFunction = node.arguments[0];
+    if (!ts.isFunctionExpression(generatorFunction))
+      return yield* none2();
+    if (generatorFunction.asteriskToken === void 0)
+      return yield* none2();
+    if (!ts.isPropertyAccessExpression(node.expression))
+      return yield* none2();
+    const propertyAccess = node.expression;
+    if (propertyAccess.name.text !== "gen")
+      return yield* none2();
+    return yield* importedEffectModule(ts, typeChecker)(propertyAccess.expression).pipe(
+      map(() => ({ body: generatorFunction.body }))
+    );
+  });
+}
+function expectedAndRealType(ts, typeChecker) {
+  return (node) => {
+    if (ts.isVariableDeclaration(node) && node.initializer) {
+      const expectedType = typeChecker.getTypeAtLocation(node.name);
+      const realType = typeChecker.getTypeAtLocation(node.initializer);
+      return [[node.name, expectedType, node.initializer, realType]];
+    }
+    if (ts.isCallExpression(node)) {
+      const resolvedSignature = typeChecker.getResolvedSignature(node);
+      if (resolvedSignature) {
+        return resolvedSignature.getParameters().map((parameter, index) => {
+          const expectedType = typeChecker.getTypeOfSymbolAtLocation(parameter, node);
+          const realType = typeChecker.getTypeAtLocation(node.arguments[index]);
+          return [node.arguments[index], expectedType, node.arguments[index], realType];
+        });
+      }
+    }
+    if (ts.isIdentifier(node) || ts.isStringLiteral(node) || ts.isNumericLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+      const parent = node.parent;
+      if (ts.isObjectLiteralElement(parent)) {
+        if (ts.isObjectLiteralExpression(parent.parent) && parent.name === node) {
+          const type = typeChecker.getContextualType(parent.parent);
+          if (type) {
+            const symbol3 = typeChecker.getPropertyOfType(type, node.text);
+            if (symbol3) {
+              const expectedType = typeChecker.getTypeOfSymbolAtLocation(symbol3, node);
+              const realType = typeChecker.getTypeAtLocation(node);
+              return [[node, expectedType, node, realType]];
+            }
+          }
+        }
+      }
+    }
+    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+      const expectedType = typeChecker.getTypeAtLocation(node.left);
+      const realType = typeChecker.getTypeAtLocation(node.right);
+      return [[node.left, expectedType, node.right, realType]];
+    }
+    if (ts.isReturnStatement(node) && node.expression) {
+      const expectedType = typeChecker.getContextualType(node.expression);
+      const realType = typeChecker.getTypeAtLocation(node.expression);
+      if (expectedType)
+        return [[node, expectedType, node, realType]];
+    }
+    if (ts.isArrowFunction(node) && ts.isExpression(node.body)) {
+      const body = node.body;
+      const expectedType = typeChecker.getContextualType(body);
+      const realType = typeChecker.getTypeAtLocation(body);
+      if (expectedType)
+        return [[body, expectedType, body, realType]];
+    }
+    if (ts.isSatisfiesExpression(node)) {
+      const expectedType = typeChecker.getTypeAtLocation(node.type);
+      const realType = typeChecker.getTypeAtLocation(node.expression);
+      return [[node.expression, expectedType, node.expression, realType]];
+    }
+    return [];
+  };
+}
+
+// src/diagnostics/floatingEffect.ts
+var floatingEffect = createDiagnostic({
+  code: 3,
+  apply: (ts, program) => (sourceFile) => {
+    const typeChecker = program.getTypeChecker();
+    const effectDiagnostics = [];
+    const visit = (node) => {
+      if (ts.isExpressionStatement(node) && (ts.isBlock(node.parent) || ts.isSourceFile(node.parent))) {
+        const type = typeChecker.getTypeAtLocation(node.expression);
+        const effect = effectTypeArguments(ts, typeChecker)(type, node.expression);
+        if (isSome2(effect)) {
+          effectDiagnostics.push({
+            node,
+            category: ts.DiagnosticCategory.Error,
+            messageText: `Effect must be yielded or assigned to a variable.`
+          });
+        }
+      }
+      ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(sourceFile, visit);
+    return effectDiagnostics;
+  }
+});
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/array.js
+var isNonEmptyArray = (self) => self.length > 0;
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Array.js
 var fromIterable = (collection) => Array.isArray(collection) ? collection : Array.from(collection);
 var append = /* @__PURE__ */ dual(2, (self, last) => [...self, last]);
 var appendAll = /* @__PURE__ */ dual(2, (self, that) => fromIterable(self).concat(fromIterable(that)));
+var isArray = Array.isArray;
+var isNonEmptyReadonlyArray = isNonEmptyArray;
 var isOutOfBound = (i, as) => i < 0 || i >= as.length;
 var get = /* @__PURE__ */ dual(2, (self, index) => {
   const i = Math.floor(index);
   return isOutOfBound(i, self) ? none2() : some2(self[i]);
 });
+var unsafeGet = /* @__PURE__ */ dual(2, (self, index) => {
+  const i = Math.floor(index);
+  if (isOutOfBound(i, self)) {
+    throw new Error(`Index ${i} out of bounds`);
+  }
+  return self[i];
+});
 var head = /* @__PURE__ */ get(0);
+var headNonEmpty = /* @__PURE__ */ unsafeGet(0);
+var tailNonEmpty = (self) => self.slice(1);
+var sort = /* @__PURE__ */ dual(2, (self, O) => {
+  const out = Array.from(self);
+  out.sort(O);
+  return out;
+});
 var empty = () => [];
 var map2 = /* @__PURE__ */ dual(2, (self, f) => self.map(f));
 var filter = /* @__PURE__ */ dual(2, (self, predicate) => {
@@ -644,28 +930,22 @@ var filter = /* @__PURE__ */ dual(2, (self, predicate) => {
   }
   return out;
 });
-
-// src/definition.ts
-function createRefactor(definition) {
-  return definition;
-}
+var dedupeWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => {
+  const input = fromIterable(self);
+  if (isNonEmptyReadonlyArray(input)) {
+    const out = [headNonEmpty(input)];
+    const rest = tailNonEmpty(input);
+    for (const r of rest) {
+      if (out.every((a) => !isEquivalent(r, a))) {
+        out.push(r);
+      }
+    }
+    return out;
+  }
+  return [];
+});
 
 // src/utils/AST.ts
-var NoSuchSourceFile = class {
-  constructor(fileName) {
-    this.fileName = fileName;
-  }
-  _tag = "NoSuchSourceFile";
-};
-function getSourceFile(program) {
-  return (fileName) => {
-    const sourceFile = program.getSourceFile(fileName);
-    if (!sourceFile) {
-      throw new NoSuchSourceFile(fileName);
-    }
-    return sourceFile;
-  };
-}
 function getNodesContainingRange(ts) {
   return (sourceFile, textRange) => {
     const precedingToken = ts.findPrecedingToken(textRange.pos, sourceFile);
@@ -674,7 +954,9 @@ function getNodesContainingRange(ts) {
     let result = empty();
     let parent = precedingToken;
     while (parent) {
-      result = pipe(result, append(parent));
+      if (parent.end >= textRange.end) {
+        result = pipe(result, append(parent));
+      }
       parent = parent.parent;
     }
     return result;
@@ -763,20 +1045,14 @@ function findModuleImportIdentifierNameViaTypeChecker(ts, typeChecker) {
     }));
   };
 }
-function transformAsyncAwaitToEffectGen(ts, preferredEffectGenAdapterName) {
+function transformAsyncAwaitToEffectGen(ts) {
   return (node, effectName, onAwait) => {
     function visitor(_) {
       if (ts.isAwaitExpression(_)) {
         const expression = ts.visitEachChild(_.expression, visitor, ts.nullTransformationContext);
         return ts.factory.createYieldExpression(
           ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
-          ts.factory.createCallExpression(
-            ts.factory.createIdentifier(preferredEffectGenAdapterName),
-            void 0,
-            [
-              onAwait(expression)
-            ]
-          )
+          onAwait(expression)
         );
       }
       return ts.visitEachChild(_, visitor, ts.nullTransformationContext);
@@ -787,7 +1063,7 @@ function transformAsyncAwaitToEffectGen(ts, preferredEffectGenAdapterName) {
       ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
       void 0,
       [],
-      [ts.factory.createParameterDeclaration(void 0, void 0, preferredEffectGenAdapterName)],
+      [],
       void 0,
       generatorBody
       // NOTE(mattia): intended, to use same routine for both ConciseBody and Body
@@ -948,16 +1224,204 @@ function asDataFirstExpression(ts, checker) {
     return none2();
   };
 }
+function deterministicTypeOrder(ts, typeChecker) {
+  return make2((a, b) => {
+    const aName = typeChecker.typeToString(a);
+    const bName = typeChecker.typeToString(b);
+    if (aName < bName)
+      return -1;
+    if (aName > bName)
+      return 1;
+    return 0;
+  });
+}
+
+// src/utils/TypeCheckerApi.ts
+function getMissingTypeEntriesInTargetType(ts, typeChecker) {
+  return (realType, expectedType) => {
+    const result = [];
+    const toTest = [realType];
+    while (toTest.length > 0) {
+      const type = toTest.pop();
+      if (!type)
+        return result;
+      if (type.isUnion()) {
+        toTest.push(...type.types);
+      } else {
+        const assignable = typeChecker.isTypeAssignableTo(type, expectedType);
+        if (!assignable) {
+          result.push(type);
+        }
+      }
+    }
+    return result;
+  };
+}
+
+// src/diagnostics/missingEffectContext.ts
+var missingEffectContext = createDiagnostic({
+  code: 1,
+  apply: (ts, program) => (sourceFile) => {
+    const typeChecker = program.getTypeChecker();
+    const effectDiagnostics = [];
+    const sortTypes = sort(deterministicTypeOrder(ts, typeChecker));
+    const visit = (node) => {
+      const entries = expectedAndRealType(ts, typeChecker)(node);
+      for (const [node2, expectedType, valueNode, realType] of entries) {
+        gen(function* () {
+          const expectedEffect = yield* effectTypeArguments(ts, typeChecker)(
+            expectedType,
+            node2
+          );
+          const realEffect = yield* effectTypeArguments(ts, typeChecker)(
+            realType,
+            valueNode
+          );
+          const missingContext = getMissingTypeEntriesInTargetType(
+            ts,
+            typeChecker
+          )(
+            realEffect.R,
+            expectedEffect.R
+          );
+          if (missingContext.length > 0) {
+            effectDiagnostics.push(
+              {
+                node: node2,
+                category: ts.DiagnosticCategory.Error,
+                messageText: `Missing '${sortTypes(missingContext).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect context.`
+              }
+            );
+          }
+        });
+      }
+      ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(sourceFile, visit);
+    return effectDiagnostics;
+  }
+});
+
+// src/diagnostics/missingEffectError.ts
+var missingEffectError = createDiagnostic({
+  code: 2,
+  apply: (ts, program) => (sourceFile) => {
+    const typeChecker = program.getTypeChecker();
+    const effectDiagnostics = [];
+    const sortTypes = sort(deterministicTypeOrder(ts, typeChecker));
+    const visit = (node) => {
+      const entries = expectedAndRealType(ts, typeChecker)(node);
+      for (const [node2, expectedType, valueNode, realType] of entries) {
+        gen(function* () {
+          const expectedEffect = yield* effectTypeArguments(ts, typeChecker)(
+            expectedType,
+            node2
+          );
+          const realEffect = yield* effectTypeArguments(ts, typeChecker)(
+            realType,
+            valueNode
+          );
+          const missingErrorTypes = getMissingTypeEntriesInTargetType(
+            ts,
+            typeChecker
+          )(
+            realEffect.E,
+            expectedEffect.E
+          );
+          if (missingErrorTypes.length > 0) {
+            effectDiagnostics.push(
+              {
+                node: node2,
+                category: ts.DiagnosticCategory.Error,
+                messageText: `Missing '${sortTypes(missingErrorTypes).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect errors.`
+              }
+            );
+          }
+        });
+      }
+      ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(sourceFile, visit);
+    return effectDiagnostics;
+  }
+});
+
+// src/diagnostics/missingStarInYieldEffectGen.ts
+var missingStarInYieldEffectGen = createDiagnostic({
+  code: 4,
+  apply: (ts, program) => (sourceFile) => {
+    const typeChecker = program.getTypeChecker();
+    const effectDiagnostics = [];
+    const visitWhileInGenerator = (node) => {
+      if (ts.isYieldExpression(node) && node.expression && node.asteriskToken === void 0) {
+        const type = typeChecker.getTypeAtLocation(node.expression);
+        const effect = effectTypeArguments(ts, typeChecker)(type, node.expression);
+        if (isSome2(effect)) {
+          effectDiagnostics.push({
+            node,
+            category: ts.DiagnosticCategory.Error,
+            messageText: `When yielding Effects inside Effect.gen, you should use yield* instead of yield.`
+          });
+        }
+      }
+      const effectGen2 = effectGen(ts, typeChecker)(node);
+      if (isSome2(effectGen2)) {
+        ts.forEachChild(effectGen2.value.body, visitWhileInGenerator);
+      } else if ((ts.isFunctionExpression(node) || ts.isMethodDeclaration(node)) && node.asteriskToken !== void 0) {
+        ts.forEachChild(node, visit);
+      } else {
+        ts.forEachChild(node, visitWhileInGenerator);
+      }
+    };
+    const visit = (node) => {
+      const effectGen2 = effectGen(ts, typeChecker)(node);
+      if (isSome2(effectGen2)) {
+        ts.forEachChild(effectGen2.value.body, visitWhileInGenerator);
+      } else {
+        ts.forEachChild(node, visit);
+      }
+    };
+    ts.forEachChild(sourceFile, visit);
+    return effectDiagnostics;
+  }
+});
+
+// src/diagnostics.ts
+var diagnostics = {
+  missingEffectContext,
+  missingEffectError,
+  floatingEffect,
+  missingStarInYieldEffectGen
+};
+
+// src/quickinfo.ts
+var SymbolDisplayPartEq = make(
+  (fa, fb) => fa.kind === fb.kind && fa.text === fb.text
+);
+var JSDocTagInfoEq = make(
+  (fa, fb) => fa.name === fb.name && typeof fa.text === typeof fb.text && (typeof fa.text !== "undefined" ? array(SymbolDisplayPartEq)(fa.text, fb.text) : true)
+);
+function dedupeJsDocTags(quickInfo) {
+  if (quickInfo.tags) {
+    return {
+      ...quickInfo,
+      tags: dedupeWith(quickInfo.tags, JSDocTagInfoEq)
+    };
+  }
+  return quickInfo;
+}
 
 // src/refactors/asyncAwaitToGen.ts
 var asyncAwaitToGen = createRefactor({
   name: "effect/asyncAwaitToGen",
   description: "Convert to Effect.gen",
-  apply: (ts, program, options) => (sourceFile, textRange) => pipe(
+  apply: (ts, program) => (sourceFile, textRange) => pipe(
     getNodesContainingRange(ts)(sourceFile, textRange),
     filter(ts.isFunctionDeclaration),
     filter((node) => !!node.body),
-    filter((node) => !!(ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Async)),
+    filter(
+      (node) => !!(ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Async)
+    ),
     head,
     map((node) => ({
       kind: "refactor.rewrite.effect.asyncAwaitToGen",
@@ -965,8 +1429,7 @@ var asyncAwaitToGen = createRefactor({
       apply: (changeTracker) => {
         const effectName = getEffectModuleIdentifier(ts, program.getTypeChecker())(sourceFile);
         const newDeclaration = transformAsyncAwaitToEffectGen(
-          ts,
-          options.preferredEffectGenAdapterName
+          ts
         )(
           node,
           effectName,
@@ -998,11 +1461,13 @@ var asyncAwaitToGen = createRefactor({
 var asyncAwaitToGenTryPromise = createRefactor({
   name: "effect/asyncAwaitToGenTryPromise",
   description: "Convert to Effect.gen with failures",
-  apply: (ts, program, options) => (sourceFile, textRange) => pipe(
+  apply: (ts, program) => (sourceFile, textRange) => pipe(
     getNodesContainingRange(ts)(sourceFile, textRange),
     filter(ts.isFunctionDeclaration),
     filter((node) => !!node.body),
-    filter((node) => !!(ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Async)),
+    filter(
+      (node) => !!(ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Async)
+    ),
     head,
     map((node) => ({
       kind: "refactor.rewrite.effect.asyncAwaitToGenTryPromise",
@@ -1024,8 +1489,7 @@ var asyncAwaitToGenTryPromise = createRefactor({
           ]);
         }
         const newDeclaration = transformAsyncAwaitToEffectGen(
-          ts,
-          options.preferredEffectGenAdapterName
+          ts
         )(
           node,
           effectName,
@@ -1362,12 +1826,48 @@ var init = (modules) => {
   function create(info) {
     const languageService = info.languageService;
     const pluginOptions = {
-      preferredEffectGenAdapterName: info.config.preferredEffectGenAdapterName ?? "_"
+      diagnostics: info.config && "diagnostics" in info.config && typeof info.config.diagnostics === "boolean" ? info.config.diagnostics : true
     };
     const proxy = /* @__PURE__ */ Object.create(null);
     for (const k of Object.keys(info.languageService)) {
       proxy[k] = (...args) => languageService[k].apply(languageService, args);
     }
+    proxy.getSemanticDiagnostics = (fileName, ...args) => {
+      const applicableDiagnostics = languageService.getSemanticDiagnostics(fileName, ...args);
+      const program = languageService.getProgram();
+      if (pluginOptions.diagnostics && program) {
+        const effectDiagnostics = pipe(
+          fromNullable(program.getSourceFile(fileName)),
+          map(
+            (sourceFile) => pipe(
+              Object.values(diagnostics).map(
+                (diagnostic) => pipe(
+                  diagnostic.apply(modules.typescript, program, pluginOptions)(
+                    sourceFile,
+                    applicableDiagnostics
+                  ).map((_) => ({
+                    file: sourceFile,
+                    start: _.node.getStart(sourceFile),
+                    length: _.node.getEnd() - _.node.getStart(sourceFile),
+                    messageText: _.messageText,
+                    category: _.category,
+                    code: diagnostic.code,
+                    source: "effect"
+                  }))
+                )
+              ),
+              (_) => _.reduce(
+                (arr, maybeRefactor) => arr.concat(maybeRefactor),
+                []
+              )
+            )
+          ),
+          getOrElse(() => [])
+        );
+        return effectDiagnostics.concat(applicableDiagnostics);
+      }
+      return applicableDiagnostics;
+    };
     proxy.getApplicableRefactors = (...args) => {
       const applicableRefactors = languageService.getApplicableRefactors(...args);
       const [fileName, positionOrRange] = args;
@@ -1375,30 +1875,33 @@ var init = (modules) => {
       if (program) {
         const textRange = toTextRange(positionOrRange);
         const effectRefactors = pipe(
-          getSourceFile(program)(fileName),
-          (sourceFile) => pipe(
-            Object.values(refactors).map(
-              (refactor) => pipe(
-                refactor.apply(modules.typescript, program, pluginOptions)(
-                  sourceFile,
-                  textRange
-                ),
-                map((_) => ({
-                  name: refactor.name,
-                  description: refactor.description,
-                  actions: [{
+          fromNullable(program.getSourceFile(fileName)),
+          map(
+            (sourceFile) => pipe(
+              Object.values(refactors).map(
+                (refactor) => pipe(
+                  refactor.apply(modules.typescript, program, pluginOptions)(
+                    sourceFile,
+                    textRange
+                  ),
+                  map((_) => ({
                     name: refactor.name,
-                    description: _.description,
-                    kind: _.kind
-                  }]
-                }))
+                    description: refactor.description,
+                    actions: [{
+                      name: refactor.name,
+                      description: _.description,
+                      kind: _.kind
+                    }]
+                  }))
+                )
+              ),
+              (_) => _.reduce(
+                (arr, maybeRefactor) => arr.concat(isSome2(maybeRefactor) ? [maybeRefactor.value] : []),
+                []
               )
-            ),
-            (_) => _.reduce(
-              (arr, maybeRefactor) => arr.concat(isSome2(maybeRefactor) ? [maybeRefactor.value] : []),
-              []
             )
-          )
+          ),
+          getOrElse(() => [])
         );
         info.project.projectService.logger.info(
           "[@effect/language-service] possible refactors are " + JSON.stringify(effectRefactors)
@@ -1412,11 +1915,15 @@ var init = (modules) => {
       if (program) {
         for (const refactor of Object.values(refactors)) {
           if (refactor.name === refactorName) {
-            const sourceFile = getSourceFile(program)(fileName);
             const textRange = toTextRange(positionOrRange);
-            const possibleRefactor = refactor.apply(modules.typescript, program, pluginOptions)(
-              sourceFile,
-              textRange
+            const possibleRefactor = pipe(
+              fromNullable(program.getSourceFile(fileName)),
+              flatMap(
+                (sourceFile) => refactor.apply(modules.typescript, program, pluginOptions)(
+                  sourceFile,
+                  textRange
+                )
+              )
             );
             if (isNone2(possibleRefactor)) {
               info.project.projectService.logger.info(
@@ -1450,8 +1957,16 @@ var init = (modules) => {
         ...args
       );
     };
+    proxy.getQuickInfoAtPosition = (fileName, position, ...args) => {
+      const quickInfo = languageService.getQuickInfoAtPosition(fileName, position, ...args);
+      if (quickInfo) {
+        return dedupeJsDocTags(quickInfo);
+      }
+      return quickInfo;
+    };
     return proxy;
   }
   return { create };
 };
 module.exports = init;
+//# sourceMappingURL=index.cjs.map