🥮 mooncakes.io
    Sign in

    moonvcs

    Native MoonBit VCS core with typed SHA-256 objects, lazy storage and policy boundaries.

    version-control
    content-addressed-storage
    wasm
    moonbit
    Download zip
    Version
    0.1.0
    License
    Apache-2.0
    Repository
    Last updated
    4 days ago
    Downloads
    25

    #MoonVCS Core

    Native MoonBit source module for the MoonVCS research prototype: typed Blob, Tree and Commit objects, canonical SHA-256 encoding, object stores, lazy history, and repository operations with policy validation boundaries.

    Candidate module: any07557-wq/moonvcs@0.1.0, prepared for the maintainer's confirmed Mooncakes username any07557-wq. Not published yet; authenticated publication permissions and version availability remain unverified. A local package archive is not a published release; do not assume moon add any07557-wq/moonvcs is available.

    #Scope

    The module contains the MoonBit core and native CLI source. It does not ship the Rust/Wasmtime Host, compiled Wasm policies, WIT, runtime configuration, toolchain archives, or a prebuilt moonvcs executable. Installing this module alone does not provision the complete policy-enforced VCS.

    Use the full source repository and its installation instructions for the end-to-end CLI and policies. The repository-only bypass test client is excluded from this module archive; it remains available in the repository tests.

    #Minimal library example

    After making the module available as a local dependency (or after its actual publication under a confirmed namespace), import it in your moon.pkg:

    import {
      "any07557-wq/moonvcs" @vcs,
    }

    pkgtype(kind: "executable")

    fn main {
      try {
        let id = @vcs.object_id_for(@vcs.BlobObject({ content: b"", }))
        println(id.to_string())
      } catch {
        _ => println("object encoding failed")
      }
    }

    The empty Blob ID is 3f2f7192ae4599c2d0886683b3b2833896f695ed1a83af663117e49a894deaa7. It hashes MoonVCS's typed encoding, not just the empty payload and not Git's object encoding.

    #Compatibility and limitations

    • Native backend; verified in Linux x86-64 environments. This is not a claim of browser, JS, Wasm-GC or cross-platform support for the entire module.
    • Candidate 0.1.0 API is experimental, not a stable production API commitment.
    • Real repository commits/receives need a valid policy context and external Host/plugins. Do not replace required policy validation with a mock validator.
    • Included white-box tests also contain repository integration tests requiring the full repository and built runtime. A standalone module check/build is not a standalone pass of the complete test suite.
    • File-system/stdio remotes have no authentication, ACL, TLS or server OS privilege separation. This is not a production Git replacement.

    For test evidence and security boundaries see the repository's CI validation and SECURITY.md. The CI result applies to its recorded commit, not automatically to this later packaging preparation.

    #License

    Apache-2.0; the module includes the same LICENSE notice as the repository.

    ObjectStore

    source
    pub(open) trait ObjectStore {
      async fn put(Self, VcsObject) -> ObjectId
      async fn get(Self, ObjectId) -> VcsObject
      async fn has(Self, ObjectId) -> Bool
      async fn verify(Self, ObjectId) -> Bool
    }

    PolicyValidator

    source
    pub(open) trait PolicyValidator {
      async fn validate(Self, CommitCandidate) -> PolicyDecision
    }

    VcsError

    source
    pub(all) suberror VcsError {
      InvalidObjectId(String)
      InvalidObject(String)
      InvalidTree(String)
      InvalidPath(String)
      ObjectNotFound(String)
      UnknownObject(String)
      ObjectUnavailableOffline(String)
      RemoteUnavailable(String)
      RemoteObjectMissing(String)
      InvalidPromise(String)
      RemoteRefChanged(String)
      RepositoryNotFound(String)
      RepositoryExists(String)
      RefConflict(String)
      StagingBusy(String)
      PublicationUncertain(String)
      ReceiveRejected(String)
      ReceiveInvalid(String)
      ReceivePolicyError(String)
      ReceiveProcessExit(Int)
      PolicyRejected(String)
      PolicyExecutionFailed(String)
      InvalidCommand(String)
      DiffFailed(String)
      CheckoutFailed(String)
      SwitchIncomplete(String)
    } derive(
    Debug    )

    VcsError::to_repr

    source

    Blob

    source
    pub(all) struct Blob {
      content : Bytes
    } derive(Eq, 
    Debug    )

    Blob::equal

    source
    fn Blob::equal(Blob, Blob) -> Bool

    Blob::not_equal

    source
    fn Blob::not_equal(x : Blob, y : Blob) -> Bool

    Blob::to_repr

    source

    CandidateFile

    source
    pub(all) struct CandidateFile {
      path : String
      blob_id : ObjectId
      content : Bytes
    } derive(Eq, 
    Debug    )

    CandidateFile::equal

    source

    CandidateFile::not_equal

    source
    fn CandidateFile::not_equal(x : CandidateFile, y : CandidateFile) -> Bool

    CandidateFile::to_repr

    source

    Commit

    source
    pub(all) struct Commit {
      tree_id : ObjectId
      parents : Array[ObjectId]
      author : String
      timestamp : UInt64
      message : String
    } derive(Eq, 
    Debug    )

    Commit::equal

    source
    fn Commit::equal(Commit, Commit) -> Bool

    Commit::not_equal

    source
    fn Commit::not_equal(x : Commit, y : Commit) -> Bool

    Commit::to_repr

    source

    CommitCandidate

    source
    pub(all) struct CommitCandidate {
      tree_id : ObjectId
      parents : Array[ObjectId]
      author : String
      timestamp : UInt64
      message : String
      staged_files : Array[CandidateFile]
    } derive(Eq, 
    Debug    )

    CommitCandidate::equal

    source

    CommitCandidate::not_equal

    source
    fn CommitCandidate::not_equal(x : CommitCandidate, y : CommitCandidate) -> Bool

    CommitCandidate::to_repr

    source

    ConfiguredRule

    source
    pub struct ConfiguredRule {
      id : String
      literal : String
    } derive(ToJson, 
    FromJson    )

    DiffMode

    source
    pub(all) enum DiffMode {
      WorkingDiff
      StagedDiff
      HeadDiff
    } derive(Eq, 
    Debug    )

    DiffMode::equal

    source
    fn DiffMode::equal(DiffMode, DiffMode) -> Bool

    DiffMode::not_equal

    source
    fn DiffMode::not_equal(x : DiffMode, y : DiffMode) -> Bool

    DiffMode::to_repr

    source

    EngineDecision

    source
    pub(all) enum EngineDecision {
      Accept
      Warning(Array[PolicyDiagnostic])
      Reject(Array[PolicyDiagnostic])
      EngineError(String)
    }

    FileObjectStore

    source
    pub struct FileObjectStore {
      objects_dir : String
    }

    FileObjectStore::get

    source
    async fn FileObjectStore::get(self : FileObjectStore, id : ObjectId) -> VcsObject

    FileObjectStore::has

    source
    async fn FileObjectStore::has(self : FileObjectStore, id : ObjectId) -> Bool

    FileObjectStore::new

    source
    fn FileObjectStore::new(repository_root : String) -> FileObjectStore

    FileObjectStore::object_path

    source
    fn FileObjectStore::object_path(self : FileObjectStore, id : ObjectId) -> String

    FileObjectStore::put

    source
    async fn FileObjectStore::put(self : FileObjectStore, object : VcsObject) -> ObjectId

    FileObjectStore::verify

    source
    async fn FileObjectStore::verify(self : FileObjectStore, id : ObjectId) -> Bool

    Index

    source
    pub(all) struct Index {
      entries : Array[IndexEntry]
    } derive(Eq, 
    Debug    )

    Index::equal

    source
    fn Index::equal(Index, Index) -> Bool

    Index::not_equal

    source
    fn Index::not_equal(x : Index, y : Index) -> Bool

    Index::to_repr

    source

    IndexEntry

    source
    pub(all) struct IndexEntry {
      path : String
      blob_id : ObjectId
    } derive(Eq, 
    Debug    )

    IndexEntry::equal

    source
    fn IndexEntry::equal(IndexEntry, IndexEntry) -> Bool

    IndexEntry::not_equal

    source
    fn IndexEntry::not_equal(x : IndexEntry, y : IndexEntry) -> Bool

    IndexEntry::to_repr

    source

    LazyObjectStore

    source
    pub struct LazyObjectStore {
      root : String
      cache : LocalObjectStore
      offline : Bool
      fetch_events : Bool
    }

    LazyObjectStore::get

    source
    async fn LazyObjectStore::get(self : LazyObjectStore, id : ObjectId) -> VcsObject

    LazyObjectStore::has

    source
    async fn LazyObjectStore::has(self : LazyObjectStore, id : ObjectId) -> Bool

    LazyObjectStore::new

    source
    fn LazyObjectStore::new(root : String, offline? : Bool, fetch_events? : Bool) -> LazyObjectStore

    LazyObjectStore::object_path

    source
    fn LazyObjectStore::object_path(self : LazyObjectStore, id : ObjectId) -> String

    LazyObjectStore::put

    source
    async fn LazyObjectStore::put(self : LazyObjectStore, object : VcsObject) -> ObjectId

    LazyObjectStore::state

    source
    async fn LazyObjectStore::state(self : LazyObjectStore, id : ObjectId) -> ObjectState

    LazyObjectStore::transfer_stats

    source
    async fn LazyObjectStore::transfer_stats(self : LazyObjectStore) -> TransferStats

    LazyObjectStore::verify

    source
    async fn LazyObjectStore::verify(self : LazyObjectStore, id : ObjectId) -> Bool

    LocalObjectStore

    source
    pub struct LocalObjectStore {
      disk : FileObjectStore
    }

    LocalObjectStore::get

    source
    async fn LocalObjectStore::get(self : LocalObjectStore, id : ObjectId) -> VcsObject

    LocalObjectStore::has

    source
    async fn LocalObjectStore::has(self : LocalObjectStore, id : ObjectId) -> Bool

    LocalObjectStore::new

    source
    fn LocalObjectStore::new(root : String) -> LocalObjectStore

    LocalObjectStore::put

    source
    async fn LocalObjectStore::put(self : LocalObjectStore, object : VcsObject) -> ObjectId

    LocalObjectStore::verify

    source
    async fn LocalObjectStore::verify(self : LocalObjectStore, id : ObjectId) -> Bool

    MemoryObjectStore

    source
    pub struct MemoryObjectStore {
      objects : Map[String, Bytes]
    }

    MemoryObjectStore::corrupt_for_test

    source
    fn MemoryObjectStore::corrupt_for_test(self : MemoryObjectStore, id : ObjectId, bytes : Bytes) -> Unit

    MemoryObjectStore::count

    source
    fn MemoryObjectStore::count(self : MemoryObjectStore) -> Int

    MemoryObjectStore::get

    source
    async fn MemoryObjectStore::get(self : MemoryObjectStore, id : ObjectId) -> VcsObject

    MemoryObjectStore::has

    source
    async fn MemoryObjectStore::has(self : MemoryObjectStore, id : ObjectId) -> Bool

    MemoryObjectStore::new

    source

    MemoryObjectStore::put

    source
    async fn MemoryObjectStore::put(self : MemoryObjectStore, object : VcsObject) -> ObjectId

    MemoryObjectStore::verify

    source
    async fn MemoryObjectStore::verify(self : MemoryObjectStore, id : ObjectId) -> Bool

    MockPolicyValidator

    source
    pub struct MockPolicyValidator {
      allow : Bool
      reason : String
    }

    MockPolicyValidator::pass

    source

    MockPolicyValidator::reject

    source
    fn MockPolicyValidator::reject(reason : String) -> MockPolicyValidator

    MockPolicyValidator::validate

    source

    ObjectId

    source
    pub struct ObjectId {
      hex : String
    } derive(Eq, 
    Debug    )

    ObjectId::equal

    source
    fn ObjectId::equal(ObjectId, ObjectId) -> Bool

    ObjectId::not_equal

    source
    fn ObjectId::not_equal(x : ObjectId, y : ObjectId) -> Bool

    ObjectId::parse

    source
    fn ObjectId::parse(value : String) -> ObjectId raise VcsError

    ObjectId::to_repr

    source

    ObjectId::to_string

    source
    fn ObjectId::to_string(self : ObjectId) -> String

    ObjectState

    source
    pub(all) enum ObjectState {
      Local
      PromisedRemote
      Unknown
    } derive(Eq, 
    Debug    )

    ObjectState::equal

    source
    fn ObjectState::equal(ObjectState, ObjectState) -> Bool

    ObjectState::not_equal

    source
    fn ObjectState::not_equal(x : ObjectState, y : ObjectState) -> Bool

    ObjectState::to_repr

    source

    PolicyContext

    source
    pub struct PolicyContext {
      schema : Int
      host : String
      required : Array[RequiredPolicy]
      allowed_capabilities : Array[String]
      limits : PolicyLimits
      custom_rules : Array[ConfiguredRule]
    } derive(ToJson, 
    FromJson    )

    PolicyDecision

    source
    pub(all) enum PolicyDecision {
      PolicyPass
      PolicyReject(String)
      PolicyError(String)
    } derive(Eq, 
    Debug    )

    PolicyDecision::equal

    source

    PolicyDecision::not_equal

    source
    fn PolicyDecision::not_equal(x : PolicyDecision, y : PolicyDecision) -> Bool

    PolicyDecision::to_repr

    source

    PolicyDiagnostic

    source
    pub struct PolicyDiagnostic {
      plugin : String
      rule : String
      file : String?
      line : Int?
      severity : String
      message : String
    }

    PolicyLimits

    source
    pub struct PolicyLimits {
      fuel : Int
      timeout_ms : Int
      max_memory_bytes : Int
      max_input_bytes : Int
      max_output_bytes : Int
      max_log_bytes : Int
    } derive(ToJson, 
    FromJson    )

    ReceiveReport

    source
    pub struct ReceiveReport {
      ref_name : String
      target : ObjectId
      checked_commits : Int
      promoted_objects : Int
      policy_revision : String
    }

    ReceiveRequest

    source
    pub(all) struct ReceiveRequest {
      ref_name : String
      expected_old : ObjectId?
      target : ObjectId
      objects : Array[ReceivedObject]
    }

    ReceivedObject

    source
    pub(all) struct ReceivedObject {
      id : ObjectId
      encoded : Bytes
    }

    Ref

    source
    pub(all) struct Ref {
      name : String
      target : ObjectId
    } derive(Eq, 
    Debug    )

    Ref::equal

    source
    fn Ref::equal(Ref, Ref) -> Bool

    Ref::not_equal

    source
    fn Ref::not_equal(x : Ref, y : Ref) -> Bool

    Ref::to_repr

    source

    RemoteObjectStore

    source
    pub struct RemoteObjectStore {
      root : String
    }

    RemoteObjectStore::fetch_encoded

    source
    async fn RemoteObjectStore::fetch_encoded(self : RemoteObjectStore, id : ObjectId) -> Bytes

    RemoteObjectStore::get

    source
    async fn RemoteObjectStore::get(self : RemoteObjectStore, id : ObjectId) -> VcsObject

    RemoteObjectStore::has

    source
    async fn RemoteObjectStore::has(self : RemoteObjectStore, id : ObjectId) -> Bool

    RemoteObjectStore::new

    source
    fn RemoteObjectStore::new(root : String) -> RemoteObjectStore

    RemoteObjectStore::put

    source

    RemoteObjectStore::verify

    source
    async fn RemoteObjectStore::verify(self : RemoteObjectStore, id : ObjectId) -> Bool

    Repository

    source
    pub struct Repository {
      root : String
      store : LazyObjectStore
    }

    Repository::add

    source
    async fn Repository::add(self : Repository, paths : Array[String]) -> Array[IndexEntry]

    Repository::at

    source
    fn Repository::at(root : String, offline? : Bool, fetch_events? : Bool) -> Repository

    Repository::branches

    source
    async fn Repository::branches(self : Repository) -> Array[String]

    Repository::commit

    source
    async fn Repository::commit(self : Repository, author : String, timestamp : UInt64, message : String) -> ObjectId

    Repository::commit_with_validator

    source
    async fn[V : PolicyValidator] Repository::commit_with_validator(self : Repository, author : String, timestamp : UInt64, message : String, validator : V) -> ObjectId

    Repository::create_branch

    source
    async fn Repository::create_branch(self : Repository, name : String) -> ObjectId

    Repository::diff

    source
    async fn Repository::diff(self : Repository, mode : DiffMode, paths? : Array[String]) -> String

    Repository::get_object

    source
    async fn Repository::get_object(self : Repository, id : ObjectId) -> VcsObject

    Repository::head

    source
    async fn Repository::head(self : Repository) -> ObjectId?

    Repository::head_ref_name

    source
    async fn Repository::head_ref_name(self : Repository) -> String

    Repository::load_index

    source
    async fn Repository::load_index(self : Repository) -> Index

    Repository::log

    source
    async fn Repository::log(self : Repository, max_count? : Int) -> Array[(ObjectId, Commit)]

    Repository::make_candidate

    source
    async fn Repository::make_candidate(self : Repository, author : String, timestamp : UInt64, message : String) -> CommitCandidate

    Repository::read_ref

    source
    async fn Repository::read_ref(self : Repository, name : String) -> ObjectId?

    Repository::root

    source
    fn Repository::root(self : Repository) -> String

    Repository::status

    source
    async fn Repository::status(self : Repository) -> Array[String]

    Repository::switch_branch

    source
    async fn Repository::switch_branch(self : Repository, name : String) -> SwitchPlan

    Repository::switch_plan

    source
    async fn Repository::switch_plan(self : Repository, name : String) -> SwitchPlan

    RequiredPolicy

    source
    pub struct RequiredPolicy {
      name : String
      version : String
      module_digest : String
      component : String
      manifest : String
      granted_capabilities : Array[String]
    } derive(ToJson, 
    FromJson    )

    SwitchPlan

    source
    pub(all) struct SwitchPlan {
      from_ref : String
      target_ref : String
      from_commit : String?
      target_commit : String
      additions : Array[String]
      replacements : Array[String]
      deletions : Array[String]
    } derive(ToJson)

    SwitchPlan::to_json

    source
    fn SwitchPlan::to_json(SwitchPlan) -> Json

    TransferStats

    source
    pub struct TransferStats {
      requests : UInt64
      received_objects : UInt64
      received_bytes : UInt64
      cached_objects : UInt64
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    TransferStats::equal

    source

    TransferStats::from_json

    source

    TransferStats::not_equal

    source
    fn TransferStats::not_equal(x : TransferStats, y : TransferStats) -> Bool

    TransferStats::to_json

    source

    TransferStats::to_repr

    source

    Tree

    source
    pub(all) struct Tree {
      entries : Array[TreeEntry]
    } derive(Eq, 
    Debug    )

    Tree::equal

    source
    fn Tree::equal(Tree, Tree) -> Bool

    Tree::new

    source
    fn Tree::new(entries : Array[TreeEntry]) -> Tree raise VcsError

    Tree::not_equal

    source
    fn Tree::not_equal(x : Tree, y : Tree) -> Bool

    Tree::to_repr

    source

    TreeEntry

    source
    pub(all) struct TreeEntry {
      name : String
      kind : TreeEntryKind
      object_id : ObjectId
    } derive(Eq, 
    Debug    )

    TreeEntry::equal

    source
    fn TreeEntry::equal(TreeEntry, TreeEntry) -> Bool

    TreeEntry::not_equal

    source
    fn TreeEntry::not_equal(x : TreeEntry, y : TreeEntry) -> Bool

    TreeEntry::to_repr

    source

    TreeEntryKind

    source
    pub(all) enum TreeEntryKind {
      BlobEntry
      TreeEntry
    } derive(Eq, 
    Debug    )

    TreeEntryKind::equal

    source

    TreeEntryKind::not_equal

    source
    fn TreeEntryKind::not_equal(x : TreeEntryKind, y : TreeEntryKind) -> Bool

    TreeEntryKind::to_repr

    source

    VcsObject

    source
    pub(all) enum VcsObject {
      BlobObject(Blob)
      TreeObject(Tree)
      CommitObject(Commit)
    } derive(Eq, 
    Debug    )

    VcsObject::equal

    source
    fn VcsObject::equal(VcsObject, VcsObject) -> Bool

    VcsObject::not_equal

    source
    fn VcsObject::not_equal(x : VcsObject, y : VcsObject) -> Bool

    VcsObject::to_repr

    source

    clone_repository

    source
    async fn clone_repository(remote : String, destination : String, policy_config? : String, fetch_events? : Bool) -> Repository

    decode_object

    source
    fn decode_object(encoded : Bytes) -> VcsObject raise

    decode_receive_request

    source
    fn decode_receive_request(bytes : Bytes) -> ReceiveRequest raise

    encode_object

    source
    fn encode_object(object : VcsObject) -> Bytes raise VcsError

    encode_receive_request

    source
    fn encode_receive_request(request : ReceiveRequest) -> Bytes raise

    find_repository_root

    source
    async fn find_repository_root(start : String) -> String

    init_repository

    source
    async fn init_repository(root : String, policy_config? : String) -> Repository

    install_receive_policy

    source
    async fn install_receive_policy(server : Repository, text : String, initialize? : Bool) -> Unit

    normalize_repository_path

    source
    fn normalize_repository_path(path : String) -> String raise

    object_id_for

    source
    fn object_id_for(object : VcsObject) -> ObjectId raise VcsError

    object_id_for_bytes

    source
    fn object_id_for_bytes(encoded : Bytes) -> ObjectId

    parse_policy_context

    source
    fn parse_policy_context(text : String) -> PolicyContext raise

    prepare_receive_request

    source
    async fn prepare_receive_request(source : Repository, ref_name : String, expected_old : ObjectId?, target : ObjectId) -> ReceiveRequest

    receive_bundle_file

    source
    async fn receive_bundle_file(server : Repository, path : String) -> ReceiveReport

    receive_candidate

    source
    async fn receive_candidate(server : Repository, request : ReceiveRequest) -> ReceiveReport

    run_cli

    source
    async fn run_cli(argv : ArrayView[String]) -> Unit

    validate_policies

    source
    async fn validate_policies(candidate : CommitCandidate, context : PolicyContext, hook? : String) -> EngineDecision

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io