🥮 mooncakes.io

moonchunk

Content-defined chunking and incremental synchronization primitives for MoonBit

chunking
deduplication
merkle
sync
storage
moon add xgzh1111/moonchunk@0.1.0
Download zip
Author
Version
0.1.0
License
Apache-2.0
Repository
Last updated
7 days ago
Downloads
2
README

#MoonChunk

MoonChunk is a MoonBit-native content-defined chunking and incremental synchronization library. It turns a byte stream into stable, content-addressed chunks, builds a verifiable Merkle manifest, and produces a plan that reuses unchanged chunks between versions.

Repository: https://github.com/xgzh1111/1234

Module: xgzh1111/moonchunk

#Why it exists

Fixed-size blocks are simple, but inserting a few bytes near the beginning of a large file shifts every later block. A content-defined boundary follows the data instead of the absolute offset, so backups, build caches, edge replicas, and object stores can avoid retransmitting unchanged content.

#Current capabilities

  • Configurable content-defined chunking with minimum, average, and maximum sizes.
  • Streaming chunker for fragmented input.
  • Dependency-free deterministic 256-bit content digest for addressing and corruption detection. It is not a cryptographic authentication primitive.
  • Canonical line-oriented Manifest format with root validation.
  • Merkle roots, inclusion proofs, and proof verification.
  • Manifest diffing and a reusable in-memory ChunkStore.
  • Restore and integrity reports that identify missing, corrupt, or incorrectly sized chunks.
  • Native executable example and MoonBit test suite.

#Quick start

Install the MoonBit toolchain, then run:

moon check
moon test --target js
moon run cmd/main --target js

Library usage:

let input = "hello MoonChunk".to_bytes().to_array()
let cfg = @moonchunk.ChunkerConfig::new(min_size=16, average_size=32, max_size=64)
let chunks = @moonchunk.chunk_bytes(input, cfg~)
let manifest = @moonchunk.manifest_from_chunks("hello.txt", chunks)
let store = @moonchunk.ChunkStore::new()
@moonchunk.store_chunks(store, chunks)
let report = @moonchunk.verify_store(store, manifest)
assert_true(report.passed())

#What the example does

The runnable example in cmd/main chunks a sample document, builds a manifest, stores the chunks in an in-memory store, and verifies that the stored content can be checked back against the manifest root.

Expected output:

MoonChunk demonstration
source bytes: 250
chunks: 9
root: 7019a4e06126793bfd0a35c6654fbc33
valid: 9 chunks, 250 bytes

#Build and test status

  • moon check passes
  • moon test --target js passes with 56/56 tests
  • moon run cmd/main --target js runs successfully
  • moon package --list produces the publishable package artifact
  • GitHub Actions runs check, test, and runnable example commands on every push

On this Windows machine, MoonBit native runtime compilation currently fails in the toolchain C runtime (rand_s related compile error). The project remains fully verifiable through the JavaScript target locally and through CI on GitHub.

#Design boundaries

MoonChunk is a library and reference CLI, not a network protocol or a cloud storage service. Transport, authentication, encryption, and durable storage belong to the application embedding it. The public API is intentionally backend-neutral so the same model can be used from Native, JavaScript, or WebAssembly builds.

#Acceptance evidence

#Project layout

FileResponsibility
types.mbtPublic data model and synchronization result types
digest.mbtDeterministic digest and Merkle primitives
chunker.mbtBatch and streaming content-defined chunking
manifest.mbtManifest construction and canonical encoding
sync.mbtDiff plans, in-memory store, restore
verify.mbtIntegrity reports and proof checks
cmd/mainRunnable demonstration

#License

Apache-2.0. See LICENSE.

#
BenchmarkInput

source
pub(all) struct BenchmarkInput {
  name : String
  bytes : Array[Byte]
  description : String
} derive(Show)
Deterministic benchmark scenarios without wall-clock dependencies.

The benchmark reports work in bytes and operations so it can be compared across Native, JavaScript, and WebAssembly targets in CI.

#
BenchmarkInput::bytes

source
fn BenchmarkInput::bytes(self : BenchmarkInput) -> Array[Byte]

