diff --git a/tools/hls-fuzzer/ConjunctionTypeSystem.h b/tools/hls-fuzzer/ConjunctionTypeSystem.h
index 3f5b50745..5c4a8674f 100644
--- a/tools/hls-fuzzer/ConjunctionTypeSystem.h
+++ b/tools/hls-fuzzer/ConjunctionTypeSystem.h
@@ -31,6 +31,8 @@ class ConjunctionTypeSystemBase
       TypeSystem<std::tuple<typename SubTypeSystems::Context...>, Self>;
   using Context = typename Base::Context;
 
+  ConjunctionTypeSystemBase() = default;
+
   /// Constructs a conjunctive typesystem from the instances of the
   /// sub-typesystems.
   explicit ConjunctionTypeSystemBase(SubTypeSystems &&...subTypeSystems)
diff --git a/tools/hls-fuzzer/LimitTypeSystem.cpp b/tools/hls-fuzzer/LimitTypeSystem.cpp
index cd9321544..8824cf4f2 100644
--- a/tools/hls-fuzzer/LimitTypeSystem.cpp
+++ b/tools/hls-fuzzer/LimitTypeSystem.cpp
@@ -1,8 +1,8 @@
 #include "LimitTypeSystem.h"
 
 dynamatic::ProbabilityTable<dynamatic::gen::AbstractTypeSystem::ExpressionKey>
