private final CIFSContext context;
    private final LeaseManager baseLeaseManager;
    private final ConcurrentHashMap<String, DirectoryCacheEntry> directoryCache;
    private final ConcurrentHashMap<Smb2LeaseKey, String> leaseToPath;
    private final ScheduledExecutorService scheduler;
    private final DirectoryChangeNotifier changeNotifier;

    /**

 */
public class LeaseManager {

    private static final Logger log = LoggerFactory.getLogger(LeaseManager.class);

    private final ConcurrentHashMap<Smb2LeaseKey, LeaseEntry> leases;
    private final ConcurrentHashMap<String, Smb2LeaseKey> pathToLease;
    private final ConcurrentHashMap<String, WeakReference<SmbFile>> fileCache;
    private final ReadWriteLock lock;
    private final CIFSContext context;

    private final InetAddress witnessServer;
    private final int port;
    private final CIFSContext context;
    private final ConcurrentHashMap<String, WitnessRegistration> registrations;
    private final ConcurrentHashMap<String, WitnessNotificationListener> listeners;
    private final ConcurrentHashMap<String, CompletableFuture<Void>> asyncNotifyTasks;
    private final ScheduledExecutorService scheduler;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class DirectoryLeaseManager {
    private final CIFSContext context;
    private final LeaseManager baseLeaseManager;  // Reuse existing lease manager
    private final ConcurrentHashMap<String, DirectoryCacheEntry> directoryCache;

 */
public class PersistentHandleManager {

    private static final Logger log = LoggerFactory.getLogger(PersistentHandleManager.class);

    private final ConcurrentHashMap<String, HandleInfo> handles;
    private final ConcurrentHashMap<HandleGuid, HandleInfo> guidToHandle;
    private final Path stateDirectory;
    private final ScheduledExecutorService scheduler;
    private final CIFSContext context;

    private static final int MAX_BACKOFF_SHIFT = 3; // Maximum 8 seconds (2^3 * 1000ms)

    private final DirectoryLeaseManager leaseManager;
    private final ConcurrentHashMap<String, ChangeNotificationHandle> activeWatchers;
    private final ConcurrentHashMap<String, Integer> failureCounts;

    /**
     * Directory change types
     */
    public enum DirectoryChangeType {
        /**

    private static final Logger logger = LogManager.getLogger(ProcessHelper.class);

    /** Map of running processes indexed by session ID */
    protected final ConcurrentHashMap<String, JobProcess> runningProcessMap = new ConcurrentHashMap<>();

    /** Timeout in seconds for process destruction */
    protected int processDestroyTimeout = 10;

    /**
     * Default constructor for ProcessHelper.

            }
            this.maxCountLimit = maxCountLimit;
            this.totalCount = new AtomicInteger();
            this.counters = new ConcurrentHashMap<>();
            this.problems = new ConcurrentHashMap<>();
            this.filter = requireNonNull(filter, "filter");
        }

        @Override
        public int problemsReportedFor(BuilderProblem.Severity... severity) {

    private static final Logger log = LoggerFactory.getLogger(SecureKeyManager.class);

    private final Map<String, SecretKey> sessionKeys = new ConcurrentHashMap<>();
    private final Map<String, byte[]> rawKeys = new ConcurrentHashMap<>();
    private final SecureRandom secureRandom = new SecureRandom();
    private KeyStore keyStore;
    private char[] keyStorePassword;
    private volatile boolean closed = false;

    private final Map<String, ConnectionMetrics> connectionMetrics = new ConcurrentHashMap<>();

    // Proactive health monitoring
    private volatile boolean proactiveHealthCheckEnabled = true;
    private final long proactiveCheckInterval = DEFAULT_PROACTIVE_CHECK_INTERVAL;

    // Connection failure tracking
    private final Map<String, Long> lastFailureTimes = new ConcurrentHashMap<>();