#
BenchmarkInput::description

source
fn BenchmarkInput::description(self : BenchmarkInput) -> String

#
BenchmarkInput::name

source
fn BenchmarkInput::name(self : BenchmarkInput) -> String

#
BenchmarkResult

source
pub(all) struct BenchmarkResult {
  name : String
  input_bytes : Int
  chunks : Int
  digest_operations : Int
  manifest_bytes : Int
  restored_bytes : Int
  reused_bytes : Int
  uploaded_bytes : Int
  checksum : String
} derive(Show)

#
BenchmarkResult::checksum

source
fn BenchmarkResult::checksum(self : BenchmarkResult) -> String

#
BenchmarkResult::chunks

source
fn BenchmarkResult::chunks(self : BenchmarkResult) -> Int

#
BenchmarkResult::digest_ops

source
fn BenchmarkResult::digest_ops(self : BenchmarkResult) -> Int

#
BenchmarkResult::input

source
fn BenchmarkResult::input(self : BenchmarkResult) -> Int

#
BenchmarkResult::manifest_size

source
fn BenchmarkResult::manifest_size(self : BenchmarkResult) -> Int

#
BenchmarkResult::name

source
fn BenchmarkResult::name(self : BenchmarkResult) -> String

#
BenchmarkResult::restored

source
fn BenchmarkResult::restored(self : BenchmarkResult) -> Int

#
BenchmarkResult::reused

source
fn BenchmarkResult::reused(self : BenchmarkResult) -> Int

#
BenchmarkResult::uploaded

source
fn BenchmarkResult::uploaded(self : BenchmarkResult) -> Int

#
Chunk

source
pub(all) struct Chunk {
  ordinal : Int
  span : Span
  digest : String
  data : Array[Byte]
} derive(Show)
A content-addressed block. The digest is represented as a stable hex string.

#
Chunk::bytes

source
fn Chunk::bytes(self : Chunk) -> Array[Byte]

#
Chunk::id

source
fn Chunk::id(self : Chunk) -> String

#
Chunk::index

source
fn Chunk::index(self : Chunk) -> Int

#
Chunk::new

source
fn Chunk::new(ordinal : Int, span : Span, data : Array[Byte]) -> Chunk

#
Chunk::range

source
fn Chunk::range(self : Chunk) -> Span

#
Chunk::size

source
fn Chunk::size(self : Chunk) -> Int

#
ChunkProfile

source
pub(all) struct ChunkProfile {
  total_bytes : Int
  chunk_count : Int
  mean_size : Int
  median_size : Int
  min_size : Int
  max_size : Int
  unique_count : Int
  duplicate_count : Int
  histogram : Array[Int]
} derive(Show)
Analysis helpers used by the CLI, examples, and benchmark reports.

#
ChunkProfile::bytes

source
fn ChunkProfile::bytes(self : ChunkProfile) -> Int

#
ChunkProfile::count

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

#
ChunkProfile::distribution

source
fn ChunkProfile::distribution(self : ChunkProfile) -> Array[Int]

#
ChunkProfile::duplicates

source
fn ChunkProfile::duplicates(self : ChunkProfile) -> Int

#
ChunkProfile::maximum

source
fn ChunkProfile::maximum(self : ChunkProfile) -> Int

#
ChunkProfile::mean

source
fn ChunkProfile::mean(self : ChunkProfile) -> Int

#
ChunkProfile::median

source
fn ChunkProfile::median(self : ChunkProfile) -> Int

#
ChunkProfile::minimum

source
fn ChunkProfile::minimum(self : ChunkProfile) -> Int

#
ChunkProfile::unique

source
fn ChunkProfile::unique(self : ChunkProfile) -> Int

#
ChunkRef

source
pub(all) struct ChunkRef {
  position : Int
  digest : String
  size : Int
} derive(Eq, Show)
A reference to a stored chunk inside a manifest.

#
ChunkRef::at

source
fn ChunkRef::at(self : ChunkRef) -> Int

#
ChunkRef::id

source
fn ChunkRef::id(self : ChunkRef) -> String

