@effect/language-service 0.72.0 → 0.73.0

package/transform.js

@@ -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,42 @@ 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);
+      const effectPkgs = resolvedPackages["effect"];
+      if (!effectPkgs) continue;
+      for (const version of Object.keys(effectPkgs)) {
+        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 +2856,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
@@ -2952,7 +3006,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     fn("TypeParser.isEffectDataSourceFile")(function* (sourceFile) {
       const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
       if (!moduleSymbol) return yield* typeParserIssue("Node has no symbol", void 0, sourceFile);
-      const taggedEnumSymbol = typeChecker.tryGetMemberInModuleExports("TaggedEnum", moduleSymbol);
+      const taggedEnumSymbol = typeChecker.tryGetMemberInModuleExports("TaggedEnum", moduleSymbol) || typeChecker.tryGetMemberInModuleExports("taggedEnum", moduleSymbol);
       if (!taggedEnumSymbol) return yield* typeParserIssue("TaggedEnum not found", void 0, sourceFile);
       const taggedErrorSymbol = typeChecker.tryGetMemberInModuleExports("TaggedError", moduleSymbol);
       if (!taggedErrorSymbol) return yield* typeParserIssue("TaggedError not found", void 0, sourceFile);
@@ -3143,10 +3197,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 +3320,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 +3553,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 +3590,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 +3629,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 +3651,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 +3671,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 +3691,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 +3752,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 +3790,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 +3830,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 +3843,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 +3881,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 +3923,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 +3950,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
                       }
                     }
                     return {
-                      ...parsedContextTag.value,
+                      ...parsedContextTag,
                       className: atLocation.name,
                       selfTypeNode,
                       args: wholeCall.arguments,
@@ -3906,9 +4020,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 +4145,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 +4165,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 +4173,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 +4193,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 +4216,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 +4246,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 +4275,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 +4422,14 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     extendsDataTaggedError,
     extendsDataTaggedClass,
     extendsSchemaTaggedRequest,
+    extendsSchemaRequestClass,
     extendsEffectSqlModelClass,
     lazyExpression,
     emptyFunction,
     pipingFlows,
-    reconstructPipingFlow
+    reconstructPipingFlow,
+    getEffectRelatedPackages,
+    supportedEffect
   };
 }
 
@@ -4429,6 +4545,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 +4560,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 +4573,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 +4590,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 +4601,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 +4636,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 +4701,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 +4933,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 +5768,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 +6599,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 +6697,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 +8917,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 +9126,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 +9162,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 +9184,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 +9205,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: []
+                    });
+                  }
                 }
               }
             }