Struct Repo 

pub struct Repo {
    pub index_file: String,
    pub scanned_folders: HashSet<PathBuf>,
    pub queued_folders: HashMap<PathBuf, QueuedFolder>,
    pub markdown_files: MarkdownFiles,
    pub other_files: OtherFiles,
    pub tag_index: Arc<TagIndex>,
    pub relationship_index: Arc<RelationshipIndex>,
    pub wikilink_index: Arc<WikilinkIndex>,
    /* private fields */
}

Fields

index_file: String

The configured index file name (e.g., “index.md” or “_index.md”). Exposed in site.json for frontend use.

scanned_folders: HashSet<PathBuf>

Every folder walked so far, by its canonical key, so a directory reached twice (a symlink to a folder that is also walked directly) is listed once.

queued_folders: HashMap<PathBuf, QueuedFolder>

Folders found but not walked yet, by key (the folder’s path as listed, not canonicalized — the next hop canonicalizes it).

markdown_files: MarkdownFiles

other_files: OtherFiles

tag_index: Arc<TagIndex>

Thread-safe index of tagged pages.

relationship_index: Arc<RelationshipIndex>

Thread-safe index of typed relationships between notes.

wikilink_index: Arc<WikilinkIndex>

Thread-safe global name index for body-wikilink ([[Name]]) resolution. Always built (independent of relationship tracking).

Implementations

impl Repo

pub fn with_change_tracking(self) -> Self

Records a FileStamp for every file the scan indexes, which is what Self::diff_vault and Self::snapshot compare against. Call before scanning.

pub fn tracks_changes(&self) -> bool

Whether Self::with_change_tracking was called.

pub fn snapshot_fingerprint(&self) -> String

Identifies everything a snapshot’s contents depend on besides the files themselves: this build (the frontmatter simplifier changes between versions) and the scan configuration (which files are notes, which are ignored, how URLs are formed).

pub fn snapshot(&self) -> RepoSnapshot

The repository’s current contents as a RepoSnapshot: every indexed file of the root vault that has a stamp (so only with change tracking).

pub fn restore_snapshot( &self, snapshot: RepoSnapshot, ) -> Result<usize, SnapshotError>

Fills an empty repository from snapshot without reading storage, and rebuilds the tag index from the restored frontmatter. Returns the number of files restored.

The caller then does what it does after a scan — build the relationship and wikilink indexes, mark the scan complete — and runs a Self::diff_vault to catch what changed since the snapshot. Entries that no longer parse as vault paths are dropped (the diff re-adds them if they exist). Stamps are restored with them, so with change tracking the diff compares against the snapshot’s view.

pub fn diff_vault(&self) -> RepoDiff

Re-lists the vault (and an external static overlay) with the scan’s ignore rules and compares every file with its recorded stamp. Reads no file contents. Blocking.

A folder whose listing is not downloaded (see RepoDiff::not_downloaded_folders) is requested from the vault on every diff until it lists; the files the index already has under it are kept, not deleted.

Without change tracking every listed file is “created” — the diff of a repository that recorded nothing.

pub fn record_diff(&self, diff: &RepoDiff)

Stores the stamps of a diff once its events have been applied, so the same changes are not reported again. A no-op without change tracking.

pub fn not_downloaded_folder_count(&self) -> usize

How many folders could not be listed because their contents are not downloaded yet, as of the last scan or Repo::record_diff. Their download has been requested; a later Repo::diff_vault lists them.

impl Repo

pub fn init_from_config(c: &Config) -> Self

pub fn with_symlink_mounts(self, enabled: bool) -> Self

Turns read-only symlink mounts off (enabled == false): the operator’s --no-symlink-mounts / MBR_NO_SYMLINK_MOUNTS. The vaults are rebuilt as plain LocalVaults on the same (canonical) roots, so a link out of the repository or the overlay is OutsideRoot — 404 on the server, not placed by a build — exactly as before mounts. Hidden-file blocking is unaffected. Logs one line when it disables anything.

Call before scanning: it replaces the storage the scan reads through.

pub fn with_explicit_hidden_dirs(self, explicit_hidden_dirs: &[PathBuf]) -> Self

Re-admits the hidden directories the user named on the command line (Config::explicit_hidden_dirs) to the scan.

A builder rather than an Self::init parameter: init already carries eight positional arguments, and every caller but the two live entry points wants the default of “no exemptions”.

Rebasing happens here, once, and onto canonical_root rather than the configured root — the scan descends from the canonicalized root, so an exemption built from the configured spelling would silently never match wherever the two differ (/tmp vs /private/tmp on macOS).

pub fn exempt_hidden_dirs(&self) -> &[VaultPath]

The hidden directories the user named on the command line, as vault paths of Self::vault — the exemption to “hidden files are never served” (see crate::vault::has_hidden_segment).

pub fn init<S: Into<String>, P: Into<PathBuf>>( root_dir: P, static_folder: S, markdown_extensions: &[String], ignore_dirs: &[String], ignore_globs: &[String], index_file: S, tag_sources: &[TagSource], relationship_types: &[RelationType], ) -> Self

A repository on the local filesystem at root_dir, stored through a LocalVault (plus a second one for an external static overlay).

Both vaults serve symlinks out of them as read-only mounts (crate::vault::MountPolicy), each protecting the other’s root, so the server and the static build — which both start here — mount exactly the same folders and refuse exactly the same targets.

pub fn init_with_vault<S: Into<String>>( vault: Arc<dyn Vault>, static_folder: S, markdown_extensions: &[String], ignore_dirs: &[String], ignore_globs: &[String], index_file: S, tag_sources: &[TagSource], relationship_types: &[RelationType], ) -> Self

