pub(all) struct BenchmarkInput {
  name : String
  bytes : Array[Byte]
  description : String
} derive(Show)

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)

pub(all) struct Chunk {
  ordinal : Int
  span : Span
  digest : String
  data : Array[Byte]
} derive(Show)

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)

pub(all) struct ChunkRef {
  position : Int
  digest : String
  size : Int
} derive(Eq, Show)

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

pub(all) struct ChunkerConfig {
  min_size : Int
  average_size : Int
  max_size : Int
  seed : UInt
} derive(Eq, Show)

pub(all) struct ChunkerStats {
  input_bytes : Int
  chunk_count : Int
  smallest : Int
  largest : Int
  average : Int
  boundaries : Array[Int]
} derive(Show)

pub(all) struct Manifest {
  name : String
  total_size : Int
  chunks : Array[ChunkRef]
  root : String
  format_version : Int
} derive(Show)

pub(all) struct Span {
  start : Int
  end : Int
} derive(Eq, Show)

pub(all) struct StorageReport {
  logical_bytes : Int
  physical_bytes : Int
  chunk_count : Int
  unique_chunks : Int
  deduplicated_bytes : Int
  manifest_bytes : Int
} derive(Show)

pub(all) struct StreamingChunker {
  config : ChunkerConfig
  buffer : Array[Byte]
  total_seen : Int
  next_ordinal : Int
  rolling : UInt
  boundaries : Array[Int]
}

pub(all) enum SyncOp {
  Reuse(digest~ : String, size~ : Int)
  Upload(digest~ : String, size~ : Int, source_index~ : Int)
  Remove(digest~ : String)
} derive(Eq, Show)

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

pub(all) struct VerificationReport {
  result : VerifyResult
  checked_chunks : Int
  checked_bytes : Int
  warnings : Array[String]
} derive(Show)

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)

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)

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

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

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

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

fn benchmark_deletion_overlap(config : ChunkerConfig) -> Int

fn benchmark_inputs_are_deterministic() -> Bool

fn benchmark_insertion_overlap(config : ChunkerConfig) -> Int

fn benchmark_mutation_overlap(config : ChunkerConfig) -> Int

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

fn benchmark_round_trip_ok(result : BenchmarkResult) -> Bool

fn benchmark_scenarios() -> Array[BenchmarkInput]

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

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

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

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

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

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

fn chunk_bytes(source : Array[Byte], cfg : ChunkerConfig) -> Array[Chunk]

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

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

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

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

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

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

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

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

fn comparison_report(result : BenchmarkResult) -> String

fn comparison_summary(comparison : VersionComparison) -> String

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

fn decode_manifest(encoded : String) -> Result[Manifest, String]

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

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

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

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

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

fn digest_string(value : String) -> String

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

fn empty_storage_report() -> StorageReport

fn encode_manifest(manifest : Manifest) -> String

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

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

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

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

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

fn inventory_digest(report : StorageReport) -> String

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

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

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

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

fn manifest_from_chunks(name : String, chunks : Array[Chunk]) -> Manifest

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

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