#
ChunkRef::length

source
fn ChunkRef::length(self : ChunkRef) -> Int

#
ChunkRef::new

source
fn ChunkRef::new(position : Int, digest : String, size : Int) -> ChunkRef

#
ChunkStore

source
pub(all) struct ChunkStore {
  digests : Array[String]
  blocks : Array[Array[Byte]]
  inserted : Int
  hits : Int
}

#
ChunkStore::all_digests

source
fn ChunkStore::all_digests(self : ChunkStore) -> Array[String]

#
ChunkStore::clear

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

#
ChunkStore::get

source
fn ChunkStore::get(self : ChunkStore, digest : String) -> Array[Byte]?

#
ChunkStore::has

source
fn ChunkStore::has(self : ChunkStore, digest : String) -> Bool

#
ChunkStore::hits

source
fn ChunkStore::hits(self : ChunkStore) -> Int

#
ChunkStore::insertions

source
fn ChunkStore::insertions(self : ChunkStore) -> Int

#
ChunkStore::len

source
fn ChunkStore::len(self : ChunkStore) -> Int

#
ChunkStore::new

source
fn ChunkStore::new() -> ChunkStore

#
ChunkStore::put

source
fn ChunkStore::put(self : ChunkStore, chunk : Chunk) -> Bool

#
ChunkStore::remove

source
fn ChunkStore::remove(self : ChunkStore, digest : String) -> Bool

#
ChunkerConfig

source
pub(all) struct ChunkerConfig {
  min_size : Int
  average_size : Int
  max_size : Int
  seed : UInt
} derive(Eq, Show)
Parameters used by the rolling chunker.

#
ChunkerConfig::average

source
fn ChunkerConfig::average(self : ChunkerConfig) -> Int

#
ChunkerConfig::maximum

source
fn ChunkerConfig::maximum(self : ChunkerConfig) -> Int

#
ChunkerConfig::minimum

source
fn ChunkerConfig::minimum(self : ChunkerConfig) -> Int

#
ChunkerConfig::new

source
fn ChunkerConfig::new(min_size? : Int, average_size? : Int, max_size? : Int, seed? : UInt) -> ChunkerConfig

#
ChunkerConfig::validate

source
fn ChunkerConfig::validate(self : ChunkerConfig) -> Result[Unit, String]

#
ChunkerConfig::with_seed

source
fn ChunkerConfig::with_seed(self : ChunkerConfig, seed : UInt) -> ChunkerConfig

#
ChunkerStats

source
pub(all) struct ChunkerStats {
  input_bytes : Int
  chunk_count : Int
  smallest : Int
  largest : Int
  average : Int
  boundaries : Array[Int]
} derive(Show)
Content-defined chunking.

#
ChunkerStats::boundary_offsets

source
fn ChunkerStats::boundary_offsets(self : ChunkerStats) -> Array[Int]

#
ChunkerStats::count

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

#
ChunkerStats::empty

source
fn ChunkerStats::empty() -> ChunkerStats

#
ChunkerStats::input

source
fn ChunkerStats::input(self : ChunkerStats) -> Int

#
ChunkerStats::max_size

source
fn ChunkerStats::max_size(self : ChunkerStats) -> Int

#
ChunkerStats::mean

source
fn ChunkerStats::mean(self : ChunkerStats) -> Int

#
ChunkerStats::min_size

source
fn ChunkerStats::min_size(self : ChunkerStats) -> Int

#
Manifest

source
pub(all) struct Manifest {
  name : String
  total_size : Int
  chunks : Array[ChunkRef]
  root : String
  format_version : Int
} derive(Show)
An immutable description of one version of a file.

#
Manifest::count

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

#
Manifest::filename

source
fn Manifest::filename(self : Manifest) -> String

#
Manifest::is_valid

source
fn Manifest::is_valid(self : Manifest) -> Bool

#
Manifest::new

source
fn Manifest::new(name : String, chunks : Array[ChunkRef]) -> Manifest

#
Manifest::references

source
fn Manifest::references(self : Manifest) -> Array[ChunkRef]

