Core `BaseFileLock` class with `FileLockMeta` metaclass implementing singleton caching via parameter validation and weak-value dictionary. Defines the acquire/release contract, `AcquireReturnProxy` pattern for context manager support, error handling policies (chain/group), fork transition guards (`_fork_transition`, `_register_fork_object`), and thread-local context (`ThreadLocalFileContext`). This module is the architectural foundation for all lock backends and is reusable as a template for any resource synchronization that needs singleton, fork-safe, context-manager-aware behavior.

Implements `ReadWriteLock` using SQLite database as a coordination point. Uses SQLite's WAL mode and row-level locking (`INSERT OR IGNORE`, `BEGIN IMMEDIATE`) to implement cross-process read/write semantics with multiple readers and exclusive writers. Includes upgrade/downgrade prohibition, reentrancy within same mode, and explicit close handling. Demonstrates a non-obvious use of SQLite for distributed locking without external dependencies, and the pattern is reusable for any project needing a lightweight, portable read-write lock.

Provides `StrictSoftFileLock` using hard links (`os.link`) to atomically claim a lock. The lock file is created as a unique hard link, and mutual exclusion is verified by checking the number of hard links on the target inode. This design is fail-closed: even if the claiming process crashes, the lock remains held. It avoids race conditions inherent in existence-based locks. The technique is non-obvious and robust, and the module is self-contained enough to be extracted as a pattern for any Unix-based locking requiring strict atomicity.

Implements `SoftFileLock` as a cooperative lock using a marker file that stores the hostname and PID of the lock holder. Stale detection is performed by comparing the marker's mtime against a threshold and verifying that the PID is not alive. This pattern is simple, works across NFS, and is useful for advisory locking where performance and simplicity are preferred over strict guarantees. The module is cleanly separated and reusable for any marker-based synchronization.

Defines `SoftFileLease`, a time-limited lock that uses a heartbeat thread to periodically update the lock file's modification time, preventing stale detection from evicting an active holder. Includes a `compromise` callback mechanism to notify when the lease is lost (e.g., due to a rogue process or filesystem failure). The heartbeat interval, stale threshold, and timeout are configurable. This pattern is reusable for any lease-based resource management with automatic renewal and compromise handling.

A standalone script that probes the runtime environment for capabilities like `os.link`, `os.fork`, `fcntl.flock`, symlink support, and filesystem type. It returns a JSON report used by CI and tests to skip incompatible tests. This pattern is reusable for any library that needs to detect platform-specific features at runtime, and the module is independent of the rest of the codebase (no internal imports).