🥮 mooncakes.io

    bit_vfs

    Virtual FS over commits

    git
    vfs
    Download zip
    Author
    Version
    0.48.0
    License
    Apache-2.0
    Repository
    Last updated
    9 days ago
    Downloads
    116

    Dependencies

    pub struct Fs {
      git_dir : String
      base_tree : 
    ObjectId
      base_commit : 
    ObjectId    ?
      working : WorkingLayer
      layers : Array[Layer]
      cache : ObjectCache
      config : FsConfig
      cached_db : 
    ObjectDb    ?
      cached_promisor_db : 
    PromisorDb    ?
      lazy_mode : Bool
    }

    Fs::add_layer

    source

    Fs::add_layer_from_commit

    source
    fn Fs::add_layer_from_commit(self : Fs, backing_fs : &
    RepoFileSystem    , commit_id : 
    ObjectId    , name : String) -> Unit raise 
    GitError

    Fs::base_commit

    source
    fn Fs::base_commit(self : Fs) -> 
    ObjectId    ?

    Fs::base_tree

    source
    fn Fs::base_tree(self : Fs) -> 
    ObjectId

    Fs::checkout_snapshot

    source

    Fs::clear_layers

    source
    fn Fs::clear_layers(self : Fs) -> Unit

    Fs::collect_files_bfs

    source
    fn Fs::collect_files_bfs(self : Fs, read_fs : &
    RepoFileSystem    , limit : Int) -> Array[String] raise 
    GitError

    Collect files in breadth-first order up to a limit. Useful for progressive preloading.

    Fs::discard_changes

    source
    fn Fs::discard_changes(self : Fs) -> Unit

    Fs::empty

    source
    fn Fs::empty(git_dir : String, config? : FsConfig) -> Fs

    Create an empty Fs (no base tree). Uses config.lazy_load to determine loading strategy (default: lazy).

    Fs::exists_in_base

    source
    fn Fs::exists_in_base(self : Fs, backing_fs : &
    RepoFileSystem    , path : String) -> Bool

    Check if file exists in base tree (ignoring working layer)

    Fs::flatten_layers

    source

    Fs::from_branch

    source
    fn Fs::from_branch(backing_fs : &
    RepoFileSystem    , git_dir : String, branch : String, config? : FsConfig) -> Fs raise 
    GitError

    Create Fs from a branch name. Uses config.lazy_load to determine loading strategy (default: lazy).

    Fs::from_commit

    source
    fn Fs::from_commit(backing_fs : &
    RepoFileSystem    , git_dir : String, commit_id : 
    ObjectId    , config? : FsConfig) -> Fs raise 
    GitError

    Create Fs from a commit. Uses config.lazy_load to determine loading strategy (default: lazy).

    Fs::from_tree

    source
    fn Fs::from_tree(git_dir : String, tree_id : 
    ObjectId    , config? : FsConfig) -> Fs

    Create Fs from a tree ID. Uses config.lazy_load to determine loading strategy (default: lazy).

    Fs::get_db

    source

    Get or load the ObjectDb (cached for performance). Respects lazy_mode: uses lazy loading when true, eager loading when false.

    Fs::get_deleted_files

    source
    fn Fs::get_deleted_files(self : Fs) -> Array[String]

    Fs::get_pending_fetches

    source
    fn Fs::get_pending_fetches(self : Fs, read_fs : &
    RepoFileSystem    , limit : Int) -> Array[String] raise 
    GitError

    Get list of files that need fetching, in BFS order. Useful for showing progress or prioritizing fetches.

    Fs::get_promisor_db

    source

    Get or load the PromisorDb (cached for performance). Returns None if promisor support is disabled in config.

    Fs::get_promisor_remote

    source
    fn Fs::get_promisor_remote(self : Fs, backing_fs : &
    RepoFileSystem    ) -> String?

    Get the promisor remote URL if available

    Fs::get_working_files

    source
    fn Fs::get_working_files(self : Fs) -> Array[String]

    Fs::git_dir

    source
    fn Fs::git_dir(self : Fs) -> String

    Fs::has_layer

    source
    fn Fs::has_layer(self : Fs, name : String) -> Bool

    Fs::has_promisor

    source
    fn Fs::has_promisor(self : Fs, backing_fs : &
    RepoFileSystem    ) -> Bool

    Check if this Fs is backed by a partial clone with promisor remote

    Fs::is_dir

    source
    fn Fs::is_dir(self : Fs, backing_fs : &
    RepoFileSystem    , path : String) -> Bool

    Fs::is_dirty

    source
    fn Fs::is_dirty(self : Fs) -> Bool

    Fs::is_file

    source
    fn Fs::is_file(self : Fs, backing_fs : &
    RepoFileSystem    , path : String) -> Bool

    Fs::is_lazy

    source
    fn Fs::is_lazy(self : Fs) -> Bool

    Check if lazy loading is enabled

    Fs::is_promisor_enabled

    source
    fn Fs::is_promisor_enabled(self : Fs) -> Bool

    Check if promisor support is enabled

    Fs::list_layers

    source
    fn Fs::list_layers(self : Fs) -> Array[Layer]

    Fs::list_snapshots

    source
    fn Fs::list_snapshots(self : Fs, backing_fs : &
    RepoFileSystem    , max_count? : Int) -> Array[Snapshot] raise 
    GitError

    Fs::mkdir_p

    source
    fn Fs::mkdir_p(self : Fs, path : String) -> Unit

    Fs::needs_fetch

    source
    fn Fs::needs_fetch(self : Fs, read_fs : &
    RepoFileSystem    , path : String) -> Bool raise 
    GitError

    Check if a file requires fetching from remote

    Fs::prefetch

    source
    async fn Fs::prefetch(self : Fs, read_fs : &
    RepoFileSystem    , write_fs : &
    FileSystem    , paths : Array[String]) -> Int raise 
    GitError

    Prefetch multiple objects from promisor remote (async). Useful for batch fetching before accessing many files.

    Fs::prefetch_bfs

    source
    async fn Fs::prefetch_bfs(self : Fs, read_fs : &
    RepoFileSystem    , write_fs : &
    FileSystem    , limit : Int) -> Int raise 
    GitError

    Prefetch files in breadth-first order. Prioritizes shallow files (root level first, then subdirs).

    Fs::prefetch_glob

    source
    async fn Fs::prefetch_glob(self : Fs, read_fs : &
    RepoFileSystem    , write_fs : &
    FileSystem    , pattern : String) -> Int raise 
    GitError

    Prefetch files matching a glob pattern. Example patterns: ".rs", "src//.mbt", "README.*"

    Fs::read_file

    source
    fn Fs::read_file(self : Fs, backing_fs : &
    RepoFileSystem    , path : String) -> Bytes raise 
    GitError

    Fs::read_file_async

    source
    async fn Fs::read_file_async(self : Fs, read_fs : &
    RepoFileSystem    , write_fs : &
    FileSystem    , path : String) -> Bytes raise 
    GitError

    Read file content, fetching from remote if not available locally (async). This is the primary method for partial clone repositories.

    Fs::readdir

    source
    fn Fs::readdir(self : Fs, backing_fs : &
    RepoFileSystem    , path : String) -> Array[String] raise 
    GitError

    Fs::remove_dir

    source
    fn Fs::remove_dir(self : Fs, path : String) -> Unit

    Fs::remove_file

    source
    fn Fs::remove_file(self : Fs, path : String) -> Unit

    Fs::remove_layer

    source
    fn Fs::remove_layer(self : Fs, name : String) -> Bool

    Fs::rollback

    source
    fn Fs::rollback(self : Fs) -> Unit

    Fs::snapshot

    source
    fn Fs::snapshot(self : Fs, backing_fs : &
    FileSystem    , rfs : &
    RepoFileSystem    , message : String, author : String, timestamp : Int64) -> Snapshot raise 
    GitError

    Fs::write_file

    source
    fn Fs::write_file(self : Fs, path : String, content : Bytes) -> Unit

    Fs::write_string

    source
    fn Fs::write_string(self : Fs, path : String, content : String) -> Unit

    FsConfig

    source
    pub struct FsConfig {
      max_cache_bytes : Int
      max_cache_entries : Int
      lazy_load : Bool
      enable_promisor : Bool
    }

    FsConfig::default

    source
    fn FsConfig::default() -> FsConfig

    FsConfig::eager

    source
    fn FsConfig::eager() -> FsConfig

    Create config with eager loading (load all packs upfront)

    FsConfig::local_only

    source
    fn FsConfig::local_only() -> FsConfig

    Create config for local-only access (no network fetches)

    Layer

    source
    pub(all) struct Layer {
      tree_id : 
    ObjectId
      commit_id : 
    ObjectId    ?
      name : String
    }

    LruCache

    source
    pub struct LruCache[V] {
      hot : Map[String, V]
      cold : Map[String, V]
      hot_bytes : Int
      cold_bytes : Int
      max_bytes : Int
      size_fn : (V) -> Int
    }

    LruCache::clear

    source
    fn[V] LruCache::clear(self : LruCache[V]) -> Unit

    LruCache::contains

    source
    fn[V] LruCache::contains(self : LruCache[V], key : String) -> Bool

    LruCache::get

    source
    fn[V] LruCache::get(self : LruCache[V], key : String) -> V?

    LruCache::length

    source
    fn[V] LruCache::length(self : LruCache[V]) -> Int

    LruCache::new

    source
    fn[V] LruCache::new(max_bytes : Int, size_fn : (V) -> Int) -> LruCache[V]

    LruCache::remove

    source
    fn[V] LruCache::remove(self : LruCache[V], key : String) -> Unit

    LruCache::set

    source
    fn[V] LruCache::set(self : LruCache[V], key : String, value : V) -> Unit

    LruCache::total_bytes

    source
    fn[V] LruCache::total_bytes(self : LruCache[V]) -> Int

    ObjectCache

    source
    pub(all) struct ObjectCache {
      blob_cache : LruCache[Bytes]
      trees : Map[
    ObjectId    , Array[
    TreeEntry    ]]
      path_cache : Map[String, 
    ObjectId    ?]
    }

    ObjectCache::clear

    source
    fn ObjectCache::clear(self : ObjectCache) -> Unit

    ObjectCache::get_blob

    source
    fn ObjectCache::get_blob(self : ObjectCache, path : String) -> Bytes?

    ObjectCache::get_path

    source
    fn ObjectCache::get_path(self : ObjectCache, path : String) -> 
    ObjectId    ??

    ObjectCache::get_tree

    source

    ObjectCache::invalidate_path

    source
    fn ObjectCache::invalidate_path(self : ObjectCache, path : String) -> Unit

    ObjectCache::new

    source
    fn ObjectCache::new(max_bytes : Int) -> ObjectCache

    ObjectCache::set_blob

    source
    fn ObjectCache::set_blob(self : ObjectCache, path : String, data : Bytes) -> Unit

    ObjectCache::set_path

    source
    fn ObjectCache::set_path(self : ObjectCache, path : String, id : 
    ObjectId    ?) -> Unit

    ObjectCache::set_tree

    source

    Snapshot

    source
    pub(all) struct Snapshot {
      commit_id : 
    ObjectId
      tree_id : 
    ObjectId
      message : String
      author : String
      timestamp : Int64
    }

    Snapshot::new

    source
    fn Snapshot::new(commit_id : 
    ObjectId    , tree_id : 
    ObjectId    , message : String, author : String, timestamp : Int64) -> Snapshot

    WorkingLayer

    source
    pub(all) struct WorkingLayer {
      files : Map[String, Bytes]
      deleted : Map[String, Bool]
      dirs : Map[String, Bool]
      dirty : Bool
    }

    WorkingLayer::clear

    source
    fn WorkingLayer::clear(self : WorkingLayer) -> Unit

    WorkingLayer::is_dirty

    source
    fn WorkingLayer::is_dirty(self : WorkingLayer) -> Bool

    WorkingLayer::new

    source

    build_tree_from_working

    source

    join_path

    source
    fn join_path(root : String, path : String) -> String

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io