#
Manifest::root_digest

source
fn Manifest::root_digest(self : Manifest) -> String

#
Manifest::size

source
fn Manifest::size(self : Manifest) -> Int

#
Manifest::version

source
fn Manifest::version(self : Manifest) -> Int

#
Span

source
pub(all) struct Span {
  start : Int
  end : Int
} derive(Eq, Show)
A half-open byte interval in the source stream.

#
Span::is_empty

source
fn Span::is_empty(self : Span) -> Bool

#
Span::length

source
fn Span::length(self : Span) -> Int

#
Span::new

source
fn Span::new(start : Int, end : Int) -> Span

#
StorageReport

source
pub(all) struct StorageReport {
  logical_bytes : Int
  physical_bytes : Int
  chunk_count : Int
  unique_chunks : Int
  deduplicated_bytes : Int
  manifest_bytes : Int
} derive(Show)
Inventory and accounting functions for storage dashboards.

#
StorageReport::chunks

source
fn StorageReport::chunks(self : StorageReport) -> Int

#
StorageReport::logical

source
fn StorageReport::logical(self : StorageReport) -> Int

#
StorageReport::manifest

source
fn StorageReport::manifest(self : StorageReport) -> Int

#
StorageReport::physical

source
fn StorageReport::physical(self : StorageReport) -> Int

#
StorageReport::saved

source
fn StorageReport::saved(self : StorageReport) -> Int

#
StorageReport::unique

source
fn StorageReport::unique(self : StorageReport) -> Int

#
StreamingChunker

source
pub(all) struct StreamingChunker {
  config : ChunkerConfig
  buffer : Array[Byte]
  total_seen : Int
  next_ordinal : Int
  rolling : UInt
  boundaries : Array[Int]
}
Incremental chunker for readers that arrive in arbitrary input fragments.

#
StreamingChunker::bytes_seen

source
fn StreamingChunker::bytes_seen(self : StreamingChunker) -> Int

#
StreamingChunker::config

source

#
StreamingChunker::finish

source
Finish the stream and return the final partial chunk.

#
StreamingChunker::finish_all

source
fn StreamingChunker::finish_all(self : StreamingChunker) -> Array[Chunk]

#
StreamingChunker::new

source

#
StreamingChunker::pending_size

source
fn StreamingChunker::pending_size(self : StreamingChunker) -> Int

#
StreamingChunker::push

source
fn StreamingChunker::push(self : StreamingChunker, fragment : Array[Byte]) -> Array[Chunk]
Feed one fragment. It may return zero or more complete chunks.

#
SyncOp

source
pub(all) enum SyncOp {
  Reuse(digest~ : String, size~ : Int)
  Upload(digest~ : String, size~ : Int, source_index~ : Int)
  Remove(digest~ : String)
} derive(Eq, Show)
A single operation in an incremental synchronization plan.

#
SyncPlan

source
pub(all) struct SyncPlan {
  operations : Array[SyncOp]
  reused_bytes : Int
  uploaded_bytes : Int
  removed_chunks : Int
} derive(Show)

#
SyncPlan::new

source
fn SyncPlan::new(operations : Array[SyncOp]) -> SyncPlan

#
SyncPlan::operations

source
fn SyncPlan::operations(self : SyncPlan) -> Array[SyncOp]

#
SyncPlan::removed

source
fn SyncPlan::removed(self : SyncPlan) -> Int

#
SyncPlan::reused

source
fn SyncPlan::reused(self : SyncPlan) -> Int

#
SyncPlan::uploaded

source
fn SyncPlan::uploaded(self : SyncPlan) -> Int

#
VerificationReport

source
pub(all) struct VerificationReport {
  result : VerifyResult
  checked_chunks : Int
  checked_bytes : Int
  warnings : Array[String]
} derive(Show)
Integrity checks and diagnostic reports.

#
VerificationReport::bytes

source
fn VerificationReport::bytes(self : VerificationReport) -> Int

#
VerificationReport::checked

source
fn VerificationReport::checked(self : VerificationReport) -> Int

#
VerificationReport::passed

