jskelet 0.6.2 → 0.6.4

package/src/server/html-cache.js

@@ -26,8 +26,8 @@
  * (L1) **birincil kalır**: `read()` senkron, sıkıştırılmış gövdeler girdiyle
  * birlikte ve tutarlılık makinesi (`tokens`, `purgedDeps`) tek proseste. Redis
  * yalnızca L1'de bulunmayan bir yol için render'ı atlatır ve invalidation'ı
- * diğer node'lara duyurur. Redis erişilemez olduğunda bu modül birebir eskisi
- * gibi çalışır.
+ * diğer node'lara duyurur. Redis yoksa aynı kayıt `.jskelet/cache/<buildId>/`
+ * altına yazılır; bu tek makinenin yeniden açılışını karşılar, kümeyi değil.
  */
 
 import { getConfig } from "../config/index.js";
@@ -38,6 +38,7 @@ import {
 import { collectDependencies } from "./cache-deps.js";
 import { compilePattern, matchPattern } from "../config/pattern.js";
 import { pathOfCacheKey, publicHost } from "./cache-vary.js";
+import { diskDrop, diskDropMatching, diskGetJson, diskSetJson, diskShares } from "./disk-cache.js";
 import {
   cacheKey,
   onCacheEvent,
@@ -118,6 +119,13 @@ const EARLY_REFRESH_MIN_MS = 250;
 /** Trafiksiz girdileri erken pencerede soft-bayatlatma aralığı. */
 const EARLY_SWEEP_INTERVAL_MS = 1000;
 
+/**
+ * Bir sweep turunda soft-bayatlatılan girdi tavanı. Aynı TTL'i paylaşan
+ * yüzlerce sayfa tek saniyede kuyruğa girip render dalgası yaratmasın;
+ * kalanlar sonraki turlara kalır. Öncelik `expiresAt`'i en yakın olan.
+ */
+const EARLY_SWEEP_MARK_BUDGET = 4;
+
 /** @type {Map<string, HtmlEntry>} */
 const store = new Map();
 
@@ -354,7 +362,9 @@ function read(key) {
  * @param {HtmlEntry} entry
  */
 function share(key, entry) {
-  if (!redisShares("html")) return;
+  const onRedis = redisShares("html");
+  const onDisk = diskShares("html");
+  if (!onRedis && !onDisk) return;
 
   const ttlMs = entry.staleUntil - Date.now();
   if (ttlMs <= 0) return;
@@ -370,7 +380,7 @@ function share(key, entry) {
     deps: [...entry.deps],
   };
 
-  if (redisSharesEncoded() && entry.encoded.size) {
+  if (onRedis && redisSharesEncoded() && entry.encoded.size) {
     /** @type {Record<string, string>} */
     const encoded = {};
     for (const [encoding, buffer] of entry.encoded) {
@@ -380,7 +390,8 @@ function share(key, entry) {
     entry.sharedEncodings = entry.encoded.size;
   }
 
-  redisSetJson(cacheKey("html", key), payload, ttlMs);
+  if (onRedis) redisSetJson(cacheKey("html", key), payload, ttlMs);
+  else diskSetJson("html", key, payload);
 }
 
 /**
@@ -394,11 +405,17 @@ function share(key, entry) {
  * @returns {Promise<HtmlEntry | null>}
  */
 async function readShared(key) {
-  if (!redisShares("html")) return null;
+  const onRedis = redisShares("html");
+  const onDisk = diskShares("html");
+  if (!onRedis && !onDisk) return null;
 
-  const payload = await redisGetJson(cacheKey("html", key));
+  const payload = onRedis
+    ? await redisGetJson(cacheKey("html", key))
+    : await diskGetJson("html", key);
   if (!payload || typeof payload.html !== "string") return null;
   if (typeof payload.expiresAt !== "number" || Date.now() >= payload.expiresAt) {
+    // Dosyanın TTL'i yok; süresi dolmuş kopya okununca silinir.
+    if (onDisk) diskDrop("html", [key]);
     return null;
   }
 
@@ -418,6 +435,14 @@ async function readShared(key) {
         encoded.set(encoding, Buffer.from(base64, "base64"));
       }
     }
+    // Eski bir replica iki kodlama yazmış olabilir. L1 tek kopya tutar;
+    // brotli varsa o kalır.
+    if (encoded.size > 1) {
+      const keep = encoded.has("br") ? "br" : encoded.keys().next().value;
+      const buffer = keep ? encoded.get(keep) : undefined;
+      encoded.clear();
+      if (keep && buffer) encoded.set(keep, buffer);
+    }
   }
 
   return {
@@ -665,6 +690,7 @@ export function clearHtmlCache() {
   clearLocal();
 
   if (redisShares("html")) void redisDropMatching("html");
+  else if (diskShares("html")) void diskDropMatching("html");
   publishCacheEvent({ type: "html:clear" });
 }
 
@@ -767,12 +793,12 @@ export function invalidateHtmlCache(target, options = {}) {
   // webhook binlerce anahtarı birden düşürüyor. Silmenin bedeli, o yolu hiç
   // görmemiş bir node'un bir kez render etmesi; L1'i sıcak olan node'lar eski
   // HTML'i bayat pencerede servis etmeye devam ediyor.
-  if (redisShares("html")) {
+  if (redisShares("html") || diskShares("html")) {
     const matchers = compileMatchers(targets);
     if (matchers.length) {
-      void redisDropMatching("html", (key) =>
-        matchers.some((matcher) => matcher(pathOf(key))),
-      );
+      const match = (key) => matchers.some((matcher) => matcher(pathOf(key)));
+      if (redisShares("html")) void redisDropMatching("html", match);
+      else void diskDropMatching("html", match);
     }
   }
 
@@ -926,6 +952,8 @@ export function invalidateHtmlByDependency(dataKeys) {
   // kopyası TTL'ini bekler.
   if (keys.size && redisShares("html")) {
     redisDrop([...keys].map((key) => cacheKey("html", key)));
+  } else if (keys.size && diskShares("html")) {
+    diskDrop("html", [...keys]);
   }
 
   return keys.size;
@@ -946,6 +974,7 @@ export function dropHtmlCacheKey(key) {
   const existed = dropLocalKey(key);
 
   if (redisShares("html")) redisDrop([cacheKey("html", key)]);
+  else if (diskShares("html")) diskDrop("html", [key]);
   publishCacheEvent({ type: "html:drop", key });
 
   return existed;
@@ -997,19 +1026,19 @@ function pathWithQuery(key) {
  * açılmaz.
  *
  * @param {string} [onlyHost]
- * @returns {{ path: string, host: string }[]}
+ * @returns {{ key: string, path: string, host: string }[]}
  */
 export function takeInvalidatedTargets(onlyHost) {
   if (!invalidated.size) return [];
 
-  /** @type {{ path: string, host: string }[]} */
+  /** @type {{ key: string, path: string, host: string }[]} */
   const taken = [];
 
   for (const key of [...invalidated]) {
     const host = hostOfCacheKey(key);
     if (onlyHost && host && host !== onlyHost) continue;
     invalidated.delete(key);
-    taken.push({ path: pathWithQuery(key), host });
+    taken.push({ key, path: pathWithQuery(key), host });
   }
 
   return taken;
@@ -1082,25 +1111,70 @@ export function isHtmlCacheFresh(pathname, req) {
   return false;
 }
 
+/**
+ * Bu anahtarın girdisi hâlâ taze mi? Süre dolumu ısıtması anahtarı bildiği
+ * için yol taraması yapmaz. Soft-bayat (`expiresAt === 0`) taze sayılmaz:
+ * ziyaretçi arada yenilediyse yeni `expiresAt` taze döner ve HTTP atlanır.
+ *
+ * @param {string} key
+ * @returns {boolean}
+ */
+export function isHtmlCacheKeyFresh(key) {
+  const entry = store.get(key);
+  if (!entry) return false;
+  return Date.now() < entry.expiresAt;
+}
+
+/**
+ * Girdide en fazla bir sıkıştırılmış gövde durur. Yeni kodlama eskisinin
+ * yerini alır; ham HTML kalır. Bayt sayacı `noteHtmlCacheGrowth` ile işlenir.
+ *
+ * @param {Map<string, Buffer>} encoded
+ * @param {string} encoding
+ * @param {Buffer} buffer
+ * @returns {void}
+ */
+export function rememberHtmlEncoding(encoded, encoding, buffer) {
+  for (const key of [...encoded.keys()]) {
+    if (key !== encoding) encoded.delete(key);
+  }
+  encoded.set(encoding, buffer);
+  noteHtmlCacheGrowth();
+}
+
 /**
  * Erken tazeleme penceresine girmiş (veya TTL'i dolmuş) trafiksiz girdileri
  * soft-bayatlatır ve ısıtma kuyruğuna alır. HTTP ısıtması producer'sız
  * çalıştığı için soft-bayat şart: taze HIT yenileme tetiklemez.
  *
+ * Tur başına en fazla `EARLY_SWEEP_MARK_BUDGET` girdi. Önce süresi en yakın
+ * dolacak olan; kota dolunca kalanlar bir sonraki tura kalır.
+ *
  * @returns {number} İşaretlenen girdi sayısı.
  */
 export function sweepEarlyExpiry() {
   const now = Date.now();
-  let marked = 0;
+  /** @type {{ key: string, expiresAt: number }[]} */
+  const due = [];
 
   for (const [key, entry] of store) {
     if (inflight.has(key)) continue;
     // Zaten soft-bayat / kuyrukta — her saniye yeniden ekleme.
     if (entry.expiresAt === 0) continue;
     if (now < entry.expiresAt && !isEarly(entry, now)) continue;
+    due.push({ key, expiresAt: entry.expiresAt });
+  }
+
+  due.sort((a, b) => a.expiresAt - b.expiresAt);
+
+  let marked = 0;
+  for (const item of due) {
+    if (marked >= EARLY_SWEEP_MARK_BUDGET) break;
+    const entry = store.get(item.key);
+    if (!entry || inflight.has(item.key) || entry.expiresAt === 0) continue;
 
     entry.expiresAt = 0;
-    if (invalidated.size < MAX_INVALIDATED) invalidated.add(key);
+    if (invalidated.size < MAX_INVALIDATED) invalidated.add(item.key);
     marked += 1;
   }
 

package/src/server/image-optimizer.js

@@ -19,6 +19,7 @@ import fs from "node:fs";
 import path from "node:path";
 import process from "node:process";
 import { tryImportFromApp } from "../build/resolve-peer.mjs";
+import { IMAGE_CACHE_BYTE_BUDGET } from "../config/defaults.js";
 import { getConfig } from "../config/index.js";
 
 /** @type {typeof import('sharp') | null | undefined} */
@@ -27,8 +28,96 @@ let sharpModule;
 /** @type {string | null} */
 let cacheDir = null;
 
+/**
+ * Bilinen dosyalar. HIT `existsSync` yerine bu kümeye bakar; açılışta dizin
+ * bir kez okunur. Değer yazım zamanı ve bayttır — tahliye en eskiden.
+ *
+ * @type {Map<string, { bytes: number, mtimeMs: number }>}
+ */
+const imageCacheIndex = new Map();
+
+/** @type {number} */
+let imageCacheBytes = 0;
+
 const MAX_REDIRECTS = 5;
 
+/**
+ * @param {string} dir
+ * @returns {void}
+ */
+function loadImageCacheIndex(dir) {
+  imageCacheIndex.clear();
+  imageCacheBytes = 0;
+
+  let names;
+  try {
+    names = fs.readdirSync(dir);
+  } catch {
+    return;
+  }
+
+  for (const name of names) {
+    if (!name.endsWith(".webp")) continue;
+    const filePath = path.join(dir, name);
+    try {
+      const stat = fs.statSync(filePath);
+      if (!stat.isFile()) continue;
+      imageCacheIndex.set(filePath, { bytes: stat.size, mtimeMs: stat.mtimeMs });
+      imageCacheBytes += stat.size;
+    } catch {
+      // Yarım tmp veya silinmiş dosya indeksi bozmasın.
+    }
+  }
+
+  evictImageCache("");
+}
+
+/**
+ * @param {string} filePath
+ * @param {number} bytes
+ * @returns {void}
+ */
+function noteImageCacheFile(filePath, bytes) {
+  const prev = imageCacheIndex.get(filePath);
+  if (prev) imageCacheBytes -= prev.bytes;
+  imageCacheIndex.set(filePath, { bytes, mtimeMs: Date.now() });
+  imageCacheBytes += bytes;
+  evictImageCache(filePath);
+}
+
+/**
+ * Tavan aşılınca en eski dosyayı siler. `protect` az önce yazılan yoldur:
+ * bu yanıt onu hâlâ okuyacak, bu turda düşmez.
+ *
+ * @param {string} protect
+ * @returns {void}
+ */
+function evictImageCache(protect) {
+  while (imageCacheBytes > IMAGE_CACHE_BYTE_BUDGET && imageCacheIndex.size > 1) {
+    let oldestPath = "";
+    let oldestMtime = Infinity;
+    let oldestBytes = 0;
+
+    for (const [filePath, meta] of imageCacheIndex) {
+      if (filePath === protect) continue;
+      if (meta.mtimeMs < oldestMtime) {
+        oldestMtime = meta.mtimeMs;
+        oldestPath = filePath;
+        oldestBytes = meta.bytes;
+      }
+    }
+
+    if (!oldestPath) break;
+    imageCacheIndex.delete(oldestPath);
+    imageCacheBytes = Math.max(0, imageCacheBytes - oldestBytes);
+    try {
+      fs.rmSync(oldestPath, { force: true });
+    } catch {
+      // Dosya yoksa indeks yine de düşmüş olsun.
+    }
+  }
+}
+
 /**
  * @returns {import('../config/index.js').ImagesRemoteConfig | null}
  */
@@ -214,6 +303,7 @@ export async function mountImageOptimizer(app) {
   const config = getConfig();
   cacheDir = path.join(config.dirs.generated, "image-cache");
   fs.mkdirSync(cacheDir, { recursive: true });
+  loadImageCacheIndex(cacheDir);
 
   sharpModule = await tryImportFromApp(config.root, "sharp");
   if (!sharpModule) {
@@ -260,7 +350,7 @@ async function handleOptimize(req, res, remote) {
   const filePath = path.join(/** @type {string} */ (cacheDir), `${key}.webp`);
 
   try {
-    if (fs.existsSync(filePath)) {
+    if (imageCacheIndex.has(filePath)) {
       sendCached(res, filePath, remote.cacheMaxAge);
       return;
     }
@@ -286,7 +376,10 @@ async function handleOptimize(req, res, remote) {
     const tmp = `${filePath}.${process.pid}.tmp`;
     await fs.promises.writeFile(tmp, buffer);
     await fs.promises.rename(tmp, filePath);
-
+    // Yeni dosya için yer aç: en eski düşer. Az önce yazılan, tek başına
+    // tavanı aşıyorsa kalır; bir sonraki yazım onu düşürür. Silme, bu
+    // yanıtın `sendFile`'ından önce olmasın.
+    noteImageCacheFile(filePath, buffer.length);
     sendCached(res, filePath, remote.cacheMaxAge);
   } catch (error) {
     console.warn("[images.remote] optimize failed:", error);

package/src/server/logs/file-sink.js

@@ -1,66 +1,193 @@
 /**
- * Günlük rotasyonlu NDJSON dosya sink'i.
+ * Kısa ömürlü dosya logu.
  *
- * Yol `path.resolve(root, dir)` ile bulunur — `getConfig().dirs` şişirilmez;
- * log dizini opsiyonel bir yüzey ve çoğu kurulumda hiç açılmaz.
+ * Satırlar ~1 sn veya 32 satırda bir zstd NDJSON parçası olur. Diskte en
+ * fazla 5 dakika kalır; süresi dolan en eski parça silinir. `drainLog`
+ * her mühürlenen parçayı alır — hook hata verse de site düşmez, dosya
+ * süresi dolana kadar durur.
+ *
+ * Yol `path.resolve(root, dir)` ile bulunur. `getConfig().dirs` şişirilmez;
+ * log dizini opsiyoneldir ve çoğu kurulumda hiç açılmaz.
  */
 import fs from "node:fs/promises";
 import path from "node:path";
+import zlib from "node:zlib";
 
 /**
+ * @typedef {{ body: Buffer, encoding: "zstd", bytes: number, lines: number,
+ *   at: number }} LogChunk
  * @typedef {{ write: (entry: Record<string, unknown>) => Promise<void>,
  *   flush: () => Promise<void>, close: () => Promise<void> }} LogSink
+ * @typedef {(chunk: LogChunk) => void | Promise<void>} DrainLog
  */
 
+/** Satır satır yazmak yerine kısa tampon. */
+const FLUSH_INTERVAL_MS = 1000;
+const FLUSH_MAX_LINES = 32;
+
+/** Diskteki parçaların ömrü. Config yükseltemez. */
+export const FILE_LOG_RETENTION_MS = 5 * 60 * 1000;
+
 /**
- * @param {{ root: string, dir: string }} options
+ * @param {{ root: string, dir: string, persist?: boolean,
+ *   retentionMs?: number, drainLog?: DrainLog | null }} options
+ *   `persist: false` diske yazmaz; yalnız `drainLog` çağrılır.
  * @returns {LogSink}
  */
 export function createFileSink(options) {
+  const persist = options.persist !== false;
+  const retentionMs = options.retentionMs ?? FILE_LOG_RETENTION_MS;
+  const drainLog = typeof options.drainLog === "function" ? options.drainLog : null;
   const baseDir = path.resolve(options.root, options.dir);
-  /** @type {string | null} */
-  let currentDay = null;
-  /** @type {string | null} */
-  let currentPath = null;
+  /** @type {string[]} */
+  let pending = [];
+  /** @type {ReturnType<typeof setTimeout> | null} */
+  let timer = null;
+  /** @type {Promise<void>} */
+  let chain = Promise.resolve();
+  let seq = 0;
   let ready = false;
+  let drainWarned = false;
 
-  /** @returns {string} */
-  function dayStamp(date = new Date()) {
-    const y = date.getUTCFullYear();
-    const m = String(date.getUTCMonth() + 1).padStart(2, "0");
-    const d = String(date.getUTCDate()).padStart(2, "0");
-    return `${y}-${m}-${d}`;
+  /**
+   * @param {string} message
+   * @param {unknown} [error]
+   */
+  function warnDrain(message, error) {
+    if (drainWarned) return;
+    drainWarned = true;
+    console.warn(`[logs] ${message}`, error ?? "");
+  }
+
+  /**
+   * @returns {Promise<void>}
+   */
+  async function ensureDir() {
+    if (ready) return;
+    await fs.mkdir(baseDir, { recursive: true });
+    ready = true;
   }
 
   /**
-   * @param {string} day
-   * @returns {Promise<string>}
+   * Süresi dolmuş `jskelet-*` parçalarını eskiden yeniye siler. Başka
+   * dosyalara dokunulmaz. Eski günlük `.log` dosyaları da bu ada uyar.
+   *
+   * @returns {Promise<void>}
    */
-  async function ensureFile(day) {
-    if (!ready) {
-      await fs.mkdir(baseDir, { recursive: true });
-      ready = true;
+  async function prune() {
+    if (!persist) return;
+    let names;
+    try {
+      names = await fs.readdir(baseDir);
+    } catch {
+      return;
+    }
+
+    const now = Date.now();
+    /** @type {{ file: string, mtimeMs: number }[]} */
+    const doomed = [];
+
+    for (const name of names) {
+      if (!name.startsWith("jskelet-")) continue;
+      const file = path.join(baseDir, name);
+      try {
+        const stat = await fs.stat(file);
+        if (!stat.isFile()) continue;
+        if (now - stat.mtimeMs < retentionMs) continue;
+        doomed.push({ file, mtimeMs: stat.mtimeMs });
+      } catch {
+        // Silinmiş veya okunamayan girdi turu bozmasın.
+      }
+    }
+
+    doomed.sort((a, b) => a.mtimeMs - b.mtimeMs);
+    for (const item of doomed) {
+      await fs.rm(item.file, { force: true });
     }
-    if (currentDay === day && currentPath) return currentPath;
-    currentDay = day;
-    currentPath = path.join(baseDir, `jskelet-${day}.log`);
-    return currentPath;
+  }
+
+  /**
+   * @param {string} text
+   * @param {number} lines
+   * @returns {Promise<void>}
+   */
+  async function seal(text, lines) {
+    const body = zlib.zstdCompressSync(Buffer.from(text, "utf8"));
+    const at = Date.now();
+
+    if (persist) {
+      await ensureDir();
+      seq += 1;
+      const file = path.join(baseDir, `jskelet-${at}-${seq}.ndjson.zst`);
+      await fs.writeFile(file, body);
+      await prune();
+    }
+
+    if (!drainLog) return;
+
+    try {
+      await drainLog({
+        body,
+        encoding: "zstd",
+        bytes: body.length,
+        lines,
+        at,
+      });
+    } catch (error) {
+      warnDrain(
+        persist
+          ? "drainLog failed; the chunk stays on disk until it expires"
+          : "drainLog failed; the chunk was not stored",
+        error,
+      );
+    }
+  }
+
+  /**
+   * @returns {Promise<void>}
+   */
+  async function flushPending() {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    if (!pending.length) return;
+
+    const lines = pending;
+    pending = [];
+    await seal(lines.join(""), lines.length);
+  }
+
+  /** @returns {void} */
+  function schedule() {
+    if (timer || !pending.length) return;
+    timer = setTimeout(() => {
+      timer = null;
+      chain = chain.then(() => flushPending());
+    }, FLUSH_INTERVAL_MS);
+    timer.unref?.();
   }
 
   return {
     async write(entry) {
-      const day = dayStamp(
-        typeof entry.at === "number" ? new Date(entry.at) : new Date(),
-      );
-      const file = await ensureFile(day);
-      await fs.appendFile(file, `${JSON.stringify(entry)}\n`, "utf8");
+      pending.push(`${JSON.stringify(entry)}\n`);
+
+      if (pending.length >= FLUSH_MAX_LINES) {
+        chain = chain.then(() => flushPending());
+        await chain;
+        return;
+      }
+
+      schedule();
     },
     async flush() {
-      // appendFile senkron flush eder; ekstra iş yok.
+      chain = chain.then(() => flushPending());
+      await chain;
     },
     async close() {
-      currentDay = null;
-      currentPath = null;
+      chain = chain.then(() => flushPending());
+      await chain;
+      if (persist) await prune();
     },
   };
 }

package/src/server/logs/pipeline.js

@@ -36,7 +36,7 @@ let accessMounted = false;
  */
 export function shouldMountAccessLog(logs) {
   if (!logs.kinds.includes("http")) return false;
-  if (logs.file.enabled || logs.s3.enabled) return true;
+  if (logs.file.enabled || logs.s3.enabled || logs.drainLog) return true;
   return logs.console && process.env.NODE_ENV !== "development";
 }
 
@@ -61,8 +61,15 @@ export async function configureLogs(config) {
   /** @type {LogSink[]} */
   const next = [];
 
-  if (logs.file.enabled) {
-    next.push(createFileSink({ root: config.root, dir: logs.file.dir }));
+  if (logs.file.enabled || logs.drainLog) {
+    next.push(
+      createFileSink({
+        root: config.root,
+        dir: logs.file.dir,
+        persist: logs.file.enabled,
+        drainLog: logs.drainLog,
+      }),
+    );
   }
 
   if (logs.s3.enabled) {

package/src/server/middleware/static-precompressed.js

@@ -10,6 +10,7 @@
  */
 import fs from "node:fs";
 import path from "node:path";
+import process from "node:process";
 import { negotiateEncoding } from "./compression.js";
 import { IMMUTABLE_CACHE } from "../../config/defaults.js";
 
@@ -31,6 +32,33 @@ const CONTENT_TYPES = {
  */
 export function staticPrecompressed(publicDir) {
   const root = path.resolve(publicDir);
+  // Hash'li `/assets/` süreç ömründe değişmez. Üretimde olumlu ve olumsuz
+  // `stat` sonucu bellekte kalır; dev'de watch hash değiştirdiği için yok.
+  const cacheStats = process.env.NODE_ENV !== "development";
+  /** @type {Map<string, number | null>} yol → bayt, `null` → dosya yok */
+  const statCache = new Map();
+
+  /**
+   * @param {string} file
+   * @returns {number | null}
+   */
+  function fileSize(file) {
+    if (cacheStats && statCache.has(file)) {
+      return /** @type {number | null} */ (statCache.get(file));
+    }
+
+    /** @type {number | null} */
+    let size = null;
+    try {
+      const stat = fs.statSync(file);
+      if (stat.isFile()) size = stat.size;
+    } catch {
+      size = null;
+    }
+
+    if (cacheStats) statCache.set(file, size);
+    return size;
+  }
 
   return (req, res, next) => {
     if (req.method !== "GET" && req.method !== "HEAD") {
@@ -67,23 +95,16 @@ export function staticPrecompressed(publicDir) {
     }
 
     const file = `${target}${encoding === "br" ? ".br" : ".gz"}`;
+    const size = fileSize(file);
 
-    let stat;
-    try {
-      stat = fs.statSync(file);
-    } catch {
-      next();
-      return;
-    }
-
-    if (!stat.isFile()) {
+    if (size == null) {
       next();
       return;
     }
 
     res.setHeader("Content-Type", type);
     res.setHeader("Content-Encoding", encoding);
-    res.setHeader("Content-Length", String(stat.size));
+    res.setHeader("Content-Length", String(size));
     res.setHeader("Vary", "Accept-Encoding");
 
     if (req.path.startsWith("/assets/")) {