🥮 mooncakes.io

    jhshuai/moontestledger/wire does not have a README file

    Bundle

    source
    pub(all) struct Bundle {
      documents : Array[ReportFile]
    } derive(Eq, 
    Debug    )

    Bundle::equal

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

    Bundle::not_equal

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

    Bundle::to_repr

    source

    CollectedXml

    source
    pub(all) struct CollectedXml {
      id : String
      xml : String
    } derive(Eq, 
    Debug    )

    Original XML supplied by a storage adapter for a declared report ID.

    CollectedXml::equal

    source

    CollectedXml::not_equal

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

    CollectedXml::to_repr

    source

    CollectionFile

    source
    pub(all) struct CollectionFile {
      id : String
      path : String
    } derive(Eq, 
    Debug    )

    One explicitly expected relative artifact path; forward slashes only.

    CollectionFile::equal

    source

    CollectionFile::not_equal

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

    CollectionFile::to_repr

    source

    CollectionSpec

    source
    type CollectionSpec

    A complete expected inventory and exact artifact path mapping. Paths never define run/revision/test identities; the caller owns the declared contract.

    CollectionSpec::collect

    source

    Atomically collect only explicitly supplied original reports. Omitted reports/cases remain incomplete against the full inventory. An invalid report refuses the whole operation; no input or previous spec is modified.

    CollectionSpec::collect_tar

    source

    Collect regular-file POSIX USTAR against the full declared path inventory. Missing paths retain incompleteness; unknown paths/extensions are refused.

    CollectionSpec::collect_zip

    source

    Collect a bounded classic ZIP against the full expected inventory. Missing declared members remain incomplete; unlisted members are refused. Paths never create report/run identities; all bindings come from the spec.

    CollectionSpec::encode

    source

    CollectionSpec::files

    source

    CollectionSpec::new

    source

    Construct a complete path contract before artifacts arrive.

    test {
      let reports : Array[@ledger.ExpectedReport] = [
        {
          id: "report",
          environment: "linux",
          shard: "all",
          attempt: 1,
          cases: [{ classname: "C", name: "a", }],
        },
      ]
      let plan = @ledger.RunPlan::new("run", "revision", reports)
      let files : Array[@wire.CollectionFile] = [
        { id: "report", path: "job/results.xml", },
      ]
      let spec = @wire.CollectionSpec::new(plan, files[:])
      let absent : Array[@wire.CollectedXml] = []
      inspect(spec.collect(absent[:]).exit_code(), content="3")
    }

    Evidence

    source
    type Evidence

    A validated, replayable JUnit archive. Storage and gate policy are opaque.

    Evidence::check_integrity

    source

    Check every manifest component against the replayed archive. Raises on any discrepancy without mutating either input. Success does not change the archive's existing gate: call Evidence::exit_code after checking integrity.

    Evidence::deny_recovered

    source
    fn Evidence::deny_recovered(self : Evidence) -> Bool

    Evidence::detach

    source

    Detach exact original XML without losing the full plan, policy or bindings. Both returned values are independent of the input. Index and members can be passed to any storage adapter; restore checks all hashes before replay.

    Evidence::encode

    source

    Evidence::exit_code

    source
    fn Evidence::exit_code(self : Evidence) -> Int

    Evidence::ingest_reports

    source

    Append original JUnit documents without mutating the archive. The batch is atomic; custom projections, conflicts and unsupported XML are refused.

    Evidence::integrity

    source

    Bind the full validated inventory, recovery policy, accepted report bindings and original XML. Incomplete and failing archives can have valid manifests. Canonicalization is versioned MoonTestLedger JSON, not RFC 8785.

    Evidence::snapshot

    source

    Independent inventory/document copies, including accepted empty reports.

    Evidence::source

    source
    fn Evidence::source(self : Evidence, report_id : String) -> String?

    Evidence::summary

    source

    Evidence::tar_pack

    source

    Deterministic uncompressed USTAR carrier with fixed regular-file metadata.

    Evidence::zip_pack

    source

    Deterministic classic ZIP carrier for the sealed full-plan file pack. Compression is supplied by hustcer/fzip; this API is not a general archiver.

    IntegrityDocument

    source
    pub(all) struct IntegrityDocument {
      binding : 
    ReportBinding
      sha256 : String
      utf8_bytes : Int
    } derive(Eq, 
    Debug    )

    Receipt for an accepted report, including its full binding and exact UTF-8 source digest. Returned arrays are independent copies of manifest storage.

    IntegrityDocument::equal

    source

    IntegrityDocument::not_equal

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

    IntegrityDocument::to_repr

    source

    IntegrityManifest

    source
    type IntegrityManifest

    A validated checksum manifest. Trust the expected manifest separately from the archive: checksums do not authenticate its author or prove execution.

    IntegrityManifest::documents

    source

    IntegrityManifest::encode

    source

    Deterministic JSON: receipts and missing IDs are sorted by exact report ID. Refuses output beyond the configured JSON budget instead of truncating it.

    IntegrityManifest::missing_reports

    source
    fn IntegrityManifest::missing_reports(self : IntegrityManifest) -> Array[String]

    PackFile

    source
    pub(all) struct PackFile {
      name : String
      xml : String
    } derive(Eq, 
    Debug    )

    Exact decoded UTF-8 XML and a content-addressed flat filename. No arbitrary paths or binary members are supported by the evidence file-pack profile.

    PackFile::equal

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

    PackFile::not_equal

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

    PackFile::to_repr

    source

    PackIndex

    source
    type PackIndex

    Full expected inventory plus an integrity manifest; accepted XML is stored separately. A missing expected report remains missing, not a missing member.

    PackIndex::encode

    source

    PackIndex::filenames

    source
    fn PackIndex::filenames(self : PackIndex) -> Array[String]

    Independent sorted list of required members, deduplicated by exact digest.

    PackIndex::restore

    source

    Require exactly the declared members, verify original UTF-8 bytes, then replay all XML against the full plan and verify the complete archive digest. Missing stored members and undeclared extras are invalid, never truncated.

    PlanChange

    source
    pub(all) struct PlanChange {
      kind : PlanChangeKind
      report_id : String
      key : 
    CaseKey    ?
    } derive(Eq, 
    Debug    )

    Report additions/removals cover the whole report in the retained plans. An empty report_id denotes run metadata; key is set only for case changes.

    PlanChange::equal

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

    PlanChange::not_equal

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

    PlanChange::to_repr

    source

    PlanChangeKind

    source
    pub(all) enum PlanChangeKind {
      RunMetadataChanged
      ReportAdded
      ReportRemoved
      ReportBindingChanged
      CaseAdded
      CaseRemoved
      CaseOrderChanged
    } derive(Eq, 
    Debug    )

    PlanChangeKind::equal

    source

    PlanChangeKind::not_equal

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

    PlanChangeKind::to_repr

    source

    PlanReview

    source
    type PlanReview

    A bounded, deterministic review of two complete declared inventories. Its token binds both plans and every derived change; it is not a signature.

    PlanReview::approve

    source

    Acknowledge this exact review against an unchanged baseline, for a fresh run. Returns a copy of the proposed plan. Existing evidence is never rewritten. The caller must obtain approval before supplying the displayed token; this checks content/staleness, not the identity or presence of a human reviewer.

    PlanReview::before

    source

    PlanReview::changes

    source
    fn PlanReview::changes(self : PlanReview) -> Array[PlanChange]

    PlanReview::encode

    source

    Full plans and deterministic changes are retained. Over-budget reviews are refused, never shortened. Digests use the existing canonical plan encoding.

    PlanReview::proposed

    source

    PlanReview::token

    source
    fn PlanReview::token(self : PlanReview) -> String

    ReportFile

    source
    pub(all) struct ReportFile {
      binding : 
    ReportBinding
      path : String
    } derive(Eq, 
    Debug    )

    A producer-supplied binding and path to an unchanged XML artifact.

    ReportFile::equal

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

    ReportFile::not_equal

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

    ReportFile::to_repr

    source

    RetryReport

    source
    pub(all) struct RetryReport {
      id : String
      environment : String
      shard : String
    } derive(Eq, 
    Debug    )

    A new producer report identity for one failing environment/shard group.

    RetryReport::equal

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

    RetryReport::not_equal

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

    RetryReport::to_repr

    source

    decode_bundle

    source

    Decode producer bindings separately from the expected plan. Paths are relative to the bundle file in the CLI, or supplied directly by library users.

    decode_collection

    source

    decode_evidence

    source

    Strictly replay all stored reports against the stored plan. Missing artifacts stay incomplete; unknown fields and malformed XML are rejected.

    decode_integrity

    source

    Strict versioned manifest reader. Unknown fields/algorithms, duplicates, conflicting IDs and rounded integer lexemes are refused.

    decode_pack_index

    source

    Strict index validation before any member access. Every planned report must have exactly one matching receipt or an explicit missing-report ID.

    decode_plan

    source

    Decode a complete expected artifact/test inventory. Unknown versions and fields are refused; duplicate keys are checked in the original JSON text.

    decode_plan_review

    source

    Strictly decode then recompute both plan hashes, every change and the token. Duplicate/unknown fields and any supplied projection mismatch are refused.

    decode_retry_reports

    source

    decode_tar_pack

    source
    fn decode_tar_pack(data : Bytes, limits? : 
    Limits    , max_bytes? : Int) -> Evidence raise 
    InputError

    Restore only a sealed evidence pack; reject unsupported USTAR extensions, duplicate/extra members, changed original XML or inconsistent full plan.

    decode_zip_pack

    source
    fn decode_zip_pack(data : Bytes, limits? : 
    Limits    , max_bytes? : Int) -> Evidence raise 
    InputError

    Reject unsupported carrier metadata, then verify original XML, full plan, policy and whole evidence digest. This does not authenticate the sender.

    encode_bundle

    source
    fn encode_bundle(bundle : Bundle) -> String

    encode_diagnostic

    source
    fn encode_diagnostic(diagnostic : 
    Diagnostic    ) -> String

    encode_evidence

    source

    Archive the full inventory, exact original XML and recovery policy. Custom projections that do not match the supported JUnit parser are refused.

    encode_plan

    source
    fn encode_plan(plan : 
    RunPlan    ) -> String

    encode_retry_reports

    source
    fn encode_retry_reports(reports : ArrayView[RetryReport]) -> String

    encode_summary

    source
    fn encode_summary(summary : 
    Summary    , deny_recovered? : Bool) -> String

    Render derived evidence. Original XML is retained by the ledger and input files; this is not a JUnit conversion or a lossless XML export.

    merge_evidence

    source

    Combine partial archives of one run with the same full inventory and policy. Identical documents are idempotent; conflicting replacements are refused. Inputs are never modified. Inventory order is normalized for deterministic output.

    prepare_retry

    source

    Extend a complete run by exactly one selective retry for every group with a final failed/error/unresolved case. All existing inventory/source/policy stays. The returned archive is incomplete until the newly declared reports arrive.

    review_plan

    source

    Compare reviewed declarations, never received reports or observed outcomes. Reordering reports follows RunPlan's existing canonical report ordering; changed case order remains visible because it affects evidence identity.

    Source Files

    Powered by MoonBit

    Site sourceReport issueModulesSkillsCLIBuild queueStatistics

    © 2026 mooncakes.io