source
fn VerificationReport::passed(self : VerificationReport) -> Bool

#
VerificationReport::result

source

#
VerificationReport::warnings

source
fn VerificationReport::warnings(self : VerificationReport) -> Array[String]

#
VerifyResult

source
pub(all) enum VerifyResult {
  Valid
  InvalidManifest(reason~ : String)
  MissingChunk(digest~ : String, position~ : Int)
  CorruptChunk(expected~ : String, actual~ : String, position~ : Int)
  SizeMismatch(expected~ : Int, actual~ : Int)
} derive(Eq, Show)
A detailed verification result suitable for a CLI or a UI.

#
VerifyResult::ok

source
fn VerifyResult::ok(self : VerifyResult) -> Bool

#
VersionComparison

source
pub(all) struct VersionComparison {
  old_bytes : Int
  new_bytes : Int
  reused_bytes : Int
  uploaded_bytes : Int
  removed_chunks : Int
  reuse_ratio : Double
  upload_ratio : Double
} derive(Show)

#
VersionComparison::new_size

source
fn VersionComparison::new_size(self : VersionComparison) -> Int

#
VersionComparison::old_size

source
fn VersionComparison::old_size(self : VersionComparison) -> Int

#
VersionComparison::removed

source
fn VersionComparison::removed(self : VersionComparison) -> Int

#
VersionComparison::reuse_fraction

source
fn VersionComparison::reuse_fraction(self : VersionComparison) -> Double

#
VersionComparison::reused

source
fn VersionComparison::reused(self : VersionComparison) -> Int

#
VersionComparison::upload_fraction

source
fn VersionComparison::upload_fraction(self : VersionComparison) -> Double

#
VersionComparison::uploaded

source
fn VersionComparison::uploaded(self : VersionComparison) -> Int

#
add_storage_reports

source
fn add_storage_reports(left : StorageReport, right : StorageReport) -> StorageReport

#
apply_plan

source
fn apply_plan(old_store : ChunkStore, new_store : ChunkStore, old_manifest : Manifest, new_manifest : Manifest) -> Result[Array[Byte], String]

#
benchmark_all

source
fn benchmark_all(config? : ChunkerConfig) -> Array[BenchmarkResult]

#
benchmark_checksum_chain

source
fn benchmark_checksum_chain(inputs : Array[BenchmarkInput]) -> String

#
benchmark_deletion_overlap

source
fn benchmark_deletion_overlap(config : ChunkerConfig) -> Int

#
benchmark_inputs_are_deterministic

source
fn benchmark_inputs_are_deterministic() -> Bool

#
benchmark_insertion_overlap

source
fn benchmark_insertion_overlap(config : ChunkerConfig) -> Int

#
benchmark_mutation_overlap

source
fn benchmark_mutation_overlap(config : ChunkerConfig) -> Int

#
benchmark_report

source
fn benchmark_report(results : Array[BenchmarkResult]) -> String

#
benchmark_round_trip_ok

source
fn benchmark_round_trip_ok(result : BenchmarkResult) -> Bool

#
benchmark_scenarios

source
fn benchmark_scenarios() -> Array[BenchmarkInput]

#
benchmark_total_chunks

source
fn benchmark_total_chunks(results : Array[BenchmarkResult]) -> Int

#
benchmark_total_input

source
fn benchmark_total_input(results : Array[BenchmarkResult]) -> Int

#
benchmark_total_manifest_bytes

source
fn benchmark_total_manifest_bytes(results : Array[BenchmarkResult]) -> Int

#
boundary_gaps

source
fn boundary_gaps(chunks : Array[Chunk]) -> Array[Int]

#
boundary_jitter

source
fn boundary_jitter(chunks : Array[Chunk]) -> Int

#
chunk_boundaries

source
fn chunk_boundaries(chunks : Array[Chunk]) -> Array[Int]

#
chunk_bytes

source
fn chunk_bytes(source : Array[Byte], cfg : ChunkerConfig) -> Array[Chunk]
Split a complete byte array using content-defined boundaries.

#
chunk_histogram

source
fn chunk_histogram(chunks : Array[Chunk], buckets : Int) -> Array[Int]

