How do I clip label within a Rect?

[tmvkrpxl0]

I've been trying to implement console ui for my game but the text partially clips out of rect.
Below is copy of my console ui code. The closure passed to ScrollArea is what renders the text.

pub struct Console {
    output: Vec<(MessageType, String)>,
    input: String,
    history: Vec<String>,
    history_index: usize,
    output_receiver: Receiver<(MessageType, String)>,
    vk_command: Sender<VkCommand>,
    beam_command: Sender<BeamCommand>,
}

pub enum MessageType {
    Debug,
    Info,
    Warn,
    Error,
}

impl Console {
    pub const fn new(
        output_receiver: Receiver<(MessageType, String)>,
        vk_command: Sender<VkCommand>,
        beam_command: Sender<BeamCommand>,
    ) -> Self {
        Self {
            output: Vec::new(),
            input: String::new(),
            history: Vec::new(),
            history_index: 0,
            output_receiver,
            vk_command,
            beam_command,
        }
    }

    pub fn show(&mut self, ctx: &Context) {
        loop {
            let result = self.output_receiver.try_recv();
            match result {
                Ok(v) => {
                    self.output.push(v);
                }
                Err(TryRecvError::Empty) => {
                    break;
                }
                Err(e) => {
                    panic_with_dialog(e);
                }
            }
        }

        Window::new("Console")
            .collapsible(false)
            .default_open(true)
            .resizable(true)
            .movable(true)
            .title_bar(false)
            .show(ctx, |ui| {
                let title = RichText::new("Console")
                    .small_raised()
                    .color(Color32::WHITE)
                    .line_height(Some(25.0));

                ui.label(title);

                ui.with_layout(Layout::bottom_up(Align::Max), |ui| {
                    ui.with_layout(Layout::right_to_left(Align::Max), |ui| {
                        ui.horizontal(|ui| {
                            let mut should_submit = false;
                            let mut regain_focus = false;
                            if Button::new(RichText::new("Submit  ").color(Color32::BLACK))
                                .fill(ctx.style().visuals.window_fill)
                                .stroke(Stroke::new(1.0, Color32::WHITE))
                                .ui(ui)
                                .clicked()
                            {
                                should_submit = true;
                            }

                            let input_field = TextEdit::singleline(&mut self.input)
                                .code_editor()
                                .desired_width(f32::INFINITY)
                                .lock_focus(true)
                                .show(ui);

                            if input_field.response.has_focus() {
                                let (up, down) = ui.input(|i| {
                                    (
                                        i.key_pressed(egui::Key::ArrowUp),
                                        i.key_pressed(egui::Key::ArrowDown),
                                    )
                                });

                                if up {
                                    self.history_index = self.history_index.saturating_sub(1);
                                } else if down {
                                    self.history_index = self.history_index.saturating_add(1);
                                }
                                self.history_index =
                                    self.history_index.clamp(0, self.history.len());

                                if up || down {
                                    if self.history_index >= self.history.len() {
                                        self.history_index = self.history.len();
                                        self.input = String::new();
                                    } else {
                                        self.input = self.history[self.history_index].clone();
                                    }
                                }
                            }

                            if input_field.response.lost_focus()
                                && ui.input(|i| i.key_pressed(egui::Key::Enter))
                            {
                                should_submit = true;
                                regain_focus = true;
                            }

                            if should_submit {
                                let input = self.input.take();
                                self.submit(input.trim());
                            }

                            if regain_focus {
                                input_field.response.request_focus();
                            }
                        })
                    });

                    ui.with_layout(Layout::top_down(Align::Min), |ui| {
                        let window_height = ui.available_height();
                        let font_height = ui.text_style_height(&TextStyle::Monospace);
                        let row_height = font_height;
                        let rows = self.output.len();
                        ScrollArea::vertical()
                            .enable_scrolling(true)
                            .auto_shrink(false)
                            .max_height(window_height)
                            .stick_to_bottom(true)
                            .scroll_bar_visibility(ScrollBarVisibility::AlwaysVisible)
                            .show_rows(ui, row_height, rows, |ui, range| {
                                let rect = ui.clip_rect();
                                let size = ui.available_size_before_wrap();
                                ui.painter().rect(
                                    rect,
                                    CornerRadius::ZERO,
                                    ui.visuals().extreme_bg_color,
                                    ui.visuals().selection.stroke,
                                    StrokeKind::Middle,
                                );
                                ui.allocate_ui(size, |ui| {
                                    self.output[range].iter().for_each(
                                        |(message_type, contents)| {
                                            let text = RichText::new(contents)
                                                .text_style(TextStyle::Monospace)
                                                .color(message_type.color());
                                            Label::new(text).ui(ui);
                                        },
                                    );
                                });
                            });
                    })
                });
            })
            .unwrap();
    }
}

impl MessageType {
    pub fn color(&self) -> Color32 {
        match self {
            MessageType::Debug => Color32::GRAY,
            MessageType::Info => Color32::WHITE,
            MessageType::Warn => Color32::YELLOW,
            MessageType::Error => Color32::RED,
        }
    }
}

I want the upper parts of a line to be clipped when it goes out side of darker area.

[tmvkrpxl0]

Interesting feature I noticed is that it can clip out parts of text if the whole wrapped line is out of rect like this:

Compared to the 1st image, it deleted "Failed to grab cursor" text