///|
fn write_file_header(output : @buffer.Buffer) -> Unit {
  output.write_byte(VCD_MAGIC_1)
  output.write_byte(VCD_MAGIC_2)
  output.write_byte(VCD_MAGIC_3)
  output.write_byte(VCD_VERSION)
  output.write_byte(b'\x00')
}

///|
fn serialize_window(
  target : Bytes,
  plan : WindowPlan,
  output : @buffer.Buffer,
) -> Unit raise VcdiffError {
  let sections = encode_window_sections(target, plan)
  let delta_body = @buffer.Buffer()
  write_varint(delta_body, sections.output_size)
  delta_body.write_byte(b'\x00')
  write_varint(delta_body, sections.data.length())
  write_varint(delta_body, sections.instructions.length())
  write_varint(delta_body, sections.addresses.length())
  delta_body.write_bytes(sections.data)
  delta_body.write_bytes(sections.instructions)
  delta_body.write_bytes(sections.addresses)
  if plan.source_size > 0 {
    output.write_byte(VCD_SOURCE.to_byte())
    write_varint(output, plan.source_size)
    write_varint(output, plan.source_position)
  } else {
    output.write_byte(b'\x00')
  }
  write_varint(output, delta_body.length())
  output.write_bytes(delta_body.to_bytes())
}

///|
/// Encodes target bytes into a deterministic RFC 3284 delta.
///
/// A bounded hash-chain planner selects source and target COPY matches, detects
/// runs, and uses canonical ADD instructions for remaining bytes.
pub fn encode(
  source : Bytes,
  target : Bytes,
  options : EncodeOptions,
) -> Bytes raise VcdiffError {
  validate_encode_options(options)
  let output = @buffer.Buffer(size_hint=target.length() + 32)
  write_file_header(output)
  let plans = plan_windows(source, target, options)
  for plan in plans {
    let actual = plan_output_size(plan)
    if actual != plan.target_size {
      raise LengthMismatch(offset=-1, expected=plan.target_size, actual~)
    }
    ignore(plan.target_offset)
    serialize_window(target, plan, output)
  }
  output.to_bytes()
}