#
chunk_ids_with_positions

source
fn chunk_ids_with_positions(chunks : Array[Chunk]) -> Array[(Int, String)]

#
chunk_stats

source
fn chunk_stats(chunks : Array[Chunk], input_bytes : Int) -> ChunkerStats

#
chunk_total_size

source
fn chunk_total_size(chunks : Array[Chunk]) -> Int

#
collect_extra

source
fn collect_extra(store : ChunkStore, manifest : Manifest) -> Array[String]

#
collect_missing

source
fn collect_missing(store : ChunkStore, manifest : Manifest) -> Array[ChunkRef]

#
compare_boundaries

source
fn compare_boundaries(left : Array[Chunk], right : Array[Chunk]) -> Int

#
compare_versions

source
fn compare_versions(old : Manifest, next : Manifest) -> VersionComparison

#
comparison_report

source
fn comparison_report(result : BenchmarkResult) -> String

#
comparison_summary

source
fn comparison_summary(comparison : VersionComparison) -> String

#
content_overlap

source
fn content_overlap(left : Array[Chunk], right : Array[Chunk]) -> Int

#
decode_manifest

source
fn decode_manifest(encoded : String) -> Result[Manifest, String]
Parse the canonical format and validate the recomputed Merkle root.

#
delete_region

source
fn delete_region(input : BenchmarkInput, start : Int, length : Int) -> BenchmarkInput

#
diff_manifests

source
fn diff_manifests(old : Manifest, next : Manifest) -> SyncPlan

#
digest_bytes

source
fn digest_bytes(data : Array[Byte]) -> String

#
digest_equal

source
fn digest_equal(left : String, right : String) -> Bool

#
digest_frequency

source
fn digest_frequency(chunks : Array[Chunk]) -> Array[(String, Int)]

#
digest_string

source
fn digest_string(value : String) -> String

#
duplicate_ratio

source
fn duplicate_ratio(chunks : Array[Chunk]) -> Double

#
empty_storage_report

source
fn empty_storage_report() -> StorageReport

#
encode_manifest

source
fn encode_manifest(manifest : Manifest) -> String
Canonical line-oriented encoding. It is intentionally simple to make the format inspectable in a hex editor and stable across MoonBit backends.

#
estimated_savings

source
fn estimated_savings(chunks : Array[Chunk]) -> Int

#
estimated_storage

source
fn estimated_storage(chunks : Array[Chunk]) -> Int

#
format_histogram

source
fn format_histogram(histogram : Array[Int]) -> String

#
insert_region

source
fn insert_region(input : BenchmarkInput, at : Int, inserted : Array[Byte]) -> BenchmarkInput

#
inspect_storage

source
fn inspect_storage(store : ChunkStore, manifest : Manifest) -> StorageReport

#
inventory_digest

source
fn inventory_digest(report : StorageReport) -> String

#
inventory_equal

source
fn inventory_equal(left : StorageReport, right : StorageReport) -> Bool

#
manifest_chunk_sizes

source
fn manifest_chunk_sizes(manifest : Manifest) -> Array[Int]

#
manifest_contains

source
fn manifest_contains(manifest : Manifest, digest : String) -> Bool

#
manifest_digests

source
fn manifest_digests(manifest : Manifest) -> Array[String]

#
manifest_from_chunks

source
fn manifest_from_chunks(name : String, chunks : Array[Chunk]) -> Manifest
Manifest construction, canonical encoding and lookup helpers.

#
manifest_from_digests

source
fn manifest_from_digests(name : String, digests : Array[String], sizes : Array[Int]) -> Result[Manifest, String]

#
manifest_has_all_chunks

source
fn manifest_has_all_chunks(store : ChunkStore, manifest : Manifest) -> Bool

#
manifest_has_no_extra_chunks

source
fn manifest_has_no_extra_chunks(store : ChunkStore, manifest : Manifest) -> Bool

#
manifest_lookup

source
fn manifest_lookup(manifest : Manifest, digest : String) -> ChunkRef?

#
manifest_position

