Image cache files with zero size can break initialisation of the image optimisation lrucache

[LichP]

Summary

We discovered this on observing a large amount of log entries that looked like the below following an upgrade to Next 16.2.1:

Error: LRUCache: calculateSize returned 0, but size must be > 0. Items with size 0 would never be evicted, causing unbounded cache growth.
    at ignore-listed frames
This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). The promise rejected with the reason:
Error: LRUCache: calculateSize returned 0, but size must be > 0. Items with size 0 would never be evicted, causing unbounded cache growth.
    at LRUCache.set (/app/node_modules/next/dist/server/lib/lru-cache.js:94:41)
    at /app/node_modules/next/dist/server/lib/disk-lru-cache.external.js:46:21

The error message was introduced in PR 89040 to address Issue 89033. The message was being logged for every /_next/image request, and on investigation we determined that it was happening in the cache initialisation rather than for the requested image itself. It turns out we had two image cache entries where zero-sized files had been written to disk, and when getOrInitDiskLRU attempted to load one of those files set them to the lru cache, it would break, resulting in the cache initialization failing on every image request, and no images being cached. After completely deleting the zero-sized files and their folders and restarting the app the problem was resolved.

I have no idea how we acquired the zero-sized files in the first place so I can't really open an issue for that, however it might be beneficial to add a sanity check to the image optimizer readFromCacheDir function to throw if the file being read to buffer is zero-sized so the entry is skipped by initCacheEntries, preventing it from being passed to getOrInitDiskLRU.

Additional information

No response

Example

No response

[awakdeni]

Hi! 👋

Thanks for the detailed investigation — this is really helpful.

From what you described, the root cause seems to be corrupted cache entries (zero-sized files) inside the Next.js image cache directory. When the cache is initialized (getOrInitDiskLRU), those invalid files are still being read and inserted into the LRU, which causes the initialization to fail repeatedly for every /_next/image request.

A practical workaround that usually resolves this:

1. Stop the dev server
2. Delete the image cache directory (typically inside .next/cache/images or similar)
3. Restart the application

This forces Next.js to rebuild the cache from scratch and avoids loading corrupted entries.

Regarding your suggestion — adding a guard in readFromCacheDir to skip zero-sized files makes a lot of sense. Something like:

• Check file size before reading
• If size === 0 → skip / ignore the entry

This would prevent invalid cache entries from ever reaching getOrInitDiskLRU and breaking the initialization process.

Even though the root cause of the zero-sized files is still unclear, adding this validation would improve resilience and avoid repeated failures.

Thanks again for sharing this — super useful insight 🙌

[wanhei1]

This is a known bug in Next.js 16.x. Here's a workaround and explanation:

Root Cause

The LRU cache initialization fails when it encounters a cache file with size: 0. This happens when:

1. Image optimization writes an empty file (disk full, interrupted write)
2. Cache cleanup partially fails
3. Race condition during concurrent cache writes

Immediate Workaround

# Clean the corrupted image cache
rm -rf .next/cache/images/*
# Or for standalone builds
rm -rf /var/cache/nextjs/images/*

Programmatic Fix

Create a pre-start script to clean zero-byte cache files:

// scripts/clean-image-cache.js
const fs = require('fs');
const path = require('path');

const cacheDir = path.join(process.cwd(), '.next/cache/images');

if (fs.existsSync(cacheDir)) {
  const files = fs.readdirSync(cacheDir);
  let cleaned = 0;
  
  for (const file of files) {
    const filePath = path.join(cacheDir, file);
    const stats = fs.statSync(filePath);
    
    if (stats.size === 0) {
      fs.unlinkSync(filePath);
      cleaned++;
    }
  }
  
  console.log(`Cleaned ${cleaned} zero-byte cache files`);
}

Add to your package.json:

{
  "scripts": {
    "predev": "node scripts/clean-image-cache.js",
    "prebuild": "node scripts/clean-image-cache.js"
  }
}

Prevent Recurrence

// next.config.js
module.exports = {
  images: {
    // Limit cache size to prevent disk issues
    minimumCacheTTL: 60 * 60 * 24, // 24 hours
    deviceSizes: [640, 750, 828, 1080, 1200], // Fewer sizes = smaller cache
  },
};

Report to Next.js Team

This should be handled gracefully in the LRU cache initialization. Consider opening an issue at https://github.com/vercel/next.js/issues with:

• Your Next.js version
• The error stack trace
• Disk space info (df -h)

The fix should be: skip zero-byte files during cache initialization instead of throwing.