@effect/language-service 0.71.2 → 0.72.1

package/transform.js

@@ -24,7 +24,7 @@ __export(transform_exports, {
 });
 module.exports = __toCommonJS(transform_exports);
 
-// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Function.js
+// ../../node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Function.js
 var isFunction = (input) => typeof input === "function";
 var dual = function(arity, body) {
   if (typeof arity === "function") {
@@ -120,7 +120,7 @@ function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
   }
 }
 
-// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/GlobalValue.js
+// ../../node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/GlobalValue.js
 var globalStoreId = `effect/GlobalValue`;
 var globalStore;
 var globalValue = (id, compute) => {
@@ -134,7 +134,7 @@ var globalValue = (id, compute) => {
   return globalStore.get(id);
 };
 
-// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Predicate.js
+// ../../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";
@@ -144,7 +144,7 @@ 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
+// ../../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;
@@ -266,7 +266,7 @@ var internalCall = isNotOptimizedAway ? standard.effect_internal_function : forc
 var genConstructor = function* () {
 }.constructor;
 
-// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Hash.js
+// ../../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");
 var hash = (self) => {
@@ -368,7 +368,7 @@ var cached = function() {
   return hash2;
 };
 
-// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Equal.js
+// ../../node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Equal.js
 var symbol2 = /* @__PURE__ */ Symbol.for("effect/Equal");
 function equals() {
   if (arguments.length === 1) {
@@ -424,7 +424,7 @@ function compareBoth(self, that) {
 var isEqual = (u) => hasProperty(u, symbol2);
 var equivalence = () => equals;
 
-// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Inspectable.js
+// ../../node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Inspectable.js
 var NodeInspectSymbol = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
 var toJSON = (x) => {
   try {
@@ -476,7 +476,7 @@ var redact = (u) => {
   return u;
 };
 
-// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Pipeable.js
+// ../../node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Pipeable.js
 var pipeArguments = (self, args2) => {
   switch (args2.length) {
     case 0:
@@ -509,14 +509,14 @@ var pipeArguments = (self, args2) => {
   }
 };
 
-// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/internal/opCodes/effect.js
+// ../../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
+// ../../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
+// ../../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");
@@ -603,7 +603,7 @@ var StructuralCommitPrototype = {
   ...StructuralPrototype
 };
 
-// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/internal/option.js
+// ../../node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/internal/option.js
 var TypeId = /* @__PURE__ */ Symbol.for("effect/Option");
 var CommonProto = {
   ...EffectPrototype,
@@ -661,7 +661,7 @@ var some = (value) => {
   return a;
 };
 
-// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/internal/either.js
+// ../../node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/internal/either.js
 var TypeId2 = /* @__PURE__ */ Symbol.for("effect/Either");
 var CommonProto2 = {
   ...EffectPrototype,
@@ -723,7 +723,7 @@ var right = (right3) => {
   return a;
 };
 
-// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Either.js
+// ../../node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Either.js
 var right2 = right;
 var left2 = left;
 var isLeft2 = isLeft;
@@ -731,14 +731,14 @@ 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
+// ../../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
+// ../../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@3.19.14/node_modules/effect/dist/esm/Option.js
+// ../../node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Option.js
 var none2 = () => none;
 var some2 = some;
 var isNone2 = isNone;
@@ -748,7 +748,7 @@ var orElse = /* @__PURE__ */ dual(2, (self, that) => isNone2(self) ? that() : se
 var fromNullable = (nullableValue) => nullableValue == null ? none2() : some2(nullableValue);
 var getOrUndefined = /* @__PURE__ */ getOrElse2(constUndefined);
 
-// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Record.js
+// ../../node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Record.js
 var map2 = /* @__PURE__ */ dual(2, (self, f) => {
   const out = {
     ...self
@@ -760,7 +760,7 @@ 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
+// ../../node_modules/.pnpm/effect@3.19.14/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)));
@@ -1161,6 +1161,13 @@ var option = (fa) => {
   nano[contE] = (_) => _ instanceof NanoDefectException ? fail(_) : succeed(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);
+  return nano;
+};
 var ignore = (fa) => {
   const nano = Object.create(MatchProto);
   nano[args] = fa;
@@ -1352,7 +1359,7 @@ function makeTypeScriptUtils(ts) {
     if (!hasProperty(packageJsonScope, "packageDirectory")) return;
     if (!isString(packageJsonScope.packageDirectory)) return;
     const { name } = packageJsonContent;
-    const version = hasProperty(packageJsonScope, "version") ? packageJsonScope.version : "";
+    const version = hasProperty(packageJsonContent, "version") ? packageJsonContent.version : "unknown";
     if (!isString(name)) return;
     if (!isString(version)) return;
     const hasEffectInPeerDependencies = hasProperty(packageJsonContent, "peerDependencies") && isObject(packageJsonContent.peerDependencies) && hasProperty(packageJsonContent.peerDependencies, "effect");
@@ -2563,6 +2570,8 @@ function makeTypeCheckerUtils(ts, typeChecker, tsUtils) {
 }
 
 // src/core/TypeParser.ts
+var checkedPackagesCache = /* @__PURE__ */ new Map();
+var programResolvedCacheSize = /* @__PURE__ */ new Map();
 var TypeParser = Tag("@effect/language-service/TypeParser");
 var nanoLayer3 = (fa) => gen(function* () {
   const ts = yield* service(TypeScriptApi);
@@ -2583,6 +2592,40 @@ function typeParserIssue(_message, _type, _node) {
   return TypeParserIssue.issue;
 }
 function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
+  function supportedEffect() {
+    for (const fileName of program.getRootFileNames()) {
+      const sourceFile = program.getSourceFile(fileName);
+      if (!sourceFile) continue;
+      const resolvedPackages = getEffectRelatedPackages(sourceFile);
+      for (const version of Object.keys(resolvedPackages["effect"])) {
+        if (String(version).startsWith("4")) return "v4";
+        if (String(version).startsWith("3")) return "v3";
+      }
+    }
+    return "v3";
+  }
+  function getEffectRelatedPackages(sourceFile) {
+    let resolvedPackages = checkedPackagesCache.get(sourceFile.fileName) || {};
+    const newResolvedModuleSize = hasProperty(program, "resolvedModules") && hasProperty(program.resolvedModules, "size") && isNumber(program.resolvedModules.size) ? program.resolvedModules.size : 0;
+    const oldResolvedSize = programResolvedCacheSize.get(sourceFile.fileName) || -1;
+    if (newResolvedModuleSize !== oldResolvedSize) {
+      const seenPackages = /* @__PURE__ */ new Set();
+      resolvedPackages = {};
+      program.getSourceFiles().map((_) => {
+        const packageInfo = tsUtils.parsePackageContentNameAndVersionFromScope(_);
+        if (!packageInfo) return;
+        const packageNameAndVersion = packageInfo.name + "@" + packageInfo.version;
+        if (seenPackages.has(packageNameAndVersion)) return;
+        seenPackages.add(packageNameAndVersion);
+        if (!(packageInfo.name === "effect" || packageInfo.hasEffectInPeerDependencies)) return;
+        resolvedPackages[packageInfo.name] = resolvedPackages[packageInfo.name] || {};
+        resolvedPackages[packageInfo.name][packageInfo.version] = packageInfo.packageDirectory;
+      });
+      checkedPackagesCache.set(sourceFile.fileName, resolvedPackages);
+      programResolvedCacheSize.set(sourceFile.fileName, newResolvedModuleSize);
+    }
+    return resolvedPackages;
+  }
   const getSourceFilePackageInfo = cachedBy(
     fn("TypeParser.getSourceFilePackageInfo")(function* (sourceFile) {
       return tsUtils.resolveModuleWithPackageInfoFromSourceFile(program, sourceFile);
@@ -2811,19 +2854,28 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
   );
   const effectType = cachedBy(
     fn("TypeParser.effectType")(function* (type, atLocation) {
-      const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
-        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration
-      );
-      if (propertiesSymbols.length === 0) {
-        return yield* typeParserIssue("Type has no effect variance struct", type, atLocation);
+      if (supportedEffect() === "v4") {
+        const typeIdSymbol = typeChecker.getPropertyOfType(type, "~effect/Effect");
+        if (typeIdSymbol) {
+          const typeIdType = typeChecker.getTypeOfSymbolAtLocation(typeIdSymbol, atLocation);
+          return yield* effectVarianceStruct(typeIdType, atLocation);
+        }
+        return yield* typeParserIssue("Type is not an effect", type, atLocation);
+      } else {
+        const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
+          (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration
+        );
+        if (propertiesSymbols.length === 0) {
+          return yield* typeParserIssue("Type has no effect variance struct", type, atLocation);
+        }
+        propertiesSymbols.sort(
+          (a, b) => ts.symbolName(b).indexOf("EffectTypeId") - ts.symbolName(a).indexOf("EffectTypeId")
+        );
+        return yield* firstSuccessOf(propertiesSymbols.map((propertySymbol) => {
+          const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
+          return effectVarianceStruct(propertyType, atLocation);
+        }));
       }
-      propertiesSymbols.sort(
-        (a, b) => ts.symbolName(b).indexOf("EffectTypeId") - ts.symbolName(a).indexOf("EffectTypeId")
-      );
-      return yield* firstSuccessOf(propertiesSymbols.map((propertySymbol) => {
-        const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
-        return effectVarianceStruct(propertyType, atLocation);
-      }));
     }),
     "TypeParser.effectType",
     (type) => type
@@ -3143,10 +3195,10 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
               }))
             )
           ),
-          option
+          orUndefined
         );
-        if (isSome2(isEffectGen)) {
-          effectGenResult = isEffectGen.value;
+        if (isEffectGen) {
+          effectGenResult = isEffectGen;
         }
       }
       if (scopeNode && effectGenResult) {
@@ -3266,6 +3318,21 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
   const effectSchemaType = cachedBy(
     fn("TypeParser.effectSchemaType")(function* (type, atLocation) {
       yield* pipeableType(type, atLocation);
+      const typeId = typeChecker.getPropertyOfType(type, "~effect/Schema/Schema");
+      if (typeId) {
+        const typeKey = typeChecker.getPropertyOfType(type, "Type");
+        const encodedKey = typeChecker.getPropertyOfType(type, "Encoded");
+        if (typeKey && encodedKey) {
+          const typeType = typeChecker.getTypeOfSymbolAtLocation(typeKey, atLocation);
+          const encodedType = typeChecker.getTypeOfSymbolAtLocation(encodedKey, atLocation);
+          return {
+            A: typeType,
+            I: encodedType,
+            R: typeChecker.getNeverType()
+          };
+        }
+        return yield* typeParserIssue("missing Type and Encoded");
+      }
       const ast = typeChecker.getPropertyOfType(type, "ast");
       if (!ast) return yield* typeParserIssue("Has no 'ast' property", type, atLocation);
       const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
@@ -3484,9 +3551,9 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
               if (ts.isCallExpression(schemaCall) && schemaCall.typeArguments && schemaCall.typeArguments.length > 0) {
                 const isEffectSchemaModuleApi = yield* pipe(
                   isNodeReferenceToEffectSchemaModuleApi("Class")(schemaCall.expression),
-                  option
+                  orUndefined
                 );
-                if (isSome2(isEffectSchemaModuleApi)) {
+                if (isEffectSchemaModuleApi) {
                   return {
                     className: atLocation.name,
                     selfTypeNode: schemaCall.typeArguments[0]
@@ -3521,9 +3588,9 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
                 const selfTypeNode = schemaTaggedClassTCall.typeArguments[0];
                 const isEffectSchemaModuleApi = yield* pipe(
                   isNodeReferenceToEffectSchemaModuleApi("TaggedClass")(schemaTaggedClassTCall.expression),
-                  option
+                  orUndefined
                 );
-                if (isSome2(isEffectSchemaModuleApi)) {
+                if (isEffectSchemaModuleApi) {
                   return {
                     className: atLocation.name,
                     selfTypeNode,
@@ -3560,9 +3627,9 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
                 const selfTypeNode = schemaTaggedErrorTCall.typeArguments[0];
                 const isEffectSchemaModuleApi = yield* pipe(
                   isNodeReferenceToEffectSchemaModuleApi("TaggedError")(schemaTaggedErrorTCall.expression),
-                  option
+                  orUndefined
                 );
-                if (isSome2(isEffectSchemaModuleApi)) {
+                if (isEffectSchemaModuleApi) {
                   return {
                     className: atLocation.name,
                     selfTypeNode,
@@ -3582,6 +3649,9 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
   );
   const extendsSchemaTaggedRequest = cachedBy(
     fn("TypeParser.extendsSchemaTaggedRequest")(function* (atLocation) {
+      if (supportedEffect() === "v4") {
+        return yield* typeParserIssue("Schema.TaggedClass is not supported in Effect v4", void 0, atLocation);
+      }
       if (!atLocation.name) {
         return yield* typeParserIssue("Class has no name", void 0, atLocation);
       }
@@ -3599,9 +3669,9 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
                 const selfTypeNode = schemaTaggedRequestTCall.typeArguments[0];
                 const isEffectSchemaModuleApi = yield* pipe(
                   isNodeReferenceToEffectSchemaModuleApi("TaggedRequest")(schemaTaggedRequestTCall.expression),
-                  option
+                  orUndefined
                 );
-                if (isSome2(isEffectSchemaModuleApi)) {
+                if (isEffectSchemaModuleApi) {
                   return {
                     className: atLocation.name,
                     selfTypeNode,
@@ -3619,6 +3689,48 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     "TypeParser.extendsSchemaTaggedRequest",
     (atLocation) => atLocation
   );
+  const extendsSchemaRequestClass = cachedBy(
+    fn("TypeParser.extendsSchemaRequestClass")(function* (atLocation) {
+      if (supportedEffect() === "v3") {
+        return yield* typeParserIssue("Schema.RequestClass is not supported in Effect v3", void 0, atLocation);
+      }
+      if (!atLocation.name) {
+        return yield* typeParserIssue("Class has no name", void 0, atLocation);
+      }
+      const heritageClauses = atLocation.heritageClauses;
+      if (!heritageClauses) {
+        return yield* typeParserIssue("Class has no heritage clauses", void 0, atLocation);
+      }
+      for (const heritageClause of heritageClauses) {
+        for (const typeX of heritageClause.types) {
+          if (ts.isExpressionWithTypeArguments(typeX)) {
+            const expression = typeX.expression;
+            if (ts.isCallExpression(expression)) {
+              const schemaTaggedRequestTCall = expression.expression;
+              if (ts.isCallExpression(schemaTaggedRequestTCall) && schemaTaggedRequestTCall.typeArguments && schemaTaggedRequestTCall.typeArguments.length > 0) {
+                const selfTypeNode = schemaTaggedRequestTCall.typeArguments[0];
+                const isEffectSchemaModuleApi = yield* pipe(
+                  isNodeReferenceToEffectSchemaModuleApi("RequestClass")(schemaTaggedRequestTCall.expression),
+                  orUndefined
+                );
+                if (isEffectSchemaModuleApi) {
+                  return {
+                    className: atLocation.name,
+                    selfTypeNode,
+                    tagStringLiteral: void 0,
+                    keyStringLiteral: schemaTaggedRequestTCall.arguments.length > 0 && ts.isStringLiteral(schemaTaggedRequestTCall.arguments[0]) ? schemaTaggedRequestTCall.arguments[0] : void 0
+                  };
+                }
+              }
+            }
+          }
+        }
+      }
+      return yield* typeParserIssue("Class does not extend Schema.RequestClass", void 0, atLocation);
+    }),
+    "TypeParser.extendsSchemaRequestClass",
+    (atLocation) => atLocation
+  );
   const extendsDataTaggedError = cachedBy(
     fn("TypeParser.extendsDataTaggedError")(function* (atLocation) {
       if (!atLocation.name) {
@@ -3638,13 +3750,13 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
               if (ts.isPropertyAccessExpression(dataIdentifier) && ts.isIdentifier(dataIdentifier.name) && ts.idText(dataIdentifier.name) === "TaggedError") {
                 const parsedDataModule = yield* pipe(
                   importedDataModule(dataIdentifier.expression),
-                  option
+                  orUndefined
                 );
-                if (isSome2(parsedDataModule)) {
+                if (parsedDataModule) {
                   return {
                     className: atLocation.name,
                     keyStringLiteral: dataTaggedErrorCall.arguments.length > 0 && ts.isStringLiteral(dataTaggedErrorCall.arguments[0]) ? dataTaggedErrorCall.arguments[0] : void 0,
-                    Data: parsedDataModule.value
+                    Data: parsedDataModule
                   };
                 }
               }
@@ -3676,13 +3788,13 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
               if (ts.isPropertyAccessExpression(dataIdentifier) && ts.isIdentifier(dataIdentifier.name) && ts.idText(dataIdentifier.name) === "TaggedClass") {
                 const parsedDataModule = yield* pipe(
                   importedDataModule(dataIdentifier.expression),
-                  option
+                  orUndefined
                 );
-                if (isSome2(parsedDataModule)) {
+                if (parsedDataModule) {
                   return {
                     className: atLocation.name,
                     keyStringLiteral: dataTaggedClassCall.arguments.length > 0 && ts.isStringLiteral(dataTaggedClassCall.arguments[0]) ? dataTaggedClassCall.arguments[0] : void 0,
-                    Data: parsedDataModule.value
+                    Data: parsedDataModule
                   };
                 }
               }
@@ -3716,9 +3828,9 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
                 if (ts.isPropertyAccessExpression(contextTagIdentifier) && ts.isIdentifier(contextTagIdentifier.name) && ts.idText(contextTagIdentifier.name) === "Tag") {
                   const parsedContextModule = yield* pipe(
                     importedContextModule(contextTagIdentifier.expression),
-                    option
+                    orUndefined
                   );
-                  if (isSome2(parsedContextModule)) {
+                  if (parsedContextModule) {
                     const classSym = typeChecker.getSymbolAtLocation(atLocation.name);
                     if (!classSym) return yield* typeParserIssue("Class has no symbol", void 0, atLocation);
                     const type = typeChecker.getTypeOfSymbol(classSym);
@@ -3729,7 +3841,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
                       keyStringLiteral: ts.isStringLiteral(contextTagCall.arguments[0]) ? contextTagCall.arguments[0] : void 0,
                       args: contextTagCall.arguments,
                       Identifier: tagType.Identifier,
-                      Tag: parsedContextModule.value
+                      Tag: parsedContextModule
                     };
                   }
                 }
@@ -3767,9 +3879,9 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
                 const selfTypeNode = wholeCall.typeArguments[0];
                 const isEffectTag = yield* pipe(
                   isNodeReferenceToEffectModuleApi("Tag")(effectTagIdentifier),
-                  option
+                  orUndefined
                 );
-                if (isSome2(isEffectTag)) {
+                if (isEffectTag) {
                   return {
                     className: atLocation.name,
                     selfTypeNode,
@@ -3809,17 +3921,17 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
                 const selfTypeNode = effectServiceCall.typeArguments[0];
                 const isEffectService = yield* pipe(
                   isNodeReferenceToEffectModuleApi("Service")(effectServiceIdentifier),
-                  option
+                  orUndefined
                 );
-                if (isSome2(isEffectService)) {
+                if (isEffectService) {
                   const classSym = typeChecker.getSymbolAtLocation(atLocation.name);
                   if (!classSym) return yield* typeParserIssue("Class has no symbol", void 0, atLocation);
                   const type = typeChecker.getTypeOfSymbol(classSym);
                   const parsedContextTag = yield* pipe(
                     contextTag(type, atLocation),
-                    option
+                    orUndefined
                   );
-                  if (isSome2(parsedContextTag)) {
+                  if (parsedContextTag) {
                     let accessors2 = void 0;
                     let dependencies = void 0;
                     if (wholeCall.arguments.length >= 2) {
@@ -3836,7 +3948,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
                       }
                     }
                     return {
-                      ...parsedContextTag.value,
+                      ...parsedContextTag,
                       className: atLocation.name,
                       selfTypeNode,
                       args: wholeCall.arguments,
@@ -3906,9 +4018,9 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
               if (ts.isCallExpression(schemaCall) && schemaCall.typeArguments && schemaCall.typeArguments.length > 0) {
                 const isEffectSchemaModuleApi = yield* pipe(
                   isNodeReferenceToEffectSqlModelModuleApi("Class")(schemaCall.expression),
-                  option
+                  orUndefined
                 );
-                if (isSome2(isEffectSchemaModuleApi)) {
+                if (isEffectSchemaModuleApi) {
                   return {
                     className: atLocation.name,
                     selfTypeNode: schemaCall.typeArguments[0]
@@ -4031,19 +4143,18 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
                 map4((s) => ({ _tag: "call", ...s }))
               )
             ),
-            option
+            orUndefined
           );
-          if (isSome2(parsed)) {
-            const result2 = parsed.value;
+          if (parsed) {
             let transformations;
             let flowNode;
             let childrenToTraverse = [];
-            if (result2._tag === "pipe") {
-              const signature = typeChecker.getResolvedSignature(result2.node);
+            if (parsed._tag === "pipe") {
+              const signature = typeChecker.getResolvedSignature(parsed.node);
               const typeArguments = signature ? typeChecker.getTypeArgumentsForResolvedSignature(signature) : void 0;
               transformations = [];
-              for (let i = 0; i < result2.args.length; i++) {
-                const arg = result2.args[i];
+              for (let i = 0; i < parsed.args.length; i++) {
+                const arg = parsed.args[i];
                 const outType = typeArguments?.[i + 1];
                 if (ts.isCallExpression(arg)) {
                   transformations.push({
@@ -4052,7 +4163,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
                     args: Array.from(arg.arguments),
                     // e.g., [(x) => x + 1]
                     outType,
-                    kind: result2.kind
+                    kind: parsed.kind
                   });
                 } else {
                   transformations.push({
@@ -4060,17 +4171,17 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
                     // e.g., Effect.asVoid
                     args: void 0,
                     outType,
-                    kind: result2.kind
+                    kind: parsed.kind
                   });
                 }
               }
-              flowNode = result2.node;
-              childrenToTraverse = result2.args;
+              flowNode = parsed.node;
+              childrenToTraverse = parsed.args;
             } else {
               const callSignature = typeChecker.getResolvedSignature(node);
               const outType = callSignature ? typeChecker.getReturnTypeOfSignature(callSignature) : void 0;
               transformations = [{
-                callee: result2.callee,
+                callee: parsed.callee,
                 args: void 0,
                 outType,
                 kind: "call"
@@ -4080,20 +4191,20 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
             if (parentFlow) {
               parentFlow.transformations.unshift(...transformations);
               parentFlow.subject = {
-                node: result2.subject,
-                outType: typeCheckerUtils.getTypeAtLocation(result2.subject)
+                node: parsed.subject,
+                outType: typeCheckerUtils.getTypeAtLocation(parsed.subject)
               };
-              workQueue.push([result2.subject, parentFlow]);
+              workQueue.push([parsed.subject, parentFlow]);
             } else {
               const newFlow = {
                 node: flowNode,
                 subject: {
-                  node: result2.subject,
-                  outType: typeCheckerUtils.getTypeAtLocation(result2.subject)
+                  node: parsed.subject,
+                  outType: typeCheckerUtils.getTypeAtLocation(parsed.subject)
                 },
                 transformations
               };
-              workQueue.push([result2.subject, newFlow]);
+              workQueue.push([parsed.subject, newFlow]);
             }
             for (const child of childrenToTraverse) {
               ts.forEachChild(child, (c) => {
@@ -4103,17 +4214,17 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
             continue;
           }
           if (includeEffectFn) {
-            const effectFnGenParsed = yield* pipe(effectFnGen(node), option);
-            const effectFnUntracedGenParsed = isNone2(effectFnGenParsed) ? yield* pipe(effectFnUntracedGen(node), option) : none2();
-            const effectFnNonGenParsed = isNone2(effectFnGenParsed) && isNone2(effectFnUntracedGenParsed) ? yield* pipe(effectFn(node), option) : none2();
-            const isEffectFnGen = isSome2(effectFnGenParsed);
-            const isEffectFnUntracedGen = isSome2(effectFnUntracedGenParsed);
-            const isEffectFnNonGen = isSome2(effectFnNonGenParsed);
-            const transformationKind = isEffectFnUntracedGen ? "effectFnUntraced" : "effectFn";
-            if (isEffectFnGen || isEffectFnUntracedGen) {
-              const effectFnParsed = isEffectFnGen ? effectFnGenParsed : effectFnUntracedGenParsed;
-              if (isSome2(effectFnParsed) && effectFnParsed.value.pipeArguments.length > 0) {
-                const fnResult = effectFnParsed.value;
+            const effectFnKind = yield* pipe(
+              map4(effectFnGen(node), (_) => ({ kind: "effectFnGen", ..._ })),
+              orElse2(
+                () => map4(effectFnUntracedGen(node), (_) => ({ kind: "effectFnUntracedGen", ..._ }))
+              ),
+              orElse2(() => map4(effectFn(node), (_) => ({ kind: "effectFn", ..._ }))),
+              orUndefined
+            );
+            if (effectFnKind && (effectFnKind.kind === "effectFnGen" || effectFnKind.kind === "effectFnUntracedGen")) {
+              if (effectFnKind.pipeArguments.length > 0) {
+                const fnResult = effectFnKind;
                 const pipeArgs = fnResult.pipeArguments;
                 const transformations = [];
                 let subjectType;
@@ -4133,14 +4244,14 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
                       callee: arg.expression,
                       args: Array.from(arg.arguments),
                       outType,
-                      kind: transformationKind
+                      kind: effectFnKind.kind === "effectFnUntracedGen" ? "effectFnUntraced" : "effectFn"
                     });
                   } else {
                     transformations.push({
                       callee: arg,
                       args: void 0,
                       outType,
-                      kind: transformationKind
+                      kind: effectFnKind.kind === "effectFnUntracedGen" ? "effectFnUntraced" : "effectFn"
                     });
                   }
                 }
@@ -4162,8 +4273,8 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
                 continue;
               }
             }
-            if (isEffectFnNonGen && isSome2(effectFnNonGenParsed) && effectFnNonGenParsed.value.pipeArguments.length > 0) {
-              const fnResult = effectFnNonGenParsed.value;
+            if (effectFnKind && effectFnKind.kind === "effectFn" && effectFnKind.pipeArguments.length > 0) {
+              const fnResult = effectFnKind;
               const pipeArgs = fnResult.pipeArguments;
               const transformations = [];
               let subjectType;
@@ -4309,11 +4420,14 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     extendsDataTaggedError,
     extendsDataTaggedClass,
     extendsSchemaTaggedRequest,
+    extendsSchemaRequestClass,
     extendsEffectSqlModelClass,
     lazyExpression,
     emptyFunction,
     pipingFlows,
-    reconstructPipingFlow
+    reconstructPipingFlow,
+    getEffectRelatedPackages,
+    supportedEffect
   };
 }
 
@@ -4429,6 +4543,7 @@ var catchAllToMapError = createDiagnostic({
   apply: fn("catchAllToMapError.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
+    const catchAllName = typeParser.supportedEffect() === "v3" ? "catchAll" : "catch";
     const getFunctionBody = (node) => {
       if (ts.isArrowFunction(node)) {
         return node.body;
@@ -4443,10 +4558,10 @@ var catchAllToMapError = createDiagnostic({
         if (ts.isCallExpression(body)) {
           const isFailCall = yield* pipe(
             typeParser.isNodeReferenceToEffectModuleApi("fail")(body.expression),
-            option
+            orUndefined
           );
-          if (isSome2(isFailCall) && body.arguments.length >= 1) {
-            return some2({ failCall: body, failArg: body.arguments[0] });
+          if (isFailCall && body.arguments.length >= 1) {
+            return { failCall: body, failArg: body.arguments[0] };
           }
         }
         if (ts.isBlock(body)) {
@@ -4456,15 +4571,14 @@ var catchAllToMapError = createDiagnostic({
             if (ts.isReturnStatement(stmt) && stmt.expression && ts.isCallExpression(stmt.expression)) {
               const isFailCall = yield* pipe(
                 typeParser.isNodeReferenceToEffectModuleApi("fail")(stmt.expression.expression),
-                option
+                orUndefined
               );
-              if (isSome2(isFailCall) && stmt.expression.arguments.length >= 1) {
-                return some2({ failCall: stmt.expression, failArg: stmt.expression.arguments[0] });
+              if (isFailCall && stmt.expression.arguments.length >= 1) {
+                return { failCall: stmt.expression, failArg: stmt.expression.arguments[0] };
               }
             }
           }
         }
-        return none2();
       });
     };
     const flows = yield* typeParser.pipingFlows(true)(sourceFile);
@@ -4474,10 +4588,10 @@ var catchAllToMapError = createDiagnostic({
           continue;
         }
         const isCatchAllCall = yield* pipe(
-          typeParser.isNodeReferenceToEffectModuleApi("catchAll")(transformation.callee),
-          option
+          typeParser.isNodeReferenceToEffectModuleApi(catchAllName)(transformation.callee),
+          orUndefined
         );
-        if (isNone2(isCatchAllCall)) {
+        if (!isCatchAllCall) {
           continue;
         }
         const callback = transformation.args[0];
@@ -4485,11 +4599,11 @@ var catchAllToMapError = createDiagnostic({
         const functionBody = getFunctionBody(callback);
         if (!functionBody) continue;
         const failCallInfo = yield* getEffectFailCallInfo(functionBody);
-        if (isNone2(failCallInfo)) continue;
-        const { failArg, failCall } = failCallInfo.value;
+        if (!failCallInfo) continue;
+        const { failArg, failCall } = failCallInfo;
         report({
           location: transformation.callee,
-          messageText: `You can use Effect.mapError instead of Effect.catchAll + Effect.fail to transform the error type.`,
+          messageText: `You can use Effect.mapError instead of Effect.${catchAllName} + Effect.fail to transform the error type.`,
           fixes: [{
             fixName: "catchAllToMapError_fix",
             description: "Replace with Effect.mapError",
@@ -4520,7 +4634,7 @@ var catchUnfailableEffect = createDiagnostic({
   apply: fn("catchUnfailableEffect.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
-    const catchFunctions = ["catchAll", "catch", "catchIf", "catchSome", "catchTag", "catchTags"];
+    const catchFunctions = typeParser.supportedEffect() === "v3" ? ["catchAll", "catch", "catchIf", "catchSome", "catchTag", "catchTags"] : ["catch", "catchIf", "catchTag", "catchTags"];
     const flows = yield* typeParser.pipingFlows(true)(sourceFile);
     for (const flow2 of flows) {
       for (let i = 0; i < flow2.transformations.length; i++) {
@@ -4585,7 +4699,12 @@ var classSelfMismatch = createDiagnostic({
           orElse2(() => typeParser.extendsSchemaClass(node)),
           orElse2(() => typeParser.extendsSchemaTaggedClass(node)),
           orElse2(() => typeParser.extendsSchemaTaggedError(node)),
-          orElse2(() => typeParser.extendsSchemaTaggedRequest(node)),
+          orElse2(
+            () => pipe(
+              typeParser.extendsSchemaTaggedRequest(node),
+              orElse2(() => typeParser.extendsSchemaRequestClass(node))
+            )
+          ),
           orElse2(() => typeParser.extendsEffectSqlModelClass(node)),
           orElse2(() => void_)
         );
@@ -4812,39 +4931,18 @@ var deterministicKeys = createDiagnostic({
 });
 
 // src/diagnostics/duplicatePackage.ts
-var checkedPackagesCache = /* @__PURE__ */ new Map();
-var programResolvedCacheSize = /* @__PURE__ */ new Map();
 var duplicatePackage = createDiagnostic({
   name: "duplicatePackage",
   code: 6,
   description: "Detects when multiple versions of the same Effect package are loaded",
   severity: "warning",
   apply: fn("duplicatePackage.apply")(function* (sourceFile, report) {
-    const program = yield* service(TypeScriptProgram);
-    const tsUtils = yield* service(TypeScriptUtils);
+    const typeParser = yield* service(TypeParser);
     const options = yield* service(LanguageServicePluginOptions);
     if (sourceFile.statements.length < 1) return;
-    let resolvedPackages = checkedPackagesCache.get(sourceFile.fileName) || {};
-    const newResolvedModuleSize = hasProperty(program, "resolvedModules") && hasProperty(program.resolvedModules, "size") && isNumber(program.resolvedModules.size) ? program.resolvedModules.size : 0;
-    const oldResolvedSize = programResolvedCacheSize.get(sourceFile.fileName) || -1;
-    if (newResolvedModuleSize !== oldResolvedSize) {
-      const seenPackages = /* @__PURE__ */ new Set();
-      resolvedPackages = {};
-      program.getSourceFiles().map((_) => {
-        const packageInfo = tsUtils.parsePackageContentNameAndVersionFromScope(_);
-        if (!packageInfo) return;
-        const packageNameAndVersion = packageInfo.name + "@" + packageInfo.version;
-        if (seenPackages.has(packageNameAndVersion)) return;
-        seenPackages.add(packageNameAndVersion);
-        if (!(packageInfo.name === "effect" || packageInfo.hasEffectInPeerDependencies)) return;
-        if (options.allowedDuplicatedPackages.indexOf(packageInfo.name) > -1) return;
-        resolvedPackages[packageInfo.name] = resolvedPackages[packageInfo.name] || {};
-        resolvedPackages[packageInfo.name][packageInfo.version] = packageInfo.packageDirectory;
-      });
-      checkedPackagesCache.set(sourceFile.fileName, resolvedPackages);
-      programResolvedCacheSize.set(sourceFile.fileName, newResolvedModuleSize);
-    }
+    const resolvedPackages = typeParser.getEffectRelatedPackages(sourceFile);
     for (const packageName of Object.keys(resolvedPackages)) {
+      if (options.allowedDuplicatedPackages.indexOf(packageName) > -1) return;
       if (Object.keys(resolvedPackages[packageName]).length > 1) {
         const versions = Object.keys(resolvedPackages[packageName]);
         report({
@@ -5668,23 +5766,25 @@ var globalErrorInEffectCatch = createDiagnostic({
         if (isEffectWithCatch) {
           const signature = typeChecker.getResolvedSignature(node);
           if (signature) {
-            const objectType = typeChecker.getParameterType(signature, 0);
-            const catchFunctionSymbol = typeChecker.getPropertyOfType(objectType, "catch");
-            if (catchFunctionSymbol) {
-              const catchFunctionType = typeChecker.getTypeOfSymbolAtLocation(catchFunctionSymbol, node);
-              const signatures = typeChecker.getSignaturesOfType(catchFunctionType, ts.SignatureKind.Call);
-              if (signatures.length > 0) {
-                const returnType = typeChecker.getReturnTypeOfSignature(signatures[0]);
-                if (returnType && typeCheckerUtils.isGlobalErrorType(returnType)) {
-                  const nodeText = sourceFile.text.substring(
-                    ts.getTokenPosOfNode(node.expression, sourceFile),
-                    node.expression.end
-                  );
-                  report({
-                    location: node.expression,
-                    messageText: `The 'catch' callback in ${nodeText} returns global 'Error', which loses type safety as untagged errors merge together. Consider using a tagged error and optionally wrapping the original in a 'cause' property.`,
-                    fixes: []
-                  });
+            const firstParameterType = typeChecker.getParameterType(signature, 0);
+            for (const objectType of typeCheckerUtils.unrollUnionMembers(firstParameterType)) {
+              const catchFunctionSymbol = typeChecker.getPropertyOfType(objectType, "catch");
+              if (catchFunctionSymbol) {
+                const catchFunctionType = typeChecker.getTypeOfSymbolAtLocation(catchFunctionSymbol, node);
+                const signatures = typeChecker.getSignaturesOfType(catchFunctionType, ts.SignatureKind.Call);
+                if (signatures.length > 0) {
+                  const returnType = typeChecker.getReturnTypeOfSignature(signatures[0]);
+                  if (returnType && typeCheckerUtils.isGlobalErrorType(returnType)) {
+                    const nodeText = sourceFile.text.substring(
+                      ts.getTokenPosOfNode(node.expression, sourceFile),
+                      node.expression.end
+                    );
+                    report({
+                      location: node.expression,
+                      messageText: `The 'catch' callback in ${nodeText} returns global 'Error', which loses type safety as untagged errors merge together. Consider using a tagged error and optionally wrapping the original in a 'cause' property.`,
+                      fixes: []
+                    });
+                  }
                 }
               }
             }
@@ -6497,22 +6597,23 @@ var missingEffectError = createDiagnostic({
           map4((result) => {
             if (result.missingErrorTypes.length === 0) return;
             const fixes = [];
-            if (ts.isExpression(valueNode) && result.expectedErrorType.flags & ts.TypeFlags.Never) {
+            const catchAllErrorsName = typeParser.supportedEffect() === "v3" ? "catchAll" : "catch";
+            if (ts.isExpression(valueNode) && result.expectedErrorType.flags & ts.TypeFlags.Never && catchAllErrorsName) {
               fixes.push({
-                fixName: "missingEffectError_catchAll",
-                description: "Catch all errors with Effect.catchAll",
+                fixName: `missingEffectError_${catchAllErrorsName}`,
+                description: `Catch all errors with Effect.${catchAllErrorsName}`,
                 apply: gen(function* () {
                   const changeTracker = yield* service(ChangeTracker);
                   changeTracker.insertText(
                     sourceFile,
                     ts.getTokenPosOfNode(valueNode, sourceFile),
-                    effectModuleIdentifier + ".catchAll("
+                    effectModuleIdentifier + `.${catchAllErrorsName}(`
                   );
                   changeTracker.insertText(sourceFile, valueNode.end, ", () => ");
                   changeTracker.insertNodeAt(
                     sourceFile,
                     valueNode.end,
-                    createDieMessage("TODO: catchAll not implemented")
+                    createDieMessage(`TODO: ${catchAllErrorsName} not implemented`)
                   );
                   changeTracker.insertText(sourceFile, valueNode.end, ")");
                 })
@@ -6594,6 +6695,7 @@ var missingEffectServiceDependency = createDiagnostic({
     const typeChecker = yield* service(TypeCheckerApi);
     const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const typeParser = yield* service(TypeParser);
+    if (typeParser.supportedEffect() !== "v3") return;
     const nodeToVisit = [];
     const appendNodeToVisit = (node) => {
       nodeToVisit.push(node);
@@ -8813,6 +8915,7 @@ var scopeInLayerEffect = createDiagnostic({
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
     const typeCheckerUtils = yield* service(TypeCheckerUtils);
+    if (typeParser.supportedEffect() !== "v3") return;
     const layerModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
       sourceFile,
       "effect",
@@ -9021,6 +9124,17 @@ var tryCatchInEffectGen = createDiagnostic({
   apply: fn("tryCatchInEffectGen.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
+    const alternatives = typeParser.supportedEffect() === "v4" ? [
+      "Effect.try",
+      "Effect.tryPromise",
+      "Effect.catch",
+      "Effect.catchTag"
+    ] : [
+      "Effect.try",
+      "Effect.tryPromise",
+      "Effect.catchAll",
+      "Effect.catchTag"
+    ];
     const nodeToVisit = [];
     const appendNodeToVisit = (node) => {
       nodeToVisit.push(node);
@@ -9046,7 +9160,7 @@ var tryCatchInEffectGen = createDiagnostic({
             map4(() => {
               report({
                 location: node,
-                messageText: "Avoid using try/catch inside Effect generators. Use Effect's error handling mechanisms instead (e.g., Effect.try, Effect.tryPromise, Effect.catchAll, Effect.catchTag).",
+                messageText: `Avoid using try/catch inside Effect generators. Use Effect's error handling mechanisms instead (e.g. ${alternatives.join(", ")}).`,
                 fixes: []
               });
             }),
@@ -9068,6 +9182,7 @@ var unknownInEffectCatch = createDiagnostic({
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
     const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const nodeToVisit = [];
     const appendNodeToVisit = (node) => {
       nodeToVisit.push(node);
@@ -9088,24 +9203,26 @@ var unknownInEffectCatch = createDiagnostic({
         if (isEffectWithCatch) {
           const signature = typeChecker.getResolvedSignature(node);
           if (signature) {
-            const objectType = typeChecker.getParameterType(signature, 0);
-            const catchFunctionSymbol = typeChecker.getPropertyOfType(objectType, "catch");
-            if (catchFunctionSymbol) {
-              const catchFunctionType = typeChecker.getTypeOfSymbolAtLocation(catchFunctionSymbol, node);
-              const signatures = typeChecker.getSignaturesOfType(catchFunctionType, ts.SignatureKind.Call);
-              if (signatures.length > 0) {
-                const returnType = typeChecker.getReturnTypeOfSignature(signatures[0]);
-                if (returnType && (returnType.flags & ts.TypeFlags.Unknown || returnType.flags & ts.TypeFlags.Any)) {
-                  const nodeText = sourceFile.text.substring(
-                    ts.getTokenPosOfNode(node.expression, sourceFile),
-                    node.expression.end
-                  );
-                  report({
-                    location: node.expression,
-                    messageText: `The 'catch' callback in ${nodeText} returns 'unknown'. The catch callback should be used to provide typed errors.
+            const parameterType = typeChecker.getParameterType(signature, 0);
+            for (const objectType of typeCheckerUtils.unrollUnionMembers(parameterType)) {
+              const catchFunctionSymbol = typeChecker.getPropertyOfType(objectType, "catch");
+              if (catchFunctionSymbol) {
+                const catchFunctionType = typeChecker.getTypeOfSymbolAtLocation(catchFunctionSymbol, node);
+                const signatures = typeChecker.getSignaturesOfType(catchFunctionType, ts.SignatureKind.Call);
+                if (signatures.length > 0) {
+                  const returnType = typeChecker.getReturnTypeOfSignature(signatures[0]);
+                  if (returnType && (returnType.flags & ts.TypeFlags.Unknown || returnType.flags & ts.TypeFlags.Any)) {
+                    const nodeText = sourceFile.text.substring(
+                      ts.getTokenPosOfNode(node.expression, sourceFile),
+                      node.expression.end
+                    );
+                    report({
+                      location: node.expression,
+                      messageText: `The 'catch' callback in ${nodeText} returns 'unknown'. The catch callback should be used to provide typed errors.
 Consider wrapping unknown errors into Effect's Data.TaggedError for example, or narrow down the type to the specific error raised.`,
-                    fixes: []
-                  });
+                      fixes: []
+                    });
+                  }
                 }
               }
             }