diff --git a/xls/passes/BUILD b/xls/passes/BUILD
index cbcb73da0c..faabedff30 100644
--- a/xls/passes/BUILD
+++ b/xls/passes/BUILD
@@ -1662,6 +1662,7 @@ cc_library(
         "@com_google_absl//absl/algorithm:container",
         "@com_google_absl//absl/container:flat_hash_map",
         "@com_google_absl//absl/container:flat_hash_set",
+        "@com_google_absl//absl/functional:any_invocable",
         "@com_google_absl//absl/log:check",
         "@com_google_absl//absl/status",
         "@com_google_absl//absl/status:statusor",
@@ -4846,13 +4847,12 @@ cc_library(
         "//xls/ir:source_location",
         "//xls/ir:type",
         "//xls/ir:value",
-        "@com_google_absl//absl/algorithm:container",
+        "@com_google_absl//absl/container:btree",
         "@com_google_absl//absl/container:flat_hash_map",
         "@com_google_absl//absl/container:flat_hash_set",
         "@com_google_absl//absl/log:check",
         "@com_google_absl//absl/status",
         "@com_google_absl//absl/status:statusor",
-        "@com_google_absl//absl/strings",
         "@com_google_absl//absl/types:span",
     ],
 )
@@ -4880,6 +4880,7 @@ cc_test(
         "//xls/ir:function_builder",
         "//xls/ir:ir_matcher",
         "//xls/ir:ir_test_base",
+        "//xls/ir:op",
         "//xls/visualization:math_notation",
         "@com_google_absl//absl/log",
         "@com_google_absl//absl/status:statusor",
diff --git a/xls/passes/visibility_analysis.cc b/xls/passes/visibility_analysis.cc
index 30132ebf61..d21a646289 100644
--- a/xls/passes/visibility_analysis.cc
+++ b/xls/passes/visibility_analysis.cc
@@ -25,6 +25,7 @@
 #include "absl/algorithm/container.h"
 #include "absl/container/flat_hash_map.h"
 #include "absl/container/flat_hash_set.h"
+#include "absl/functional/any_invocable.h"
 #include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
@@ -538,6 +539,8 @@ BddNodeIndex OperandVisibilityAnalysis::ConditionOfUse(Node* node,
     return ConditionOnPredicate(node, user->As<Send>()->predicate());
   } else if (user->Is<Next>()) {
     return ConditionOnNextUse(user->As<Next>(), node);
+  } else if (user->Is<Gate>()) {
+    return ConditionOnPredicate(node, user->As<Gate>()->condition());
   } else if (user->OpIn({Op::kAnd, Op::kNand})) {
     return ConditionOfUseWithAnd(node, user->As<NaryOp>());
   } else if (user->OpIn({Op::kOr, Op::kNor})) {
@@ -796,8 +799,10 @@ bool VisibilityAnalysis::IsMutuallyExclusive(Node* one, Node* other) const {
   return bdd.Implies(*GetInfo(one), bdd.Not(*GetInfo(other))) == bdd.one();
 }
 
-absl::StatusOr<bool> OperandVisibilityAnalysis::IsVisibilityIndependentOf(
-    Node* operand, Node* node, std::vector<Node*>& sources) const {
+namespace {
+
+std::vector<Node*> GetVisibilityControlConditions(const Node* operand,
+                                                  const Node* node) {
   std::vector<Node*> conditions;
   if (node->Is<PrioritySelect>()) {
     conditions.push_back(node->As<PrioritySelect>()->selector());
@@ -807,16 +812,31 @@ absl::StatusOr<bool> OperandVisibilityAnalysis::IsVisibilityIndependentOf(
     conditions.push_back(*node->As<Send>()->predicate());
   } else if (node->Is<Next>() && node->As<Next>()->predicate().has_value()) {
     conditions.push_back(*node->As<Next>()->predicate());
+  } else if (node->Is<Gate>()) {
+    conditions.push_back(node->As<Gate>()->condition());
   } else if (node->OpIn({Op::kAnd, Op::kOr, Op::kNand, Op::kNor})) {
     for (Node* other_op : node->operands()) {
       if (other_op != operand) {
         conditions.push_back(other_op);
       }
     }
-  } else {
-    return absl::InvalidArgumentError(
-        absl::StrFormat("Unsupported node type for visibility expression: %s",
-                        node->ToString()));
+  }
+  return conditions;
+}
+
+}  // namespace
+
+absl::StatusOr<bool> OperandVisibilityAnalysis::IsVisibilityIndependentOf(
+    Node* operand, Node* node, std::vector<Node*>& sources) const {
+  std::vector<Node*> conditions = GetVisibilityControlConditions(operand, node);
+  if (conditions.empty()) {
+    if (!node->Is<PrioritySelect>() && !node->Is<Select>() &&
+        !node->Is<Send>() && !node->Is<Next>() &&
+        !node->OpIn({Op::kAnd, Op::kOr, Op::kNand, Op::kNor})) {
+      return absl::InvalidArgumentError(
+          absl::StrFormat("Unsupported node type for visibility expression: %s",
+                          node->ToString()));
+    }
   }
 
   for (Node* condition : conditions) {
@@ -977,6 +997,55 @@ VisibilityAnalysis::GetEdgesForMutuallyExclusiveVisibilityExpr(
   return kept_edges;
 }
 
+absl::StatusOr<absl::flat_hash_set<OperandVisibilityAnalysis::OperandNode>>
+VisibilityAnalysis::GetEdgesForConservativeVisibilityExpr(
+    Node* one, absl::AnyInvocable<bool(Node*) const> is_live_source,
+    int64_t max_edges_to_handle) const {
+  absl::flat_hash_set<OperandNode> kept_edges;
+  std::queue<Node*> worklist;
+  worklist.push(one);
+  absl::flat_hash_set<Node*> visited = {one};
+
+  while (!worklist.empty()) {
+    Node* node = worklist.front();
+    worklist.pop();
+
+    for (Node* user : node->users()) {
+      std::vector<Node*> conditions =
+          GetVisibilityControlConditions(node, user);
+
+      bool any_condition_live = false;
+      for (Node* condition : conditions) {
+        if (is_live_source(condition)) {
+          any_condition_live = true;
+          break;
+        }
+      }
+
+      const bool live_conditions = absl::c_any_of(
+          conditions,
+          [&](Node* condition) { return is_live_source(condition); });
+
+      if (conditions.empty() || live_conditions) {
+        if (operand_visibility_->OperandVisibilityThroughNode(node, user) !=
+            bdd_query_engine_->bdd().one()) {
+          kept_edges.insert({node, user});
+        }
+      }
+      if (visited.contains(user)) {
+        continue;
+      }
+      visited.insert(user);
+      worklist.push(user);
+    }
+  }
+
+  if (max_edges_to_handle >= 0 && kept_edges.size() > max_edges_to_handle) {
+    return absl::flat_hash_set<OperandNode>{};
+  }
+  return kept_edges;
+}
+
 /* static */ absl::StatusOr<std::unique_ptr<SingleSelectVisibilityAnalysis>>
 SingleSelectVisibilityAnalysis::Create(
     const OperandVisibilityAnalysis* operand_vis,
diff --git a/xls/passes/visibility_analysis.h b/xls/passes/visibility_analysis.h
index c962382398..dc83fcf280 100644
--- a/xls/passes/visibility_analysis.h
+++ b/xls/passes/visibility_analysis.h
@@ -24,6 +24,7 @@
 
 #include "absl/container/flat_hash_map.h"
 #include "absl/container/flat_hash_set.h"
+#include "absl/functional/any_invocable.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
@@ -229,6 +230,15 @@ class VisibilityAnalysis : public LazyNodeData<BddNodeIndex> {
                                              absl::Span<Node* const> others,
                                              int64_t max_edges_to_handle) const;
 
+  // Returns the (node -> user) edges necessary to compute a conservative
+  // visibility expression for 'one' such that only source nodes satisfying the
+  // given liveness predicate are included. Invalid edges are dynamically
+  // pruned to fold the expression conservatively.
+  absl::StatusOr<absl::flat_hash_set<OperandNode>>
+  GetEdgesForConservativeVisibilityExpr(
+      Node* one, absl::AnyInvocable<bool(Node*) const> is_live_source,
+      int64_t max_edges_to_handle) const;
+
   BddNodeIndex VisibilityOfNearestPostDominator(Node* node) const;
 
   const BddQueryEngine* bdd_query_engine() const { return bdd_query_engine_; }
diff --git a/xls/passes/visibility_expr_builder.cc b/xls/passes/visibility_expr_builder.cc
index 807d542f16..4fc3aab5dc 100644
--- a/xls/passes/visibility_expr_builder.cc
+++ b/xls/passes/visibility_expr_builder.cc
@@ -14,19 +14,20 @@
 
 #include "xls/passes/visibility_expr_builder.h"
 
+#include <algorithm>
 #include <cstdint>
+#include <functional>
 #include <optional>
 #include <tuple>
 #include <utility>
 #include <vector>
 
-#include "absl/algorithm/container.h"
+#include "absl/container/btree_set.h"
 #include "absl/container/flat_hash_map.h"
 #include "absl/container/flat_hash_set.h"
 #include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
-#include "absl/strings/str_cat.h"
 #include "absl/types/span.h"
 #include "xls/common/status/status_macros.h"
 #include "xls/data_structures/binary_decision_diagram.h"
@@ -50,14 +51,16 @@
 namespace xls {
 
 absl::StatusOr<Node*> VisibilityBuilder::GetSelectorIfIndependent(
-    Node* node, Node* select, Node* source, FunctionBase* func) {
+    Node* node, Node* select, Node* source, FunctionBase* func,
+    const std::function<bool(Node*)>& is_live_source) {
   Node* selector = nullptr;
   if (select->Is<Select>()) {
     selector = select->As<Select>()->selector();
   } else if (select->Is<PrioritySelect>()) {
     selector = select->As<PrioritySelect>()->selector();
   }
-  if (!selector || nda_.IsDependent(source, selector)) {
+  if (!selector || nda_.IsDependent(source, selector) ||
+      (is_live_source && !is_live_source(selector))) {
     return nullptr;
   }
   return MakeParamIfTmpFunc(selector, func);
@@ -91,9 +94,12 @@ bool VisibilityBuilder::DoesCaseImplyNoPrevCase(PrioritySelect* select,
 }
 
 absl::StatusOr<Node*> VisibilityBuilder::GetVisibilityExprForPrioritySelect(
-    Node* node, PrioritySelect* select, Node* source, FunctionBase* func) {
-  XLS_ASSIGN_OR_RETURN(Node * selector,
-                       GetSelectorIfIndependent(node, select, source, func));
+    Node* node, PrioritySelect* select, Node* source, FunctionBase* func,
+    const std::function<bool(Node*)>& is_live_source,
+    const std::function<int64_t(Node*)>& get_remaining_delay) {
+  XLS_ASSIGN_OR_RETURN(
+      Node * selector,
+      GetSelectorIfIndependent(node, select, source, func, is_live_source));
   if (!selector) {
     return nullptr;
   }
@@ -138,13 +144,22 @@ absl::StatusOr<Node*> VisibilityBuilder::GetVisibilityExprForPrioritySelect(
         func->MakeNode<CompareOp>(select->loc(), selector, zero, Op::kEq));
     or_cases.push_back(selector_is_zero);
   }
-  return OrOperands(or_cases);
+
+  XLS_ASSIGN_OR_RETURN(Node * result, OrOperands(or_cases));
+  if (get_remaining_delay && get_remaining_delay(result) < 0) {
+    // This would push the condition over the acceptable delay.
+    return nullptr;
+  }
+  return result;
 }
 
 absl::StatusOr<Node*> VisibilityBuilder::GetVisibilityExprForSelect(
-    Node* node, Select* select, Node* source, FunctionBase* func) {
-  XLS_ASSIGN_OR_RETURN(Node * selector,
-                       GetSelectorIfIndependent(node, select, source, func));
+    Node* node, Select* select, Node* source, FunctionBase* func,
+    const std::function<bool(Node*)>& is_live_source,
+    const std::function<int64_t(Node*)>& get_remaining_delay) {
+  XLS_ASSIGN_OR_RETURN(
+      Node * selector,
+      GetSelectorIfIndependent(node, select, source, func, is_live_source));
   if (!selector) {
     return nullptr;
   }
@@ -175,12 +190,18 @@ absl::StatusOr<Node*> VisibilityBuilder::GetVisibilityExprForSelect(
                                                    value_num_cases, Op::kUGe));
     or_cases.push_back(is_default);
   }
-  return OrOperands(or_cases);
+  XLS_ASSIGN_OR_RETURN(Node * result, OrOperands(or_cases));
+  if (get_remaining_delay && get_remaining_delay(result) < 0) {
+    // This would push the condition over the acceptable delay.
+    return nullptr;
+  }
+  return result;
 }
 
 // Find the source bits of operand, and if unknown, use the operand itself.
 absl::StatusOr<Node*> VisibilityBuilder::GetNonRepeatedSourceOf(
-    Node* operand, FunctionBase* func) {
+    Node* operand, FunctionBase* func,
+    const std::function<bool(Node*)>& is_live_source) {
   XLS_ASSIGN_OR_RETURN(auto bit_sources_tree, bpa_.GetBitSources(operand));
   LeafTypeTree<TreeBitSources> trimmed_bit_sources_tree =
       BitProvenanceAnalysis::TrimRepeatedSourceBits(
@@ -189,6 +210,9 @@ absl::StatusOr<Node*> VisibilityBuilder::GetNonRepeatedSourceOf(
   if (source_ranges.size() == 1) {
     const TreeBitSources::BitRange& single_range = source_ranges[0];
     Node* source = single_range.source_node();
+    if (is_live_source && !is_live_source(source)) {
+      return operand;
+    }
     // Clone the source node if building expressions in a temp function.
     XLS_ASSIGN_OR_RETURN(source, MakeParamIfTmpFunc(source, func));
     // If derived from a single range of contiguous bits, find or create a bit
@@ -211,7 +235,9 @@ absl::StatusOr<Node*> VisibilityBuilder::GetNonRepeatedSourceOf(
 }
 
 absl::StatusOr<Node*> VisibilityBuilder::GetVisibilityExprForAnd(
-    Node* node, NaryOp* and_node, Node* source, FunctionBase* func) {
+    Node* node, NaryOp* and_node, Node* source, FunctionBase* func,
+    const std::function<bool(Node*)>& is_live_source,
+    const std::function<int64_t(Node*)>& get_remaining_delay) {
   std::vector<Node*> others_not_zero;
   for (Node* operand : and_node->operands()) {
     if (nda_.IsDependent(source, operand)) {
@@ -219,10 +245,8 @@ absl::StatusOr<Node*> VisibilityBuilder::GetVisibilityExprForAnd(
     }
 
     XLS_ASSIGN_OR_RETURN(Node * compare_val,
-                         GetNonRepeatedSourceOf(operand, func));
+                         GetNonRepeatedSourceOf(operand, func, is_live_source));
 
-    // If operand is derived from a single bit, we can simply check that the
-    // source bit is set to determine that @node is visible
     if (compare_val->GetType()->GetFlatBitCount() == 1) {
       others_not_zero.push_back(compare_val);
       continue;
@@ -238,11 +262,41 @@ absl::StatusOr<Node*> VisibilityBuilder::GetVisibilityExprForAnd(
                                                    value_zero, Op::kNe));
     others_not_zero.push_back(is_not_zero);
   }
-  return AndOperands(others_not_zero);
+
+  if (others_not_zero.empty()) {
+    return AndOperands(others_not_zero);
+  }
+  if (others_not_zero.size() == 1) {
+    return others_not_zero[0];
+  }
+
+  XLS_ASSIGN_OR_RETURN(
+      Node * result,
+      func->MakeNode<NaryOp>(and_node->loc(), others_not_zero, Op::kAnd));
+  if (get_remaining_delay && get_remaining_delay(result) < 0) {
+    std::sort(others_not_zero.begin(), others_not_zero.end(),
+              [&](Node* a, Node* b) {
+                return get_remaining_delay(a) > get_remaining_delay(b);
+              });
+    while (!others_not_zero.empty() && get_remaining_delay(result) < 0) {
+      others_not_zero.pop_back();
+      if (others_not_zero.empty()) {
+        XLS_ASSIGN_OR_RETURN(result, func->MakeNode<Literal>(
+                                         and_node->loc(), Value(UBits(1, 1))));
+        break;
+      }
+      XLS_ASSIGN_OR_RETURN(
+          result,
+          func->MakeNode<NaryOp>(and_node->loc(), others_not_zero, Op::kAnd));
+    }
+  }
+  return result;
 }
 
 absl::StatusOr<Node*> VisibilityBuilder::GetVisibilityExprForOr(
-    Node* node, NaryOp* or_node, Node* source, FunctionBase* func) {
+    Node* node, NaryOp* or_node, Node* source, FunctionBase* func,
+    const std::function<bool(Node*)>& is_live_source,
+    const std::function<int64_t(Node*)>& get_remaining_delay) {
   std::vector<Node*> others_not_ones;
   for (Node* operand : or_node->operands()) {
     if (nda_.IsDependent(source, operand)) {
@@ -250,10 +304,8 @@ absl::StatusOr<Node*> VisibilityBuilder::GetVisibilityExprForOr(
     }
 
     XLS_ASSIGN_OR_RETURN(Node * compare_val,
-                         GetNonRepeatedSourceOf(operand, func));
+                         GetNonRepeatedSourceOf(operand, func, is_live_source));
 
-    // If operand is derived from a single bit, we can simply check that the
-    // source bit is NOT set to determine that @node is visible
     if (compare_val->GetType()->GetFlatBitCount() == 1) {
       XLS_ASSIGN_OR_RETURN(
           Node * not_single_bit_value,
@@ -272,48 +324,88 @@ absl::StatusOr<Node*> VisibilityBuilder::GetVisibilityExprForOr(
                                                    value_ones, Op::kNe));
     others_not_ones.push_back(is_not_ones);
   }
-  return AndOperands(others_not_ones);
+
+  if (others_not_ones.empty()) {
+    return AndOperands(others_not_ones);
+  }
+
+  XLS_ASSIGN_OR_RETURN(Node * result, AndOperands(others_not_ones));
+  if (get_remaining_delay && get_remaining_delay(result) < 0) {
+    std::sort(others_not_ones.begin(), others_not_ones.end(),
+              [&](Node* a, Node* b) {
+                return get_remaining_delay(a) > get_remaining_delay(b);
+              });
+    while (!others_not_ones.empty() && get_remaining_delay(result) < 0) {
+      others_not_ones.pop_back();
+      if (others_not_ones.empty()) {
+        XLS_ASSIGN_OR_RETURN(result, func->MakeNode<Literal>(
+                                         or_node->loc(), Value(UBits(1, 1))));
+        break;
+      }
+      XLS_ASSIGN_OR_RETURN(result, AndOperands(others_not_ones));
+    }
+  }
+  return result;
 }
 
 absl::StatusOr<Node*> VisibilityBuilder::GetVisibilityExprForPredicate(
-    std::optional<Node*> predicate, Node* source, FunctionBase* func) {
-  if (!predicate.has_value() || nda_.IsDependent(source, *predicate)) {
+    std::optional<Node*> predicate, Node* source, FunctionBase* func,
+    const std::function<bool(Node*)>& is_live_source,
+    const std::function<int64_t(Node*)>& get_remaining_delay) {
+  if (!predicate.has_value() || nda_.IsDependent(source, *predicate) ||
+      (is_live_source && !is_live_source(*predicate))) {
     return nullptr;
   }
   return MakeParamIfTmpFunc(*predicate, func);
 }
 
 absl::StatusOr<Node*> VisibilityBuilder::BuildVisibilityExprHelper(
-    Node* node, Node* user, Node* source, FunctionBase* func) {
+    Node* node, Node* user, Node* source, FunctionBase* func,
+    const std::function<bool(Node*)>& is_live_source,
+    const std::function<int64_t(Node*)>& get_remaining_delay) {
   if (user->Is<Select>()) {
-    return GetVisibilityExprForSelect(node, user->As<Select>(), source, func);
+    return GetVisibilityExprForSelect(node, user->As<Select>(), source, func,
+                                      is_live_source, get_remaining_delay);
   } else if (user->Is<PrioritySelect>()) {
     return GetVisibilityExprForPrioritySelect(node, user->As<PrioritySelect>(),
-                                              source, func);
+                                              source, func, is_live_source,
+                                              get_remaining_delay);
   } else if (user->Is<Send>()) {
     return GetVisibilityExprForPredicate(user->As<Send>()->predicate(), source,
-                                         func);
+                                         func, is_live_source,
+                                         get_remaining_delay);
   } else if (user->Is<Next>()) {
     return GetVisibilityExprForPredicate(user->As<Next>()->predicate(), source,
-                                         func);
+                                         func, is_live_source,
+                                         get_remaining_delay);
+  } else if (user->Is<Gate>()) {
+    return GetVisibilityExprForPredicate(user->As<Gate>()->condition(), source,
+                                         func, is_live_source,
+                                         get_remaining_delay);
   } else if (user->OpIn({Op::kAnd, Op::kNand})) {
-    return GetVisibilityExprForAnd(node, user->As<NaryOp>(), source, func);
+    return GetVisibilityExprForAnd(node, user->As<NaryOp>(), source, func,
+                                   is_live_source, get_remaining_delay);
   } else if (user->OpIn({Op::kOr, Op::kNor})) {
-    return GetVisibilityExprForOr(node, user->As<NaryOp>(), source, func);
+    return GetVisibilityExprForOr(node, user->As<NaryOp>(), source, func,
+                                  is_live_source, get_remaining_delay);
   }
   return nullptr;
 }
 
 // Builds predicate for node `u` being used by `v` on `func`.
 absl::StatusOr<Node*> VisibilityBuilder::BuildVisibilityExpr(
-    Node* node, Node* user, Node* source, FunctionBase* func) {
+    Node* node, Node* user, Node* source, FunctionBase* func,
+    const std::function<bool(Node*)>& is_live_source,
+    const std::function<int64_t(Node*)>& get_remaining_delay) {
   auto cache_key = std::make_tuple(node, user, func);
   if (auto it = visibility_expr_cache_.find(cache_key);
       it != visibility_expr_cache_.end()) {
     return it->second;
   }
-  XLS_ASSIGN_OR_RETURN(Node * visibility,
-                       BuildVisibilityExprHelper(node, user, source, func));
+  XLS_ASSIGN_OR_RETURN(
+      Node * visibility,
+      BuildVisibilityExprHelper(node, user, source, func, is_live_source,
+                                get_remaining_delay));
   return visibility_expr_cache_[cache_key] = visibility;
 }
 
@@ -339,7 +431,11 @@ absl::StatusOr<Node*> VisibilityBuilder::BuildVisibilityIRExprFromEdges(
     const absl::flat_hash_set<OperandVisibilityAnalysis::OperandNode>&
         conditional_edges,
     absl::flat_hash_map<Node*, Node*>& node_to_visibility_ir_cache,
-    Literal* always_visible) {
+    Literal* always_visible, const std::function<bool(Node*)>& is_live_source,
+    const std::function<int64_t(Node*)>& get_remaining_delay) {
+  if (is_live_source && !is_live_source(node)) {
+    return always_visible;
+  }
   if (node->users().empty()) {
     return always_visible;
   }
@@ -348,39 +444,81 @@ absl::StatusOr<Node*> VisibilityBuilder::BuildVisibilityIRExprFromEdges(
     return it->second;
   }
 
-  absl::flat_hash_set<Node*> user_visibilities;
+  absl::btree_set<Node*, Node::NodeIdLessThan> user_visibilities;
   for (Node* user : node->users()) {
     if (user->id() > prior_existing_id_) {
       continue;
     }
-    XLS_ASSIGN_OR_RETURN(Node * user_is_used,
-                         BuildVisibilityIRExprFromEdges(
-                             func, user, source, conditional_edges,
-                             node_to_visibility_ir_cache, always_visible));
+    XLS_ASSIGN_OR_RETURN(
+        Node * user_is_used,
+        BuildVisibilityIRExprFromEdges(
+            func, user, source, conditional_edges, node_to_visibility_ir_cache,
+            always_visible, is_live_source, get_remaining_delay));
     Node* user_uses_node = always_visible;
     if (conditional_edges.contains({node, user})) {
-      XLS_ASSIGN_OR_RETURN(user_uses_node,
-                           BuildVisibilityExpr(node, user, source, func));
+      XLS_ASSIGN_OR_RETURN(
+          user_uses_node,
+          BuildVisibilityExpr(node, user, source, func, is_live_source,
+                              get_remaining_delay));
       if (!user_uses_node) {
-        return absl::InternalError(absl::StrCat(
-            "conditional edge exists but visibility expression could NOT be "
-            "made between ",
-            node->GetName(), " and ", user->GetName()));
+        user_uses_node = always_visible;
       }
     }
     if (user_uses_node == always_visible && user_is_used == always_visible) {
       return node_to_visibility_ir_cache[node] = always_visible;
     }
 
+    std::vector<Node*> and_operands;
+    if (user_uses_node != always_visible) {
+      if (user_uses_node->op() == Op::kAnd) {
+        and_operands.insert(and_operands.end(),
+                            user_uses_node->operands().begin(),
+                            user_uses_node->operands().end());
+      } else {
+        and_operands.push_back(user_uses_node);
+      }
+    }
+    if (user_is_used != always_visible) {
+      if (user_is_used->op() == Op::kAnd) {
+        and_operands.insert(and_operands.end(),
+                            user_is_used->operands().begin(),
+                            user_is_used->operands().end());
+      } else {
+        and_operands.push_back(user_is_used);
+      }
+    }
+
     Node* node_and_user_visible;
-    if (user_uses_node == always_visible) {
-      node_and_user_visible = user_is_used;
-    } else if (user_is_used == always_visible) {
-      node_and_user_visible = user_uses_node;
+    if (and_operands.empty()) {
+      node_and_user_visible = always_visible;
+    } else if (and_operands.size() == 1) {
+      node_and_user_visible = and_operands[0];
     } else {
       XLS_ASSIGN_OR_RETURN(
           node_and_user_visible,
-          FindOrMakeBinaryNode(Op::kAnd, user_uses_node, user_is_used));
+          func->MakeNode<NaryOp>(SourceInfo(), and_operands, Op::kAnd));
+      if (get_remaining_delay &&
+          get_remaining_delay(node_and_user_visible) < 0) {
+        std::sort(and_operands.begin(), and_operands.end(),
+                  [&](Node* a, Node* b) {
+                    return get_remaining_delay(a) > get_remaining_delay(b);
+                  });
+        while (!and_operands.empty() &&
+               get_remaining_delay(node_and_user_visible) < 0) {
+          and_operands.pop_back();
+          if (and_operands.empty()) {
+            node_and_user_visible = always_visible;
+            break;
+          }
+          if (and_operands.size() == 1) {
+            node_and_user_visible = and_operands[0];
+          } else {
+            XLS_ASSIGN_OR_RETURN(
+                node_and_user_visible,
+                func->MakeNode<NaryOp>(SourceInfo(), and_operands, Op::kAnd));
+          }
+        }
+      }
     }
     user_visibilities.insert(node_and_user_visible);
   }
@@ -391,15 +529,30 @@ absl::StatusOr<Node*> VisibilityBuilder::BuildVisibilityIRExprFromEdges(
   if (user_visibilities.size() == 1) {
     return node_to_visibility_ir_cache[node] = *user_visibilities.begin();
   }
-  std::vector<Node*> user_vis_vec{user_visibilities.begin(),
-                                  user_visibilities.end()};
-  absl::c_sort(user_vis_vec,
-               [&](Node* a, Node* b) { return a->id() < b->id(); });
-  Node* any_user_visible = user_vis_vec[0];
-  for (int64_t i = 1; i < user_vis_vec.size(); ++i) {
+  std::vector<Node*> user_vis_vec;
+  for (Node* n : user_visibilities) {
+    if (n != always_visible) {
+      if (n->op() == Op::kOr) {
+        user_vis_vec.insert(user_vis_vec.end(), n->operands().begin(),
+                            n->operands().end());
+      } else {
+        user_vis_vec.push_back(n);
+      }
+    }
+  }
+
+  Node* any_user_visible;
+  if (user_vis_vec.empty()) {
+    any_user_visible = always_visible;
+  } else if (user_vis_vec.size() == 1) {
+    any_user_visible = user_vis_vec[0];
+  } else {
     XLS_ASSIGN_OR_RETURN(
         any_user_visible,
-        FindOrMakeBinaryNode(Op::kOr, any_user_visible, user_vis_vec[i]));
+        func->MakeNode<NaryOp>(SourceInfo(), user_vis_vec, Op::kOr));
+    if (get_remaining_delay && get_remaining_delay(any_user_visible) < 0) {
+      any_user_visible = always_visible;
+    }
   }
   return node_to_visibility_ir_cache[node] = any_user_visible;
 }
@@ -407,22 +560,80 @@ absl::StatusOr<Node*> VisibilityBuilder::BuildVisibilityIRExprFromEdges(
 absl::StatusOr<Node*> VisibilityBuilder::BuildVisibilityIRExpr(
     FunctionBase* func, Node* node,
     const absl::flat_hash_set<OperandVisibilityAnalysis::OperandNode>&
-        conditional_edges) {
+        conditional_edges,
+    std::function<bool(Node*)> is_live_source,
+    std::function<int64_t(Node*)> get_remaining_delay,
+    std::optional<int64_t> target_stage) {
+  int64_t max_id_before = 0;
+  if (target_stage.has_value()) {
+    for (Node* n : func->nodes()) {
+      max_id_before = std::max(max_id_before, n->id());
+    }
+  }
+
   XLS_ASSIGN_OR_RETURN(
       Literal * always_visible,
       func->MakeNode<Literal>(SourceInfo(), Value(UBits(1, 1))));
+
+  Node* result_expr = nullptr;
   if (conditional_edges.size() == 1) {
     XLS_ASSIGN_OR_RETURN(
         Node * user_uses_node,
         BuildVisibilityExpr(conditional_edges.begin()->operand,
-                            conditional_edges.begin()->node, node, func));
-    return user_uses_node ? user_uses_node : always_visible;
-  }
-  absl::flat_hash_map<Node*, Node*> node_to_visibility_ir_cache;
-  absl::flat_hash_map<std::tuple<Op, Node*, Node*>, Node*> binary_op_cache;
-  return BuildVisibilityIRExprFromEdges(func, node, node, conditional_edges,
-                                        node_to_visibility_ir_cache,
-                                        always_visible);
+                            conditional_edges.begin()->node, node, func,
+                            is_live_source, get_remaining_delay));
+    result_expr = user_uses_node ? user_uses_node : always_visible;
+  } else {
+    absl::flat_hash_map<Node*, Node*> node_to_visibility_ir_cache;
+    absl::flat_hash_map<std::tuple<Op, Node*, Node*>, Node*> binary_op_cache;
+    XLS_ASSIGN_OR_RETURN(
+        result_expr,
+        BuildVisibilityIRExprFromEdges(
+            func, node, node, conditional_edges, node_to_visibility_ir_cache,
+            always_visible, is_live_source, get_remaining_delay));
+  }
+
+  if (target_stage.has_value()) {
+    for (Node* n : func->nodes()) {
+      if (n->id() > max_id_before) {
+        XLS_RETURN_IF_ERROR(func->AddNodeToStage(*target_stage, n).status());
+      }
+    }
+  }
+
+  return result_expr;
+}
+
+absl::Status VisibilityBuilder::CleanUpUnusedNodes(FunctionBase* fb) {
+  std::vector<Node*> worklist;
+  absl::flat_hash_set<Node*> dead_nodes;
+
+  for (Node* n : fb->nodes()) {
+    if (n->id() > prior_existing_id_ && n->IsDead()) {
+      dead_nodes.insert(n);
+      worklist.push_back(n);
+    }
+  }
+
+  while (!worklist.empty()) {
+    Node* n = worklist.back();
+    worklist.pop_back();
+
+    std::vector<Node*> operands(n->operands().begin(), n->operands().end());
+
+    CHECK_GT(dead_nodes.erase(n), 0);
+    XLS_RETURN_IF_ERROR(fb->RemoveNode(n));
+
+    for (Node* operand : operands) {
+      if (operand->id() > prior_existing_id_ && operand->IsDead()) {
+        if (auto [_, inserted] = dead_nodes.insert(operand); inserted) {
+          worklist.push_back(operand);
+        }
+      }
+    }
+  }
+
+  return absl::OkStatus();
 }
 
 absl::StatusOr<VisibilityEstimator::AreaDelay>
diff --git a/xls/passes/visibility_expr_builder.h b/xls/passes/visibility_expr_builder.h
index 10a253c5e8..c2ff65cb50 100644
--- a/xls/passes/visibility_expr_builder.h
+++ b/xls/passes/visibility_expr_builder.h
@@ -16,6 +16,7 @@
 #define XLS_PASSES_VISIBILITY_EXPR_BUILDER_H_
 
 #include <cstdint>
+#include <functional>
 #include <optional>
 #include <tuple>
 
@@ -100,38 +101,55 @@ class VisibilityBuilder : public ExpressionBuilder {
   absl::StatusOr<Node*> BuildVisibilityIRExpr(
       FunctionBase* func, Node* node,
       const absl::flat_hash_set<OperandVisibilityAnalysis::OperandNode>&
-          conditional_edges);
+          conditional_edges,
+      std::function<bool(Node*)> is_live_source = nullptr,
+      std::function<int64_t(Node*)> get_remaining_delay = nullptr,
+      std::optional<int64_t> target_stage = std::nullopt);
+
+  // Cleans up any nodes created by this builder that have no users.
+  // This is useful for removing dead visibility expressions.
+  absl::Status CleanUpUnusedNodes(FunctionBase* fb);
 
  private:
   absl::StatusOr<Node*> MakeParamIfTmpFunc(Node* node, FunctionBase* func) {
     return func == TmpFunc() ? TmpFuncNodeOrParam(node) : node;
   }
 
-  absl::StatusOr<Node*> GetSelectorIfIndependent(Node* node, Node* select,
-                                                 Node* source,
-                                                 FunctionBase* func);
+  absl::StatusOr<Node*> GetSelectorIfIndependent(
+      Node* node, Node* select, Node* source, FunctionBase* func,
+      const std::function<bool(Node*)>& is_live_source);
   bool DoesCaseImplyNoPrevCase(PrioritySelect* select, int64_t case_index);
 
   absl::StatusOr<Node*> GetVisibilityExprForPrioritySelect(
-      Node* node, PrioritySelect* select, Node* source, FunctionBase* func);
-  absl::StatusOr<Node*> GetVisibilityExprForSelect(Node* node, Select* select,
-                                                   Node* source,
-                                                   FunctionBase* func);
-  absl::StatusOr<Node*> GetVisibilityExprForAnd(Node* node, NaryOp* and_node,
-                                                Node* source,
-                                                FunctionBase* func);
-  absl::StatusOr<Node*> GetVisibilityExprForOr(Node* node, NaryOp* or_node,
-                                               Node* source,
-                                               FunctionBase* func);
+      Node* node, PrioritySelect* select, Node* source, FunctionBase* func,
+      const std::function<bool(Node*)>& is_live_source,
+      const std::function<int64_t(Node*)>& get_remaining_delay);
+  absl::StatusOr<Node*> GetVisibilityExprForSelect(
+      Node* node, Select* select, Node* source, FunctionBase* func,
+      const std::function<bool(Node*)>& is_live_source,
+      const std::function<int64_t(Node*)>& get_remaining_delay);
+  absl::StatusOr<Node*> GetVisibilityExprForAnd(
+      Node* node, NaryOp* and_node, Node* source, FunctionBase* func,
+      const std::function<bool(Node*)>& is_live_source,
+      const std::function<int64_t(Node*)>& get_remaining_delay);
+  absl::StatusOr<Node*> GetVisibilityExprForOr(
+      Node* node, NaryOp* or_node, Node* source, FunctionBase* func,
+      const std::function<bool(Node*)>& is_live_source,
+      const std::function<int64_t(Node*)>& get_remaining_delay);
   absl::StatusOr<Node*> GetVisibilityExprForPredicate(
-      std::optional<Node*> predicate, Node* source, FunctionBase* func);
-
-  absl::StatusOr<Node*> BuildVisibilityExprHelper(Node* node, Node* user,
-                                                  Node* source,
-                                                  FunctionBase* func);
+      std::optional<Node*> predicate, Node* source, FunctionBase* func,
+      const std::function<bool(Node*)>& is_live_source,
+      const std::function<int64_t(Node*)>& get_remaining_delay);
+
+  absl::StatusOr<Node*> BuildVisibilityExprHelper(
+      Node* node, Node* user, Node* source, FunctionBase* func,
+      const std::function<bool(Node*)>& is_live_source,
+      const std::function<int64_t(Node*)>& get_remaining_delay);
   // Builds predicate for node `u` being used by `v` on `func`.
-  absl::StatusOr<Node*> BuildVisibilityExpr(Node* node, Node* user,
-                                            Node* source, FunctionBase* func);
+  absl::StatusOr<Node*> BuildVisibilityExpr(
+      Node* node, Node* user, Node* source, FunctionBase* func,
+      const std::function<bool(Node*)>& is_live_source,
+      const std::function<int64_t(Node*)>& get_remaining_delay);
   absl::StatusOr<Node*> BuildNodeAndUserVisibleExpr(FunctionBase* func,
                                                     Node* user_uses_node,
                                                     Node* user_is_used,
@@ -142,10 +160,12 @@ class VisibilityBuilder : public ExpressionBuilder {
       const absl::flat_hash_set<OperandVisibilityAnalysis::OperandNode>&
           conditional_edges,
       absl::flat_hash_map<Node*, Node*>& node_to_visibility_ir_cache,
-      Literal* always_visible);
+      Literal* always_visible, const std::function<bool(Node*)>& is_live_source,
+      const std::function<int64_t(Node*)>& get_remaining_delay);
 
-  absl::StatusOr<Node*> GetNonRepeatedSourceOf(Node* operand,
-                                               FunctionBase* func);
+  absl::StatusOr<Node*> GetNonRepeatedSourceOf(
+      Node* operand, FunctionBase* func,
+      const std::function<bool(Node*)>& is_live_source);
 };
 
 class VisibilityEstimator : public VisibilityBuilder {
diff --git a/xls/passes/visibility_expr_builder_test.cc b/xls/passes/visibility_expr_builder_test.cc
index 81c0f87b32..716b00f095 100644
--- a/xls/passes/visibility_expr_builder_test.cc
+++ b/xls/passes/visibility_expr_builder_test.cc
@@ -14,6 +14,7 @@
 
 #include "xls/passes/visibility_expr_builder.h"
 
+#include <cstdint>
 #include <memory>
 #include <utility>
 #include <vector>
@@ -33,6 +34,9 @@
 #include "xls/ir/function_builder.h"
 #include "xls/ir/ir_matcher.h"
 #include "xls/ir/ir_test_base.h"
+#include "xls/ir/nodes.h"
+#include "xls/ir/op.h"
+#include "xls/ir/scheduled_builder.h"
 #include "xls/passes/bdd_query_engine.h"
 #include "xls/passes/bit_provenance_analysis.h"
 #include "xls/passes/node_dependency_analysis.h"
@@ -113,20 +117,19 @@ TEST_F(VisibilityExprBuilderTest, ExampleInFunctionHeaderComment) {
   VLOG(3) << "is 'y' used:\n" << ToMathNotation(is_y_used.first);
 
   EXPECT_THAT(is_x_used.first,
-              m::Or(m::Or(m::Eq(m::Param("op1"), m::Literal(0)),
-                          m::Eq(m::Param("op1"), m::Literal(2))),
+              m::Or(m::Eq(m::Param("op1"), m::Literal(0)),
+                    m::Eq(m::Param("op1"), m::Literal(2)),
                     m::And(m::ULt(m::Param("op2"), m::Literal(5)),
                            m::UGe(m::Param("op1"), m::Literal(3)))));
-  // 6 instead of 7 because of the re-use of the ult.
-  EXPECT_EQ(is_x_used.second.area, 6);
+  // 5 instead of 6 because of flat OR gate consolidation.
+  EXPECT_EQ(is_x_used.second.area, 5);
   EXPECT_EQ(is_x_used.second.delay, 3);
-  EXPECT_THAT(is_y_used.first,
-              m::Or(m::Or(m::Eq(m::Param("op1"), m::Literal(1)),
-                          m::UGe(m::Param("op1"), m::Literal(3))),
-                    m::Or(m::Eq(m::Param("op1"), m::Literal(0)),
-                          m::Eq(m::Param("op1"), m::Literal(2)))));
-  EXPECT_EQ(is_y_used.second.area, 7);
-  EXPECT_EQ(is_y_used.second.delay, 3);
+  EXPECT_THAT(is_y_used.first, m::Or(m::Eq(m::Param("op1"), m::Literal(1)),
+                                     m::UGe(m::Param("op1"), m::Literal(3)),
+                                     m::Eq(m::Param("op1"), m::Literal(0)),
+                                     m::Eq(m::Param("op1"), m::Literal(2))));
+  EXPECT_EQ(is_y_used.second.area, 5);
+  EXPECT_EQ(is_y_used.second.delay, 2);
 
   // Now that the returned expression must be mutually exclusive with z's
   // visibility, it must condition on the selection criteria of 'select2'.
@@ -136,11 +139,11 @@ TEST_F(VisibilityExprBuilderTest, ExampleInFunctionHeaderComment) {
   VLOG(3) << "is 'x' used and 'z' not used:\n"
           << ToMathNotation(is_x_used_and_z_not.first);
   EXPECT_THAT(is_x_used_and_z_not.first,
-              m::Or(m::Or(m::Eq(m::Param("op1"), m::Literal(0)),
-                          m::Eq(m::Param("op1"), m::Literal(2))),
+              m::Or(m::Eq(m::Param("op1"), m::Literal(0)),
+                    m::Eq(m::Param("op1"), m::Literal(2)),
                     m::UGe(m::Param("op1"), m::Literal(3))));
-  EXPECT_EQ(is_x_used_and_z_not.second.area, 5);
-  EXPECT_EQ(is_x_used_and_z_not.second.delay, 3);
+  EXPECT_EQ(is_x_used_and_z_not.second.area, 4);
+  EXPECT_EQ(is_x_used_and_z_not.second.delay, 2);
 }
 
 TEST_F(VisibilityExprBuilderTest, PrioritySelectOneHot) {
@@ -207,9 +210,9 @@ TEST_F(VisibilityExprBuilderTest, Ors) {
   std::pair<Node*, VisibilityEstimator::AreaDelay> is_y_used;
   XLS_ASSERT_OK_AND_ASSIGN(is_y_used,
                            BuildDefaultVisibilityExpr(f, y.node(), {}));
-  ASSERT_THAT(is_y_used.first,
-              m::Ne(m::BitSlice(m::Param("x"), 1, 2), m::Literal(3)));
-  EXPECT_EQ(is_y_used.first->operand(0), bits12.node());
+  EXPECT_THAT(is_y_used.first,
+              m::Or(m::Not(m::BitSlice(m::Param("x"), 1, 1)),
+                    m::Ne(m::BitSlice(m::Param("x"), 1, 2), m::Literal(3))));
 }
 
 TEST_F(VisibilityExprBuilderTest, Ands) {
@@ -226,7 +229,9 @@ TEST_F(VisibilityExprBuilderTest, Ands) {
   std::pair<Node*, VisibilityEstimator::AreaDelay> is_y_used;
   XLS_ASSERT_OK_AND_ASSIGN(is_y_used,
                            BuildDefaultVisibilityExpr(f, y.node(), {}));
-  EXPECT_EQ(is_y_used.first, bit1.node());
+  EXPECT_THAT(is_y_used.first,
+              m::And(m::Ne(m::BitSlice(m::Param("x"), 1, 2), m::Literal(0)),
+                     m::BitSlice(m::Param("x"), 1, 1)));
 }
 
 TEST_F(VisibilityExprBuilderTest, FindsSourceOfOperandInComparison) {
@@ -260,5 +265,330 @@ TEST_F(VisibilityExprBuilderTest, NotAFunctionOfSelf) {
   EXPECT_THAT(is_x_used.first, m::Ne(m::Param("y"), m::Literal(7)));
 }
 
+TEST_F(VisibilityExprBuilderTest, LivenessHalting) {
+  auto p = CreatePackage();
+  FunctionBuilder fb(TestName(), p.get());
+  BValue x = fb.Param("x", p->GetBitsType(32));
+  BValue y = fb.Param("y", p->GetBitsType(32));
+  BValue z = fb.Param("z", p->GetBitsType(32));
+  BValue op1 = fb.Param("op1", p->GetBitsType(4));
+  BValue op2 = fb.Param("op2", p->GetBitsType(4));
+  BValue select1 = fb.Select(op1, {x, y, x}, y);
+  BValue lt1 = fb.ULt(op2, fb.Literal(UBits(5, 4)));
+  BValue and1 = fb.And(x, fb.SignExtend(lt1, 32));
+  BValue select2 = fb.Select(op1, {y, z, y}, and1);
+  BValue ret = fb.Tuple({select1, select2});
+  XLS_ASSERT_OK_AND_ASSIGN(Function * f, fb.BuildWithReturnValue(ret));
+
+  NodeForwardDependencyAnalysis nda;
+  XLS_ASSERT_OK(nda.Attach(f).status());
+  LazyPostDominatorAnalysis post_dom;
+  XLS_ASSERT_OK(post_dom.Attach(f).status());
+  std::unique_ptr<BddQueryEngine> bdd_engine = BddQueryEngine::MakeDefault();
+  XLS_ASSERT_OK(bdd_engine->Populate(f).status());
+  XLS_ASSERT_OK_AND_ASSIGN(
+      auto operand_visibility,
+      OperandVisibilityAnalysis::Create(&nda, bdd_engine.get()));
+  XLS_ASSERT_OK_AND_ASSIGN(
+      auto visibility, VisibilityAnalysis::Create(&operand_visibility,
+                                                  bdd_engine.get(), &post_dom));
+  XLS_ASSERT_OK_AND_ASSIGN(
+      auto conditional_edges,
+      visibility->GetEdgesForMutuallyExclusiveVisibilityExpr(x.node(), {}, -1));
+
+  auto last_node_id = f->nodes_reversed().begin()->id();
+  XLS_ASSERT_OK_AND_ASSIGN(AreaEstimator * ae, GetAreaEstimator("unit"));
+  XLS_ASSERT_OK_AND_ASSIGN(DelayEstimator * de, GetDelayEstimator("unit"));
+  BitProvenanceAnalysis bpa;
+  VisibilityEstimator estimator(last_node_id, bdd_engine.get(), nda, bpa, ae,
+                                de);
+
+  // A callback that says 'and1' is not live!
+  auto is_live_source = [&](Node* n) { return n != and1.node(); };
+
+  XLS_ASSERT_OK_AND_ASSIGN(Node * expr,
+                           estimator.BuildVisibilityIRExpr(
+                               f, x.node(), conditional_edges, is_live_source));
+
+  // Because and1 is ignored, we only accumulate its immediate condition (lt1 !=
+  // 0) combined with the conditions from select1!
+  EXPECT_THAT(expr, m::Or(m::ULt(m::Param("op2"), m::Literal(5)),
+                          m::Eq(m::Param("op1"), m::Literal(0)),
+                          m::Eq(m::Param("op1"), m::Literal(2))));
+}
+
+TEST_F(VisibilityExprBuilderTest, AndPruning) {
+  auto p = CreatePackage();
+  FunctionBuilder fb(TestName(), p.get());
+  BValue y = fb.Param("y", p->GetBitsType(1));
+  BValue a = fb.Param("a", p->GetBitsType(1));
+  BValue b = fb.Param("b", p->GetBitsType(1));
+  BValue c = fb.Param("c", p->GetBitsType(1));
+
+  BValue and_gate = fb.And({a, b, c, y});
+  XLS_ASSERT_OK_AND_ASSIGN(Function * f, fb.BuildWithReturnValue(and_gate));
+
+  NodeForwardDependencyAnalysis nda;
+  XLS_ASSERT_OK(nda.Attach(f).status());
+  LazyPostDominatorAnalysis post_dom;
+  XLS_ASSERT_OK(post_dom.Attach(f).status());
+  std::unique_ptr<BddQueryEngine> bdd_engine = BddQueryEngine::MakeDefault();
+  XLS_ASSERT_OK(bdd_engine->Populate(f).status());
+  XLS_ASSERT_OK_AND_ASSIGN(
+      auto operand_visibility,
+      OperandVisibilityAnalysis::Create(&nda, bdd_engine.get()));
+  XLS_ASSERT_OK_AND_ASSIGN(
+      auto visibility, VisibilityAnalysis::Create(&operand_visibility,
+                                                  bdd_engine.get(), &post_dom));
+  XLS_ASSERT_OK_AND_ASSIGN(
+      auto conditional_edges,
+      visibility->GetEdgesForMutuallyExclusiveVisibilityExpr(y.node(), {}, -1));
+
+  auto last_node_id = f->nodes_reversed().begin()->id();
+  XLS_ASSERT_OK_AND_ASSIGN(AreaEstimator * ae, GetAreaEstimator("unit"));
+  XLS_ASSERT_OK_AND_ASSIGN(DelayEstimator * de, GetDelayEstimator("unit"));
+  BitProvenanceAnalysis bpa;
+  VisibilityEstimator estimator(last_node_id, bdd_engine.get(), nda, bpa, ae,
+                                de);
+
+  // Mock slacks: we make 'c' have worst slack (10), then 'b' (20), then 'a'
+  // (30).
+  auto get_remaining_delay = [&](Node* n) -> int64_t {
+    if (n == c.node()) {
+      return 10;
+    }
+    if (n == b.node()) {
+      return 20;
+    }
+    if (n == a.node()) {
+      return 30;
+    }
+
+    // For the resulting AND, if it includes all three expected operands, we
+    // return -1 (exceeds limit!). Otherwise, we return a positive slack.
+    if (n->op() == Op::kAnd && n->operands().size() == 3) {
+      return -1;
+    }
+    if (n->op() == Op::kAnd && n->operands().size() == 2) {
+      return 5;
+    }
+    return 100;
+  };
+
+  XLS_ASSERT_OK_AND_ASSIGN(
+      Node * expr, estimator.BuildVisibilityIRExpr(
+                       f, y.node(), conditional_edges,
+                       /*is_live_source=*/nullptr, get_remaining_delay));
+
+  // The expected result should omit 'c'! So it should be AND(a, b)!
+  EXPECT_THAT(expr, m::And(m::Param("a"), m::Param("b")));
+}
+
+TEST_F(VisibilityExprBuilderTest, OrPruning) {
+  auto p = CreatePackage();
+  FunctionBuilder fb(TestName(), p.get());
+  BValue x = fb.Param("x", p->GetBitsType(3));
+  BValue y = fb.Param("y", p->GetBitsType(2));
+  BValue bit1 = fb.BitSlice(x, 1, 1);
+  BValue or_y = fb.Or(fb.SignExtend(bit1, 2), y);
+  BValue bits12 = fb.BitSlice(x, 1, 2);
+  BValue or_y2 = fb.Or(bits12, y);
+  XLS_ASSERT_OK_AND_ASSIGN(Function * f,
+                           fb.BuildWithReturnValue(fb.Tuple({or_y, or_y2})));
+
+  NodeForwardDependencyAnalysis nda;
+  XLS_ASSERT_OK(nda.Attach(f).status());
+  LazyPostDominatorAnalysis post_dom;
+  XLS_ASSERT_OK(post_dom.Attach(f).status());
+  std::unique_ptr<BddQueryEngine> bdd_engine = BddQueryEngine::MakeDefault();
+  XLS_ASSERT_OK(bdd_engine->Populate(f).status());
+  XLS_ASSERT_OK_AND_ASSIGN(
+      auto operand_visibility,
+      OperandVisibilityAnalysis::Create(&nda, bdd_engine.get()));
+  XLS_ASSERT_OK_AND_ASSIGN(
+      auto visibility, VisibilityAnalysis::Create(&operand_visibility,
+                                                  bdd_engine.get(), &post_dom));
+  XLS_ASSERT_OK_AND_ASSIGN(
+      auto conditional_edges,
+      visibility->GetEdgesForMutuallyExclusiveVisibilityExpr(y.node(), {}, -1));
+
+  auto last_node_id = f->nodes_reversed().begin()->id();
+  XLS_ASSERT_OK_AND_ASSIGN(AreaEstimator * ae, GetAreaEstimator("unit"));
+  XLS_ASSERT_OK_AND_ASSIGN(DelayEstimator * de, GetDelayEstimator("unit"));
+  BitProvenanceAnalysis bpa;
+  VisibilityEstimator estimator(last_node_id, bdd_engine.get(), nda, bpa, ae,
+                                de);
+
+  // Mock delay limit! If the OR node contains conditions from bits12 (which
+  // corresponds to user 2), it will exceed timing slack limits!
+  auto get_remaining_delay = [&](Node* n) -> int64_t {
+    if (n->op() == Op::kOr) {
+      for (Node* operand : n->operands()) {
+        if (operand->Is<CompareOp>() && operand->operand(0) == bits12.node()) {
+          return -1;
+        }
+      }
+    }
+    return 100;
+  };
+
+  XLS_ASSERT_OK_AND_ASSIGN(
+      Node * expr, estimator.BuildVisibilityIRExpr(
+                       f, y.node(), conditional_edges,
+                       /*is_live_source=*/nullptr, get_remaining_delay));
+
+  // The expected result should be true because the operation is pruned to
+  // literal(1)!
+  EXPECT_THAT(expr, m::Literal(1));
+}
+
+TEST_F(VisibilityExprBuilderTest, SelectPruning) {
+  auto p = CreatePackage();
+  FunctionBuilder fb(TestName(), p.get());
+  BValue x = fb.Param("x", p->GetBitsType(32));
+  BValue y = fb.Param("y", p->GetBitsType(32));
+  BValue op = fb.Param("op", p->GetBitsType(1));
+  BValue sel = fb.Select(op, {x}, y);
+  XLS_ASSERT_OK_AND_ASSIGN(Function * f, fb.BuildWithReturnValue(sel));
+
+  NodeForwardDependencyAnalysis nda;
+  XLS_ASSERT_OK(nda.Attach(f).status());
+  LazyPostDominatorAnalysis post_dom;
+  XLS_ASSERT_OK(post_dom.Attach(f).status());
+  std::unique_ptr<BddQueryEngine> bdd_engine = BddQueryEngine::MakeDefault();
+  XLS_ASSERT_OK(bdd_engine->Populate(f).status());
+  XLS_ASSERT_OK_AND_ASSIGN(
+      auto operand_visibility,
+      OperandVisibilityAnalysis::Create(&nda, bdd_engine.get()));
+  XLS_ASSERT_OK_AND_ASSIGN(
+      auto visibility, VisibilityAnalysis::Create(&operand_visibility,
+                                                  bdd_engine.get(), &post_dom));
+  XLS_ASSERT_OK_AND_ASSIGN(
+      auto conditional_edges,
+      visibility->GetEdgesForMutuallyExclusiveVisibilityExpr(x.node(), {}, -1));
+
+  auto last_node_id = f->nodes_reversed().begin()->id();
+  XLS_ASSERT_OK_AND_ASSIGN(AreaEstimator * ae, GetAreaEstimator("unit"));
+  XLS_ASSERT_OK_AND_ASSIGN(DelayEstimator * de, GetDelayEstimator("unit"));
+  BitProvenanceAnalysis bpa;
+  VisibilityEstimator estimator(last_node_id, bdd_engine.get(), nda, bpa, ae,
+                                de);
+
+  auto get_remaining_delay = [&](Node* n) -> int64_t {
+    if (n->op() == Op::kOr || n->op() == Op::kEq) {
+      return -1;
+    }
+    return 100;
+  };
+
+  XLS_ASSERT_OK_AND_ASSIGN(
+      Node * expr, estimator.BuildVisibilityIRExpr(
+                       f, x.node(), conditional_edges,
+                       /*is_live_source=*/nullptr, get_remaining_delay));
+
+  EXPECT_THAT(expr, m::Literal(1));
+}
+
+TEST_F(VisibilityExprBuilderTest, PrioritySelectPruning) {
+  auto p = CreatePackage();
+  FunctionBuilder fb(TestName(), p.get());
+  BValue x = fb.Param("x", p->GetBitsType(32));
+  BValue y = fb.Param("y", p->GetBitsType(32));
+  BValue sel = fb.Param("sel", p->GetBitsType(2));
+  BValue prio = fb.PrioritySelect(sel, {x, y}, fb.Literal(UBits(0, 32)));
+  XLS_ASSERT_OK_AND_ASSIGN(Function * f, fb.BuildWithReturnValue(prio));
+
+  NodeForwardDependencyAnalysis nda;
+  XLS_ASSERT_OK(nda.Attach(f).status());
+  LazyPostDominatorAnalysis post_dom;
+  XLS_ASSERT_OK(post_dom.Attach(f).status());
+  std::unique_ptr<BddQueryEngine> bdd_engine = BddQueryEngine::MakeDefault();
+  XLS_ASSERT_OK(bdd_engine->Populate(f).status());
+  XLS_ASSERT_OK_AND_ASSIGN(
+      auto operand_visibility,
+      OperandVisibilityAnalysis::Create(&nda, bdd_engine.get()));
+  XLS_ASSERT_OK_AND_ASSIGN(
+      auto visibility, VisibilityAnalysis::Create(&operand_visibility,
+                                                  bdd_engine.get(), &post_dom));
+  XLS_ASSERT_OK_AND_ASSIGN(
+      auto conditional_edges,
+      visibility->GetEdgesForMutuallyExclusiveVisibilityExpr(x.node(), {}, -1));
+
+  auto last_node_id = f->nodes_reversed().begin()->id();
+  XLS_ASSERT_OK_AND_ASSIGN(AreaEstimator * ae, GetAreaEstimator("unit"));
+  XLS_ASSERT_OK_AND_ASSIGN(DelayEstimator * de, GetDelayEstimator("unit"));
+  BitProvenanceAnalysis bpa;
+  VisibilityEstimator estimator(last_node_id, bdd_engine.get(), nda, bpa, ae,
+                                de);
+
+  auto get_remaining_delay = [&](Node* n) -> int64_t {
+    if (n->op() == Op::kOr || n->op() == Op::kEq || n->op() == Op::kBitSlice) {
+      return -1;
+    }
+    return 100;
+  };
+
+  XLS_ASSERT_OK_AND_ASSIGN(
+      Node * expr, estimator.BuildVisibilityIRExpr(
+                       f, x.node(), conditional_edges,
+                       /*is_live_source=*/nullptr, get_remaining_delay));
+
+  EXPECT_THAT(expr, m::Literal(1));
+}
+
+TEST_F(VisibilityExprBuilderTest, TargetStageEnforcement) {
+  auto p = CreatePackage();
+  ScheduledFunctionBuilder fb(TestName(), p.get());
+  BValue x = fb.Param("x", p->GetBitsType(32));
+  BValue y = fb.Param("y", p->GetBitsType(32));
+  BValue select1 = fb.Select(fb.Literal(UBits(1, 1)), {x}, y);
+  XLS_ASSERT_OK_AND_ASSIGN(ScheduledFunction * f,
+                           fb.BuildWithReturnValue(select1));
+
+  // Add empty stages to make it a scheduled function!
+  f->AddEmptyStages(3);
+
+  NodeForwardDependencyAnalysis nda;
+  XLS_ASSERT_OK(nda.Attach(f).status());
+  LazyPostDominatorAnalysis post_dom;
+  XLS_ASSERT_OK(post_dom.Attach(f).status());
+  std::unique_ptr<BddQueryEngine> bdd_engine = BddQueryEngine::MakeDefault();
+  XLS_ASSERT_OK(bdd_engine->Populate(f).status());
+  XLS_ASSERT_OK_AND_ASSIGN(
+      auto operand_visibility,
+      OperandVisibilityAnalysis::Create(&nda, bdd_engine.get()));
+  XLS_ASSERT_OK_AND_ASSIGN(
+      auto visibility, VisibilityAnalysis::Create(&operand_visibility,
+                                                  bdd_engine.get(), &post_dom));
+  XLS_ASSERT_OK_AND_ASSIGN(
+      auto conditional_edges,
+      visibility->GetEdgesForMutuallyExclusiveVisibilityExpr(x.node(), {}, -1));
+
+  auto last_node_id = f->nodes_reversed().begin()->id();
+  XLS_ASSERT_OK_AND_ASSIGN(AreaEstimator * ae, GetAreaEstimator("unit"));
+  XLS_ASSERT_OK_AND_ASSIGN(DelayEstimator * de, GetDelayEstimator("unit"));
+  BitProvenanceAnalysis bpa;
+  VisibilityEstimator estimator(last_node_id, bdd_engine.get(), nda, bpa, ae,
+                                de);
+
+  int64_t kTargetStage = 2;
+  XLS_ASSERT_OK_AND_ASSIGN(
+      Node * expr,
+      estimator.BuildVisibilityIRExpr(
+          f, x.node(), conditional_edges, /*is_live_source=*/nullptr,
+          /*get_remaining_delay=*/nullptr, kTargetStage));
+  (void)expr;
+
+  // All nodes created during BuildVisibilityIRExpr should be assigned to stage
+  // 2!
+  for (Node* n : f->nodes()) {
+    if (n->id() > last_node_id) {
+      EXPECT_TRUE(f->IsStaged(n));
+      XLS_ASSERT_OK_AND_ASSIGN(int64_t stage, f->GetStageIndex(n));
+      EXPECT_EQ(stage, kTargetStage);
+    }
+  }
+}
+
 }  // namespace
 }  // namespace xls