Struct WorktreesRegistry 

pub struct WorktreesRegistry { /* private fields */ }

The cross-window worktree registry: the in-memory, TTL-reaped set of open windows. Hosted by WorktreesService.

Implementations

impl WorktreesRegistry

pub fn new() -> Self

Creates the registry with the default liveness TTL. Cheap — no I/O.

pub fn subscribe_changes(&self) -> Receiver<u64>

A change-notification receiver for the push subscription: it observes a new value each time the visible window set changes (see changes and bump). Created with the current version already marked seen, so the first watch::Receiver::changed resolves on the next change — the subscriber sends its own initial snapshot up front and then waits for deltas (#1267).

pub fn change_generation(&self) -> u64

The current change-notify generation — the counter bump increments on every visible-set change. Read (never subscribed) so a coalescing consumer — the service’s shared tree-snapshot cache (#1303) — can tell whether the registry has changed since it last computed and rebuild only then. The value itself is immaterial; only whether it differs between two reads matters, so wrapping_add overflow is benign.

pub fn register(&self, req: RegisterRequest)

Records (upserts) a window registration. Reaps stale entries first, then — only when a genuinely new key would grow the map past [MAX_WINDOWS] — evicts the longest-silent entry. Infallible: an upsert never evicts, and callers validate the key before reaching here.

pub fn heartbeat(&self, key: &str) -> bool

Refreshes a window’s liveness. Returns whether the key was known: a false tells a window that started before the daemon — or survived a daemon restart — to re-register, since the registry is in-memory and has no record of it.

pub fn unregister(&self, key: &str) -> bool

Drops a window’s registration. Returns whether an entry was present.

pub fn mark_close_pending(&self, key: &str)

Records a pending “close yourself” directive for key, to be surfaced on that window’s next heartbeat. Set by the close op when signalling a window it can only reply to. Idempotent; infallible.

pub fn take_close_pending(&self, key: &str) -> bool

Takes (returns and clears) key’s pending close directive. Called on each heartbeat so the directive fires exactly once; a false means no close is pending.

pub fn mark_reload_pending(&self, key: &str)

Records a pending “reload yourself” directive for key, to be surfaced on that window’s next heartbeat (#1417). Set by the reload op for every target window, which — unlike a close — includes no waiting: the caller learns only that the directive was marked. Idempotent; infallible.

pub fn take_reload_pending(&self, key: &str) -> bool

Takes (returns and clears) key’s pending reload directive. Called on each heartbeat so the directive fires exactly once; a false means no reload is pending.

pub fn mark_rebasing(&self, paths: &[PathBuf]) -> bool

Marks paths as being rebased right now (#1415), returning whether the set actually changed.

A real change bumps the change-notify so every subscribed window re-pushes a snapshot carrying the spinner — the same cross-window sync set_show_closed / set_polling rely on. Bumping only on a real change is load-bearing rather than an optimization: an unconditional bump defeats the server’s snapshot diff and re-pushes to every window on every tick.

Callers pass already-canonicalized paths, so these match the tree snapshot’s own keys. Canonicalizing is disk I/O, which belongs in the adapter (where canonical() lives), not in this engine — the same split that keeps the git enrichment out of here.

pub fn clear_rebasing(&self, paths: &[PathBuf]) -> bool

Clears the rebasing mark on paths, returning whether the set changed. Called on every exit from a phase-2 execute, so a panicking or failing rebase can never leave a permanent spinner on a row.

pub fn mark_pushing(&self, paths: &[PathBuf]) -> bool

Marks paths as being pushed right now (#1443), returning whether the set actually changed. The mark_rebasing twin, with the same canonicalized-paths-in and bump-only-on-a-real-change contract.

pub fn clear_pushing(&self, paths: &[PathBuf]) -> bool

Clears the pushing mark on paths, returning whether the set changed. Called on every exit from a phase-2 execute — and it is the only thing that clears this cue, since a push leaves no on-disk state a later snapshot could correct a stale mark from.

pub fn rebasing_paths(&self) -> HashSet<PathBuf>

The worktree paths currently being rebased, canonicalized. Read into each tree/subscribe snapshot; cheap (a set clone of at most a batch’s worth of paths) and never held across an .await.

pub fn pushing_paths(&self) -> HashSet<PathBuf>

The worktree paths currently being pushed, canonicalized (#1443). The rebasing_paths twin, read into the same snapshot.

pub fn show_closed(&self) -> bool

The current show/hide-closed toggle: whether the tree view shows worktrees with no open window (#1301). Read into every tree/subscribe snapshot so every window renders the same, live-synced state.

pub fn set_show_closed(&self, show_closed: bool) -> bool

Sets the show/hide-closed toggle, returning whether the value actually changed. A real change bumps the change-notify so every subscriber re-pushes a snapshot carrying the new value — the reliable cross-window sync context.globalState could not provide. A no-op set (same value) neither bumps nor wakes anyone.

pub fn is_polling_enabled(&self, owner: &str, name: &str) -> bool

Whether PR polling is currently leased for the GitHub repo owner/name (#1376) — the entry exists and its lease has not expired. Defaults false (a never-toggled repo does not poll), so only repos the user has explicitly enabled, within the last poll_ttl, poll.

pub fn enabled_polling_repos(&self) -> HashSet<String>

The repos with a live (unexpired) lease, as a set of "owner/name" keys — what stamps polling_enabled onto the tree snapshot. Reaps expired leases first (the window-TTL reap-on-read precedent), so an idle repo drops out on the next snapshot build without a background timer. Cloned out so the lock is never held across the (blocking-thread) tree build that reads it.

pub fn polling_snapshot(&self) -> Vec<(String, DateTime<Utc>)>

The live leases as (repo, expiry) pairs sorted by repo, for deterministic persistence to the 0600 prefs file (#1376) — the expiry is stored so a daemon restart within the lease window keeps the remaining time rather than resetting the clock. Reaps expired leases first, so a stale entry is never written back.

pub fn set_polling(&self, owner: &str, name: &str, enabled: bool) -> bool

Enables (leases for poll_ttl) or disables PR polling for owner/name, returning whether the stored map changed — which the adapter uses to decide whether to persist. Enabling an already-leased repo refreshes the lease (a new expiry), which is a change worth persisting.

bumps the change-notify only when the repo’s effective enabled state flips (off→on or on→off), so every subscribed window re-pushes a snapshot that recolours the icon and drops/keeps badges — the set_show_closed precedent. A lease refresh (already on, still on) changes the expiry but not the visible state, so it persists without waking anyone.

pub fn seed_polling( &self, leases: impl IntoIterator<Item = (String, DateTime<Utc>)>, )

Replaces the lease map wholesale from the persisted 0600 prefs file (#1376), dropping any lease that already expired while the daemon was down. Does not bump: it runs before any window subscribes, so there is no one to notify, and each window’s first snapshot already reflects the seeded leases.

pub fn list(&self) -> Vec<WindowEntry>

Reaps stale entries, then returns the live set sorted for deterministic output. Holds the lock only for pure-CPU work.

Like the other reads (open_folders, first_folder) this reaps but never bumps: the only observer of a read-path reap is the push subscription’s own re-snapshot (or status/menu), and the subscription’s periodic tick already re-samples read-only staleness — so bumping here would only make the subscription wake itself (#1267).

pub fn first_folder(&self, key: &str) -> Option<PathBuf>

The first workspace folder of a still-live window, if it has one. Used by the tray “focus” action to resolve a key to a folder to open. Does not reap — a menu action races the reaper either way, and the caller handles a None (the window may have closed).

pub fn open_folders(&self) -> Vec<PathBuf>

Snapshots the distinct workspace folders across all live windows — the seed set the adapter resolves to repositories (each folder → its git common dir → repo root) to enumerate every worktree per repo (#1265).

Reaps stale entries first, then returns the folders sorted and deduplicated. Like list it is pure CPU under the lock: the git resolution the “distinct repos” derivation needs is disk I/O and stays in the adapter, off the registry lock, honouring the Mutex-never-across-.await invariant.

Trait Implementations

impl Default for WorktreesRegistry

fn default() -> Self

Returns the “default value” for a type.