Struct WindowResources 

pub struct WindowResources {

    pub config: Arc<Config>,
    pub grammar_registry: Arc<GrammarRegistry>,
    pub theme_registry: Arc<ThemeRegistry>,
    pub theme_cache: Arc<RwLock<HashMap<String, Value>>>,
    pub keybindings: Arc<RwLock<KeybindingResolver>>,
    pub command_registry: Arc<RwLock<CommandRegistry>>,
    pub fs_manager: Arc<FsManager>,
    pub local_filesystem: Arc<dyn FileSystem + Send + Sync>,
    pub buffer_id_alloc: BufferIdAllocator,
    pub authority: Authority,
    pub time_source: SharedTimeSource,
    pub dir_context: DirectoryContext,
    pub tokio_runtime: Option<Arc<Runtime>>,
    pub async_bridge: Option<AsyncBridge>,
    pub plugin_manager: Arc<RwLock<PluginManager>>,
    pub theme: Arc<RwLock<Theme>>,
    pub event_broadcaster: EventBroadcaster,
    pub recovery_service: Arc<Mutex<RecoveryService>>,
}

Editor-global resources that every Window holds an Arc-cloned reference to.

One instance is constructed in editor_init and cloned into the base Window. Editor::create_window and the first-dive seed path in set_active_window clone it into every subsequent Window. All fields are cheap to clone (Arc increment or Clone-by-value where the inner type already carries Arcs like Authority).

A Window handler that needs any of these reads it directly: self.resources.config.editor.line_wrap, self.resources.authority.path_translation, etc. The [Window::config()] / Window::authority() accessors are the canonical reading API; the field itself stays pub(crate) so call sites can split-borrow disjoint sub-fields when the borrow checker needs it.

Fields

config: Arc<Config>

Read-only editor configuration. Hot-reloaded by swapping the Arc’s pointee when the user edits their config file.

grammar_registry: Arc<GrammarRegistry>

Tree-sitter grammar registry. Arc because grammar loading can be expensive and is shared across windows.

theme_registry: Arc<ThemeRegistry>

Theme registry (the catalogue of available themes, not the active theme — that’s Editor::theme for now, pending the Tier-2 wrap).

theme_cache: Arc<RwLock<HashMap<String, Value>>>

Cache of plugin-supplied theme JSONs, populated by plugin commands and read by the theme loader.

keybindings: Arc<RwLock<KeybindingResolver>>

Keybinding resolver (mode → key → command map). RwLock because plugin commands can mutate the resolver at runtime.

command_registry: Arc<RwLock<CommandRegistry>>

Command registry (named commands a plugin or user can invoke). RwLock for the same reason as keybindings.

fs_manager: Arc<FsManager>

Filesystem operation manager (background renames, deletes, etc.)

local_filesystem: Arc<dyn FileSystem + Send + Sync>

Direct host-filesystem handle. Held alongside the active authority’s filesystem because some operations (recovery file IO, history persistence) intentionally bypass the authority’s translation.

buffer_id_alloc: BufferIdAllocator

Globally-unique BufferId allocator (see BufferIdAllocator).

authority: Authority

Active filesystem authority (local / devcontainer / remote). Authority is Clone because it internally holds Arcs for the filesystem and path-translation handles; cloning here gives each window an independent handle that points at the same underlying authority.

time_source: SharedTimeSource

Editor-wide time source (real clock in production, controllable in tests). Already Arc-internal.

dir_context: DirectoryContext

Directory context (config dir, themes dir, plugins dir, etc.). Cloned by value because it’s a small struct of PathBufs.

tokio_runtime: Option<Arc<Runtime>>

Tokio runtime for async I/O tasks (LSP, file watchers, git, etc.). Single runtime shared across all windows via Arc. None means the editor was constructed without async support (rare).

async_bridge: Option<AsyncBridge>

Async-message bridge (Sender + Arc’d Receiver). Windows clone this to publish messages back to the editor’s main loop. The Receiver is Arc<Mutex<>> internally, so all clones drain the same queue.

plugin_manager: Arc<RwLock<PluginManager>>

Plugin manager (single QuickJS instance), wrapped in Arc<RwLock<>> so windows can fire hooks and read state without going through Editor. Reads take a read lock; the few &mut self methods (process_commands, check_thread_health, test_inject_command) take a write lock.

theme: Arc<RwLock<Theme>>

Active resolved theme, mirrored from Editor.theme. Each set_theme / theme-reload pushes the new value into this Arc<RwLock<>> so Window methods can read colors without going through Editor.

event_broadcaster: EventBroadcaster

Editor-wide event broadcaster (cloneable, Arc inside).

recovery_service: Arc<Mutex<RecoveryService>>

Hot-exit / crash recovery service. Arc<Mutex> because it carries mutable session state (session_started, per-buffer save times) and is shared by every window — per-window restore and auto-save reach it directly (no active-window flip).

Trait Implementations

impl Clone for WindowResources

fn clone(&self) -> WindowResources

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.