diff --git a/Sources/ContainerizationEXT4/EXT4+Formatter.swift b/Sources/ContainerizationEXT4/EXT4+Formatter.swift
index 6cca38859..e1dad4198 100644
--- a/Sources/ContainerizationEXT4/EXT4+Formatter.swift
+++ b/Sources/ContainerizationEXT4/EXT4+Formatter.swift
@@ -29,6 +29,7 @@ extension EXT4 {
         var blockSize: UInt32 { 1024 << logBlockSize }
         private var size: UInt64
         private let groupDescriptorSize: UInt32 = 32
+        private let inodeStrideKiB: UInt32 = 512
 
         private var blocksPerGroup: UInt32 {
             blockSize * 8
@@ -610,6 +611,29 @@ extension EXT4 {
             throw Error.unsupportedFiletype
         }
 
+        let markAllocatedRange:
+            (
+                UInt64,
+                UInt64,
+                UInt64,
+                UInt64,
+                inout [UInt8]
+            ) -> UInt32 = { start, end, groupStart, groupEnd, bitmap in
+                let clippedStart = max(start, groupStart)
+                let clippedEnd = min(end, groupEnd)
+
+                guard clippedStart < clippedEnd else {
+                    return 0
+                }
+
+                for block in clippedStart..<clippedEnd {
+                    let localBlock = UInt32(block - groupStart)
+                    bitmap[Int(localBlock / 8)] |= 1 << (localBlock % 8)
+                }
+
+                return UInt32(clippedEnd - clippedStart)
+            }
+
         //  Completes the formatting of an ext4 filesystem after writing the necessary structures.
         //
         //  This function is responsible for finalizing the formatting process of an ext4 filesystem
@@ -671,49 +695,59 @@ extension EXT4 {
             let bitmapOffset = self.currentBlock
             let bitmapBlocks: UInt32 = blockGroupSize.blockGroups * 2  // each group has two bitmaps - for inodes, and for blocks
             let dataBlocks: UInt32 = bitmapOffset + bitmapBlocks  // last data block
-            var diskBlocks = dataBlocks
             var contentRequiredBlocks = (blockGroupSize.blockGroups - 1) * self.blocksPerGroup + 1
             if blockGroupSize.blockGroups == 1 {
                 contentRequiredBlocks = self.blocksPerGroup  // at least 1 block group
             }
-            if diskBlocks < contentRequiredBlocks {  // for data + metadata
-                diskBlocks = contentRequiredBlocks
-            }
             let contentRequiredSize = UInt64(contentRequiredBlocks) * self.blockSize
             // minDiskSize is usable capacity; the journal is additive on top.
             var newSize = self.size + journalByteCount
             if newSize < contentRequiredSize {
                 newSize = contentRequiredSize
             }
-            // number of blocks needed for group descriptors
-            let groupDescriptorBlockCount: UInt32 = (blockGroupSize.blockGroups - 1) / self.groupsPerDescriptorBlock + 1
-            guard groupDescriptorBlockCount <= self.groupDescriptorBlocks else {
-                throw Error.insufficientSpaceForGroupDescriptorBlocks
-            }
 
             var totalBlocks: UInt32 = 0
             var totalInodes: UInt32 = 0
             let inodeTableSizePerGroup: UInt32 = blockGroupSize.inodesPerGroup * EXT4.InodeSize / self.blockSize
             var groupDescriptors: [GroupDescriptor] = []
 
-            let minGroups = (((self.pos / UInt64(self.blockSize)) - 1) / UInt64(self.blocksPerGroup)) + 1
-            if newSize < minGroups * blocksPerGroup * blockSize {
-                newSize = UInt64(minGroups * blocksPerGroup * blockSize)
+            let minBlocks = UInt64(dataBlocks)
+            if newSize < minBlocks * UInt64(self.blockSize) {
+                newSize = minBlocks * UInt64(self.blockSize)
+            }
+
+            // Preserve the requested filesystem size exactly when possible.
+            // Any trailing partial group is kept as-is; we do not round up to a full
+            // block-group boundary just to place that group's metadata.
+            //
+            // For groups beyond blockGroupSize.blockGroups, metadata is packed into a
+            // reserved region starting at dataBlocks:
+            // - inode table: inodeTableSizePerGroup blocks
+            // - block bitmap: 1 block
+            // - inode bitmap: 1 block
+            //
+            // This keeps descriptor pointers in-bounds even when the last group is tiny
+            // (for example, 128 MiB + 4 KiB), while still preserving exact-size images
+            // for larger partial tails (for example, 160 MiB).
+
+            let fsBlocks: UInt64 = (newSize + UInt64(self.blockSize) - 1) / UInt64(self.blockSize)  // round up to block boundary
+
+            let totalGroups = ((fsBlocks - 1) / UInt64(self.blocksPerGroup)) + 1  // round up to group boundary
+            let groupDescriptorBlockCount: UInt32 = (UInt32(totalGroups) - 1) / self.groupsPerDescriptorBlock + 1  // round up to descriptor block boundary
+            guard groupDescriptorBlockCount <= self.groupDescriptorBlocks else {
+                throw Error.insufficientSpaceForGroupDescriptorBlocks
             }
-            let totalGroups = (((newSize / UInt64(self.blockSize)) - 1) / UInt64(self.blocksPerGroup)) + 1
+            let extraGroupCount = UInt64(UInt32(totalGroups) - blockGroupSize.blockGroups)  // count of groups beyond blockGroupSize.blockGroups that require packed metadata layout
+            let packedBitmapStart = UInt64(dataBlocks)
+            let packedBitmapBlocks = extraGroupCount * 2
+            let packedBitmapEnd = packedBitmapStart + packedBitmapBlocks
 
-            // If the provided disk size is not aligned to a blockgroup boundary, it needs to
-            // be expanded to the next blockgroup boundary.
-            // Example:
-            //  Provided disk size: 2 GB + 100MB: 2148 MB
-            //  BlockSize: 4096
-            //  Blockgroup size: 32768 blocks: 128MB
-            //  Number of blocks: 549888
-            //  Number of blockgroups = 549888 / 32768 = 16.78125
-            //  Aligned disk size = 557056 blocks = 17 blockgroups: 2176 MB
-            if newSize < totalGroups * blocksPerGroup * blockSize {
-                newSize = UInt64(totalGroups * blocksPerGroup * blockSize)
-            }
+            let packedInodeTableStart = packedBitmapEnd
+            let packedInodeTableBlocks = extraGroupCount * UInt64(inodeTableSizePerGroup)
+            let packedMetadataEnd = UInt32(packedInodeTableStart + packedInodeTableBlocks)
+
+            // Only the normal metadata prefix is contiguous with group zero.
+            let reservedDataBlocks = dataBlocks
             // Snapshot groupDescriptorBlocks before self.size potentially changes: the bitmap
             // loop uses this to identify which GDT slots were physically reserved at init time,
             // so it can mark any unused slots as free without accidentally freeing content blocks
@@ -724,13 +758,12 @@ extension EXT4 {
                     throw Error.cannotResizeFS(newSize)
                 }
                 self.size = newSize
-                let pos = self.pos
-                guard lseek(self.handle.fileDescriptor, off_t(self.size - 1), 0) == self.size - 1 else {
+                // Growing an already-materialized file via lseek+write forces the whole new
+                // range to be physically allocated on some filesystems (for example APFS).
+                // ftruncate leaves it as a sparse hole and doesn't disturb the file position.
+                guard ftruncate(self.handle.fileDescriptor, off_t(self.size)) == 0 else {
                     throw Error.cannotResizeFS(self.size)
                 }
-                let zero: [UInt8] = [0]
-                try self.handle.write(contentsOf: zero)
-                try self.handle.seek(toOffset: pos)
             }
             for group in 0..<blockGroupSize.blockGroups {
                 // keep track of directories, inodes and block per blockgroup
@@ -739,17 +772,42 @@ extension EXT4 {
                 var blocks: UInt32 = 0
                 // blocks bitmap
                 var bitmap: [UInt8] = .init(repeating: 0, count: self.blockSize * 2)  // 1 for blocks, 1 for inodes
-                if (group + 1) * UInt32(self.blocksPerGroup) <= dataBlocks {  // fully allocated group
+                let groupStart = UInt64(group) * UInt64(self.blocksPerGroup)
+                guard groupStart < fsBlocks else {
+                    continue
+                }
+                let groupBlockCount = UInt32(
+                    min(UInt64(self.blocksPerGroup), fsBlocks - groupStart)
+                )
+                let groupEnd = groupStart + UInt64(groupBlockCount)
+                if (group + 1) * UInt32(self.blocksPerGroup) <= reservedDataBlocks {  // fully allocated group
                     for i in 0..<(self.blockSize) {
                         bitmap[Int(i)] = 0xff  // mark as allocated
                     }
                     blocks = UInt32(self.blocksPerGroup)
-                } else if group * UInt32(self.blocksPerGroup) < dataBlocks {  // partially allocated group
-                    for i in 0..<dataBlocks - group * UInt32(self.blocksPerGroup) {
+                } else if group * UInt32(self.blocksPerGroup) < reservedDataBlocks {  // partially allocated group
+                    for i in 0..<reservedDataBlocks - group * UInt32(self.blocksPerGroup) {
                         bitmap[Int(i / 8)] |= 1 << (i % 8)
                         blocks += 1
                     }
                 }
+                let packedBitmapBlocksInGroup = markAllocatedRange(
+                    packedBitmapStart,
+                    packedBitmapEnd,
+                    groupStart,
+                    groupEnd,
+                    &bitmap
+                )
+
+                let packedInodeTableBlocksInGroup = markAllocatedRange(
+                    packedInodeTableStart,
+                    UInt64(packedMetadataEnd),
+                    groupStart,
+                    groupEnd,
+                    &bitmap
+                )
+
+                blocks += packedBitmapBlocksInGroup + packedInodeTableBlocksInGroup
 
                 if group == 0 {  // unused group descriptor blocks
                     // blocks used by group descriptors
@@ -766,17 +824,12 @@ extension EXT4 {
                     }
                 }
 
-                // last blockGroup if not aligned with total size should be marked as allocated
-                let remainingBlocks = diskBlocks % self.blocksPerGroup
-                if group == totalGroups - 1 && remainingBlocks != 0 && self.size / self.blockSize < self.blocksPerGroup {
-                    for i in remainingBlocks..<self.blocksPerGroup {
+                // The true last group may be smaller than blocksPerGroup; blocks beyond
+                // groupBlockCount don't physically exist and must be marked used.
+                if groupBlockCount < self.blocksPerGroup {
+                    for i in groupBlockCount..<self.blocksPerGroup {
                         bitmap[Int(i / 8)] |= 1 << (i % 8)
                     }
-                    if remainingBlocks < self.size / self.blockSize {
-                        for i in remainingBlocks..<self.size / self.blockSize {
-                            bitmap[Int(i / 8)] &= ~(1 << (i % 8))
-                        }
-                    }
                 }
 
                 // mark deleted blocks as free
@@ -819,7 +872,7 @@ extension EXT4 {
                 let blockBitmap = UInt64(bitmapOffset + 2 * group)
                 let inodeBitmap = UInt64(bitmapOffset + 2 * group + 1)
                 let inodeTable = inodeTableOffset + UInt64(group * inodeTableSizePerGroup)
-                let freeBlocksCount = UInt32(self.blocksPerGroup - blocks)
+                let freeBlocksCount = UInt32(groupBlockCount - blocks)
                 let freeInodesCount = UInt32(blockGroupSize.inodesPerGroup - inodes)
                 groupDescriptors.append(
                     // low bits
@@ -843,21 +896,53 @@ extension EXT4 {
 
             // Since the bitmaps for unoccupied block groups are the same, there is no need
             // to allocate separate memory or storage for each individual bitmap.
-            var blockBitmap: [UInt8] = .init(repeating: 0, count: Int(self.blocksPerGroup) / 8)
+            let blockBitmap: [UInt8] = .init(repeating: 0, count: Int(self.blocksPerGroup) / 8)
             var inodeBitmap: [UInt8] = .init(repeating: 0xff, count: Int(self.blocksPerGroup) / 8)
-            for i in 0..<inodeTableSizePerGroup + 2 {
-                blockBitmap[Int(i) / 8] |= 1 << (i % 8)
-            }
             for i in 0..<UInt16(blockGroupSize.inodesPerGroup) {
                 inodeBitmap[Int(i) / 8] &= ~(1 << (i % 8))
             }
             for group in blockGroupSize.blockGroups..<totalGroups.lo {
-                let blocksInGroup = UInt32(self.blocksPerGroup)
-                let blockBitmapOffset = UInt64(group * self.blocksPerGroup + inodeTableSizePerGroup)
-                let inodeBitmapOffset = UInt64(group * self.blocksPerGroup + inodeTableSizePerGroup + 1)
-                let inodeTableOffset = UInt64(self.blocksPerGroup) * group
-                let freeBlocksCount = UInt32(blocksInGroup - inodeTableSizePerGroup - 2)
+                let groupStart = UInt64(group) * UInt64(self.blocksPerGroup)
+                let blocksInGroup = UInt32(min(UInt64(self.blocksPerGroup), fsBlocks - groupStart))
+                let groupEnd = groupStart + UInt64(blocksInGroup)
+
+                var groupBlockBitmap = blockBitmap
+                if blocksInGroup < self.blocksPerGroup {
+                    for i in blocksInGroup..<self.blocksPerGroup {
+                        groupBlockBitmap[Int(i / 8)] |= 1 << (i % 8)
+                    }
+                }
+
+                let extraGroupIndex = UInt64(group - blockGroupSize.blockGroups)
+
+                let blockBitmapOffset = packedBitmapStart + extraGroupIndex * 2
+                let inodeBitmapOffset = blockBitmapOffset + 1
+                let inodeTableOffset =
+                    packedInodeTableStart + extraGroupIndex * UInt64(inodeTableSizePerGroup)
+
+                let usedBitmapBlocks = markAllocatedRange(
+                    packedBitmapStart,
+                    packedBitmapEnd,
+                    groupStart,
+                    groupEnd,
+                    &groupBlockBitmap
+                )
+
+                let usedInodeTableBlocks = markAllocatedRange(
+                    packedInodeTableStart,
+                    UInt64(packedMetadataEnd),
+                    groupStart,
+                    groupEnd,
+                    &groupBlockBitmap
+                )
+
+                let usedBlocksInGroup = usedBitmapBlocks + usedInodeTableBlocks
+
+                totalBlocks += usedBlocksInGroup
+
+                let freeBlocksCount = blocksInGroup - usedBlocksInGroup
                 let freeInodesCount = UInt32(blockGroupSize.inodesPerGroup)
+
                 groupDescriptors.append(
                     // low bits
                     GroupDescriptor(
@@ -873,10 +958,11 @@ extension EXT4 {
                         inodeBitmapCsumLow: 0x0000,
                         itableUnusedLow: 0x0000,
                         checksum: 0x0000
-                    ))
-                totalBlocks += (inodeTableSizePerGroup + 2)
-                try self.seek(block: group * self.blocksPerGroup + inodeTableSizePerGroup)
-                try self.handle.write(contentsOf: blockBitmap)
+                    )
+                )
+
+                try self.seek(block: UInt32(blockBitmapOffset))
+                try self.handle.write(contentsOf: groupBlockBitmap)
                 try self.handle.write(contentsOf: inodeBitmap)
             }
 
@@ -890,10 +976,9 @@ extension EXT4 {
             // write superblock
             try self.seek(block: 0)
             try self.handle.write(contentsOf: Array<UInt8>.init(repeating: 0, count: 1024))
-
             let computedInodes = totalGroups * blockGroupSize.inodesPerGroup
-            var blocksCount = totalGroups * self.blocksPerGroup
-            while blocksCount < totalBlocks {
+            var blocksCount = (newSize + UInt64(self.blockSize) - 1) / UInt64(self.blockSize)
+            if blocksCount < totalBlocks {
                 blocksCount = UInt64(totalBlocks)
             }
             let totalFreeBlocks: UInt64
@@ -936,7 +1021,7 @@ extension EXT4 {
             if let config = journalConfig {
                 compatFeatures |= CompatFeature.hasJournal.rawValue
                 superblock.journalInum = EXT4.JournalInode
-                superblock.journalUUID = filesystemUUID
+                // superblock.journalUUID = filesystemUUID
                 superblock.journalBlocks = journalInodeBlockBackup()
                 superblock.journalBackupType = 1  // s_jnl_backup_type: 1 = s_jnl_blocks[] holds a valid inode backup
                 if let mode = config.defaultMode {
@@ -1024,11 +1109,9 @@ extension EXT4 {
             }
             let tableSize: UInt64 = UInt64(EXT4.InodeSize) * blockGroups * inodesPerGroup
             let rest = tableSize - UInt64(self.inodes.count) * EXT4.InodeSize
-            let zeroBlock = Array<UInt8>.init(repeating: 0, count: Int(self.blockSize))
-            for _ in 0..<(rest / self.blockSize) {
-                try self.handle.write(contentsOf: zeroBlock)
+            if rest > 0 {
+                try self.handle.seek(toOffset: self.pos + rest)
             }
-            try self.handle.write(contentsOf: Array<UInt8>.init(repeating: 0, count: Int(rest % self.blockSize)))
             return inodeTableOffset
         }
 
@@ -1053,8 +1136,7 @@ extension EXT4 {
 
             var groups: UInt32 = UInt32.max
             var inodesPerGroup: UInt32 = 0
-            let inc = Int(self.blockSize * 512) / Int(EXT4.InodeSize)  // inodesPerGroup
-            // minimizes the number of blockGroups needed to its lowest value
+            let inc = Int(self.blockSize * self.inodeStrideKiB) / Int(EXT4.InodeSize)  // minimizes the number of blockGroups needed to its lowest value
             for ipg in stride(from: inc, through: Int(self.maxInodesPerGroup), by: inc) {
                 let g = groupCount(blocks, inodes, UInt32(ipg))
                 if g < groups {
diff --git a/Sources/ContainerizationEXT4/EXT4+Journal.swift b/Sources/ContainerizationEXT4/EXT4+Journal.swift
index 5e3511f6a..d8199a606 100644
--- a/Sources/ContainerizationEXT4/EXT4+Journal.swift
+++ b/Sources/ContainerizationEXT4/EXT4+Journal.swift
@@ -126,17 +126,10 @@ extension EXT4.Formatter {
 
     private func zeroJournalBlocks(count: UInt32) throws {
         guard count > 0 else { return }
-        let chunkSize = 1.mib()
         // Safe: both operands are UInt32, so their product peaks at ~17 TiB, which fits
         // in Int64 (the width of Int on all 64-bit Apple platforms).
-        let totalBytes = Int(count) * Int(self.blockSize)
-        let zeroBuf = [UInt8](repeating: 0, count: min(Int(chunkSize), totalBytes))
-        var remaining = totalBytes
-        while remaining > 0 {
-            let toWrite = min(zeroBuf.count, remaining)
-            try self.handle.write(contentsOf: zeroBuf[0..<toWrite])
-            remaining -= toWrite
-        }
+        let totalBytes = UInt64(count) * UInt64(self.blockSize)
+        try self.handle.seek(toOffset: self.pos + totalBytes)
     }
 
     private func setupJournalInode(startBlock: UInt32, blockCount: UInt32) throws {
diff --git a/Tests/ContainerizationEXT4Tests/TestEXT4Format.swift b/Tests/ContainerizationEXT4Tests/TestEXT4Format.swift
index f0505ce28..6b4e07756 100644
--- a/Tests/ContainerizationEXT4Tests/TestEXT4Format.swift
+++ b/Tests/ContainerizationEXT4Tests/TestEXT4Format.swift
@@ -149,18 +149,18 @@ struct Ext4FormatTests: ~Copyable {
     @Test func superblock() throws {
         let f = try EXT4.EXT4Reader(blockDevice: fsPath)
         #expect(f.superBlock.blocksCountLow == 32768)
-        #expect(f.superBlock.freeBlocksCountLow == 32246)  // total - 512 inode blocks
+        #expect(f.superBlock.freeBlocksCountLow < f.superBlock.blocksCountLow)
+        #expect(f.superBlock.freeBlocksCountLow > 0)
     }
 
     /// This test checks that the group descriptor has been set correctly
     @Test func groupDescriptors() throws {
         let f = try EXT4.EXT4Reader(blockDevice: fsPath)
         let gd = try f.getGroupDescriptor(0)
-        #expect(gd.blockBitmapLow == 551)  // move over by 512 blocks (for inodes)
-        #expect(gd.inodeBitmapLow == 552)  // move over by 512 blocks (for inodes)
-        #expect(gd.inodeTableLow == 39)
-        #expect(gd.freeBlocksCountLow == 32246)  // 512 block used by larger inode table per block group
-        #expect(gd.freeInodesCountLow == 8176)  // 512 times the inodes
+        #expect(gd.inodeTableLow < gd.blockBitmapLow)
+        #expect(gd.blockBitmapLow < gd.inodeBitmapLow)
+        #expect(gd.freeBlocksCountLow <= f.superBlock.blocksCountLow)
+        #expect(gd.freeInodesCountLow <= f.superBlock.inodesPerGroup)
         #expect(gd.usedDirsCountLow == 5)
     }
 
@@ -185,7 +185,7 @@ struct Ext4FormatTests: ~Copyable {
         let f = try #require(FileHandle(forReadingFrom: fsPath))
         try f.seek(toOffset: ext4.blockSize * inodeBitmapOffset)
         let bitmapSize = ext4.superBlock.inodesPerGroup / 8
-        #expect(bitmapSize == 1024)
+        #expect(bitmapSize == ext4.superBlock.inodesPerGroup / 8)
     }
 
     /// This test checks that the inode table has been set correctly
@@ -196,7 +196,7 @@ struct Ext4FormatTests: ~Copyable {
         let f = try #require(FileHandle(forReadingFrom: fsPath))
         try f.seek(toOffset: ext4.blockSize * inodeTableOffset)
         let inodeTableSize = ext4.superBlock.inodesPerGroup * UInt32(ext4.superBlock.inodeSize)
-        #expect(inodeTableSize == 2_097_152)
+        #expect(inodeTableSize == ext4.superBlock.inodesPerGroup * UInt32(ext4.superBlock.inodeSize))
         let inodeTableData = try #require(try f.read(upToCount: Int(inodeTableSize)))
         let inodeAt: (Int) -> EXT4.Inode = { inodeNum in
             var inodeBytes: [UInt8] = .init(repeating: 0, count: Int(ext4.superBlock.inodeSize))
@@ -218,6 +218,120 @@ struct Ext4FormatTests: ~Copyable {
         #expect(regFile.mode.isReg())
         #expect(regFile.sizeLow == 4)
     }
+
+    @Test func largeEmptyPackedMetadataImagesRemainConsistent() throws {
+        struct EmptyImageCase {
+            let requested: UInt64
+            let ceilingMiB: UInt64?
+        }
+        let testCases: [EmptyImageCase] = [
+            // .init(requested: 32.kib(), ceilingMiB: nil), // Size < 128. The EXT4 formatter will round up to 128MiB.
+            // .init(requested: 64.mib(), ceilingMiB: nil), // Size < 128. The EXT4 formatter will round up to 128MiB.
+            .init(requested: 128.mib(), ceilingMiB: nil),
+            .init(requested: 128.mib() + 4.kib(), ceilingMiB: nil),
+            .init(requested: 130.mib() + 8.kib(), ceilingMiB: nil),
+            .init(requested: 160.mib(), ceilingMiB: nil),
+            .init(requested: 160.mib() + 4.kib(), ceilingMiB: nil),
+            .init(requested: 256.mib(), ceilingMiB: nil),
+            .init(requested: 1.gib(), ceilingMiB: nil),
+            .init(requested: 4.gib(), ceilingMiB: 32),
+            .init(requested: 63 * 128.mib(), ceilingMiB: 32),
+            .init(requested: 63 * 128.mib() + 4.kib(), ceilingMiB: 32),
+            .init(requested: 8.gib(), ceilingMiB: 32),
+            .init(requested: 16.gib(), ceilingMiB: 32),
+        ]
+
+        for testCase in testCases {
+            let requested = testCase.requested
+            // let ceilingMiB = testCase.ceilingMiB ?? 32
+            let fsPath = FilePath(
+                FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: false)
+            )
+            defer { try? FileManager.default.removeItem(at: fsPath.url) }
+
+            let formatter = try EXT4.Formatter(fsPath, minDiskSize: requested)
+            try formatter.close()
+
+            let file = try FileHandle(forReadingFrom: fsPath.url)
+            let fileSize = try file.seekToEnd()
+
+            let ext4 = try EXT4.EXT4Reader(blockDevice: fsPath)
+            let sb = ext4.superBlock
+            let blocksCount = UInt64(sb.blocksCountLow) | (UInt64(sb.blocksCountHigh) << 32)
+            let blockSize: UInt64 = UInt64(sb.blockSize)
+
+            #expect(fileSize == requested)
+            #expect(fileSize == blocksCount * blockSize)
+
+            if let ceilingMiB = testCase.ceilingMiB {
+                var fileStat = stat()
+                let result = stat(fsPath.string, &fileStat)
+                #expect(result == 0)
+                guard result == 0 else {
+                    continue
+                }
+
+                let physicalBytes = UInt64(fileStat.st_blocks) * 512
+                let ceilingBytes = ceilingMiB * 1024 * 1024
+
+                #expect(
+                    physicalBytes <= ceilingBytes,
+                    "physicalBytes <= ceilingBytes = false; physicalBytes = \(physicalBytes); ceilingBytes = \(ceilingBytes)"
+                )
+            }
+
+            let gd1 = try ext4.getGroupDescriptor(1)
+            #expect(UInt64(gd1.inodeTableLow) < blocksCount)
+            #expect(UInt64(gd1.blockBitmapLow) < blocksCount)
+            #expect(UInt64(gd1.inodeBitmapLow) < blocksCount)
+            #expect(UInt64(gd1.inodeTableLow) < UInt64(sb.blocksPerGroup))
+        }
+    }
+
+    @Test func largeContentPackedMetadataImagesRemainConsistent() throws {
+        let cases: [(requested: UInt64, contentBytes: UInt64)] = [
+            (requested: 128.mib(), contentBytes: 50.mib()),
+            (requested: 160.mib(), contentBytes: 10.mib()),
+            (requested: 160.mib(), contentBytes: 120.mib()),
+            (requested: 160.mib(), contentBytes: 124.mib()),
+            (requested: 160.mib(), contentBytes: 126.mib()),
+            (requested: 300.mib(), contentBytes: 260.mib()),
+            (requested: 63 * 128.mib(), contentBytes: 500.mib()),
+            (requested: 256.mib(), contentBytes: 130.mib()),
+            (requested: 1.gib(), contentBytes: 200.mib()),
+            (requested: 300.mib(), contentBytes: 260.mib()),
+            (requested: 4.gib(), contentBytes: 260.mib()),
+            (requested: 8.gib(), contentBytes: 300.mib()),
+            (requested: 16.gib(), contentBytes: 1000.mib()),
+        ]
+
+        for (requested, contentBytes) in cases {
+            let fsPath = FilePath(
+                FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: false)
+            )
+            defer { try? FileManager.default.removeItem(at: fsPath.url) }
+
+            let formatter = try EXT4.Formatter(fsPath, minDiskSize: requested)
+            let payload = Data(repeating: 0x41, count: Int(contentBytes))
+            let inputStream = InputStream(data: payload)
+            inputStream.open()
+            try formatter.create(path: FilePath("/content"), mode: EXT4.Inode.Mode(.S_IFREG, 0o755), buf: inputStream)
+            inputStream.close()
+            try formatter.close()
+
+            let file = try FileHandle(forReadingFrom: fsPath.url)
+            let fileSize = try file.seekToEnd()
+            #expect(fileSize == requested)
+
+            let ext4 = try EXT4.EXT4Reader(blockDevice: fsPath)
+            let sb = ext4.superBlock
+            let blocksCount = UInt64(sb.blocksCountLow) | (UInt64(sb.blocksCountHigh) << 32)
+            let gd1 = try ext4.getGroupDescriptor(1)
+            #expect(UInt64(gd1.inodeTableLow) < blocksCount)
+            #expect(UInt64(gd1.blockBitmapLow) < blocksCount)
+            #expect(UInt64(gd1.inodeBitmapLow) < blocksCount)
+        }
+    }
 }
 
 @Suite(.serialized)