source
fn manifest_position(manifest : Manifest, digest : String) -> Int?

#
manifest_prefix

source
fn manifest_prefix(manifest : Manifest, count : Int) -> Manifest

#
manifest_reorder

source
fn manifest_reorder(manifest : Manifest, order : Array[Int]) -> Result[Manifest, String]

#
manifest_same_content

source
fn manifest_same_content(left : Manifest, right : Manifest) -> Bool

#
manifest_suffix

source
fn manifest_suffix(manifest : Manifest, start : Int) -> Manifest

#
manifest_summary

source
fn manifest_summary(manifest : Manifest) -> String

#
manifest_validate_order

source
fn manifest_validate_order(manifest : Manifest) -> Bool

#
merkle_proof

source
fn merkle_proof(digests : Array[String], index : Int) -> Array[(String, Bool)]

#
merkle_root

source
fn merkle_root(digests : Array[String]) -> String

#
most_repeated

source
fn most_repeated(chunks : Array[Chunk]) -> (String, Int)?

#
mutate_region

source
fn mutate_region(input : BenchmarkInput, start : Int, length : Int, seed : UInt) -> BenchmarkInput

#
plan_removals

source
fn plan_removals(plan : SyncPlan) -> Int

#
plan_reuses

source
fn plan_reuses(plan : SyncPlan) -> Int

#
plan_uploads

source
fn plan_uploads(plan : SyncPlan) -> Int

#
profile_chunks

source
fn profile_chunks(chunks : Array[Chunk], buckets? : Int) -> ChunkProfile

#
profile_is_reasonable

source
fn profile_is_reasonable(profile : ChunkProfile, config : ChunkerConfig) -> Bool

#
profile_strings

source
fn profile_strings(chunks : Array[Chunk], buckets : Int) -> String

#
repetitive_input

source
fn repetitive_input(name : String, size : Int, pattern : String) -> BenchmarkInput

#
report_message

source
fn report_message(report : VerificationReport) -> String

#
restore_manifest

source
fn restore_manifest(store : ChunkStore, manifest : Manifest) -> Result[Array[Byte], String]

#
run_benchmark

source
fn run_benchmark(input : BenchmarkInput, config : ChunkerConfig) -> BenchmarkResult

#
run_comparison

source
fn run_comparison(old : BenchmarkInput, next : BenchmarkInput, config : ChunkerConfig) -> BenchmarkResult

#
size_percentile

source
fn size_percentile(chunks : Array[Chunk], percentile : Int) -> Int

#
storage_is_consistent

source
fn storage_is_consistent(report : StorageReport) -> Bool

#
storage_report_line

source
fn storage_report_line(report : StorageReport) -> String

#
storage_saving_ratio

source
fn storage_saving_ratio(report : StorageReport) -> Double

#
store_chunks

source
fn store_chunks(store : ChunkStore, chunks : Array[Chunk]) -> Int

#
store_logical_size

source
fn store_logical_size(store : ChunkStore, manifest : Manifest) -> Int

#
store_physical_size

source
fn store_physical_size(store : ChunkStore, manifest : Manifest) -> Int

#
sync_ratio

source
fn sync_ratio(plan : SyncPlan, original_size : Int) -> Double

#
sync_savings

source
fn sync_savings(plan : SyncPlan, original_size : Int) -> Int

#
synthetic_input

source
fn synthetic_input(name : String, size : Int, seed : UInt) -> BenchmarkInput

#
text_input

source
fn text_input(name : String, paragraphs : Int) -> BenchmarkInput

#
verify_bytes

source
fn verify_bytes(data : Array[Byte], expected : String) -> Bool

#
verify_manifest_root

source
fn verify_manifest_root(manifest : Manifest) -> Bool

#
verify_merkle_proof

source
fn verify_merkle_proof(leaf : String, proof : Array[(String, Bool)], root : String) -> Bool

#
verify_proof_for_manifest

source
fn verify_proof_for_manifest(manifest : Manifest, position : Int) -> Bool

#
verify_store

source
fn verify_store(store : ChunkStore, manifest : Manifest) -> VerificationReport

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io