@effect/language-service 0.63.2 → 0.64.0

package/index.js

@@ -751,6 +751,13 @@ var make2 = (compare) => (self, that) => self === that ? 0 : compare(self, that)
 var string2 = /* @__PURE__ */ make2((self, that) => self < that ? -1 : 1);
 var number2 = /* @__PURE__ */ make2((self, that) => self < that ? -1 : 1);
 var reverse = (O) => make2((self, that) => O(that, self));
+var combine2 = /* @__PURE__ */ dual(2, (self, that) => make2((a1, a2) => {
+  const out = self(a1, a2);
+  if (out !== 0) {
+    return out;
+  }
+  return that(a1, a2);
+}));
 var mapInput = /* @__PURE__ */ dual(2, (self, f) => make2((b1, b2) => self(f(b1), f(b2))));
 
 // node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Option.js
@@ -5033,6 +5040,12 @@ function make7(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
   );
   const extendsCauseYieldableError = cachedBy(
     fn("TypeParser.extendsCauseYieldableError")(function* (givenType) {
+      if (givenType.flags & ts.TypeFlags.Never) {
+        return yield* typeParserIssue("Type is never", givenType);
+      }
+      if (givenType.flags & ts.TypeFlags.Any) {
+        return yield* typeParserIssue("Type is any", givenType);
+      }
       const symbols = yield* findSymbolsMatchingPackageAndExportedName("effect", "YieldableError")();
       for (const [symbol3, sourceFile] of symbols) {
         const causeFile = yield* pipe(isCauseTypeSourceFile(sourceFile), orElse2(() => void_));
@@ -5127,18 +5140,19 @@ function make7(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
   );
   const effectType = cachedBy(
     fn("TypeParser.effectType")(function* (type, atLocation) {
-      let result = typeParserIssue("Type has no effect variance struct", type, atLocation);
       const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
-        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration && ts.isPropertySignature(_.valueDeclaration) && ts.isComputedPropertyName(_.valueDeclaration.name)
+        (_) => _.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")
       );
-      for (const propertySymbol of propertiesSymbols) {
+      return yield* firstSuccessOf(propertiesSymbols.map((propertySymbol) => {
         const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
-        result = pipe(result, orElse2(() => effectVarianceStruct(propertyType, atLocation)));
-      }
-      return yield* result;
+        return effectVarianceStruct(propertyType, atLocation);
+      }));
     }),
     "TypeParser.effectType",
     (type) => type
@@ -5177,22 +5191,18 @@ function make7(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     fn("TypeParser.layerType")(function* (type, atLocation) {
       yield* pipeableType(type, atLocation);
       const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
-        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration && ts.isPropertySignature(_.valueDeclaration) && ts.isComputedPropertyName(_.valueDeclaration.name)
+        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration
       );
+      if (propertiesSymbols.length === 0) {
+        return yield* typeParserIssue("Type has no layer variance struct", type, atLocation);
+      }
       propertiesSymbols.sort(
         (a, b) => ts.symbolName(b).indexOf("LayerTypeId") - ts.symbolName(a).indexOf("LayerTypeId")
       );
-      for (const propertySymbol of propertiesSymbols) {
+      return yield* firstSuccessOf(propertiesSymbols.map((propertySymbol) => {
         const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
-        const varianceArgs = yield* option(layerVarianceStruct(
-          propertyType,
-          atLocation
-        ));
-        if (isSome2(varianceArgs)) {
-          return varianceArgs.value;
-        }
-      }
-      return yield* typeParserIssue("Type has no layer variance struct", type, atLocation);
+        return layerVarianceStruct(propertyType, atLocation);
+      }));
     }),
     "TypeParser.layerType",
     (type) => type
@@ -5489,20 +5499,16 @@ function make7(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
       const ast = typeChecker.getPropertyOfType(type, "ast");
       if (!ast) return yield* typeParserIssue("Has no 'ast' property", type, atLocation);
       const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
-        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration && ts.isPropertySignature(_.valueDeclaration) && ts.isComputedPropertyName(_.valueDeclaration.name)
+        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration
       );
+      if (propertiesSymbols.length === 0) {
+        return yield* typeParserIssue("Type has no schema variance struct", type, atLocation);
+      }
       propertiesSymbols.sort((a, b) => ts.symbolName(b).indexOf("TypeId") - ts.symbolName(a).indexOf("TypeId"));
-      for (const propertySymbol of propertiesSymbols) {
+      return yield* firstSuccessOf(propertiesSymbols.map((propertySymbol) => {
         const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
-        const varianceArgs = yield* option(effectSchemaVarianceStruct(
-          propertyType,
-          atLocation
-        ));
-        if (isSome2(varianceArgs)) {
-          return varianceArgs.value;
-        }
-      }
-      return yield* typeParserIssue("Type has no schema variance struct", type, atLocation);
+        return effectSchemaVarianceStruct(propertyType, atLocation);
+      }));
     }),
     "TypeParser.effectSchemaType",
     (type) => type
@@ -5538,33 +5544,54 @@ function make7(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     fn("TypeParser.contextTag")(function* (type, atLocation) {
       yield* pipeableType(type, atLocation);
       const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
-        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration && ts.isPropertySignature(_.valueDeclaration) && ts.isComputedPropertyName(_.valueDeclaration.name)
+        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration
       );
+      if (propertiesSymbols.length === 0) {
+        return yield* typeParserIssue("Type has no tag variance struct", type, atLocation);
+      }
       propertiesSymbols.sort((a, b) => ts.symbolName(b).indexOf("TypeId") - ts.symbolName(a).indexOf("TypeId"));
-      for (const propertySymbol of propertiesSymbols) {
+      return yield* firstSuccessOf(propertiesSymbols.map((propertySymbol) => {
         const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
-        const varianceArgs = yield* option(contextTagVarianceStruct(
-          propertyType,
-          atLocation
-        ));
-        if (isSome2(varianceArgs)) {
-          return varianceArgs.value;
-        }
-      }
-      return yield* typeParserIssue("Type has no tag variance struct", type, atLocation);
+        return contextTagVarianceStruct(propertyType, atLocation);
+      }));
     }),
     "TypeParser.contextTag",
     (type) => type
   );
+  const effectFunctionImportedName = cachedBy(
+    fn("TypeParser.effectFunctionImportedName")(function* (sourceFile) {
+      return tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, "effect", "Function");
+    }),
+    "TypeParser.effectFunctionImportedName",
+    (node) => node
+  );
   const pipeCall = cachedBy(
     function(node) {
       if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.name) && ts.idText(node.expression.name) === "pipe") {
-        return succeed({
-          node,
-          subject: node.expression.expression,
-          args: Array.from(node.arguments),
-          kind: "pipeable"
-        });
+        const baseExpression = node.expression.expression;
+        return pipe(
+          effectFunctionImportedName(tsUtils.getSourceFileOfNode(node)),
+          flatMap4((functionIdentifier) => {
+            if (functionIdentifier && ts.isIdentifier(baseExpression) && ts.idText(baseExpression) === functionIdentifier) {
+              if (node.arguments.length === 0) {
+                return typeParserIssue("Node is not a pipe call", void 0, node);
+              }
+              const [subject, ...args2] = node.arguments;
+              return succeed({
+                node,
+                subject,
+                args: args2,
+                kind: "pipe"
+              });
+            }
+            return succeed({
+              node,
+              subject: baseExpression,
+              args: Array.from(node.arguments),
+              kind: "pipeable"
+            });
+          })
+        );
       }
       if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && ts.idText(node.expression) === "pipe" && node.arguments.length > 0) {
         const [subject, ...args2] = node.arguments;
@@ -5579,17 +5606,10 @@ function make7(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     fn("TypeParser.scopeType")(function* (type, atLocation) {
       yield* pipeableType(type, atLocation);
       const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
-        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration && ts.isPropertySignature(_.valueDeclaration) && ts.isComputedPropertyName(_.valueDeclaration.name)
-      );
-      propertiesSymbols.sort(
-        (a, b) => ts.symbolName(b).indexOf("ScopeTypeId") - ts.symbolName(a).indexOf("ScopeTypeId")
+        (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration
       );
-      for (const propertySymbol of propertiesSymbols) {
-        const computedPropertyExpression = propertySymbol.valueDeclaration.name;
-        const symbol3 = typeChecker.getSymbolAtLocation(computedPropertyExpression.expression);
-        if (symbol3 && ts.symbolName(symbol3) === "ScopeTypeId") {
-          return type;
-        }
+      if (propertiesSymbols.some((s) => ts.symbolName(s).indexOf("ScopeTypeId") !== -1)) {
+        return type;
       }
       return yield* typeParserIssue("Type has no scope type id", type, atLocation);
     }),
@@ -6095,12 +6115,38 @@ function make7(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     "TypeParser.extendsEffectSqlModelClass",
     (atLocation) => atLocation
   );
+  const isEffectLayerTypeSourceFile = cachedBy(
+    fn("TypeParser.isEffectLayerTypeSourceFile")(function* (sourceFile) {
+      const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
+      if (!moduleSymbol) return yield* typeParserIssue("Node has no symbol", void 0, sourceFile);
+      const layerTypeSymbol = typeChecker.tryGetMemberInModuleExports("Layer", moduleSymbol);
+      if (!layerTypeSymbol) return yield* typeParserIssue("Layer type not found", void 0, sourceFile);
+      const type = typeChecker.getDeclaredTypeOfSymbol(layerTypeSymbol);
+      yield* layerType(type, sourceFile);
+      return sourceFile;
+    }),
+    "TypeParser.isEffectLayerTypeSourceFile",
+    (sourceFile) => sourceFile
+  );
+  const isNodeReferenceToEffectLayerModuleApi = (memberName) => cachedBy(
+    fn("TypeParser.isNodeReferenceToEffectLayerModuleApi")(function* (node) {
+      return yield* isNodeReferenceToExportOfPackageModule(
+        node,
+        "effect",
+        isEffectLayerTypeSourceFile,
+        memberName
+      );
+    }),
+    `TypeParser.isNodeReferenceToEffectLayerModuleApi(${memberName})`,
+    (node) => node
+  );
   return {
     isNodeReferenceToEffectModuleApi,
     isNodeReferenceToEffectSchemaModuleApi,
     isNodeReferenceToEffectDataModuleApi,
     isNodeReferenceToEffectContextModuleApi,
     isNodeReferenceToEffectSqlModelModuleApi,
+    isNodeReferenceToEffectLayerModuleApi,
     effectType,
     strictEffectType,
     layerType,
@@ -6415,9 +6461,11 @@ var parse2 = fn("writeTagClassAccessors.parse")(function* (node) {
   const typeParser = yield* service(TypeParser);
   const typeCheckerUtils = yield* service(TypeCheckerUtils);
   if (!ts.isClassDeclaration(node)) return yield* fail3("not a class declaration");
-  const { Service, accessors: accessors2, className } = yield* pipe(
-    typeParser.extendsEffectService(node),
-    orElse2(() => map8(typeParser.extendsEffectTag(node), (_) => ({ accessors: true, ..._ }))),
+  const { Service, accessors: accessors2, className, kind } = yield* pipe(
+    map8(typeParser.extendsEffectService(node), (_) => ({ kind: "effectService", ..._ })),
+    orElse2(
+      () => map8(typeParser.extendsEffectTag(node), (_) => ({ kind: "effectTag", accessors: true, ..._ }))
+    ),
     orElse2(() => fail3("not a class extending Effect.Service call"))
   );
   if (accessors2 !== true) return yield* fail3("accessors are not enabled in the Effect.Service call");
@@ -6439,7 +6487,7 @@ var parse2 = fn("writeTagClassAccessors.parse")(function* (node) {
   const hash2 = involvedMembers.map(({ property, propertyType }) => {
     return ts.symbolName(property) + ": " + typeChecker.typeToString(propertyType);
   }).concat([ts.idText(className)]).join("\n");
-  return { Service, className, atLocation: node, hash: cyrb53(hash2), involvedMembers };
+  return { Service, className, atLocation: node, hash: cyrb53(hash2), involvedMembers, kind };
 });
 var writeTagClassAccessors = createRefactor({
   name: "writeTagClassAccessors",
@@ -7426,6 +7474,100 @@ var anyUnknownInErrorContext = createDiagnostic({
   })
 });
 
+// src/diagnostics/catchAllToMapError.ts
+var catchAllToMapError = createDiagnostic({
+  name: "catchAllToMapError",
+  code: 39,
+  description: "Suggests using Effect.mapError instead of Effect.catchAll when the callback only wraps the error with Effect.fail",
+  severity: "suggestion",
+  apply: fn("catchAllToMapError.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
+    const getFunctionBody = (node) => {
+      if (ts.isArrowFunction(node)) {
+        return node.body;
+      }
+      if (ts.isFunctionExpression(node)) {
+        return node.body;
+      }
+      return void 0;
+    };
+    const getEffectFailCallInfo = (body) => {
+      return gen(function* () {
+        if (ts.isCallExpression(body)) {
+          const isFailCall = yield* pipe(
+            typeParser.isNodeReferenceToEffectModuleApi("fail")(body.expression),
+            option
+          );
+          if (isSome2(isFailCall) && body.arguments.length >= 1) {
+            return some2({ failCall: body, failArg: body.arguments[0] });
+          }
+        }
+        if (ts.isBlock(body)) {
+          const statements = body.statements;
+          if (statements.length === 1) {
+            const stmt = statements[0];
+            if (ts.isReturnStatement(stmt) && stmt.expression && ts.isCallExpression(stmt.expression)) {
+              const isFailCall = yield* pipe(
+                typeParser.isNodeReferenceToEffectModuleApi("fail")(stmt.expression.expression),
+                option
+              );
+              if (isSome2(isFailCall) && stmt.expression.arguments.length >= 1) {
+                return some2({ failCall: stmt.expression, failArg: stmt.expression.arguments[0] });
+              }
+            }
+          }
+        }
+        return none2();
+      });
+    };
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts.forEachChild(node, appendNodeToVisit);
+      if (ts.isCallExpression(node)) {
+        const isCatchAllCall = yield* pipe(
+          typeParser.isNodeReferenceToEffectModuleApi("catchAll")(node.expression),
+          option
+        );
+        if (isSome2(isCatchAllCall)) {
+          const callback = node.arguments[0];
+          if (!callback) continue;
+          const functionBody = getFunctionBody(callback);
+          if (!functionBody) continue;
+          const failCallInfo = yield* getEffectFailCallInfo(functionBody);
+          if (isNone2(failCallInfo)) continue;
+          const { failArg, failCall } = failCallInfo.value;
+          report({
+            location: node.expression,
+            messageText: `You can use Effect.mapError instead of Effect.catchAll + Effect.fail to transform the error type.`,
+            fixes: [{
+              fixName: "catchAllToMapError_fix",
+              description: "Replace with Effect.mapError",
+              apply: gen(function* () {
+                const changeTracker = yield* service(ChangeTracker);
+                if (ts.isPropertyAccessExpression(node.expression)) {
+                  changeTracker.replaceNode(
+                    sourceFile,
+                    node.expression.name,
+                    ts.factory.createIdentifier("mapError")
+                  );
+                }
+                changeTracker.replaceNode(sourceFile, failCall, failArg);
+              })
+            }]
+          });
+        }
+      }
+    }
+  })
+});
+
 // src/diagnostics/catchUnfailableEffect.ts
 var catchUnfailableEffect = createDiagnostic({
   name: "catchUnfailableEffect",
@@ -7922,6 +8064,65 @@ var genericEffectServices = createDiagnostic({
   })
 });
 
+// src/diagnostics/globalErrorInEffectCatch.ts
+var globalErrorInEffectCatch = createDiagnostic({
+  name: "globalErrorInEffectCatch",
+  code: 36,
+  description: "Warns when catch callbacks return global Error type instead of typed errors",
+  severity: "warning",
+  apply: fn("globalErrorInEffectCatch.apply")(function* (sourceFile, report) {
+    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);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts.forEachChild(node, appendNodeToVisit);
+      if (ts.isCallExpression(node)) {
+        const isEffectWithCatch = yield* pipe(
+          typeParser.isNodeReferenceToEffectModuleApi("tryPromise")(node.expression),
+          orElse2(() => typeParser.isNodeReferenceToEffectModuleApi("try")(node.expression)),
+          orElse2(() => typeParser.isNodeReferenceToEffectModuleApi("tryMap")(node.expression)),
+          orElse2(() => typeParser.isNodeReferenceToEffectModuleApi("tryMapPromise")(node.expression)),
+          orElse2(() => void_)
+        );
+        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 the global Error type. It's not recommended to use the global Error type in Effect failures as they can get merged together.
+Instead, use tagged errors or custom errors with a discriminator property to get properly type-checked errors.`,
+                    fixes: []
+                  });
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  })
+});
+
 // src/diagnostics/globalErrorInEffectFailure.ts
 var globalErrorInEffectFailure = createDiagnostic({
   name: "globalErrorInEffectFailure",
@@ -7952,7 +8153,7 @@ var globalErrorInEffectFailure = createDiagnostic({
                 return sync(
                   () => report({
                     location: node,
-                    messageText: `Effect.fail is called with the global Error type. It's not recommended to use the global Error type in Effect failures as they can get merged together. Instead, use tagged errors (Data.TaggedError) or custom errors with a discriminator property to get properly type-checked errors.`,
+                    messageText: `Effect.fail is called with the global Error type. It's not recommended to use the global Error type in Effect failures as they can get merged together. Instead, use tagged errors or custom errors with a discriminator property to get properly type-checked errors.`,
                     fixes: []
                   })
                 );
@@ -8107,6 +8308,119 @@ var importFromBarrel = createDiagnostic({
   })
 });
 
+// src/diagnostics/layerMergeAllWithDependencies.ts
+var layerMergeAllWithDependencies = createDiagnostic({
+  name: "layerMergeAllWithDependencies",
+  code: 37,
+  description: "Detects interdependencies in Layer.mergeAll calls where one layer provides a service that another layer requires",
+  severity: "warning",
+  apply: fn("layerMergeAllWithDependencies.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
+    const typeParser = yield* service(TypeParser);
+    const tsUtils = yield* service(TypeScriptUtils);
+    const layerModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+      sourceFile,
+      "effect",
+      "Layer"
+    ) || "Layer";
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      if (ts.isCallExpression(node)) {
+        const checkLayerMergeAll = yield* pipe(
+          typeParser.isNodeReferenceToEffectLayerModuleApi("mergeAll")(node.expression),
+          orElse2(() => void_)
+        );
+        if (checkLayerMergeAll) {
+          const layerArgs = node.arguments;
+          if (layerArgs.length > 1) {
+            const layerInfos = [];
+            const actuallyProvidedMap = /* @__PURE__ */ new Map();
+            for (const arg of layerArgs) {
+              const argType = typeCheckerUtils.getTypeAtLocation(arg);
+              if (!argType) continue;
+              const layerTypeParsedOption = yield* option(typeParser.layerType(argType, arg));
+              if (isNone2(layerTypeParsedOption)) continue;
+              const layerTypeParsed = layerTypeParsedOption.value;
+              const providedMembers = typeCheckerUtils.unrollUnionMembers(layerTypeParsed.ROut);
+              for (const providedType of providedMembers) {
+                if (providedType.flags & ts.TypeFlags.Never) continue;
+                const isPassThrough = typeChecker.isTypeAssignableTo(providedType, layerTypeParsed.RIn);
+                if (!isPassThrough) {
+                  actuallyProvidedMap.set(providedType, arg);
+                }
+              }
+              layerInfos.push({
+                arg,
+                requirementsType: layerTypeParsed.RIn
+              });
+            }
+            const providerToConsumers = /* @__PURE__ */ new Map();
+            for (const layer of layerInfos) {
+              for (const [providedType, providerArg] of actuallyProvidedMap) {
+                if (providerArg === layer.arg) continue;
+                if (typeChecker.isTypeAssignableTo(providedType, layer.requirementsType)) {
+                  const consumers = providerToConsumers.get(providerArg) || [];
+                  consumers.push({ consumer: layer.arg, providedType });
+                  providerToConsumers.set(providerArg, consumers);
+                }
+              }
+            }
+            for (const [providerArg, consumers] of providerToConsumers) {
+              const providedTypes = Array.from(new Set(consumers.map((c) => typeChecker.typeToString(c.providedType)))).join(", ");
+              report({
+                location: providerArg,
+                messageText: `This layer provides ${providedTypes} which is required by another layer in the same Layer.mergeAll call. Layer.mergeAll creates layers in parallel, so dependencies between layers will not be satisfied. Consider moving this layer into a Layer.provideMerge after the Layer.mergeAll.`,
+                fixes: [{
+                  fixName: "layerMergeAllWithDependencies_fix",
+                  description: "Move layer to Layer.provideMerge",
+                  apply: gen(function* () {
+                    const changeTracker = yield* service(ChangeTracker);
+                    const providerIndex = layerArgs.indexOf(providerArg);
+                    if (providerIndex === -1) return;
+                    const providerArgNode = providerArg;
+                    if (providerIndex === 0 && layerArgs.length > 1) {
+                      changeTracker.deleteRange(sourceFile, {
+                        pos: providerArgNode.pos,
+                        end: layerArgs[1].pos
+                      });
+                    } else if (providerIndex > 0) {
+                      changeTracker.deleteRange(sourceFile, {
+                        pos: layerArgs[providerIndex - 1].end,
+                        end: providerArgNode.end
+                      });
+                    }
+                    const provideMergeCall = ts.factory.createCallExpression(
+                      ts.factory.createPropertyAccessExpression(
+                        ts.factory.createIdentifier(layerModuleIdentifier),
+                        ts.factory.createIdentifier("provideMerge")
+                      ),
+                      void 0,
+                      [providerArgNode]
+                    );
+                    changeTracker.insertNodeAt(sourceFile, node.end, provideMergeCall, {
+                      prefix: ".pipe("
+                    });
+                    changeTracker.insertText(sourceFile, node.end, ")");
+                  })
+                }]
+              });
+            }
+          }
+        }
+      }
+      ts.forEachChild(node, appendNodeToVisit);
+    }
+  })
+});
+
 // src/diagnostics/leakingRequirements.ts
 var leakingRequirements = createDiagnostic({
   name: "leakingRequirements",
@@ -8205,6 +8519,7 @@ var leakingRequirements = createDiagnostic({
         location: node,
         messageText: `This Service is leaking the ${requirements.map((_) => typeChecker.typeToString(_)).join(" | ")} requirement.
 If these requirements cannot be cached and are expected to be provided per method invocation (e.g. HttpServerRequest), you can either safely disable this diagnostic for this line through quickfixes or mark the service declaration with a JSDoc @effect-leakable-service.
+Services should usually be collected in the layer creation body, and then provided at each method that requires them.
 More info at https://effect.website/docs/requirements-management/layers/#avoiding-requirement-leakage`,
         fixes: []
       });
@@ -8614,6 +8929,55 @@ var missingEffectServiceDependency = createDiagnostic({
   })
 });
 
+// src/diagnostics/missingLayerContext.ts
+var missingLayerContext = createDiagnostic({
+  name: "missingLayerContext",
+  code: 38,
+  description: "Reports missing service requirements in Layer context channel",
+  severity: "error",
+  apply: fn("missingLayerContext.apply")(function* (sourceFile, report) {
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
+    const checkForMissingContextTypes = (node, expectedType, valueNode, realType) => pipe(
+      all(
+        typeParser.layerType(expectedType, node),
+        typeParser.layerType(realType, valueNode)
+      ),
+      map8(
+        ([expectedLayer, realLayer]) => typeCheckerUtils.getMissingTypeEntriesInTargetType(
+          realLayer.RIn,
+          expectedLayer.RIn
+        )
+      )
+    );
+    const sortTypes = sort(typeCheckerUtils.deterministicTypeOrder);
+    const entries2 = getEffectLspPatchSourceFileMetadata(sourceFile)?.relationErrors || typeCheckerUtils.expectedAndRealType(sourceFile);
+    for (const [node, expectedType, valueNode, realType] of entries2) {
+      if (expectedType !== realType) {
+        yield* pipe(
+          checkForMissingContextTypes(
+            node,
+            expectedType,
+            valueNode,
+            realType
+          ),
+          map8(
+            (missingTypes) => missingTypes.length > 0 ? report(
+              {
+                location: node,
+                messageText: `Missing '${sortTypes(missingTypes).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Layer context.`,
+                fixes: []
+              }
+            ) : void 0
+          ),
+          ignore
+        );
+      }
+    }
+  })
+});
+
 // src/diagnostics/missingReturnYieldStar.ts
 var missingReturnYieldStar = createDiagnostic({
   name: "missingReturnYieldStar",
@@ -10069,9 +10433,10 @@ var unsupportedServiceAccessors = createDiagnostic({
           );
           if (missingMembers.length > 0) {
             const memberNames = missingMembers.map(({ property }) => `'${ts.symbolName(property)}'`).join(", ");
+            const suggestedFix = parseResult.kind === "effectTag" ? "\nEffect.Tag does not allow to disable accessors, so you may want to use Context.Tag instead." : "";
             report({
               location: parseResult.className,
-              messageText: `Even if accessors are enabled, accessors for ${memberNames} won't be available because the signature have generic type parameters or multiple call signatures.`,
+              messageText: `Even if accessors are enabled, accessors for ${memberNames} won't be available because the signature have generic type parameters or multiple call signatures.${suggestedFix}`,
               fixes: [{
                 fixName: "unsupportedServiceAccessors_enableCodegen",
                 description: "Enable accessors codegen",
@@ -10092,6 +10457,7 @@ var unsupportedServiceAccessors = createDiagnostic({
 // src/diagnostics.ts
 var diagnostics = [
   anyUnknownInErrorContext,
+  catchAllToMapError,
   catchUnfailableEffect,
   classSelfMismatch,
   duplicatePackage,
@@ -10099,6 +10465,7 @@ var diagnostics = [
   missingEffectContext,
   missingEffectError,
   missingEffectServiceDependency,
+  missingLayerContext,
   floatingEffect,
   missingStarInYieldEffectGen,
   unnecessaryEffectGen,
@@ -10126,7 +10493,9 @@ var diagnostics = [
   runEffectInsideEffect,
   schemaUnionOfLiterals,
   schemaStructWithTag,
-  globalErrorInEffectFailure
+  globalErrorInEffectCatch,
+  globalErrorInEffectFailure,
+  layerMergeAllWithDependencies
 ];
 
 // src/completions/effectDiagnosticsComment.ts
@@ -15714,6 +16083,7 @@ var extractLayerGraph = fn("extractLayerGraph")(function* (node, opts) {
   const extractNodeInfo = fn("extractNodeInfo")(function* (node2) {
     let provides = [];
     let requires = [];
+    let actualProvides = [];
     let layerType = void 0;
     let layerTypes = void 0;
     if (nodeInPipeContext.has(node2)) {
@@ -15736,12 +16106,13 @@ var extractLayerGraph = fn("extractLayerGraph")(function* (node, opts) {
     if (layerTypes) {
       provides = typeCheckerUtils.unrollUnionMembers(layerTypes.ROut).filter((_) => !(_.flags & ts.TypeFlags.Never));
       requires = typeCheckerUtils.unrollUnionMembers(layerTypes.RIn).filter((_) => !(_.flags & ts.TypeFlags.Never));
+      actualProvides = provides.filter((_) => !typeChecker.isTypeAssignableTo(_, layerTypes.RIn));
     }
     let displayNode = node2;
     if (node2.parent && ts.isVariableDeclaration(node2.parent) && node2.parent.initializer === node2) {
       displayNode = node2.parent.name;
     }
-    return { node: node2, displayNode, layerType, layerTypes, provides, requires };
+    return { node: node2, displayNode, layerType, layerTypes, provides, actualProvides, requires };
   });
   const addNode2 = fn("addNode")(function* (node2, nodeInfo) {
     const graphNode = addNode(mutableGraph, nodeInfo ? nodeInfo : yield* extractNodeInfo(node2));
@@ -15988,10 +16359,10 @@ var extractOutlineGraph = fn("extractOutlineGraph")(function* (layerGraph) {
       node: leafNode.node,
       displayNode: leafNode.displayNode,
       requires: leafNode.requires,
-      provides: leafNode.provides
+      provides: leafNode.provides,
+      actualProvides: leafNode.actualProvides
     });
-    for (const providedType of leafNode.provides) {
-      if (leafNode.requires.indexOf(providedType) > -1) continue;
+    for (const providedType of leafNode.actualProvides) {
       const previousProviders = providers.get(providedType) || [];
       providers.set(providedType, [...previousProviders, nodeIndex]);
     }
@@ -16087,17 +16458,21 @@ var convertOutlineGraphToLayerMagic = fn("convertOutlineGraphToLayerMagic")(
       reverse(number2),
       (_) => _.provides.length
     );
+    const orderByRequiredCount = mapInput(
+      reverse(number2),
+      (_) => _.requires.length
+    );
+    const layerOrder = combine2(orderByProvidedCount, orderByRequiredCount);
     const reversedGraph = mutate2(outlineGraph, reverse4);
     const rootIndexes = fromIterable(indices(externals(reversedGraph, { direction: "incoming" })));
     const allNodes = fromIterable(
-      values2(dfsPostOrderWithOrder(reversedGraph, { start: rootIndexes, order: orderByProvidedCount }))
+      values2(dfsPostOrderWithOrder(reversedGraph, { start: rootIndexes, order: layerOrder }))
     );
     for (const nodeInfo of allNodes) {
       if (!ts.isExpression(nodeInfo.node)) continue;
-      const reallyProvidedTypes = nodeInfo.provides.filter((_) => nodeInfo.requires.indexOf(_) === -1);
-      const shouldMerge = reallyProvidedTypes.some((_) => missingOutputTypes.has(_));
+      const shouldMerge = nodeInfo.actualProvides.some((_) => missingOutputTypes.has(_));
       if (shouldMerge) {
-        reallyProvidedTypes.forEach((_) => missingOutputTypes.delete(_));
+        nodeInfo.actualProvides.forEach((_) => missingOutputTypes.delete(_));
       }
       nodeInfo.provides.forEach((_) => currentRequiredTypes.delete(_));
       nodeInfo.requires.forEach((_) => currentRequiredTypes.add(_));