diff --git a/xls/codegen/codegen_options.h b/xls/codegen/codegen_options.h
index ca5b9321cf..aa17d09d69 100644
--- a/xls/codegen/codegen_options.h
+++ b/xls/codegen/codegen_options.h
@@ -16,6 +16,7 @@
 #define XLS_CODEGEN_CODEGEN_OPTIONS_H_
 
 #include <cstdint>
+#include <memory>
 #include <optional>
 #include <string>
 #include <string_view>
@@ -37,11 +38,32 @@
 
 namespace xls::verilog {
 
+class CodegenOptionExtension {
+ public:
+  virtual ~CodegenOptionExtension() = default;
+  virtual std::string_view extension_name() const = 0;
+};
+
 // Options describing how codegen should be performed.
 class CodegenOptions {
  public:
   explicit CodegenOptions() = default;
 
+  template <typename T>
+  const T* get_extension() const {
+    for (const auto& ext : extensions_) {
+      if (ext->extension_name() == T::kExtensionName) {
+        return static_cast<const T*>(ext.get());
+      }
+    }
+    return nullptr;
+  }
+
+  CodegenOptions& add_extension(std::unique_ptr<CodegenOptionExtension> ext) {
+    extensions_.push_back(std::move(ext));
+    return *this;
+  }
+
   // Enum to describe which codegen version to use.
   enum class Version : uint8_t {
     kDefault = 0,
@@ -461,6 +483,7 @@ class CodegenOptions {
   int64_t max_trace_verbosity_ = 0;
   RegisterMergeStrategy register_merge_strategy_ =
       RegisterMergeStrategy::kDefault;
+
   SourceAnnotationStrategy source_annotation_strategy_ =
       SourceAnnotationStrategy::kNone;
   std::optional<PackageInterfaceProto> package_interface_;
@@ -474,6 +497,8 @@ class CodegenOptions {
   std::vector<int32_t> randomize_order_seed_;
   std::optional<CodegenResidualData> residual_data_;
   std::optional<std::string> ir_dump_path_;
+
+  std::vector<std::shared_ptr<CodegenOptionExtension>> extensions_;
 };
 
 template <typename Sink>
diff --git a/xls/codegen/module_builder.cc b/xls/codegen/module_builder.cc
index 49f93f110b..fee3fde9d1 100644
--- a/xls/codegen/module_builder.cc
+++ b/xls/codegen/module_builder.cc
@@ -1247,6 +1247,13 @@ absl::StatusOr<IndexableExpression*> ModuleBuilder::EmitGate(
   XLS_ASSIGN_OR_RETURN(LogicRef * ref,
                        DeclareVariable(gate->GetName(), gate->GetType()));
 
+  if (gate->gate_type() == GateType::kIgnorableGate) {
+    // Ignorable gates don't perform zero-clamping; they can be evaluated as
+    // identity operations.
+    XLS_RETURN_IF_ERROR(Assign(ref, data, gate->GetType()));
+    return ref;
+  }
+
   // Emit the gate as an AND of the (potentially replicated) condition and the
   // data. For example:
   //
diff --git a/xls/codegen/verilog_conversion.cc b/xls/codegen/verilog_conversion.cc
index caa9b58cf4..6b21d619c0 100644
--- a/xls/codegen/verilog_conversion.cc
+++ b/xls/codegen/verilog_conversion.cc
@@ -652,6 +652,13 @@ class BlockGenerator {
       std::optional<OpOverride> op_override =
           options_.GetOpOverride(node->op());
 
+      // Ignorable-value gates are emitted as identity, so they don't need to
+      // support overrides.
+      if (node->op() == Op::kGate &&
+          node->As<Gate>()->gate_type() == GateType::kIgnorableGate) {
+        op_override = std::nullopt;
+      }
+
       if (op_override.has_value()) {
         std::vector<NodeRepresentation> inputs;
         for (const Node* operand : node->operands()) {
diff --git a/xls/codegen/verilog_conversion_test.cc b/xls/codegen/verilog_conversion_test.cc
index 4947029410..d1fd402333 100644
--- a/xls/codegen/verilog_conversion_test.cc
+++ b/xls/codegen/verilog_conversion_test.cc
@@ -2400,12 +2400,15 @@ class ZeroWidthVerilogConversionTest
   }
   std::filesystem::path GoldenFilePath(
       std::string_view test_file_name,
-      const std::filesystem::path& testdata_dir) override {
+      const std::filesystem::path& testdata_dir,
+      std::optional<std::string_view> forced_test_base_name =
+          std::nullopt) override {
     // We suffix the golden reference files with "txt" on top of the extension
     // just to indicate they're compiler byproduct comparison points and not
     // Verilog files that have been written by hand.
     std::string filename = absl::StrCat(
-        test_file_name, "_", TestBaseName(), "Input",
+        test_file_name, "_", forced_test_base_name.value_or(TestBaseName()),
+        "Input",
         ParameterizedFloppingName(std::get<0>(std::get<1>(GetParam()))),
         "Output",
         ParameterizedFloppingName(std::get<1>(std::get<1>(GetParam()))), ".",
diff --git a/xls/codegen_v_1_5/BUILD b/xls/codegen_v_1_5/BUILD
index 78e4f005cb..bb2558dfa0 100644
--- a/xls/codegen_v_1_5/BUILD
+++ b/xls/codegen_v_1_5/BUILD
@@ -61,6 +61,7 @@ cc_library(
     hdrs = ["block_conversion_pass.h"],
     deps = [
         "//xls/codegen:codegen_options",
+        "//xls/estimators/delay_model:delay_estimator",
         "//xls/passes:optimization_pass",
         "//xls/passes:pass_base",
         "//xls/scheduling:pipeline_schedule_cc_proto",
diff --git a/xls/codegen_v_1_5/block_conversion_pass.h b/xls/codegen_v_1_5/block_conversion_pass.h
index 86ae3059fe..e06ce8200f 100644
--- a/xls/codegen_v_1_5/block_conversion_pass.h
+++ b/xls/codegen_v_1_5/block_conversion_pass.h
@@ -16,6 +16,7 @@
 #define XLS_CODEGEN_V_1_5_BLOCK_CONVERSION_PASS_H_
 
 #include "xls/codegen/codegen_options.h"
+#include "xls/estimators/delay_model/delay_estimator.h"
 #include "xls/passes/optimization_pass.h"
 #include "xls/passes/pass_base.h"
 #include "xls/scheduling/pipeline_schedule.pb.h"
@@ -28,6 +29,9 @@ namespace xls::codegen {
 struct BlockConversionPassOptions : public PassOptionsBase {
   verilog::CodegenOptions codegen_options;
   PackageScheduleProto package_schedule;
+
+  // The delay estimator used for scheduling & schedule-checking purposes.
+  const DelayEstimator* delay_estimator = nullptr;
 };
 
 struct BlockConversionContext {
diff --git a/xls/codegen_v_1_5/convert_to_block.cc b/xls/codegen_v_1_5/convert_to_block.cc
index 58a1981b23..2ed26e1424 100644
--- a/xls/codegen_v_1_5/convert_to_block.cc
+++ b/xls/codegen_v_1_5/convert_to_block.cc
@@ -58,6 +58,7 @@ absl::Status ConvertToBlock(
   BlockConversionPassOptions options{
       .codegen_options = std::move(codegen_options),
       .package_schedule = std::move(schedule),
+      .delay_estimator = delay_estimator,
   };
 
   XLS_ASSIGN_OR_RETURN(std::unique_ptr<BlockConversionPass> pipeline,
diff --git a/xls/codegen_v_1_5/pipeline_register_insertion_pass.cc b/xls/codegen_v_1_5/pipeline_register_insertion_pass.cc
index 309179ec5e..0d72ffd6ee 100644
--- a/xls/codegen_v_1_5/pipeline_register_insertion_pass.cc
+++ b/xls/codegen_v_1_5/pipeline_register_insertion_pass.cc
@@ -96,6 +96,23 @@ absl::StatusOr<RegisterRead*> CreatePipelineRegister(
                        block->AddRegister(name, node->GetType(), reset_value));
 
   Node* load_enable = stage_done;
+
+  if (node->Is<Gate>() &&
+      node->As<Gate>()->gate_type() == GateType::kIgnorableGate) {
+    // Ignorable gates are used to indicate that the node is conditionally
+    // visible. We can strengthen the logic for gating the pipeline register by
+    // ANDing the stage done signal with the gate's predicate, reducing the
+    // number of times the register needs to be updated.
+    Gate* gate = node->As<Gate>();
+    Node* predicate = gate->condition();
+    node = gate->data();
+    XLS_ASSIGN_OR_RETURN(
+        load_enable,
+        block->MakeNode<NaryOp>(node->loc(),
+                                absl::MakeConstSpan({stage_done, predicate}),
+                                Op::kAnd));
+  }
+
   if (block->GetResetPort().has_value() &&
       options.codegen_options.reset().has_value() &&
       !options.codegen_options.reset()->reset_data_path()) {
@@ -109,9 +126,9 @@ absl::StatusOr<RegisterRead*> CreatePipelineRegister(
     }
     XLS_ASSIGN_OR_RETURN(
         load_enable,
-        block->MakeNode<NaryOp>(node->loc(),
-                                absl::MakeConstSpan({stage_done, reset_active}),
-                                Op::kOr));
+        block->MakeNode<NaryOp>(
+            node->loc(), absl::MakeConstSpan({load_enable, reset_active}),
+            Op::kOr));
   }
   // NOTE: The RegisterWrite is added to the block, but not to the stage. Its
   //       `load_enable` depends on `outputs_ready`, which comes from outside
@@ -139,7 +156,13 @@ absl::StatusOr<RegisterRead*> CreatePipelineRegister(
 absl::StatusOr<Node*> AddPipelineRegisterFor(
     Node* node, int64_t stage_index, Node* stage_done, ScheduledBlock* block,
     const BlockConversionPassOptions& options) {
-  std::string base_name = PipelineSignalName(node->GetName(), stage_index);
+  Node* name_source = node;
+  if (node->Is<Gate>() &&
+      node->As<Gate>()->gate_type() == GateType::kIgnorableGate) {
+    name_source = node->As<Gate>()->data();
+  }
+  std::string base_name =
+      PipelineSignalName(name_source->GetName(), stage_index);
 
   // As a special case, check if the node is a tuple
   // containing types that are of zero-width.  If so, separate them out so
diff --git a/xls/ir/function.cc b/xls/ir/function.cc
index 45157be200..83f49daf0c 100644
--- a/xls/ir/function.cc
+++ b/xls/ir/function.cc
@@ -135,17 +135,12 @@ std::string Function::DumpIr(const IrAnnotator& annotate) const {
    private:
     Node* return_value_;
   };
-  if (IsScheduled()) {
-    absl::StrAppend(&res,
-                    DumpFunctionBaseNodes(IrAnnotatorJoiner(
-                        SkipParamsAnnotator{}, AddRetAnnotator{return_value()},
-                        IrAnnotatorRef(annotate))));
-  } else {
-    absl::StrAppend(
-        &res,
-        DumpFunctionBaseNodes(IrAnnotatorJoiner(
-            SkipParamsAnnotator{}, AddRetAnnotator{return_value()},
-            IrAnnotatorRef(annotate), TopoSortAnnotator(!is_block_source_))));
+  absl::StrAppend(
+      &res,
+      DumpFunctionBaseNodes(IrAnnotatorJoiner(
+          SkipParamsAnnotator{}, AddRetAnnotator{return_value()},
+          IrAnnotatorRef(annotate), TopoSortAnnotator(!is_block_source_))));
+  if (!IsScheduled()) {
     // Need to add the 'ret' specially if the ret is also a parameter.
     if (return_value() != nullptr && return_value()->op() == Op::kParam) {
       absl::StrAppendFormat(&res, "  ret %s\n",
diff --git a/xls/ir/function_base.cc b/xls/ir/function_base.cc
index 4c422affee..3bd3854067 100644
--- a/xls/ir/function_base.cc
+++ b/xls/ir/function_base.cc
@@ -64,10 +64,33 @@ namespace {
 // sections may be empty after it runs.
 class StageSectioner : public DfsVisitorWithDefault {
  public:
-  explicit StageSectioner(const FunctionBase* fb)
-      : fb_(fb), sections_(fb->stages().size() * 2 + 1) {}
+  struct Section {
+    std::optional<int64_t> stage_index = std::nullopt;
+    std::list<Node*> nodes;
 
-  absl::Status Run() {
+    bool IsStage() const { return stage_index.has_value(); }
+
+    bool empty() const { return nodes.empty(); }
+
+    auto begin() const { return nodes.begin(); }
+    auto end() const { return nodes.end(); }
+
+    auto cbegin() const { return nodes.cbegin(); }
+    auto cend() const { return nodes.cend(); }
+
+    void push_back(Node* node) { nodes.push_back(node); }
+  };
+
+  explicit StageSectioner(const FunctionBase* fb) : fb_(fb) {
+    sections_.reserve(fb->stages().size() * 2 + 1);
+    for (int i = 0; i < fb_->stages().size(); i++) {
+      sections_.push_back(Section{.stage_index = std::nullopt});
+      sections_.push_back(Section{.stage_index = i});
+    }
+    sections_.push_back(Section{.stage_index = std::nullopt});
+  }
+
+  absl::Status Run(std::optional<std::vector<Node*>> order = std::nullopt) {
     // Capture stages and their deps.
     for (int i = 0; i < fb_->stages().size(); i++) {
       const Stage& stage = fb_->stages()[i];
@@ -107,6 +130,26 @@ class StageSectioner : public DfsVisitorWithDefault {
         XLS_RETURN_IF_ERROR(node->Accept(this));
       }
     }
+
+    // If provided, we use the given order to sort within each section.
+    if (order.has_value()) {
+      std::optional<absl::flat_hash_map<Node*, int>> node_to_index;
+      node_to_index.emplace();
+      node_to_index->reserve(order->size());
+      for (int i = 0; i < order->size(); ++i) {
+        node_to_index->emplace(order->at(i), i);
+      }
+
+      for (Section& section : sections_) {
+        CHECK(absl::c_all_of(section.nodes, [&](Node* node) {
+          return node_to_index->contains(node);
+        })) << "Some nodes not found in order";
+        section.nodes.sort([&](Node* a, Node* b) {
+          return node_to_index->at(a) < node_to_index->at(b);
+        });
+      }
+    }
+
     return absl::OkStatus();
   }
 
@@ -126,11 +169,11 @@ class StageSectioner : public DfsVisitorWithDefault {
     return absl::OkStatus();
   }
 
-  const std::vector<std::list<Node*>>& sections() const { return sections_; }
+  const std::vector<Section>& sections() const { return sections_; }
 
  private:
   const FunctionBase* fb_;
-  std::vector<std::list<Node*>> sections_;
+  std::vector<Section> sections_;
   int64_t current_stage_;
   absl::flat_hash_set<Node*> handled_;
 };
@@ -266,15 +309,12 @@ std::string FunctionBase::DumpFunctionBaseNodes(
     const IrAnnotator& annotate) const {
   std::string res;
   if (IsScheduled()) {
-    CHECK(!annotate.NodeOrder(const_cast<FunctionBase*>(this)))
-        << "Cannot use custom node order for scheduled entities";
     StageSectioner sectioner(this);
-    CHECK(sectioner.Run().ok());
-    for (const std::list<Node*>& section : sectioner.sections()) {
-      if (section.empty()) {
-        continue;
-      }
-
+    // In a scheduled entity, we use the annotator's order to sort within each
+    // section.
+    CHECK(sectioner.Run(annotate.NodeOrder(const_cast<FunctionBase*>(this)))
+              .ok());
+    for (const StageSectioner::Section& section : sectioner.sections()) {
       struct ScheduledAnnotations : public IrAnnotator {
        public:
         ScheduledAnnotations(Node* outputs_valid, Node* active_inputs_valid)
@@ -294,9 +334,8 @@ std::string FunctionBase::DumpFunctionBaseNodes(
         Node* active_inputs_valid_;
       };
 
-      Node* first = *section.begin();
-      if (IsStaged(first)) {
-        const Stage& stage = stages()[*GetStageIndex(first)];
+      if (section.IsStage()) {
+        const Stage& stage = stages()[*section.stage_index];
         IrAnnotatorJoiner joiner(
             ScheduledAnnotations(stage.outputs_valid(),
                                  stage.active_inputs_valid()),
diff --git a/xls/ir/function_base.h b/xls/ir/function_base.h
index bcd89105ec..6caf311013 100644
--- a/xls/ir/function_base.h
+++ b/xls/ir/function_base.h
@@ -102,6 +102,10 @@ class Stage {
     active_outputs_.erase(node);
   }
 
+  bool empty() const {
+    return active_inputs_.empty() && logic_.empty() && active_outputs_.empty();
+  }
+
   inline auto begin() {
     return iter::chain(active_inputs_, logic_, active_outputs_).begin();
   }
diff --git a/xls/ir/function_builder.cc b/xls/ir/function_builder.cc
index cbcbdbfe12..688f9794c3 100644
--- a/xls/ir/function_builder.cc
+++ b/xls/ir/function_builder.cc
@@ -1821,8 +1821,8 @@ BValue BuilderBase::Cover(BValue condition, std::string_view label,
                              /*original_label=*/std::nullopt, name);
 }
 
-BValue BuilderBase::Gate(BValue condition, BValue data, const SourceInfo& loc,
-                         std::string_view name) {
+BValue BuilderBase::Gate(BValue condition, BValue data, GateType gate_type,
+                         const SourceInfo& loc, std::string_view name) {
   if (ErrorPending()) {
     return BValue();
   }
@@ -1834,7 +1834,8 @@ BValue BuilderBase::Gate(BValue condition, BValue data, const SourceInfo& loc,
             condition.GetType()->ToString()),
         loc);
   }
-  return AddNode<xls::Gate>(loc, condition.node(), data.node(), name);
+  return AddNode<xls::Gate>(loc, condition.node(), data.node(), gate_type,
+                            name);
 }
 
 BValue TokenlessProcBuilder::MinDelay(int64_t delay, const SourceInfo& loc,
diff --git a/xls/ir/function_builder.h b/xls/ir/function_builder.h
index ecce51f364..dcde9405c8 100644
--- a/xls/ir/function_builder.h
+++ b/xls/ir/function_builder.h
@@ -653,6 +653,16 @@ class BuilderBase {
   // Adds a gate operation. The output of the operation is `data` if `cond` is
   // true and zero-valued otherwise. Gates are side-effecting.
   BValue Gate(BValue condition, BValue data,
+              const SourceInfo& loc = SourceInfo(),
+              std::string_view name = "") {
+    return Gate(condition, data, GateType::kZeroGate, loc, name);
+  }
+
+  // Adds a gate operation with a specified gate type. The output of the
+  // operation is `data` if `cond` is true and otherwise depends on the gate
+  // type. Gates are side-effecting.
+  // are side-effecting.
+  BValue Gate(BValue condition, BValue data, GateType gate_type,
               const SourceInfo& loc = SourceInfo(), std::string_view name = "");
 
   // Add a receive operation. The type of the data value received is
diff --git a/xls/ir/ir_parser.cc b/xls/ir/ir_parser.cc
index 46be4098ea..acb4c9b625 100644
--- a/xls/ir/ir_parser.cc
+++ b/xls/ir/ir_parser.cc
@@ -1351,8 +1351,16 @@ absl::StatusOr<BValue> Parser::ParseNode(
       break;
     }
     case Op::kGate: {
+      std::optional<IdentifierString>* gate_type_str =
+          arg_parser.AddOptionalKeywordArg<IdentifierString>("gate_type");
       XLS_ASSIGN_OR_RETURN(operands, arg_parser.Run(/*arity=*/2));
-      bvalue = fb->Gate(operands[0], operands[1], *loc, node_name);
+      if (gate_type_str->has_value()) {
+        XLS_ASSIGN_OR_RETURN(GateType gate_type,
+                             ParseGateType(gate_type_str->value().value));
+        bvalue = fb->Gate(operands[0], operands[1], gate_type, *loc, node_name);
+      } else {
+        bvalue = fb->Gate(operands[0], operands[1], *loc, node_name);
+      }
       break;
     }
     case Op::kInstantiationInput: {
diff --git a/xls/ir/node.cc b/xls/ir/node.cc
index f652fe1a5e..7c7e4345ee 100644
--- a/xls/ir/node.cc
+++ b/xls/ir/node.cc
@@ -639,6 +639,13 @@ std::string Node::ToStringInternal(bool include_operand_types) const {
       }
       break;
     }
+    case Op::kGate: {
+      const Gate* gate = As<Gate>();
+      if (gate->gate_type() == GateType::kIgnorableGate) {
+        args.push_back("gate_type=ignorable");
+      }
+      break;
+    }
     case Op::kNext: {
       const Next* next = As<Next>();
       std::string param_name = next->has_state_read()
diff --git a/xls/ir/nodes.cc b/xls/ir/nodes.cc
index a34aa926d7..12f960e2b1 100755
--- a/xls/ir/nodes.cc
+++ b/xls/ir/nodes.cc
@@ -26,6 +26,7 @@
 #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/math_util.h"
 #include "xls/common/status/ret_check.h"
@@ -1319,9 +1320,20 @@ bool InstantiationInput::IsDefinitelyEqualTo(const Node* other) const {
          port_name_ == other->As<InstantiationInput>()->port_name_;
 }
 
+absl::StatusOr<GateType> ParseGateType(std::string_view gate_type) {
+  if (gate_type == "zero") {
+    return GateType::kZeroGate;
+  } else if (gate_type == "ignorable") {
+    return GateType::kIgnorableGate;
+  }
+  return absl::InvalidArgumentError(
+      absl::StrCat("Unknown gate type: ", gate_type));
+}
+
 Gate::Gate(const SourceInfo& loc, Node* condition, Node* data,
-           std::string_view name, FunctionBase* function)
-    : Node(Op::kGate, data->GetType(), loc, name, function) {
+           GateType gate_type, std::string_view name, FunctionBase* function)
+    : Node(Op::kGate, data->GetType(), loc, name, function),
+      gate_type_(gate_type) {
   CHECK(IsOpClass<Gate>(op_))
       << "Op `" << op_ << "` is not a valid op for Node class `Gate`.";
   AddOperand(condition);
@@ -1331,8 +1343,8 @@ Gate::Gate(const SourceInfo& loc, Node* condition, Node* data,
 absl::StatusOr<Node*> Gate::CloneInNewFunction(
     absl::Span<Node* const> new_operands, FunctionBase* new_function) const {
   XLS_RET_CHECK_EQ(operand_count(), new_operands.size());
-  return new_function->MakeNodeWithName<Gate>(loc(), new_operands[0],
-                                              new_operands[1], GetNameView());
+  return new_function->MakeNodeWithName<Gate>(
+      loc(), new_operands[0], new_operands[1], gate_type(), GetNameView());
 }
 
 SliceData Concat::GetOperandSliceData(int64_t operandno) const {
diff --git a/xls/ir/nodes.h b/xls/ir/nodes.h
index a2151db377..b5ae391aa9 100755
--- a/xls/ir/nodes.h
+++ b/xls/ir/nodes.h
@@ -514,6 +514,22 @@ class ExtendOp final : public Node {
   int64_t new_bit_count_;
 };
 
+enum class GateType : uint8_t { kZeroGate, kIgnorableGate };
+
+template <typename Sink>
+void AbslStringify(Sink& sink, const GateType& gate_type) {
+  switch (gate_type) {
+    case GateType::kZeroGate:
+      absl::Format(&sink, "zero");
+      return;
+    case GateType::kIgnorableGate:
+      absl::Format(&sink, "ignorable");
+      return;
+  }
+}
+
+absl::StatusOr<GateType> ParseGateType(std::string_view gate_type);
+
 class Gate final : public Node {
  public:
   static constexpr std::array<Op, 1> kOps = {Op::kGate};
@@ -521,6 +537,11 @@ class Gate final : public Node {
   static constexpr int64_t kDataOperand = 1;
 
   Gate(const SourceInfo& loc, Node* condition, Node* data,
+       std::string_view name, FunctionBase* function)
+      : Gate(loc, condition, data, /*gate_type=*/GateType::kZeroGate, name,
+             function) {}
+
+  Gate(const SourceInfo& loc, Node* condition, Node* data, GateType gate_type,
        std::string_view name, FunctionBase* function);
 
   absl::StatusOr<Node*> CloneInNewFunction(
@@ -529,6 +550,11 @@ class Gate final : public Node {
   Node* condition() const { return operand(0); }
 
   Node* data() const { return operand(1); }
+
+  GateType gate_type() const { return gate_type_; }
+
+ private:
+  GateType gate_type_;
 };
 
 enum PortDirection : uint8_t { kInput, kOutput };
diff --git a/xls/ir/proc.cc b/xls/ir/proc.cc
index 4d88219dd8..aa1d1602cc 100644
--- a/xls/ir/proc.cc
+++ b/xls/ir/proc.cc
@@ -143,11 +143,10 @@ std::string Proc::DumpIr(const IrAnnotator& annotate) const {
     }
   }
 
-  if (IsScheduled()) {
-    absl::StrAppend(&res, DumpFunctionBaseNodes(annotate));
-  } else if (!is_block_source_) {
+  if (IsScheduled() || !is_block_source_) {
     absl::StrAppend(&res, DumpFunctionBaseNodes(IrAnnotatorJoiner(
-                              IrAnnotatorRef(annotate), TopoSortAnnotator())));
+                              IrAnnotatorRef(annotate),
+                              TopoSortAnnotator(!is_block_source_))));
   }
   absl::StrAppend(&res, "}\n");
   return res;
diff --git a/xls/passes/BUILD b/xls/passes/BUILD
index cbcb73da0c..9074f41b7f 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,7 +4880,9 @@ 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/functional:any_invocable",
         "@com_google_absl//absl/log",
         "@com_google_absl//absl/status:statusor",
         "@googletest//:gtest",
diff --git a/xls/passes/visibility_analysis.cc b/xls/passes/visibility_analysis.cc
index 30132ebf61..96b768a793 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 {
+
+absl::StatusOr<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,6 +812,8 @@ 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) {
@@ -818,6 +825,15 @@ absl::StatusOr<bool> OperandVisibilityAnalysis::IsVisibilityIndependentOf(
         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 {
+  XLS_ASSIGN_OR_RETURN(std::vector<Node*> conditions,
+                       GetVisibilityControlConditions(operand, node));
 
   for (Node* condition : conditions) {
     for (Node* source : sources) {
@@ -977,6 +993,52 @@ 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()) {
+      // Whether or not we want to keep this edge, we should add the user to
+      // the worklist if it hasn't been visited yet.
+      if (auto [_, inserted] = visited.insert(user); inserted) {
+        worklist.push(user);
+      }
+
+      XLS_ASSIGN_OR_RETURN(std::vector<Node*> conditions,
+                           GetVisibilityControlConditions(node, user));
+
+      if (!conditions.empty() &&
+          absl::c_none_of(conditions, [&](Node* condition) {
+            return is_live_source(condition);
+          })) {
+        // There are conditions, but none of them are live; we have to consider
+        // this edge always active.
+        continue;
+      }
+
+      BddNodeIndex visibility =
+          operand_visibility_->OperandVisibilityThroughNode(node, user);
+      if (visibility != bdd_query_engine_->bdd().one()) {
+        kept_edges.insert({node, 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..df88474a91 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
@@ -210,8 +234,36 @@ absl::StatusOr<Node*> VisibilityBuilder::GetNonRepeatedSourceOf(
   return MakeParamIfTmpFunc(operand, func);
 }
 
+namespace {
+
+absl::StatusOr<Node*> FilterByDelay(
+    FunctionBase* func, const SourceInfo& loc, std::vector<Node*>& operands,
+    const std::function<int64_t(Node*)>& get_remaining_delay,
+    const std::function<absl::StatusOr<Node*>(const SourceInfo&)>& build_empty,
+    const std::function<absl::StatusOr<Node*>(std::vector<Node*>&)>& build_fn) {
+  XLS_ASSIGN_OR_RETURN(Node * result, build_fn(operands));
+  if (get_remaining_delay && get_remaining_delay(result) < 0) {
+    std::sort(operands.begin(), operands.end(), [&](Node* a, Node* b) {
+      return get_remaining_delay(a) > get_remaining_delay(b);
+    });
+    while (!operands.empty() && get_remaining_delay(result) < 0) {
+      operands.pop_back();
+      if (operands.empty()) {
+        XLS_ASSIGN_OR_RETURN(result, build_empty(loc));
+        break;
+      }
+      XLS_ASSIGN_OR_RETURN(result, build_fn(operands));
+    }
+  }
+  return result;
+}
+
+}  // namespace
+
 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 +271,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 +288,30 @@ 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];
+  }
+
+  return FilterByDelay(
+      func, and_node->loc(), others_not_zero, get_remaining_delay,
+      /*build_empty=*/
+      [&](const SourceInfo& loc) -> absl::StatusOr<Node*> {
+        return func->MakeNode<Literal>(loc, Value(UBits(1, 1)));
+      },
+      /*build_fn=*/
+      [&](std::vector<Node*>& ops) -> absl::StatusOr<Node*> {
+        return AndOperands(ops);
+      });
 }
 
 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 +319,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 +339,81 @@ 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);
+  }
+
+  return FilterByDelay(
+      func, or_node->loc(), others_not_ones, get_remaining_delay,
+      /*build_empty=*/
+      [&](const SourceInfo& loc) -> absl::StatusOr<Node*> {
+        return func->MakeNode<Literal>(loc, Value(UBits(1, 1)));
+      },
+      /*build_fn=*/
+      [&](std::vector<Node*>& ops) -> absl::StatusOr<Node*> {
+        return AndOperands(ops);
+      });
 }
 
 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 +439,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 +452,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 +537,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 +568,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..3ac296526b 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,345 @@ 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))));
+}
+
+namespace {
+
+int64_t CountAndTreeOperands(Node* n) {
+  if (n->op() != Op::kAnd) {
+    return 1;
+  }
+  int64_t total = 0;
+  for (Node* operand : n->operands()) {
+    total += CountAndTreeOperands(operand);
+  }
+  return total;
+}
+
+}  // namespace
+
+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 tree, if it includes all three expected operands,
+    // we return -1 (exceeds limit!). Otherwise, we return a positive slack.
+    if (n->op() == Op::kAnd && CountAndTreeOperands(n) == 3) {
+      return -1;
+    }
+    if (n->op() == Op::kAnd && CountAndTreeOperands(n) == 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
diff --git a/xls/simulation/verilog_test_base.h b/xls/simulation/verilog_test_base.h
index d884b54ceb..29a4bc016b 100644
--- a/xls/simulation/verilog_test_base.h
+++ b/xls/simulation/verilog_test_base.h
@@ -18,6 +18,7 @@
 #include <cctype>
 #include <filesystem>
 #include <memory>
+#include <optional>
 #include <ostream>
 #include <string>
 #include <string_view>
@@ -248,12 +249,14 @@ class VerilogTestBaseWithParam : public testing::TestWithParam<ParamType> {
   // relative to the XLS source top.
   virtual std::filesystem::path GoldenFilePath(
       std::string_view test_file_name,
-      const std::filesystem::path& testdata_dir) {
+      const std::filesystem::path& testdata_dir,
+      std::optional<std::string_view> forced_test_base_name = std::nullopt) {
     // We suffix the golden reference files with "txt" on top of the extension
     // just to indicate they're compiler byproduct comparison points and not
     // Verilog files that have been written by hand.
     std::string filename =
-        absl::StrFormat("%s_%s.%s", test_file_name, TestBaseName(),
+        absl::StrFormat("%s_%s.%s", test_file_name,
+                        forced_test_base_name.value_or(TestBaseName()),
                         UseSystemVerilog() ? "svtxt" : "vtxt");
     return testdata_dir / filename;
   }
diff --git a/xls/tools/BUILD b/xls/tools/BUILD
index 200491d2c4..42b74891c0 100644
--- a/xls/tools/BUILD
+++ b/xls/tools/BUILD
@@ -725,6 +725,7 @@ cc_library(
     hdrs = ["codegen_flags.h"],
     deps = [
         ":codegen_flags_cc_proto",
+        ":codegen_flags_handler_registry",
         "//xls/codegen:codegen_residual_data_cc_proto",
         "//xls/common/file:filesystem",
         "//xls/common/status:ret_check",
@@ -765,12 +766,25 @@ cc_library(
     ],
 )
 
+cc_library(
+    name = "codegen_flags_handler_registry",
+    srcs = ["codegen_flags_handler_registry.cc"],
+    hdrs = ["codegen_flags_handler_registry.h"],
+    deps = [
+        ":codegen_flags_cc_proto",
+        "//xls/codegen:codegen_options",
+        "//xls/common/status:status_macros",
+        "@com_google_absl//absl/status",
+    ],
+)
+
 cc_library(
     name = "codegen",
     srcs = ["codegen.cc"],
     hdrs = ["codegen.h"],
     deps = [
         ":codegen_flags_cc_proto",
+        ":codegen_flags_handler_registry",
         ":schedule",
         ":scheduling_options_flags_cc_proto",
         "//xls/codegen:block_metrics",
diff --git a/xls/tools/codegen.cc b/xls/tools/codegen.cc
index 8a6b656c10..d96c74a69d 100644
--- a/xls/tools/codegen.cc
+++ b/xls/tools/codegen.cc
@@ -53,6 +53,7 @@
 #include "xls/scheduling/scheduling_options.h"
 #include "xls/scheduling/scheduling_result.h"
 #include "xls/tools/codegen_flags.pb.h"
+#include "xls/tools/codegen_flags_handler_registry.h"
 #include "xls/tools/schedule.h"
 #include "xls/tools/scheduling_options_flags.pb.h"
 
@@ -455,6 +456,7 @@ absl::StatusOr<verilog::CodegenOptions> CodegenOptionsFromProto(
     options.set_ir_dump_path(p.ir_dump_path());
   }
 
+  XLS_RETURN_IF_ERROR(CodegenFlagsHandlerRegistry::Process(p, options));
   return options;
 }
 
diff --git a/xls/tools/codegen_flags.cc b/xls/tools/codegen_flags.cc
index 2f16a6e914..129c1766f9 100644
--- a/xls/tools/codegen_flags.cc
+++ b/xls/tools/codegen_flags.cc
@@ -37,6 +37,7 @@
 #include "xls/common/status/status_macros.h"
 #include "xls/ir/xls_ir_interface.pb.h"
 #include "xls/tools/codegen_flags.pb.h"
+#include "xls/tools/codegen_flags_handler_registry.h"
 
 // LINT.IfChange
 ABSL_FLAG(
@@ -438,6 +439,7 @@ static absl::StatusOr<bool> SetOptionsFromFlags(CodegenFlagsProto& proto) {
   POPULATE_FLAG(array_index_bounds_checking);
   POPULATE_FLAG(fifo_module);
   POPULATE_FLAG(nodata_fifo_module);
+
   if (absl::GetFlag(FLAGS_materialize_internal_fifos)) {
     any_flags_set = true;
     if (!FLAGS_fifo_module.IsSpecifiedOnCommandLine()) {
@@ -451,6 +453,7 @@ static absl::StatusOr<bool> SetOptionsFromFlags(CodegenFlagsProto& proto) {
              "--materialize_internal_fifos.";
     }
   }
+
   XLS_ASSIGN_OR_RETURN(
       RegisterMergeStrategyProto merge_strategy,
       MergeStrategyFromString(absl::GetFlag(FLAGS_register_merge_strategy)));
@@ -514,6 +517,7 @@ absl::StatusOr<CodegenFlagsProto> GetCodegenFlags() {
     XLS_RETURN_IF_ERROR(xls::ParseTextProtoFile(
         absl::GetFlag(FLAGS_codegen_options_proto), &proto));
   }
+  XLS_RETURN_IF_ERROR(CodegenFlagsHandlerRegistry::ParseFlags(proto));
   if (absl::GetFlag(FLAGS_codegen_options_used_textproto_file)) {
     XLS_RETURN_IF_ERROR(SetTextProtoFile(
         *absl::GetFlag(FLAGS_codegen_options_used_textproto_file), proto));
diff --git a/xls/tools/codegen_flags.proto b/xls/tools/codegen_flags.proto
index cc561bc7ae..4051060425 100644
--- a/xls/tools/codegen_flags.proto
+++ b/xls/tools/codegen_flags.proto
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-syntax = "proto3";
+edition = "2023";
 
 package xls;
 
@@ -56,55 +56,55 @@ enum CodegenVersionProto {
 //
 // See codegen_flags.cc ABSL_FLAG() definitions for the meaning of these fields.
 message CodegenFlagsProto {
-  optional string top = 1;
-  optional GeneratorKind generator = 2;
-  optional string input_valid_signal = 3;
-  optional string output_valid_signal = 4;
-  optional string manual_load_enable_signal = 5;
-  optional bool flop_inputs = 6;
-  optional bool flop_outputs = 7;
-  optional IOKindProto flop_inputs_kind = 8;
-  optional IOKindProto flop_outputs_kind = 9;
-  optional bool flop_single_value_channels = 10;
-  optional bool add_idle_output = 11;
-  optional string module_name = 12;
-  optional string output_port_name = 13;
-  optional string reset = 14;
-  optional bool reset_active_low = 15;
-  optional bool reset_asynchronous = 16;
-  optional bool reset_data_path = 17;
-  optional bool use_system_verilog = 18;
-  optional bool separate_lines = 19;
-  optional int64 max_inline_depth = 35;
-  optional string gate_format = 20;
-  optional string assert_format = 21;
-  optional string smulp_format = 22;
-  optional string umulp_format = 23;
-  optional string streaming_channel_data_suffix = 24;
-  optional string streaming_channel_valid_suffix = 25;
-  optional string streaming_channel_ready_suffix = 26;
+  string top = 1;
+  GeneratorKind generator = 2;
+  string input_valid_signal = 3;
+  string output_valid_signal = 4;
+  string manual_load_enable_signal = 5;
+  bool flop_inputs = 6;
+  bool flop_outputs = 7;
+  IOKindProto flop_inputs_kind = 8;
+  IOKindProto flop_outputs_kind = 9;
+  bool flop_single_value_channels = 10;
+  bool add_idle_output = 11;
+  string module_name = 12;
+  string output_port_name = 13;
+  string reset = 14;
+  bool reset_active_low = 15;
+  bool reset_asynchronous = 16;
+  bool reset_data_path = 17;
+  bool use_system_verilog = 18;
+  bool separate_lines = 19;
+  int64 max_inline_depth = 35;
+  string gate_format = 20;
+  string assert_format = 21;
+  string smulp_format = 22;
+  string umulp_format = 23;
+  string streaming_channel_data_suffix = 24;
+  string streaming_channel_valid_suffix = 25;
+  string streaming_channel_ready_suffix = 26;
   repeated string ram_configurations = 27;
-  optional bool gate_recvs = 28;
-  optional bool array_index_bounds_checking = 29;
-  optional RegisterMergeStrategyProto register_merge_strategy = 30;
-  optional int64 max_trace_verbosity = 31;
+  bool gate_recvs = 28;
+  bool array_index_bounds_checking = 29;
+  RegisterMergeStrategyProto register_merge_strategy = 30;
+  int64 max_trace_verbosity = 31;
   // If present details about the interface requested. Eg specific sv types to
   // use for arguments etc. Only the 'top' and channels are interpreted. Unknown
   // interface elements are ignored.
-  optional PackageInterfaceProto package_interface = 32;
+  PackageInterfaceProto package_interface = 32;
   // Should annotated arguments be emitted with the sv_types they are annotated
   // with.
-  optional bool emit_sv_types = 33;
+  bool emit_sv_types = 33;
 
-  optional string simulation_macro_name = 34;
+  string simulation_macro_name = 34;
   repeated string assertion_macro_names = 39;
 
-  optional CodegenVersionProto codegen_version = 36;
+  CodegenVersionProto codegen_version = 36;
 
   // Which module to use for FIFOs. If empty, will materialize an internal
   // implementation.
-  optional string fifo_module = 40;
-  optional string nodata_fifo_module = 41;
+  string fifo_module = 40;
+  string nodata_fifo_module = 41;
 
   // If present, the seed used to randomize the order of lines in the output. If
   // empty, will use a default order. This can be useful for creating multiple
@@ -113,14 +113,16 @@ message CodegenFlagsProto {
 
   // If false, runtime invariant assertions (e.g. one-hot selector checks)
   // are omitted from generated RTL.  Default is true.
-  optional bool add_invariant_assertions = 42;
+  bool add_invariant_assertions = 42;
 
   // Parsed reference residual data. When present, codegen uses this to
   // influence emission order; preferred over reading from a path at runtime.
-  optional verilog.CodegenResidualData reference_residual_data = 43;
+  verilog.CodegenResidualData reference_residual_data = 43;
 
-  optional SourceAnnotationStrategyProto source_annotation_strategy = 44;
+  SourceAnnotationStrategyProto source_annotation_strategy = 44;
 
   // Debugging flag to cause the block conversion to dump its pass results.
-  optional string ir_dump_path = 45;
+  string ir_dump_path = 45;
+
+  extensions 20000 to max;
 }
diff --git a/xls/tools/codegen_flags_handler_registry.cc b/xls/tools/codegen_flags_handler_registry.cc
new file mode 100644
index 0000000000..5d3c5c5bad
--- /dev/null
+++ b/xls/tools/codegen_flags_handler_registry.cc
@@ -0,0 +1,65 @@
+// Copyright 2026 The XLS Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "xls/tools/codegen_flags_handler_registry.h"
+
+#include <string_view>
+#include <utility>
+#include <vector>
+
+#include "absl/status/status.h"
+#include "xls/codegen/codegen_options.h"
+#include "xls/common/status/status_macros.h"
+#include "xls/tools/codegen_flags.pb.h"
+
+namespace xls {
+namespace {
+
+struct RegisteredHandler {
+  std::string_view name;
+  CodegenFlagsHandler handler;
+  CodegenFlagsParser parser;
+};
+
+std::vector<RegisteredHandler>& GetRegistry() {
+  static auto* registry = new std::vector<RegisteredHandler>();
+  return *registry;
+}
+
+}  // namespace
+
+void CodegenFlagsHandlerRegistry::Register(std::string_view name,
+                                           CodegenFlagsHandler handler,
+                                           CodegenFlagsParser parser) {
+  GetRegistry().push_back({name, std::move(handler), std::move(parser)});
+}
+
+absl::Status CodegenFlagsHandlerRegistry::ParseFlags(CodegenFlagsProto& proto) {
+  for (const auto& registered : GetRegistry()) {
+    if (registered.parser != nullptr) {
+      XLS_RETURN_IF_ERROR(registered.parser(proto));
+    }
+  }
+  return absl::OkStatus();
+}
+
+absl::Status CodegenFlagsHandlerRegistry::Process(
+    const CodegenFlagsProto& proto, verilog::CodegenOptions& options) {
+  for (const auto& registered : GetRegistry()) {
+    XLS_RETURN_IF_ERROR(registered.handler(proto, options));
+  }
+  return absl::OkStatus();
+}
+
+}  // namespace xls
diff --git a/xls/tools/codegen_flags_handler_registry.h b/xls/tools/codegen_flags_handler_registry.h
new file mode 100644
index 0000000000..e54f3331eb
--- /dev/null
+++ b/xls/tools/codegen_flags_handler_registry.h
@@ -0,0 +1,86 @@
+// Copyright 2026 The XLS Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef XLS_TOOLS_CODEGEN_FLAGS_HANDLER_REGISTRY_H_
+#define XLS_TOOLS_CODEGEN_FLAGS_HANDLER_REGISTRY_H_
+
+#include <functional>
+#include <string_view>
+
+#include "absl/status/status.h"
+#include "xls/codegen/codegen_options.h"
+#include "xls/tools/codegen_flags.pb.h"
+
+namespace xls {
+
+using CodegenFlagsHandler = std::function<absl::Status(
+    const CodegenFlagsProto&, verilog::CodegenOptions&)>;
+using CodegenFlagsParser = std::function<absl::Status(CodegenFlagsProto&)>;
+
+// Registry to manage custom codegen option extensions.
+// Enables downstream pass modules to register flag-parsing hooks and options
+// handler callbacks. At runtime, the registry parses command-line flags into
+// The CodegenFlagsProto (keeping them trackable/serializable) and then
+// configures the C++ verilog::CodegenOptions container.
+//
+// Expected usage:
+// 1. Declare proto extension fields on CodegenFlagsProto in a local proto file.
+// 2. Define custom properties in a verilog::CodegenOptionExtension C++ struct.
+// 3. Register your pass handlers using the registration macro helper.
+//
+// Example registration:
+//   ABSL_FLAG(std::string, my_pass_config, "none", "My pass setting");
+//
+//   absl::Status MyHandler(const CodegenFlagsProto& proto,
+//                          verilog::CodegenOptions& options) {
+//     if (proto.HasExtension(my_extension_id)) {
+//        options.add_extension(std::make_unique<MyOptions>(...));
+//     }
+//     return absl::OkStatus();
+//   }
+//
+//   absl::Status MyParser(CodegenFlagsProto& proto) {
+//     std::string val = absl::GetFlag(FLAGS_my_pass_config);
+//     if (val != "none") {
+//       proto.SetExtension(my_extension_id, val);
+//     }
+//     return absl::OkStatus();
+//   }
+//
+//   XLS_REGISTER_CODEGEN_FLAGS_HANDLER("my_pass", MyHandler, MyParser);
+class CodegenFlagsHandlerRegistry {
+ public:
+  static void Register(std::string_view name, CodegenFlagsHandler handler,
+                       CodegenFlagsParser parser);
+  static absl::Status ParseFlags(CodegenFlagsProto& proto);
+  static absl::Status Process(const CodegenFlagsProto& proto,
+                              verilog::CodegenOptions& options);
+};
+
+#define XLS_REGISTER_CODEGEN_FLAGS_HANDLER(name, handler, parser) \
+  XLS_REGISTER_CODEGEN_FLAGS_HANDLER_UNIQHelper(__LINE__, name, handler, parser)
+
+#define XLS_REGISTER_CODEGEN_FLAGS_HANDLER_UNIQHelper(line, name, handler, \
+                                                      parser)              \
+  XLS_REGISTER_CODEGEN_FLAGS_HANDLER_UNIQ(line, name, handler, parser)
+
+#define XLS_REGISTER_CODEGEN_FLAGS_HANDLER_UNIQ(line, name, handler, parser) \
+  static bool const registrator_##line = []() {                              \
+    ::xls::CodegenFlagsHandlerRegistry::Register(name, handler, parser);     \
+    return true;                                                             \
+  }();
+
+}  // namespace xls
+
+#endif  // XLS_TOOLS_CODEGEN_FLAGS_HANDLER_REGISTRY_H_