diff --git a/crates/typst-layout/src/math/run.rs b/crates/typst-layout/src/math/run.rs
index ae64368d6..4ec76c253 100644
--- a/crates/typst-layout/src/math/run.rs
+++ b/crates/typst-layout/src/math/run.rs
@@ -278,6 +278,9 @@ impl MathRun {
         frame
     }
 
+    /// Convert this run of math fragments into a vector of inline items for
+    /// paragraph layout. Creates multiple fragments when relation or binary
+    /// operators are present to allow for line-breaking opportunities later.
     pub fn into_par_items(self) -> Vec<InlineItem> {
         let mut items = vec![];
 
@@ -295,21 +298,24 @@ impl MathRun {
 
         let mut space_is_visible = false;
 
-        let is_relation = |f: &MathFragment| matches!(f.class(), MathClass::Relation);
         let is_space = |f: &MathFragment| {
             matches!(f, MathFragment::Space(_) | MathFragment::Spacing(_, _))
         };
+        let is_line_break_opportunity = |class, next_fragment| match class {
+            // Don't split when two relations are in a row or when preceding a
+            // closing parenthesis.
+            MathClass::Binary => next_fragment != Some(MathClass::Closing),
+            MathClass::Relation => {
+                !matches!(next_fragment, Some(MathClass::Relation | MathClass::Closing))
+            }
+            _ => false,
+        };
 
         let mut iter = self.0.into_iter().peekable();
         while let Some(fragment) = iter.next() {
-            if space_is_visible {
-                match fragment {
-                    MathFragment::Space(width) | MathFragment::Spacing(width, _) => {
-                        items.push(InlineItem::Space(width, true));
-                        continue;
-                    }
-                    _ => {}
-                }
+            if space_is_visible && is_space(&fragment) {
+                items.push(InlineItem::Space(fragment.width(), true));
+                continue;
             }
 
             let class = fragment.class();
@@ -323,10 +329,9 @@ impl MathRun {
             frame.push_frame(pos, fragment.into_frame());
             empty = false;
 
-            if class == MathClass::Binary
-                || (class == MathClass::Relation
-                    && !iter.peek().map(is_relation).unwrap_or_default())
-            {
+            // Split our current frame when we encounter a binary operator or
+            // relation so that there is a line-breaking opportunity.
+            if is_line_break_opportunity(class, iter.peek().map(|f| f.class())) {
                 let mut frame_prev =
                     std::mem::replace(&mut frame, Frame::soft(Size::zero()));
 
diff --git a/tests/ref/math-linebreaking-after-relation-without-space.png b/tests/ref/math-linebreaking-after-relation-without-space.png
index 7c569ad1f..fb1413768 100644
Binary files a/tests/ref/math-linebreaking-after-relation-without-space.png and b/tests/ref/math-linebreaking-after-relation-without-space.png differ
diff --git a/tests/suite/math/multiline.typ b/tests/suite/math/multiline.typ
index 34e66b99c..70838dd8c 100644
--- a/tests/suite/math/multiline.typ
+++ b/tests/suite/math/multiline.typ
@@ -99,6 +99,9 @@ Multiple trailing line breaks.
 #let hrule(x) = box(line(length: x))
 #hrule(90pt)$<;$\
 #hrule(95pt)$<;$\
+// We don't linebreak before a closing paren, but do before an opening paren.
+#hrule(90pt)$<($\
+#hrule(95pt)$<($
 #hrule(90pt)$<)$\
 #hrule(95pt)$<)$