refactor: narrow pub(crate) items to private

Porting mapped every PHP `protected` member onto `pub(crate)`, which is
wider than nearly all of them need. Each item demoted here is reached
only from the module that defines it, so the crate-wide visibility
conveyed nothing.

Every `pub(crate)` that survives has at least one reader in another
module of the same crate.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

22 files changed, 81 insertions, 85 deletions

diff --git a/crates/shirabe/src/dependency_resolver/decisions.rs b/crates/shirabe/src/dependency_resolver/decisions.rs
index ac596054..3cf26ffb 100644
--- a/crates/shirabe/src/dependency_resolver/decisions.rs
+++ b/crates/shirabe/src/dependency_resolver/decisions.rs
@@ -8,8 +8,8 @@ use shirabe_php_shim::LogicException;
 use std::fmt;
 
 pub struct Decisions {
-    pub(crate) pool: std::rc::Rc<std::cell::RefCell<Pool>>,
-    pub(crate) decision_map: IndexMap<i64, i64>,
+    pool: std::rc::Rc<std::cell::RefCell<Pool>>,
+    decision_map: IndexMap<i64, i64>,
     pub(crate) decision_queue: Vec<(i64, std::rc::Rc<std::cell::RefCell<Rule>>)>,
 }
 
@@ -153,7 +153,7 @@ impl Decisions {
         self.decision_queue.is_empty()
     }
 
