diff --git a/pageserver/src/walingest.rs b/pageserver/src/walingest.rs
index 8df0c81c7a..1bc5e19dac 100644
--- a/pageserver/src/walingest.rs
+++ b/pageserver/src/walingest.rs
@@ -710,86 +710,250 @@ impl WalIngest {
         }
 
         // Clear the VM bits if required.
-        if new_heap_blkno.is_some() || old_heap_blkno.is_some() {
-            let vm_rel = RelTag {
-                forknum: VISIBILITYMAP_FORKNUM,
-                spcnode: decoded.blocks[0].rnode_spcnode,
-                dbnode: decoded.blocks[0].rnode_dbnode,
-                relnode: decoded.blocks[0].rnode_relnode,
-            };
+        match (new_heap_blkno, old_heap_blkno) {
+            (Some(_), Some(_)) => {
+                let vm_rel = RelTag {
+                    forknum: VISIBILITYMAP_FORKNUM,
+                    spcnode: decoded.blocks[0].rnode_spcnode,
+                    dbnode: decoded.blocks[0].rnode_dbnode,
+                    relnode: decoded.blocks[0].rnode_relnode,
+                };
 
-            let mut new_vm_blk = new_heap_blkno.map(pg_constants::HEAPBLK_TO_MAPBLOCK);
-            let mut old_vm_blk = old_heap_blkno.map(pg_constants::HEAPBLK_TO_MAPBLOCK);
+                let mut new_vm_blk = new_heap_blkno.map(pg_constants::HEAPBLK_TO_MAPBLOCK);
+                let mut old_vm_blk = old_heap_blkno.map(pg_constants::HEAPBLK_TO_MAPBLOCK);
 
-            // Sometimes, Postgres seems to create heap WAL records with the
-            // ALL_VISIBLE_CLEARED flag set, even though the bit in the VM page is
-            // not set. In fact, it's possible that the VM page does not exist at all.
-            // In that case, we don't want to store a record to clear the VM bit;
-            // replaying it would fail to find the previous image of the page, because
-            // it doesn't exist. So check if the VM page(s) exist, and skip the WAL
-            // record if it doesn't.
-            let vm_size = get_relsize(modification, vm_rel, ctx).await?;
-            if let Some(blknum) = new_vm_blk {
-                if blknum >= vm_size {
-                    new_vm_blk = None;
+                // Sometimes, Postgres seems to create heap WAL records with the
+                // ALL_VISIBLE_CLEARED flag set, even though the bit in the VM page is
+                // not set. In fact, it's possible that the VM page does not exist at all.
+                // In that case, we don't want to store a record to clear the VM bit;
+                // replaying it would fail to find the previous image of the page, because
+                // it doesn't exist. So check if the VM page(s) exist, and skip the WAL
+                // record if it doesn't.
+                let vm_size = get_relsize(modification, vm_rel, ctx).await?;
+                if let Some(blknum) = new_vm_blk {
+                    if blknum >= vm_size {
+                        new_vm_blk = None;
+                    }
                 }
-            }
-            if let Some(blknum) = old_vm_blk {
-                if blknum >= vm_size {
-                    old_vm_blk = None;
+                if let Some(blknum) = old_vm_blk {
+                    if blknum >= vm_size {
+                        old_vm_blk = None;
+                    }
                 }
-            }
 
-            if new_vm_blk.is_some() || old_vm_blk.is_some() {
-                if new_vm_blk == old_vm_blk {
-                    // An UPDATE record that needs to clear the bits for both old and the
-                    // new page, both of which reside on the same VM page.
-                    self.put_rel_wal_record(
-                        modification,
-                        vm_rel,
-                        new_vm_blk.unwrap(),
-                        NeonWalRecord::ClearVisibilityMapFlags {
-                            new_heap_blkno,
-                            old_heap_blkno,
-                            flags,
-                        },
-                        ctx,
-                    )
-                    .await?;
-                } else {
-                    // Clear VM bits for one heap page, or for two pages that reside on
-                    // different VM pages.
-                    if let Some(new_vm_blk) = new_vm_blk {
+                if new_vm_blk.is_some() || old_vm_blk.is_some() {
+                    if new_vm_blk == old_vm_blk {
+                        // An UPDATE record that needs to clear the bits for both old and the
+                        // new page, both of which reside on the same VM page.
                         self.put_rel_wal_record(
                             modification,
                             vm_rel,
-                            new_vm_blk,
+                            new_vm_blk.unwrap(),
                             NeonWalRecord::ClearVisibilityMapFlags {
                                 new_heap_blkno,
-                                old_heap_blkno: None,
-                                flags,
-                            },
-                            ctx,
-                        )
-                        .await?;
-                    }
-                    if let Some(old_vm_blk) = old_vm_blk {
-                        self.put_rel_wal_record(
-                            modification,
-                            vm_rel,
-                            old_vm_blk,
-                            NeonWalRecord::ClearVisibilityMapFlags {
-                                new_heap_blkno: None,
                                 old_heap_blkno,
                                 flags,
                             },
                             ctx,
                         )
                         .await?;
+                    } else {
+                        // Clear VM bits for one heap page, or for two pages that reside on
+                        // different VM pages.
+                        if let Some(new_vm_blk) = new_vm_blk {
+                            self.put_rel_wal_record(
+                                modification,
+                                vm_rel,
+                                new_vm_blk,
+                                NeonWalRecord::ClearVisibilityMapFlags {
+                                    new_heap_blkno,
+                                    old_heap_blkno: None,
+                                    flags,
+                                },
+                                ctx,
+                            )
+                            .await?;
+                        }
+                        if let Some(old_vm_blk) = old_vm_blk {
+                            self.put_rel_wal_record(
+                                modification,
+                                vm_rel,
+                                old_vm_blk,
+                                NeonWalRecord::ClearVisibilityMapFlags {
+                                    new_heap_blkno: None,
+                                    old_heap_blkno,
+                                    flags,
+                                },
+                                ctx,
+                            )
+                            .await?;
+                        }
                     }
                 }
             }
+            (Some(_), None) => {
+                let vm_rel = RelTag {
+                    forknum: VISIBILITYMAP_FORKNUM,
+                    spcnode: decoded.blocks[0].rnode_spcnode,
+                    dbnode: decoded.blocks[0].rnode_dbnode,
+                    relnode: decoded.blocks[0].rnode_relnode,
+                };
+
+                let mut new_vm_blk = new_heap_blkno.map(pg_constants::HEAPBLK_TO_MAPBLOCK);
+                let mut old_vm_blk = old_heap_blkno.map(pg_constants::HEAPBLK_TO_MAPBLOCK);
+
+                // Sometimes, Postgres seems to create heap WAL records with the
+                // ALL_VISIBLE_CLEARED flag set, even though the bit in the VM page is
+                // not set. In fact, it's possible that the VM page does not exist at all.
+                // In that case, we don't want to store a record to clear the VM bit;
+                // replaying it would fail to find the previous image of the page, because
+                // it doesn't exist. So check if the VM page(s) exist, and skip the WAL
+                // record if it doesn't.
+                let vm_size = get_relsize(modification, vm_rel, ctx).await?;
+                if let Some(blknum) = new_vm_blk {
+                    if blknum >= vm_size {
+                        new_vm_blk = None;
+                    }
+                }
+                if let Some(blknum) = old_vm_blk {
+                    if blknum >= vm_size {
+                        old_vm_blk = None;
+                    }
+                }
+
+                if new_vm_blk.is_some() || old_vm_blk.is_some() {
+                    if new_vm_blk == old_vm_blk {
+                        // An UPDATE record that needs to clear the bits for both old and the
+                        // new page, both of which reside on the same VM page.
+                        self.put_rel_wal_record(
+                            modification,
+                            vm_rel,
+                            new_vm_blk.unwrap(),
+                            NeonWalRecord::ClearVisibilityMapFlags {
+                                new_heap_blkno,
+                                old_heap_blkno,
+                                flags,
+                            },
+                            ctx,
+                        )
+                        .await?;
+                    } else {
+                        // Clear VM bits for one heap page, or for two pages that reside on
+                        // different VM pages.
+                        if let Some(new_vm_blk) = new_vm_blk {
+                            self.put_rel_wal_record(
+                                modification,
+                                vm_rel,
+                                new_vm_blk,
+                                NeonWalRecord::ClearVisibilityMapFlags {
+                                    new_heap_blkno,
+                                    old_heap_blkno: None,
+                                    flags,
+                                },
+                                ctx,
+                            )
+                            .await?;
+                        }
+                        if let Some(old_vm_blk) = old_vm_blk {
+                            self.put_rel_wal_record(
+                                modification,
+                                vm_rel,
+                                old_vm_blk,
+                                NeonWalRecord::ClearVisibilityMapFlags {
+                                    new_heap_blkno: None,
+                                    old_heap_blkno,
+                                    flags,
+                                },
+                                ctx,
+                            )
+                            .await?;
+                        }
+                    }
+                }
+            }
+            (None, Some(_)) => {
+                let vm_rel = RelTag {
+                    forknum: VISIBILITYMAP_FORKNUM,
+                    spcnode: decoded.blocks[0].rnode_spcnode,
+                    dbnode: decoded.blocks[0].rnode_dbnode,
+                    relnode: decoded.blocks[0].rnode_relnode,
+                };
+
+                let mut new_vm_blk = new_heap_blkno.map(pg_constants::HEAPBLK_TO_MAPBLOCK);
+                let mut old_vm_blk = old_heap_blkno.map(pg_constants::HEAPBLK_TO_MAPBLOCK);
+
+                // Sometimes, Postgres seems to create heap WAL records with the
+                // ALL_VISIBLE_CLEARED flag set, even though the bit in the VM page is
+                // not set. In fact, it's possible that the VM page does not exist at all.
+                // In that case, we don't want to store a record to clear the VM bit;
+                // replaying it would fail to find the previous image of the page, because
+                // it doesn't exist. So check if the VM page(s) exist, and skip the WAL
+                // record if it doesn't.
+                let vm_size = get_relsize(modification, vm_rel, ctx).await?;
+                if let Some(blknum) = new_vm_blk {
+                    if blknum >= vm_size {
+                        new_vm_blk = None;
+                    }
+                }
+                if let Some(blknum) = old_vm_blk {
+                    if blknum >= vm_size {
+                        old_vm_blk = None;
+                    }
+                }
+
+                if new_vm_blk.is_some() || old_vm_blk.is_some() {
+                    if new_vm_blk == old_vm_blk {
+                        // An UPDATE record that needs to clear the bits for both old and the
+                        // new page, both of which reside on the same VM page.
+                        self.put_rel_wal_record(
+                            modification,
+                            vm_rel,
+                            new_vm_blk.unwrap(),
+                            NeonWalRecord::ClearVisibilityMapFlags {
+                                new_heap_blkno,
+                                old_heap_blkno,
+                                flags,
+                            },
+                            ctx,
+                        )
+                        .await?;
+                    } else {
+                        // Clear VM bits for one heap page, or for two pages that reside on
+                        // different VM pages.
+                        if let Some(new_vm_blk) = new_vm_blk {
+                            self.put_rel_wal_record(
+                                modification,
+                                vm_rel,
+                                new_vm_blk,
+                                NeonWalRecord::ClearVisibilityMapFlags {
+                                    new_heap_blkno,
+                                    old_heap_blkno: None,
+                                    flags,
+                                },
+                                ctx,
+                            )
+                            .await?;
+                        }
+                        if let Some(old_vm_blk) = old_vm_blk {
+                            self.put_rel_wal_record(
+                                modification,
+                                vm_rel,
+                                old_vm_blk,
+                                NeonWalRecord::ClearVisibilityMapFlags {
+                                    new_heap_blkno: None,
+                                    old_heap_blkno,
+                                    flags,
+                                },
+                                ctx,
+                            )
+                            .await?;
+                        }
+                    }
+                }
+            }
+            (None, None) => {}
         }
+        if new_heap_blkno.is_some() || old_heap_blkno.is_some() {}
 
         Ok(())
     }