A repository stored in vault, which may be anything — the desktop’s LocalVault, a test’s crate::vault::MemVault, a platform vault.

static_folder is honoured when it names a folder inside the vault; an external overlay is a second vault, given with Self::with_static_vault (Self::init does both for a local repository).

pub fn with_static_vault(self, static_vault: Option<Arc<dyn Vault>>) -> Self

Sets the vault of an external static overlay (see the field docs). Its assets are indexed with the overlay prefix stripped from their URLs, and markdown inside it is skipped.

pub fn vault(&self) -> &Arc<dyn Vault>

The repository’s storage.

pub fn static_vault(&self) -> Option<&Arc<dyn Vault>>

The external static overlay’s storage, when there is one.

pub fn canonical_static_root(&self) -> Option<&Path>

The external static overlay’s canonical directory, when there is one.

pub fn locate(&self, key: &Path) -> Option<(&dyn Vault, VaultPath)>

Which vault holds the file behind an index key, and where in it.

None for a key under neither — which no scan produces, but the watcher can report (a configured template folder outside the root).

pub fn locate_shared(&self, key: &Path) -> Option<(Arc<dyn Vault>, VaultPath)>

Self::locate, with the vault shared rather than borrowed — for a caller that reads it from another task (a streamed response body).

pub fn mounts(&self) -> Vec<(PathBuf, Mount)>

The symlink mounts both vaults have accepted so far, each with the index key of its location (where the link is). Grows as the first scan discovers links; see crate::vault::Mount.

pub fn static_folder_vault(&self) -> Option<(&Arc<dyn Vault>, VaultPath)>

The vault holding the static folder and the folder’s path in it: the external overlay from its root, or the configured folder inside the repository. None when there is no static folder.

pub fn scan_folder<P: AsRef<Path>>( &self, relative_folder_path: &P, ) -> Result<(), RepoError>

Scans one folder of the root vault (non-recursively: subfolders are queued in Self::queued_folders, not walked).

relative_folder_path is relative to the root. One that climbs out of it is skipped with a warning, as a folder that resolves out of it is.

pub fn scan_vault_folder(&self, folder: &VaultPath) -> Result<(), RepoError>

Self::scan_folder for a folder given as a vault path.

pub fn scan_all(&self) -> Result<(), RepoError>

pub fn scan_static_folder(&self) -> Result<(), RepoError>

Scan the static folder and its subdirectories. Deferred from scan_all() so mark_scan_complete() fires faster.

pub fn mark_scan_complete(&self)

Mark the initial scan as complete and notify any waiters.

pub fn full_rescan(&self)

Drop every cached view of the repository and rebuild it from disk.

Used by the watcher when a change batch is too large to invalidate file by file. Blocking; call from spawn_blocking.

No step may return early. clear() resets media_populated, so any path that skips Repo::notify_media_populated leaves every later Repo::wait_for_media — that is, /.mbr/media.json — blocked for the life of the process. A failed scan is logged and the pass continues on whatever was indexed: clear() already discarded the previous contents, so the real choice is between serving partial data and hanging.

pub fn populate_basic_metadata(&self)

Populate basic file metadata (size, timestamps) for all other files. Deferred from scan_folder() to avoid blocking scan_all() completion, so search (which only needs markdown files) can proceed sooner.

pub fn is_scan_complete(&self) -> bool

Returns true if the initial scan has completed.

pub async fn wait_for_scan(&self)

Wait for the initial scan to complete. Returns immediately if already done.

mark_scan_complete() fires exactly once and Notify::notify_waiters() stores no permit, so a notification observed between a flag check and the registration of the waiter would be lost forever — and /.mbr/site.json would block for the life of the process. Registering interest before re-checking closes that window (same pattern as the in-flight waits in server.rs).

pub fn is_media_populated(&self) -> bool

Returns true if media metadata has been populated.

pub fn notify_media_populated(&self)

Notify waiters that media metadata population is complete.

pub async fn wait_for_media(&self)

Wait for media metadata to be populated. Returns immediately if already done.

Registers interest before re-checking the flag, for the same reason as Repo::wait_for_scan.

pub fn to_json(&self) -> Result<String>

pub fn populate_media_metadata(&self)

Populate media metadata (ffmpeg/lopdf) for all static files. This is deferred from initial scan to avoid blocking the first site.json response.

pub fn ensure_text_extracted(&self)

Extract text from searchable files (PDFs, text files) for search indexing. Deferred from initial scan since text is only needed for search.

pub fn clear(&self)

Clear all cached data, forcing a full rescan on next scan_all() call.

Call this when files are added, removed, or modified to ensure the next scan picks up the changes.

pub fn invalidate_file(&self, abs_path: &Path, event: &ChangeEventType)

Surgically invalidate a single file, updating only the affected cache entries.

Much cheaper than clear() + scan_all() for small batches of file changes.

pub fn tag_sources(&self) -> &[TagSource]

Rebuild the tag index from the current cached markdown files.

Call this after surgical file invalidation when tags may have changed (e.g., after deleting or modifying markdown files). Returns the configured tag sources.

pub fn build_relationship_index(&self)

Rebuild the relationship index from the current cached markdown files.

Must run after a scan (or file-change invalidation) once all note titles are known, since endpoint resolution matches on titles and filename stems across the whole repo. Modelled on Self::rebuild_tag_index.

pub fn build_wikilink_index(&self)

Rebuild the global wikilink name index from the current cached markdown files.

Unlike Self::build_relationship_index this is ungated — the index powers Obsidian-style [[Name]] body-link resolution for every repo, so it is rebuilt whenever the repo is (re)scanned or a file changes. Must run after a scan once all note titles/stems are known.

pub fn rebuild_tag_index(&self)

Trait Implementations

impl Clone for Repo

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Serialize for Repo

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.