-    pub(crate) fn add_decision(&mut self, literal: i64, level: i64) {
+    fn add_decision(&mut self, literal: i64, level: i64) {
         let package_id = literal.abs();
 
         let previous_decision = self.decision_map.get(&package_id).copied().unwrap_or(0);
diff --git a/crates/shirabe/src/dependency_resolver/default_policy.rs b/crates/shirabe/src/dependency_resolver/default_policy.rs
index 8c1a7697..f753dc48 100644
--- a/crates/shirabe/src/dependency_resolver/default_policy.rs
+++ b/crates/shirabe/src/dependency_resolver/default_policy.rs
@@ -85,11 +85,7 @@ impl DefaultPolicy {
         if a.id() < b.id() { -1 } else { 1 }
     }
 
-    pub(crate) fn group_literals_by_name(
-        &self,
-        pool: &Pool,
-        literals: &[i64],
-    ) -> IndexMap<String, Vec<i64>> {
+    fn group_literals_by_name(&self, pool: &Pool, literals: &[i64]) -> IndexMap<String, Vec<i64>> {
         let mut packages: IndexMap<String, Vec<i64>> = IndexMap::new();
         for &literal in literals {
             let package_name = pool.literal_to_package(literal).get_name().to_string();
@@ -98,7 +94,7 @@ impl DefaultPolicy {
         packages
     }
 
-    pub(crate) fn prune_to_best_version(&self, pool: &Pool, literals: Vec<i64>) -> Vec<i64> {
+    fn prune_to_best_version(&self, pool: &Pool, literals: Vec<i64>) -> Vec<i64> {
         if let Some(ref preferred_versions) = self.preferred_versions {
             let name = pool.literal_to_package(literals[0]).get_name();
             if let Some(preferred_version) = preferred_versions.get(&name) {
@@ -133,7 +129,7 @@ impl DefaultPolicy {
         best_literals
     }
 
-    pub(crate) fn prune_remote_aliases(&self, pool: &Pool, literals: Vec<i64>) -> Vec<i64> {
+    fn prune_remote_aliases(&self, pool: &Pool, literals: Vec<i64>) -> Vec<i64> {
         let mut has_local_alias = false;
 
         for &literal in &literals {
@@ -162,7 +158,7 @@ impl DefaultPolicy {
         selected
     }
 
-    pub(crate) fn replaces(&self, source: BasePackageHandle, target: BasePackageHandle) -> bool {
+    fn replaces(&self, source: BasePackageHandle, target: BasePackageHandle) -> bool {
         for link in source.get_replaces().values() {
             if link.get_target() == target.get_name().as_str() {
                 return true;
diff --git a/crates/shirabe/src/dependency_resolver/generic_rule.rs b/crates/shirabe/src/dependency_resolver/generic_rule.rs
index 8c702d32..b13333ed 100644
--- a/crates/shirabe/src/dependency_resolver/generic_rule.rs
+++ b/crates/shirabe/src/dependency_resolver/generic_rule.rs
@@ -7,7 +7,7 @@ use shirabe_php_shim::{RuntimeException, hash_raw};
 #[derive(Debug)]
 pub struct GenericRule {
     inner: RuleBase,
-    pub(crate) literals: Vec<i64>,
+    literals: Vec<i64>,
 }
 
 impl GenericRule {
diff --git a/crates/shirabe/src/dependency_resolver/lock_transaction.rs b/crates/shirabe/src/dependency_resolver/lock_transaction.rs
index e230801f..51917dd6 100644
--- a/crates/shirabe/src/dependency_resolver/lock_transaction.rs
+++ b/crates/shirabe/src/dependency_resolver/lock_transaction.rs
@@ -13,11 +13,11 @@ pub struct LockTransaction {
     inner: Transaction,
     /// packages in current lock file, platform repo or otherwise present
     /// Indexed by spl_object_hash
-    pub(crate) present_map: IndexMap<String, PackageInterfaceHandle>,
+    present_map: IndexMap<String, PackageInterfaceHandle>,
     /// Packages which cannot be mapped, platform repo, root package, other fixed repos
     /// Indexed by package id
-    pub(crate) unlockable_map: IndexMap<i64, PackageInterfaceHandle>,
-    pub(crate) result_packages: IndexMap<String, Vec<PackageInterfaceHandle>>,
+    unlockable_map: IndexMap<i64, PackageInterfaceHandle>,
+    result_packages: IndexMap<String, Vec<PackageInterfaceHandle>>,
 }
 
 impl LockTransaction {
diff --git a/crates/shirabe/src/dependency_resolver/multi_conflict_rule.rs b/crates/shirabe/src/dependency_resolver/multi_conflict_rule.rs
index b7f21074..dc99f5b4 100644
--- a/crates/shirabe/src/dependency_resolver/multi_conflict_rule.rs
+++ b/crates/shirabe/src/dependency_resolver/multi_conflict_rule.rs
@@ -6,7 +6,7 @@ use shirabe_php_shim::{RuntimeException, hash_raw};
 #[derive(Debug)]
 pub struct MultiConflictRule {
     inner: RuleBase,
-    pub(crate) literals: Vec<i64>,
+    literals: Vec<i64>,
 }
 
 impl MultiConflictRule {
diff --git a/crates/shirabe/src/dependency_resolver/operation/install_operation.rs b/crates/shirabe/src/dependency_resolver/operation/install_operation.rs
index 05349c2d..d2d665ac 100644
--- a/crates/shirabe/src/dependency_resolver/operation/install_operation.rs
+++ b/crates/shirabe/src/dependency_resolver/operation/install_operation.rs
@@ -5,7 +5,7 @@ use crate::package::PackageInterfaceHandle;
 
 #[derive(Debug, Clone)]
 pub struct InstallOperation {
-    pub(crate) package: PackageInterfaceHandle,
+    package: PackageInterfaceHandle,
 }
 
 impl InstallOperation {
diff --git a/crates/shirabe/src/dependency_resolver/operation/mark_alias_installed_operation.rs b/crates/shirabe/src/dependency_resolver/operation/mark_alias_installed_operation.rs
index 72066204..82870816 100644
--- a/crates/shirabe/src/dependency_resolver/operation/mark_alias_installed_operation.rs
+++ b/crates/shirabe/src/dependency_resolver/operation/mark_alias_installed_operation.rs
@@ -5,7 +5,7 @@ use crate::package::AliasPackageHandle;
 
 #[derive(Debug, Clone)]
 pub struct MarkAliasInstalledOperation {
-    pub(crate) package: AliasPackageHandle,
+    package: AliasPackageHandle,
 }
 
 impl MarkAliasInstalledOperation {
diff --git a/crates/shirabe/src/dependency_resolver/operation/mark_alias_uninstalled_operation.rs b/crates/shirabe/src/dependency_resolver/operation/mark_alias_uninstalled_operation.rs
index 4e4000df..902eb465 100644
--- a/crates/shirabe/src/dependency_resolver/operation/mark_alias_uninstalled_operation.rs
+++ b/crates/shirabe/src/dependency_resolver/operation/mark_alias_uninstalled_operation.rs
@@ -5,7 +5,7 @@ use crate::package::AliasPackageHandle;
 
 #[derive(Debug, Clone)]
 pub struct MarkAliasUninstalledOperation {
-    pub(crate) package: AliasPackageHandle,
+    package: AliasPackageHandle,
 }
 
 impl MarkAliasUninstalledOperation {
diff --git a/crates/shirabe/src/dependency_resolver/operation/uninstall_operation.rs b/crates/shirabe/src/dependency_resolver/operation/uninstall_operation.rs
index 2fd35af5..aeb2e86a 100644
--- a/crates/shirabe/src/dependency_resolver/operation/uninstall_operation.rs
+++ b/crates/shirabe/src/dependency_resolver/operation/uninstall_operation.rs
@@ -5,7 +5,7 @@ use crate::package::PackageInterfaceHandle;
 
 #[derive(Debug, Clone)]
 pub struct UninstallOperation {
-    pub(crate) package: PackageInterfaceHandle,
+    package: PackageInterfaceHandle,
 }
 
 impl UninstallOperation {
diff --git a/crates/shirabe/src/dependency_resolver/operation/update_operation.rs b/crates/shirabe/src/dependency_resolver/operation/update_operation.rs
index a06a9cdc..67ed73c1 100644
--- a/crates/shirabe/src/dependency_resolver/operation/update_operation.rs
+++ b/crates/shirabe/src/dependency_resolver/operation/update_operation.rs
@@ -6,8 +6,8 @@ use crate::package::version::VersionParser;
 
 #[derive(Debug, Clone)]
 pub struct UpdateOperation {
-    pub(crate) initial_package: PackageInterfaceHandle,
-    pub(crate) target_package: PackageInterfaceHandle,
+    initial_package: PackageInterfaceHandle,
+    target_package: PackageInterfaceHandle,
 }
 
 impl UpdateOperation {
diff --git a/crates/shirabe/src/dependency_resolver/pool.rs b/crates/shirabe/src/dependency_resolver/pool.rs
index a0dfd362..c12f819d 100644
--- a/crates/shirabe/src/dependency_resolver/pool.rs
+++ b/crates/shirabe/src/dependency_resolver/pool.rs
@@ -14,19 +14,19 @@ use std::fmt;
 #[derive(Debug)]
 pub struct Pool {
     /// @var BasePackage[]
-    pub(crate) packages: Vec<BasePackageHandle>,
+    packages: Vec<BasePackageHandle>,
     /// @var array<string, BasePackage[]>
-    pub(crate) package_by_name: IndexMap<String, Vec<BasePackageHandle>>,
+    package_by_name: IndexMap<String, Vec<BasePackageHandle>>,
     /// @var VersionParser
-    pub(crate) version_parser: VersionParser,
+    version_parser: VersionParser,
     /// @var array<string, array<string, BasePackage[]>>
-    pub(crate) provider_cache: IndexMap<String, IndexMap<String, Vec<BasePackageHandle>>>,
+    provider_cache: IndexMap<String, IndexMap<String, Vec<BasePackageHandle>>>,
     /// @var BasePackage[]
-    pub(crate) unacceptable_fixed_or_locked_packages: Vec<BasePackageHandle>,
+    unacceptable_fixed_or_locked_packages: Vec<BasePackageHandle>,
     /// @var array<string, array<string, string>> Map of package name => normalized version => pretty version
-    pub(crate) removed_versions: IndexMap<String, IndexMap<String, String>>,
+    removed_versions: IndexMap<String, IndexMap<String, String>>,
     /// @var array<string, array<string, string>> Map of package object hash => removed normalized versions => removed pretty version
-    pub(crate) removed_versions_by_package: IndexMap<String, IndexMap<String, String>>,
+    removed_versions_by_package: IndexMap<String, IndexMap<String, String>>,
     /// @var array<string, array<string, array<SecurityAdvisory|PartialSecurityAdvisory>>> Map of package name => normalized version => security advisories
     security_removed_versions:
         IndexMap<String, IndexMap<String, Vec<std::rc::Rc<AnySecurityAdvisory>>>>,
diff --git a/crates/shirabe/src/dependency_resolver/problem.rs b/crates/shirabe/src/dependency_resolver/problem.rs
index 1da6028c..cdb833bf 100644
--- a/crates/shirabe/src/dependency_resolver/problem.rs
+++ b/crates/shirabe/src/dependency_resolver/problem.rs
@@ -25,12 +25,12 @@ use shirabe_symfony_console::formatter::OutputFormatter;
 #[derive(Debug)]
 pub struct Problem {
     /// A map containing the id of each rule part of this problem as a key
-    pub(crate) reason_seen: IndexMap<String, bool>,
+    reason_seen: IndexMap<String, bool>,
 
     /// A set of reasons for the problem, each is a rule or a root require and a rule
-    pub(crate) reasons: IndexMap<i64, Vec<std::rc::Rc<std::cell::RefCell<Rule>>>>,
+    reasons: IndexMap<i64, Vec<std::rc::Rc<std::cell::RefCell<Rule>>>>,
 
-    pub(crate) section: i64,
+    section: i64,
 }
 
 impl Default for Problem {
@@ -360,7 +360,7 @@ impl Problem {
     }
 
     /// Store a reason descriptor but ignore duplicates
-    pub(crate) fn add_reason(&mut self, id: String, reason: std::rc::Rc<std::cell::RefCell<Rule>>) {
+    fn add_reason(&mut self, id: String, reason: std::rc::Rc<std::cell::RefCell<Rule>>) {
         // TODO: if a rule is part of a problem description in two sections, isn't this going to remove a message
         // that is important to understand the issue?
 
@@ -1377,7 +1377,7 @@ impl Problem {
     }
 
     /// Turns a constraint into text usable in a sentence describing a request
-    pub(crate) fn constraint_to_text(constraint: Option<&AnyConstraint>) -> String {
+    fn constraint_to_text(constraint: Option<&AnyConstraint>) -> String {
         if let Some(c) = constraint
             && c.is_constraint()
             && c.get_operator() == Some(CmpOp::Eq)
diff --git a/crates/shirabe/src/dependency_resolver/request.rs b/crates/shirabe/src/dependency_resolver/request.rs
index 410831dd..1b6925ed 100644
--- a/crates/shirabe/src/dependency_resolver/request.rs
+++ b/crates/shirabe/src/dependency_resolver/request.rs
@@ -231,12 +231,12 @@ pub enum UpdateAllowTransitiveDeps {
 
 #[derive(Debug)]
 pub struct Request {
-    pub(crate) locked_repository: Option<LockArrayRepositoryHandle>,
-    pub(crate) requires: IndexMap<String, AnyConstraint>,
-    pub(crate) fixed_packages: IndexMap<String, BasePackageHandle>,
-    pub(crate) locked_packages: IndexMap<String, BasePackageHandle>,
-    pub(crate) fixed_locked_packages: IndexMap<String, BasePackageHandle>,
-    pub(crate) update_allow_list: Vec<String>,
-    pub(crate) update_allow_transitive_dependencies: UpdateAllowTransitiveDeps,
+    locked_repository: Option<LockArrayRepositoryHandle>,
+    requires: IndexMap<String, AnyConstraint>,
+    fixed_packages: IndexMap<String, BasePackageHandle>,
+    locked_packages: IndexMap<String, BasePackageHandle>,
+    fixed_locked_packages: IndexMap<String, BasePackageHandle>,
+    update_allow_list: Vec<String>,
+    update_allow_transitive_dependencies: UpdateAllowTransitiveDeps,
     restrict_packages: Option<Vec<String>>,
 }
diff --git a/crates/shirabe/src/dependency_resolver/rule.rs b/crates/shirabe/src/dependency_resolver/rule.rs
index 5e009260..6b1c2274 100644
--- a/crates/shirabe/src/dependency_resolver/rule.rs
+++ b/crates/shirabe/src/dependency_resolver/rule.rs
@@ -721,9 +721,9 @@ impl std::fmt::Display for Rule {
 
 #[derive(Debug)]
 pub struct RuleBase {
-    pub(crate) bitfield: i64,
-    pub(crate) request: Option<Request>,
-    pub(crate) reason_data: ReasonData,
+    bitfield: i64,
+    request: Option<Request>,
+    reason_data: ReasonData,
 }
 
 impl RuleBase {
diff --git a/crates/shirabe/src/dependency_resolver/rule_set.rs b/crates/shirabe/src/dependency_resolver/rule_set.rs
index 50f7cb45..195e0953 100644
--- a/crates/shirabe/src/dependency_resolver/rule_set.rs
+++ b/crates/shirabe/src/dependency_resolver/rule_set.rs
@@ -11,9 +11,9 @@ use shirabe_php_shim::OutOfBoundsException;
 #[derive(Debug)]
 pub struct RuleSet {
     pub rule_by_id: IndexMap<i64, std::rc::Rc<std::cell::RefCell<Rule>>>,
-    pub(crate) rules: IndexMap<i64, Vec<std::rc::Rc<std::cell::RefCell<Rule>>>>,
-    pub(crate) next_rule_id: i64,
-    pub(crate) rules_by_hash: IndexMap<String, Vec<std::rc::Rc<std::cell::RefCell<Rule>>>>,
+    rules: IndexMap<i64, Vec<std::rc::Rc<std::cell::RefCell<Rule>>>>,
+    next_rule_id: i64,
+    rules_by_hash: IndexMap<String, Vec<std::rc::Rc<std::cell::RefCell<Rule>>>>,
 }
 
 impl Default for RuleSet {
diff --git a/crates/shirabe/src/dependency_resolver/rule_set_generator.rs b/crates/shirabe/src/dependency_resolver/rule_set_generator.rs
index 6f2213dc..aa9412c4 100644
--- a/crates/shirabe/src/dependency_resolver/rule_set_generator.rs
+++ b/crates/shirabe/src/dependency_resolver/rule_set_generator.rs
@@ -17,11 +17,11 @@ use std::collections::VecDeque;
 
 #[derive(Debug)]
 pub struct RuleSetGenerator {
-    pub(crate) policy: std::rc::Rc<dyn PolicyInterface>,
-    pub(crate) pool: std::rc::Rc<std::cell::RefCell<Pool>>,
-    pub(crate) rules: RuleSet,
-    pub(crate) added_map: IndexMap<i64, PackageInterfaceHandle>,
-    pub(crate) added_packages_by_names: IndexMap<String, Vec<PackageInterfaceHandle>>,
+    policy: std::rc::Rc<dyn PolicyInterface>,
+    pool: std::rc::Rc<std::cell::RefCell<Pool>>,
+    rules: RuleSet,
+    added_map: IndexMap<i64, PackageInterfaceHandle>,
+    added_packages_by_names: IndexMap<String, Vec<PackageInterfaceHandle>>,
 }
 
 impl RuleSetGenerator {
@@ -132,7 +132,7 @@ impl RuleSetGenerator {
         }
     }
 
-    pub(crate) fn add_rules_for_package(
+    fn add_rules_for_package(
         &mut self,
         package: PackageInterfaceHandle,
         platform_requirement_filter: &dyn PlatformRequirementFilterInterface,
@@ -221,7 +221,7 @@ impl RuleSetGenerator {
         }
     }
 
-    pub(crate) fn add_conflict_rules(
+    fn add_conflict_rules(
         &mut self,
         platform_requirement_filter: &dyn PlatformRequirementFilterInterface,
     ) {
@@ -292,7 +292,7 @@ impl RuleSetGenerator {
         }
     }
 
-    pub(crate) fn add_rules_for_request(
+    fn add_rules_for_request(
         &mut self,
         request: &Request,
         platform_requirement_filter: &dyn PlatformRequirementFilterInterface,
@@ -369,7 +369,7 @@ impl RuleSetGenerator {
         Ok(())
     }
 
-    pub(crate) fn add_rules_for_root_aliases(
+    fn add_rules_for_root_aliases(
         &mut self,
         platform_requirement_filter: &dyn PlatformRequirementFilterInterface,
     ) {
diff --git a/crates/shirabe/src/dependency_resolver/rule_set_iterator.rs b/crates/shirabe/src/dependency_resolver/rule_set_iterator.rs
index b469a193..3dcd3a85 100644
--- a/crates/shirabe/src/dependency_resolver/rule_set_iterator.rs
+++ b/crates/shirabe/src/dependency_resolver/rule_set_iterator.rs
@@ -6,11 +6,11 @@ use indexmap::IndexMap;
 /// Implements PHP \Iterator over a grouped rule set.
 #[derive(Debug)]
 pub struct RuleSetIterator {
-    pub(crate) rules: IndexMap<i64, Vec<std::rc::Rc<std::cell::RefCell<Rule>>>>,
-    pub(crate) types: Vec<i64>,
-    pub(crate) current_offset: i64,
-    pub(crate) current_type: i64,
-    pub(crate) current_type_offset: i64,
+    rules: IndexMap<i64, Vec<std::rc::Rc<std::cell::RefCell<Rule>>>>,
+    types: Vec<i64>,
+    current_offset: i64,
+    current_type: i64,
+    current_type_offset: i64,
 }
 
 impl RuleSetIterator {
diff --git a/crates/shirabe/src/dependency_resolver/rule_watch_graph.rs b/crates/shirabe/src/dependency_resolver/rule_watch_graph.rs
index 6646490b..19be7a9e 100644
--- a/crates/shirabe/src/dependency_resolver/rule_watch_graph.rs
+++ b/crates/shirabe/src/dependency_resolver/rule_watch_graph.rs
@@ -8,7 +8,7 @@ use indexmap::IndexMap;
 
 #[derive(Debug)]
 pub struct RuleWatchGraph {
-    pub(crate) watch_chains: IndexMap<i64, RuleWatchChain>,
+    watch_chains: IndexMap<i64, RuleWatchChain>,
 }
 
 impl Default for RuleWatchGraph {
@@ -121,7 +121,7 @@ impl RuleWatchGraph {
         None
     }
 
-    pub(crate) fn move_watch(
+    fn move_watch(
         &mut self,
         from_literal: i64,
         to_literal: i64,
diff --git a/crates/shirabe/src/dependency_resolver/rule_watch_node.rs b/crates/shirabe/src/dependency_resolver/rule_watch_node.rs
index b11c1771..fae7fa91 100644
--- a/crates/shirabe/src/dependency_resolver/rule_watch_node.rs
+++ b/crates/shirabe/src/dependency_resolver/rule_watch_node.rs
@@ -6,7 +6,7 @@ use crate::dependency_resolver::Rule;
 pub struct RuleWatchNode {
     pub watch1: i64,
     pub watch2: i64,
-    pub(crate) rule: std::rc::Rc<std::cell::RefCell<Rule>>,
+    rule: std::rc::Rc<std::cell::RefCell<Rule>>,
 }
 
 impl std::fmt::Debug for RuleWatchNode {
diff --git a/crates/shirabe/src/dependency_resolver/solver.rs b/crates/shirabe/src/dependency_resolver/solver.rs
index a9453a3e..cb398a0c 100644
--- a/crates/shirabe/src/dependency_resolver/solver.rs
+++ b/crates/shirabe/src/dependency_resolver/solver.rs
@@ -26,25 +26,25 @@ use shirabe_semver::constraint::AnyConstraint;
 
 #[derive(Debug)]
 pub struct Solver {
-    pub(crate) policy: std::rc::Rc<dyn PolicyInterface>,
-    pub(crate) pool: std::rc::Rc<std::cell::RefCell<Pool>>,
+    policy: std::rc::Rc<dyn PolicyInterface>,
+    pool: std::rc::Rc<std::cell::RefCell<Pool>>,
 
-    pub(crate) rules: RuleSet,
+    rules: RuleSet,
 
-    pub(crate) watch_graph: RuleWatchGraph,
-    pub(crate) decisions: Decisions,
-    pub(crate) fixed_map: IndexMap<i64, BasePackageHandle>,
+    watch_graph: RuleWatchGraph,
+    decisions: Decisions,
+    fixed_map: IndexMap<i64, BasePackageHandle>,
 
-    pub(crate) propagate_index: i64,
+    propagate_index: i64,
     /// Pairs of `(literals, level)` — PHP indexes into these with the BRANCH_* constants.
-    pub(crate) branches: Vec<(Vec<i64>, i64)>,
-    pub(crate) problems: Vec<Problem>,
-    pub(crate) learned_pool: Vec<Vec<std::rc::Rc<std::cell::RefCell<Rule>>>>,
-    pub(crate) learned_why: IndexMap<String, i64>,
+    branches: Vec<(Vec<i64>, i64)>,
+    problems: Vec<Problem>,
+    learned_pool: Vec<Vec<std::rc::Rc<std::cell::RefCell<Rule>>>>,
+    learned_why: IndexMap<String, i64>,
 
     pub test_flag_learned_positive_literal: bool,
 
-    pub(crate) io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
+    io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
 }
 
 impl Solver {
diff --git a/crates/shirabe/src/dependency_resolver/solver_problems_exception.rs b/crates/shirabe/src/dependency_resolver/solver_problems_exception.rs
index 4c948608..fe78dae5 100644
--- a/crates/shirabe/src/dependency_resolver/solver_problems_exception.rs
+++ b/crates/shirabe/src/dependency_resolver/solver_problems_exception.rs
@@ -11,8 +11,8 @@ use shirabe_php_shim::RuntimeException;
 #[derive(Debug)]
 pub struct SolverProblemsException {
     inner: RuntimeException,
-    pub(crate) problems: Vec<Problem>,
-    pub(crate) learned_pool: Vec<Vec<std::rc::Rc<std::cell::RefCell<Rule>>>>,
+    problems: Vec<Problem>,
+    learned_pool: Vec<Vec<std::rc::Rc<std::cell::RefCell<Rule>>>>,
 }
 
 impl SolverProblemsException {
diff --git a/crates/shirabe/src/dependency_resolver/transaction.rs b/crates/shirabe/src/dependency_resolver/transaction.rs
index 78037338..84879a41 100644
--- a/crates/shirabe/src/dependency_resolver/transaction.rs
+++ b/crates/shirabe/src/dependency_resolver/transaction.rs
@@ -21,18 +21,18 @@ use shirabe_php_shim::{
 #[derive(Debug, Clone)]
 pub struct Transaction {
     /// @var OperationInterface[]
-    pub(crate) operations: Vec<AnyOperation>,
+    operations: Vec<AnyOperation>,
 
     /// Packages present at the beginning of the transaction
     /// @var PackageInterface[]
-    pub(crate) present_packages: Vec<PackageInterfaceHandle>,
+    present_packages: Vec<PackageInterfaceHandle>,
 
     /// Package set resulting from this transaction
     /// @var array<string, PackageInterface>
-    pub(crate) result_package_map: IndexMap<String, PackageInterfaceHandle>,
+    result_package_map: IndexMap<String, PackageInterfaceHandle>,
 
     /// @var array<string, PackageInterface[]>
-    pub(crate) result_packages_by_name: IndexMap<String, Vec<PackageInterfaceHandle>>,
+    result_packages_by_name: IndexMap<String, Vec<PackageInterfaceHandle>>,
 }
 
 impl Default for Transaction {
@@ -104,7 +104,7 @@ impl Transaction {
         }
     }
 
-    pub(crate) fn calculate_operations(&mut self) -> Vec<AnyOperation> {
+    fn calculate_operations(&mut self) -> Vec<AnyOperation> {
         let mut operations: Vec<AnyOperation> = vec![];
 
         let mut present_package_map: IndexMap<String, PackageInterfaceHandle> = IndexMap::new();
@@ -218,7 +218,7 @@ impl Transaction {
     ///
     /// These serve as a starting point to enumerate packages in a topological order despite potential cycles.
     /// If there are packages with a cycle on the top level the package with the lowest name gets picked
-    pub(crate) fn get_root_packages(&self) -> IndexMap<String, PackageInterfaceHandle> {
+    fn get_root_packages(&self) -> IndexMap<String, PackageInterfaceHandle> {
         let mut roots: IndexMap<String, PackageInterfaceHandle> = self
             .result_package_map
             .iter()
@@ -245,7 +245,7 @@ impl Transaction {
         roots
     }
 
-    pub(crate) fn get_providers_in_result(&self, link: &Link) -> Vec<PackageInterfaceHandle> {
+    fn get_providers_in_result(&self, link: &Link) -> Vec<PackageInterfaceHandle> {
         let Some(packages) = self.result_packages_by_name.get(link.get_target()) else {
             return vec![];
         };