-dynamatic::gen::LimitTypeSystem::getExpressionProbabilityTable(
-    const LimitTypingContext &context) {
+dynamatic::gen::details::DepthTypeSystem::getExpressionProbabilityTable(
+    const DepthTypingContext &context) {
   // Default probabilities for expressions.
   // Most expressions are 100 times more likely to be generated than a
   // constant.
diff --git a/tools/hls-fuzzer/LimitTypeSystem.h b/tools/hls-fuzzer/LimitTypeSystem.h
index 34f78157c..06dde390f 100644
--- a/tools/hls-fuzzer/LimitTypeSystem.h
+++ b/tools/hls-fuzzer/LimitTypeSystem.h
@@ -1,39 +1,42 @@
 #ifndef DYNAMATIC_HLS_FUZZER_LIMITTYPESYSTEM
 #define DYNAMATIC_HLS_FUZZER_LIMITTYPESYSTEM
 
+#include "ConjunctionTypeSystem.h"
 #include "TypeSystem.h"
+#include "VisitorTypeSystem.h"
 #include <cstddef>
 
 namespace dynamatic::gen {
-struct LimitTypingContext {
+
+namespace details {
+
+struct DepthTypingContext {
   std::size_t expressionDepth{};
   std::size_t totalNumberOfStatements{};
 };
 
-/// Typesystem used to enforce limits such as number of a specific AST nodes,
-/// parameters, depth of expressions and so on.
-class LimitTypeSystem : public TypeSystem<LimitTypingContext, LimitTypeSystem> {
+class DepthTypeSystem : public TypeSystem<DepthTypingContext, DepthTypeSystem> {
 
   /// Returns a transfer function which increments 'field' of the context of
   /// 'from' before returning it.
-  template <typename ASTNode, std::size_t LimitTypingContext::*field,
+  template <typename ASTNode, std::size_t DepthTypingContext::*field,
             std::size_t from = INPUT_DEPENDENCY>
   static auto incrementDepth() {
     return TransferFn<ASTNode, from>(
-        [](LimitTypingContext context, auto &&...) {
+        [](DepthTypingContext context, auto &&...) {
           ++(context.*field);
           return context;
         });
   }
 
 public:
-  explicit LimitTypeSystem(std::size_t maxExpressionDepth = 4,
+  explicit DepthTypeSystem(std::size_t maxExpressionDepth = 4,
                            std::size_t maxTotalStatements = 10)
       : maxExpressionDepth(maxExpressionDepth),
         maxTotalStatements(maxTotalStatements) {}
 
   bool discardBinaryExpression(ast::BinaryExpression::Op,
-                               const LimitTypingContext &context) const {
+                               const DepthTypingContext &context) const {
     return context.expressionDepth >= maxExpressionDepth;
   }
 
@@ -41,16 +44,16 @@ class LimitTypeSystem : public TypeSystem<LimitTypingContext, LimitTypeSystem> {
   getBinaryExpressionTransferFns(ast::BinaryExpression::Op op) override {
     return {
         /*lhs=*/incrementDepth<ast::BinaryExpression,
-                               &LimitTypingContext::expressionDepth>(),
+                               &DepthTypingContext::expressionDepth>(),
         /*rhs=*/
         incrementDepth<ast::BinaryExpression,
-                       &LimitTypingContext::expressionDepth>(),
+                       &DepthTypingContext::expressionDepth>(),
         /*output=*/copyInputToOutput<ast::BinaryExpression>(),
     };
   }
 
   bool discardUnaryExpression(ast::UnaryExpression::Op,
-                              const LimitTypingContext &context) const {
+                              const DepthTypingContext &context) const {
     return context.expressionDepth >= maxExpressionDepth;
   }
 
@@ -58,12 +61,12 @@ class LimitTypeSystem : public TypeSystem<LimitTypingContext, LimitTypeSystem> {
   getUnaryExpressionTransferFns(ast::UnaryExpression::Op op) override {
     return {
         /*operand=*/incrementDepth<ast::UnaryExpression,
-                                   &LimitTypingContext::expressionDepth>(),
+                                   &DepthTypingContext::expressionDepth>(),
         /*output=*/copyInputToOutput<ast::UnaryExpression>(),
     };
   }
 
-  bool discardCastExpression(const LimitTypingContext &context) const {
+  bool discardCastExpression(const DepthTypingContext &context) const {
     return context.expressionDepth >= maxExpressionDepth;
   }
 
@@ -72,12 +75,12 @@ class LimitTypeSystem : public TypeSystem<LimitTypingContext, LimitTypeSystem> {
         /*target type=*/copyFromInput<ast::CastExpression>(),
         /*operand=*/
         incrementDepth<ast::CastExpression,
-                       &LimitTypingContext::expressionDepth>(),
+                       &DepthTypingContext::expressionDepth>(),
         /*output=*/copyInputToOutput<ast::CastExpression>(),
     };
   }
 
-  bool discardConditionalExpression(const LimitTypingContext &context) const {
+  bool discardConditionalExpression(const DepthTypingContext &context) const {
     return context.expressionDepth >= maxExpressionDepth;
   }
 
@@ -87,18 +90,18 @@ class LimitTypeSystem : public TypeSystem<LimitTypingContext, LimitTypeSystem> {
     // subelements.
     return {
         /*condition=*/incrementDepth<ast::ConditionalExpression,
-                                     &LimitTypingContext::expressionDepth>(),
+                                     &DepthTypingContext::expressionDepth>(),
         /*true value=*/
         incrementDepth<ast::ConditionalExpression,
-                       &LimitTypingContext::expressionDepth>(),
+                       &DepthTypingContext::expressionDepth>(),
         /*false value=*/
         incrementDepth<ast::ConditionalExpression,
-                       &LimitTypingContext::expressionDepth>(),
+                       &DepthTypingContext::expressionDepth>(),
         /*output=*/copyInputToOutput<ast::ConditionalExpression>(),
     };
   }
 
-  bool discardArrayReadExpression(const LimitTypingContext &context) const {
+  bool discardArrayReadExpression(const DepthTypingContext &context) const {
     return context.expressionDepth >= maxExpressionDepth;
   }
 
@@ -108,7 +111,7 @@ class LimitTypeSystem : public TypeSystem<LimitTypingContext, LimitTypeSystem> {
         /*array parameter=*/copyFromInput<ast::ArrayReadExpression>(),
         /*index=*/
         incrementDepth<ast::ArrayReadExpression,
-                       &LimitTypingContext::expressionDepth>(),
+                       &DepthTypingContext::expressionDepth>(),
         /*output=*/copyInputToOutput<ast::ArrayReadExpression>(),
     };
   }
@@ -123,14 +126,14 @@ class LimitTypeSystem : public TypeSystem<LimitTypingContext, LimitTypeSystem> {
         OutputTransferFn<ast::ArrayAssignmentStatement>(
             std::index_sequence<INPUT_DEPENDENCY>{},
             [](const ast::ArrayAssignmentStatement &,
-               LimitTypingContext context) {
+               DepthTypingContext context) {
               context.totalNumberOfStatements++;
               return context;
             }),
     };
   }
 
-  bool discardStatementList(const LimitTypingContext &context) const {
+  bool discardStatementList(const DepthTypingContext &context) const {
     return context.totalNumberOfStatements >= maxTotalStatements;
   }
 
@@ -147,8 +150,8 @@ class LimitTypeSystem : public TypeSystem<LimitTypingContext, LimitTypeSystem> {
         OutputTransferFn<ast::StatementList>(
             std::index_sequence<ast::StatementList::STATEMENT,
                                 ast::StatementList::STATEMENT_LIST>{},
-            [](const ast::StatementList &, LimitTypingContext statement,
-               const LimitTypingContext &statementList) {
+            [](const ast::StatementList &, DepthTypingContext statement,
+               const DepthTypingContext &statementList) {
               // Regardless of which of the two was generated first, we can
               // extract the total number of statements by taking their maximum.
               statement.totalNumberOfStatements =
@@ -167,7 +170,7 @@ class LimitTypeSystem : public TypeSystem<LimitTypingContext, LimitTypeSystem> {
         /*step=*/copyFromInput<ast::StructuredForStatement>(),
         /*statements=*/
         incrementDepth<ast::StructuredForStatement,
-                       &LimitTypingContext::totalNumberOfStatements>(),
+                       &DepthTypingContext::totalNumberOfStatements>(),
         /*output=*/
         copyToOutput<ast::StructuredForStatement,
                      ast::StructuredForStatement::BODY>(),
@@ -175,11 +178,83 @@ class LimitTypeSystem : public TypeSystem<LimitTypingContext, LimitTypeSystem> {
   }
 
   static ProbabilityTable<ExpressionKey>
-  getExpressionProbabilityTable(const LimitTypingContext &context);
+  getExpressionProbabilityTable(const DepthTypingContext &context);
 
   std::size_t maxExpressionDepth{};
   std::size_t maxTotalStatements{};
 };
+
+struct ParamTypingContext {
+  std::size_t numScalarParam{};
+  std::size_t numArrayParam{};
+
+  ParamTypingContext merge(const ParamTypingContext &rhs) const {
+    return {std::max(numScalarParam, rhs.numScalarParam),
+            std::max(numArrayParam, rhs.numArrayParam)};
+  }
+};
+
+/// Type system that caps the maximum amount of scalar parameters, array
+/// parameters and parameters in general.
+class ParamTypeSystem
+    : public VisitorTypeSystem<ParamTypingContext, ParamTypeSystem> {
+public:
+  explicit ParamTypeSystem(std::size_t maxScalarParam = 16,
+                           std::size_t maxArrayParam = 8,
+                           std::size_t maxParams = 256)
+      : maxScalarParam(maxScalarParam), maxArrayParam(maxArrayParam),
+        maxParams(maxParams) {}
+
+  bool discardFreshScalarParameter(const ParamTypingContext &context) const {
+    return context.numScalarParam >= maxScalarParam ||
+           context.numScalarParam + context.numArrayParam >= maxParams;
+  }
+
+  TransferFnArray<ast::ScalarParameter>
+  getFreshScalarParameterTransferFns() override {
+    return {
+        copyFromInput<ast::ScalarParameter>(),
+        OutputTransferFn<ast::ScalarParameter>(
+            std::index_sequence<INPUT_DEPENDENCY>{},
+            [](const ast::ScalarParameter &, ParamTypingContext context) {
+              context.numScalarParam++;
+              return context;
+            }),
+    };
+  }
+
+  bool discardFreshArrayParameter(const ParamTypingContext &context) const {
+    return context.numArrayParam >= maxArrayParam ||
+           context.numScalarParam + context.numArrayParam >= maxParams;
+  }
+
+  TransferFnArray<ast::ArrayParameter>
+  getFreshArrayParameterTransferFns() override {
+    return {
+        copyFromInput<ast::ArrayParameter>(),
+        OutputTransferFn<ast::ArrayParameter>(
+            std::index_sequence<INPUT_DEPENDENCY>{},
+            [](const ast::ArrayParameter &, ParamTypingContext context) {
+              context.numArrayParam++;
+              return context;
+            }),
+    };
+  }
+
+private:
+  std::size_t maxScalarParam{};
+  std::size_t maxArrayParam{};
+  std::size_t maxParams{};
+};
+
+} // namespace details
+
+/// Typesystem used to enforce limits such as number of a specific AST nodes,
+/// parameters, depth of expressions and so on.
+class LimitTypeSystem final
+    : public ConjunctionTypeSystemBase<
+          LimitTypeSystem, details::DepthTypeSystem, details::ParamTypeSystem> {
+};
 } // namespace dynamatic::gen
 
 #endif
diff --git a/tools/hls-fuzzer/VisitorTypeSystem.h b/tools/hls-fuzzer/VisitorTypeSystem.h
new file mode 100644
index 000000000..875cb159e
--- /dev/null
+++ b/tools/hls-fuzzer/VisitorTypeSystem.h
@@ -0,0 +1,188 @@
+#ifndef DYNAMATIC_HLS_FUZZER_VISITOR_TYPE_SYSTEM
+#define DYNAMATIC_HLS_FUZZER_VISITOR_TYPE_SYSTEM
+
+#include "TypeSystem.h"
+
+namespace dynamatic::gen {
+
+/// Convenient base class for any type systems that are "pure" visitors.
+/// These type systems:
+/// * Do not care about the order that AST nodes are generated.
+/// * Have a monotonic 'TypingContext' which only ever increases/decreases.
+///
+/// One property of this type system is that the most recent transfer function
+/// called is guaranteed to receive the maximum/minimum 'TypingContext'
+/// instance.
+/// This makes the type system especially useful to implement counters and
+/// similar.
+///
+/// The 'TypingContext' is required to contain a method with the signature:
+/// 'TypingContext merge(const TypingContext& rhs) const' which can be used
+/// to calculate the current maximum/minimum of all contexts generated so far.
+template <typename TypingContext, typename Self>
+class VisitorTypeSystem : public TypeSystem<TypingContext, Self> {
+
+public:
+  using Base = TypeSystem<TypingContext, Self>;
+
+protected:
+  /// Returns a 'TransferFn' which merges all present contexts of 'indices' and
+  /// the input context.
+  template <typename ASTNode, std::size_t... indices>
+  static auto getMergingTransferFn(std::index_sequence<indices...>) {
+    return TransferFn<TypingContext, ASTNode, INPUT_DEPENDENCY,
+                      weak(indices)...>(
+        [](TypingContext result, auto &&...args) -> TypingContext {
+          foreachInTuples(
+              [&](const auto &element) {
+                if constexpr (std::is_same_v<std::decay_t<decltype(element)>,
+                                             const TypingContext *>) {
+                  if (!element)
+                    return;
+                  result = result.merge(*element);
+                }
+              },
+              std::forward_as_tuple(std::forward<decltype(args)>(args)...));
+          return result;
+        });
+  }
+
+  /// Returns a 'TransferFn' which merges all present contexts including
+  /// the input context.
+  template <typename ASTNode>
+  static auto getMergingTransferFn() {
+    return getMergingTransferFn<ASTNode>(
+        std::make_index_sequence<
+            std::tuple_size_v<typename ASTNode::SubElements>>{});
+  }
+
+  /// Returns a 'OutputTransferFn' which merges all present contexts of
+  /// 'indices' and the input context.
+  template <typename ASTNode, std::size_t... indices>
+  static auto getMergingOutputTransferFn(std::index_sequence<indices...>) {
+    return OutputTransferFn<ASTNode>(
+        std::index_sequence<INPUT_DEPENDENCY, indices...>{},
+        [](const ASTNode &, TypingContext result,
+           const std::conditional_t<static_cast<bool>(indices), TypingContext,
+                                    TypingContext> &...args) -> TypingContext {
+          foreachInTuples(
+              [&](const auto &element) {
+                if constexpr (std::is_same_v<std::decay_t<decltype(element)>,
+                                             TypingContext>) {
+                  result = result.merge(element);
+                }
+              },
+              std::forward_as_tuple(std::forward<decltype(args)>(args)...));
+          return result;
+        });
+  }
+
+  /// Returns a 'OutputTransferFn' which merges all present contexts including
+  /// the input context.
+  template <typename ASTNode>
+  static auto getMergingOutputTransferFn() {
+    return getMergingOutputTransferFn<ASTNode>(
+        std::make_index_sequence<
+            std::tuple_size_v<typename ASTNode::SubElements>>{});
+  }
+
+  /// Returns a transfer array only consisting of merging transfer functions
+  /// and output functions.
+  template <typename ASTNode>
+  static TransferFnArray<ASTNode> getMergingTransferFnArray() {
+    return std::tuple_cat(
+        mapTuples([](auto &&) { return getMergingTransferFn<ASTNode>(); },
+                  getTupleOfIndices(
+                      std::make_index_sequence<
+                          std::tuple_size_v<typename ASTNode::SubElements>>{})),
+        std::tuple(getMergingOutputTransferFn<ASTNode>()));
+  }
+
+public:
+  TransferFnArray<ast::Function> getFunctionTransferFns() override {
+    return getMergingTransferFnArray<ast::Function>();
+  }
+
+  TransferFnArray<ast::ScalarType> getScalarTypeTransferFns() override {
+    return getMergingTransferFnArray<ast::ScalarType>();
+  }
+
+  TransferFnArray<ast::ReturnType> getReturnTypeTransferFns() override {
+    return getMergingTransferFnArray<ast::ReturnType>();
+  }
+
+  TransferFnArray<ast::ReturnStatement>
+  getReturnStatementTransferFns() override {
+    return getMergingTransferFnArray<ast::ReturnStatement>();
+  }
+
+  TransferFnArray<ast::BinaryExpression>
+  getBinaryExpressionTransferFns(ast::BinaryExpression::Op op) override {
+    return getMergingTransferFnArray<ast::BinaryExpression>();
+  }
+
+  TransferFnArray<ast::UnaryExpression>
+  getUnaryExpressionTransferFns(ast::UnaryExpression::Op op) override {
+    return getMergingTransferFnArray<ast::UnaryExpression>();
+  }
+
+  TransferFnArray<ast::Variable> getVariableTransferFns() override {
+    return getMergingTransferFnArray<ast::Variable>();
+  }
+
+  TransferFnArray<ast::CastExpression> getCastExpressionTransferFns() override {
+    return getMergingTransferFnArray<ast::CastExpression>();
+  }
+
+  TransferFnArray<ast::ConditionalExpression>
+  getConditionalExpressionTransferFns() override {
+    return getMergingTransferFnArray<ast::ConditionalExpression>();
+  }
+
+  TransferFnArray<ast::Constant> getConstantTransferFns() override {
+    return getMergingTransferFnArray<ast::Constant>();
+  }
+
+  TransferFnArray<ast::ScalarParameter>
+  getFreshScalarParameterTransferFns() override {
+    return getMergingTransferFnArray<ast::ScalarParameter>();
+  }
+
+  TransferFnArray<ast::ExistingScalarParameter>
+  getExistingScalarParameterTransferFns() override {
+    return getMergingTransferFnArray<ast::ExistingScalarParameter>();
+  }
+
+  TransferFnArray<ast::ArrayReadExpression>
+  getArrayReadExpressionTransferFns() override {
+    return getMergingTransferFnArray<ast::ArrayReadExpression>();
+  }
+
+  TransferFnArray<ast::ArrayParameter>
+  getFreshArrayParameterTransferFns() override {
+    return getMergingTransferFnArray<ast::ArrayParameter>();
+  }
+
+  TransferFnArray<ast::ExistingArrayParameter>
+  getExistingArrayParameterTransferFns() override {
+    return getMergingTransferFnArray<ast::ExistingArrayParameter>();
+  }
+
+  TransferFnArray<ast::ArrayAssignmentStatement>
+  getArrayAssignmentStatementTransferFns() override {
+    return getMergingTransferFnArray<ast::ArrayAssignmentStatement>();
+  }
+
+  TransferFnArray<ast::StatementList> getStatementListTransferFns() override {
+    return getMergingTransferFnArray<ast::StatementList>();
+  }
+
+  TransferFnArray<ast::StructuredForStatement>
+  getStructuredForStatementTransferFns() override {
+    return getMergingTransferFnArray<ast::StructuredForStatement>();
+  }
+};
+
+} // namespace dynamatic::gen
+
+#endif