@effect/language-service 0.72.0 → 0.73.0

package/cli.js

@@ -30214,7 +30214,7 @@ var runMain3 = runMain2;
 // package.json
 var package_default = {
   name: "@effect/language-service",
-  version: "0.72.0",
+  version: "0.73.0",
   publishConfig: {
     access: "public",
     directory: "dist"
@@ -30255,41 +30255,18 @@ var package_default = {
     perf: "tsx test/perf.ts"
   },
   devDependencies: {
+    pako: "^2.1.0",
+    "@typescript-eslint/project-service": "^8.52.0",
     "@effect/cli": "^0.73.0",
-    "@effect/eslint-plugin": "^0.3.2",
     "@effect/experimental": "^0.58.0",
-    "@effect/language-service": "link:dist",
     "@effect/platform": "0.94.1",
     "@effect/platform-node": "0.104.0",
     "@effect/printer-ansi": "^0.47.0",
     "@effect/rpc": "^0.73.0",
     "@effect/sql": "^0.49.0",
-    "@eslint/compat": "^2.0.1",
-    "@eslint/eslintrc": "^3.3.3",
-    "@eslint/js": "^9.39.2",
-    "@rollup/pluginutils": "^5.3.0",
-    "@types/node": "^25.0.6",
     "@types/pako": "^2.0.4",
-    "@typescript-eslint/eslint-plugin": "^8.52.0",
-    "@typescript-eslint/parser": "^8.52.0",
-    "@typescript-eslint/project-service": "^8.52.0",
-    "@vitest/coverage-v8": "^4.0.17",
     effect: "^3.19.14",
-    eslint: "^9.39.2",
-    "eslint-import-resolver-typescript": "^4.4.4",
-    "eslint-plugin-codegen": "^0.34.1",
-    "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-simple-import-sort": "^12.1.1",
-    "eslint-plugin-sort-destructure-keys": "^2.0.0",
-    madge: "^8.0.0",
-    pako: "^2.1.0",
-    rimraf: "^6.1.2",
-    "ts-patch": "^3.3.0",
-    tsup: "^8.5.1",
-    tsx: "^4.21.0",
-    typescript: "^5.9.3",
-    vite: "^7.3.1",
-    vitest: "^4.0.17"
+    "ts-patch": "^3.3.0"
   }
 };
 
@@ -31081,6 +31058,13 @@ var option5 = (fa) => {
   nano[contE] = (_) => _ instanceof NanoDefectException ? fail18(_) : succeed17(none2());
   return nano;
 };
+var orUndefined2 = (fa) => {
+  const nano = Object.create(MatchProto);
+  nano[args2] = fa;
+  nano[contA] = (_) => succeed17(_);
+  nano[contE] = (_) => _ instanceof NanoDefectException ? fail18(_) : succeed17(void 0);
+  return nano;
+};
 var ignore3 = (fa) => {
   const nano = Object.create(MatchProto);
   nano[args2] = fa;
@@ -31175,7 +31159,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");
@@ -32785,6 +32769,8 @@ function makeTypeCheckerUtils(ts, typeChecker, tsUtils) {
 }
 
 // src/core/TypeParser.ts
+var checkedPackagesCache = /* @__PURE__ */ new Map();
+var programResolvedCacheSize = /* @__PURE__ */ new Map();
 var TypeParser = Tag4("@effect/language-service/TypeParser");
 var nanoLayer3 = (fa) => gen3(function* () {
   const ts = yield* service2(TypeScriptApi);
@@ -32805,6 +32791,42 @@ function typeParserIssue(_message, _type, _node) {
   return TypeParserIssue.issue;
 }
 function make64(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(
     fn2("TypeParser.getSourceFilePackageInfo")(function* (sourceFile) {
       return tsUtils.resolveModuleWithPackageInfoFromSourceFile(program, sourceFile);
@@ -33033,19 +33055,28 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
   );
   const effectType = cachedBy(
     fn2("TypeParser.effectType")(function* (type2, atLocation) {
-      const propertiesSymbols = typeChecker.getPropertiesOfType(type2).filter(
-        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration
-      );
-      if (propertiesSymbols.length === 0) {
-        return yield* typeParserIssue("Type has no effect variance struct", type2, atLocation);
+      if (supportedEffect() === "v4") {
+        const typeIdSymbol = typeChecker.getPropertyOfType(type2, "~effect/Effect");
+        if (typeIdSymbol) {
+          const typeIdType = typeChecker.getTypeOfSymbolAtLocation(typeIdSymbol, atLocation);
+          return yield* effectVarianceStruct(typeIdType, atLocation);
+        }
+        return yield* typeParserIssue("Type is not an effect", type2, atLocation);
+      } else {
+        const propertiesSymbols = typeChecker.getPropertiesOfType(type2).filter(
+          (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration
+        );
+        if (propertiesSymbols.length === 0) {
+          return yield* typeParserIssue("Type has no effect variance struct", type2, atLocation);
+        }
+        propertiesSymbols.sort(
+          (a, b) => ts.symbolName(b).indexOf("EffectTypeId") - ts.symbolName(a).indexOf("EffectTypeId")
+        );
+        return yield* firstSuccessOf2(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* firstSuccessOf2(propertiesSymbols.map((propertySymbol) => {
-        const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
-        return effectVarianceStruct(propertyType, atLocation);
-      }));
     }),
     "TypeParser.effectType",
     (type2) => type2
@@ -33174,7 +33205,7 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     fn2("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);
@@ -33365,10 +33396,10 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
               }))
             )
           ),
-          option5
+          orUndefined2
         );
-        if (isSome2(isEffectGen)) {
-          effectGenResult = isEffectGen.value;
+        if (isEffectGen) {
+          effectGenResult = isEffectGen;
         }
       }
       if (scopeNode && effectGenResult) {
@@ -33488,6 +33519,21 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
   const effectSchemaType = cachedBy(
     fn2("TypeParser.effectSchemaType")(function* (type2, atLocation) {
       yield* pipeableType(type2, atLocation);
+      const typeId = typeChecker.getPropertyOfType(type2, "~effect/Schema/Schema");
+      if (typeId) {
+        const typeKey = typeChecker.getPropertyOfType(type2, "Type");
+        const encodedKey = typeChecker.getPropertyOfType(type2, "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(type2, "ast");
       if (!ast) return yield* typeParserIssue("Has no 'ast' property", type2, atLocation);
       const propertiesSymbols = typeChecker.getPropertiesOfType(type2).filter(
@@ -33706,9 +33752,9 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
               if (ts.isCallExpression(schemaCall) && schemaCall.typeArguments && schemaCall.typeArguments.length > 0) {
                 const isEffectSchemaModuleApi = yield* pipe(
                   isNodeReferenceToEffectSchemaModuleApi("Class")(schemaCall.expression),
-                  option5
+                  orUndefined2
                 );
-                if (isSome2(isEffectSchemaModuleApi)) {
+                if (isEffectSchemaModuleApi) {
                   return {
                     className: atLocation.name,
                     selfTypeNode: schemaCall.typeArguments[0]
@@ -33743,9 +33789,9 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
                 const selfTypeNode = schemaTaggedClassTCall.typeArguments[0];
                 const isEffectSchemaModuleApi = yield* pipe(
                   isNodeReferenceToEffectSchemaModuleApi("TaggedClass")(schemaTaggedClassTCall.expression),
-                  option5
+                  orUndefined2
                 );
-                if (isSome2(isEffectSchemaModuleApi)) {
+                if (isEffectSchemaModuleApi) {
                   return {
                     className: atLocation.name,
                     selfTypeNode,
@@ -33782,9 +33828,9 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
                 const selfTypeNode = schemaTaggedErrorTCall.typeArguments[0];
                 const isEffectSchemaModuleApi = yield* pipe(
                   isNodeReferenceToEffectSchemaModuleApi("TaggedError")(schemaTaggedErrorTCall.expression),
-                  option5
+                  orUndefined2
                 );
-                if (isSome2(isEffectSchemaModuleApi)) {
+                if (isEffectSchemaModuleApi) {
                   return {
                     className: atLocation.name,
                     selfTypeNode,
@@ -33804,6 +33850,9 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
   );
   const extendsSchemaTaggedRequest = cachedBy(
     fn2("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);
       }
@@ -33821,9 +33870,9 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
                 const selfTypeNode = schemaTaggedRequestTCall.typeArguments[0];
                 const isEffectSchemaModuleApi = yield* pipe(
                   isNodeReferenceToEffectSchemaModuleApi("TaggedRequest")(schemaTaggedRequestTCall.expression),
-                  option5
+                  orUndefined2
                 );
-                if (isSome2(isEffectSchemaModuleApi)) {
+                if (isEffectSchemaModuleApi) {
                   return {
                     className: atLocation.name,
                     selfTypeNode,
@@ -33841,6 +33890,48 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     "TypeParser.extendsSchemaTaggedRequest",
     (atLocation) => atLocation
   );
+  const extendsSchemaRequestClass = cachedBy(
+    fn2("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),
+                  orUndefined2
+                );
+                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(
     fn2("TypeParser.extendsDataTaggedError")(function* (atLocation) {
       if (!atLocation.name) {
@@ -33860,13 +33951,13 @@ function make64(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),
-                  option5
+                  orUndefined2
                 );
-                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
                   };
                 }
               }
@@ -33898,13 +33989,13 @@ function make64(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),
-                  option5
+                  orUndefined2
                 );
-                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
                   };
                 }
               }
@@ -33938,9 +34029,9 @@ function make64(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),
-                    option5
+                    orUndefined2
                   );
-                  if (isSome2(parsedContextModule)) {
+                  if (parsedContextModule) {
                     const classSym = typeChecker.getSymbolAtLocation(atLocation.name);
                     if (!classSym) return yield* typeParserIssue("Class has no symbol", void 0, atLocation);
                     const type2 = typeChecker.getTypeOfSymbol(classSym);
@@ -33951,7 +34042,7 @@ function make64(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
                     };
                   }
                 }
@@ -33989,9 +34080,9 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
                 const selfTypeNode = wholeCall.typeArguments[0];
                 const isEffectTag = yield* pipe(
                   isNodeReferenceToEffectModuleApi("Tag")(effectTagIdentifier),
-                  option5
+                  orUndefined2
                 );
-                if (isSome2(isEffectTag)) {
+                if (isEffectTag) {
                   return {
                     className: atLocation.name,
                     selfTypeNode,
@@ -34031,17 +34122,17 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
                 const selfTypeNode = effectServiceCall.typeArguments[0];
                 const isEffectService = yield* pipe(
                   isNodeReferenceToEffectModuleApi("Service")(effectServiceIdentifier),
-                  option5
+                  orUndefined2
                 );
-                if (isSome2(isEffectService)) {
+                if (isEffectService) {
                   const classSym = typeChecker.getSymbolAtLocation(atLocation.name);
                   if (!classSym) return yield* typeParserIssue("Class has no symbol", void 0, atLocation);
                   const type2 = typeChecker.getTypeOfSymbol(classSym);
                   const parsedContextTag = yield* pipe(
                     contextTag(type2, atLocation),
-                    option5
+                    orUndefined2
                   );
-                  if (isSome2(parsedContextTag)) {
+                  if (parsedContextTag) {
                     let accessors2 = void 0;
                     let dependencies = void 0;
                     if (wholeCall.arguments.length >= 2) {
@@ -34058,7 +34149,7 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
                       }
                     }
                     return {
-                      ...parsedContextTag.value,
+                      ...parsedContextTag,
                       className: atLocation.name,
                       selfTypeNode,
                       args: wholeCall.arguments,
@@ -34128,9 +34219,9 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
               if (ts.isCallExpression(schemaCall) && schemaCall.typeArguments && schemaCall.typeArguments.length > 0) {
                 const isEffectSchemaModuleApi = yield* pipe(
                   isNodeReferenceToEffectSqlModelModuleApi("Class")(schemaCall.expression),
-                  option5
+                  orUndefined2
                 );
-                if (isSome2(isEffectSchemaModuleApi)) {
+                if (isEffectSchemaModuleApi) {
                   return {
                     className: atLocation.name,
                     selfTypeNode: schemaCall.typeArguments[0]
@@ -34253,19 +34344,18 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
                 map34((s) => ({ _tag: "call", ...s }))
               )
             ),
-            option5
+            orUndefined2
           );
-          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({
@@ -34274,7 +34364,7 @@ function make64(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({
@@ -34282,17 +34372,17 @@ function make64(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"
@@ -34302,20 +34392,20 @@ function make64(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) => {
@@ -34325,17 +34415,17 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
             continue;
           }
           if (includeEffectFn) {
-            const effectFnGenParsed = yield* pipe(effectFnGen(node), option5);
-            const effectFnUntracedGenParsed = isNone2(effectFnGenParsed) ? yield* pipe(effectFnUntracedGen(node), option5) : none2();
-            const effectFnNonGenParsed = isNone2(effectFnGenParsed) && isNone2(effectFnUntracedGenParsed) ? yield* pipe(effectFn(node), option5) : 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(
+              map34(effectFnGen(node), (_) => ({ kind: "effectFnGen", ..._ })),
+              orElse15(
+                () => map34(effectFnUntracedGen(node), (_) => ({ kind: "effectFnUntracedGen", ..._ }))
+              ),
+              orElse15(() => map34(effectFn(node), (_) => ({ kind: "effectFn", ..._ }))),
+              orUndefined2
+            );
+            if (effectFnKind && (effectFnKind.kind === "effectFnGen" || effectFnKind.kind === "effectFnUntracedGen")) {
+              if (effectFnKind.pipeArguments.length > 0) {
+                const fnResult = effectFnKind;
                 const pipeArgs = fnResult.pipeArguments;
                 const transformations = [];
                 let subjectType;
@@ -34355,14 +34445,14 @@ function make64(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"
                     });
                   }
                 }
@@ -34384,8 +34474,8 @@ function make64(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;
@@ -34531,11 +34621,14 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     extendsDataTaggedError,
     extendsDataTaggedClass,
     extendsSchemaTaggedRequest,
+    extendsSchemaRequestClass,
     extendsEffectSqlModelClass,
     lazyExpression,
     emptyFunction,
     pipingFlows,
-    reconstructPipingFlow
+    reconstructPipingFlow,
+    getEffectRelatedPackages,
+    supportedEffect
   };
 }
 
@@ -35839,6 +35932,7 @@ var catchAllToMapError = createDiagnostic({
   apply: fn2("catchAllToMapError.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
+    const catchAllName = typeParser.supportedEffect() === "v3" ? "catchAll" : "catch";
     const getFunctionBody = (node) => {
       if (ts.isArrowFunction(node)) {
         return node.body;
@@ -35853,10 +35947,10 @@ var catchAllToMapError = createDiagnostic({
         if (ts.isCallExpression(body)) {
           const isFailCall = yield* pipe(
             typeParser.isNodeReferenceToEffectModuleApi("fail")(body.expression),
-            option5
+            orUndefined2
           );
-          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)) {
@@ -35866,15 +35960,14 @@ var catchAllToMapError = createDiagnostic({
             if (ts.isReturnStatement(stmt) && stmt.expression && ts.isCallExpression(stmt.expression)) {
               const isFailCall = yield* pipe(
                 typeParser.isNodeReferenceToEffectModuleApi("fail")(stmt.expression.expression),
-                option5
+                orUndefined2
               );
-              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);
@@ -35884,10 +35977,10 @@ var catchAllToMapError = createDiagnostic({
           continue;
         }
         const isCatchAllCall = yield* pipe(
-          typeParser.isNodeReferenceToEffectModuleApi("catchAll")(transformation.callee),
-          option5
+          typeParser.isNodeReferenceToEffectModuleApi(catchAllName)(transformation.callee),
+          orUndefined2
         );
-        if (isNone2(isCatchAllCall)) {
+        if (!isCatchAllCall) {
           continue;
         }
         const callback = transformation.args[0];
@@ -35895,11 +35988,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",
@@ -35930,7 +36023,7 @@ var catchUnfailableEffect = createDiagnostic({
   apply: fn2("catchUnfailableEffect.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(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++) {
@@ -35995,7 +36088,12 @@ var classSelfMismatch = createDiagnostic({
           orElse15(() => typeParser.extendsSchemaClass(node)),
           orElse15(() => typeParser.extendsSchemaTaggedClass(node)),
           orElse15(() => typeParser.extendsSchemaTaggedError(node)),
-          orElse15(() => typeParser.extendsSchemaTaggedRequest(node)),
+          orElse15(
+            () => pipe(
+              typeParser.extendsSchemaTaggedRequest(node),
+              orElse15(() => typeParser.extendsSchemaRequestClass(node))
+            )
+          ),
           orElse15(() => typeParser.extendsEffectSqlModelClass(node)),
           orElse15(() => void_8)
         );
@@ -36222,39 +36320,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: fn2("duplicatePackage.apply")(function* (sourceFile, report) {
-    const program = yield* service2(TypeScriptProgram);
-    const tsUtils = yield* service2(TypeScriptUtils);
+    const typeParser = yield* service2(TypeParser);
     const options3 = yield* service2(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 (options3.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 (options3.allowedDuplicatedPackages.indexOf(packageName) > -1) return;
       if (Object.keys(resolvedPackages[packageName]).length > 1) {
         const versions = Object.keys(resolvedPackages[packageName]);
         report({
@@ -37078,23 +37155,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: []
+                    });
+                  }
                 }
               }
             }
@@ -37907,22 +37986,23 @@ var missingEffectError = createDiagnostic({
           map34((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: gen3(function* () {
                   const changeTracker = yield* service2(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, ")");
                 })
@@ -38004,6 +38084,7 @@ var missingEffectServiceDependency = createDiagnostic({
     const typeChecker = yield* service2(TypeCheckerApi);
     const typeCheckerUtils = yield* service2(TypeCheckerUtils);
     const typeParser = yield* service2(TypeParser);
+    if (typeParser.supportedEffect() !== "v3") return;
     const nodeToVisit = [];
     const appendNodeToVisit = (node) => {
       nodeToVisit.push(node);
@@ -39190,6 +39271,7 @@ var scopeInLayerEffect = createDiagnostic({
     const typeChecker = yield* service2(TypeCheckerApi);
     const typeParser = yield* service2(TypeParser);
     const typeCheckerUtils = yield* service2(TypeCheckerUtils);
+    if (typeParser.supportedEffect() !== "v3") return;
     const layerModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
       sourceFile,
       "effect",
@@ -39398,6 +39480,17 @@ var tryCatchInEffectGen = createDiagnostic({
   apply: fn2("tryCatchInEffectGen.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(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);
@@ -39423,7 +39516,7 @@ var tryCatchInEffectGen = createDiagnostic({
             map34(() => {
               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: []
               });
             }),
@@ -39445,6 +39538,7 @@ var unknownInEffectCatch = createDiagnostic({
     const ts = yield* service2(TypeScriptApi);
     const typeParser = yield* service2(TypeParser);
     const typeChecker = yield* service2(TypeCheckerApi);
+    const typeCheckerUtils = yield* service2(TypeCheckerUtils);
     const nodeToVisit = [];
     const appendNodeToVisit = (node) => {
       nodeToVisit.push(node);
@@ -39465,24 +39559,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: []
+                    });
+                  }
                 }
               }
             }