jskelet 0.7.1 → 0.7.2

package/src/http/request-cache.js

@@ -18,6 +18,24 @@ export function withRequestCache(run) {
   return storage.run(new Map(), run);
 }
 
+/**
+ * Sık görülen ilkel argümanlarda `JSON.stringify` atlanır.
+ *
+ * @param {unknown[]} args
+ * @returns {string}
+ */
+function argsKey(args) {
+  if (args.length === 0) return "";
+  if (args.length === 1) {
+    const value = args[0];
+    const type = typeof value;
+    if (value == null) return `\0${value}`;
+    if (type === "string") return `\0s:${value}`;
+    if (type === "number" || type === "boolean") return `\0${type}:${value}`;
+  }
+  return JSON.stringify(args);
+}
+
 /**
  * @param {F} fn
  * @returns {F}
@@ -34,7 +52,7 @@ export function cache(fn) {
       contextStore.set(fn, perFn);
     }
 
-    const key = args.length === 0 ? "" : JSON.stringify(args);
+    const key = argsKey(args);
     if (perFn.has(key)) return perFn.get(key);
 
     const result = fn(...args);

package/src/index.js

@@ -11,6 +11,8 @@ export {
   renderPage,
   renderView,
   renderNotFound,
+  warmRenderEngine,
+  resetRenderEngine,
 } from "./server/render.js";
 export { renderStatusPage, statusFromError } from "./server/status-page.js";
 export { createApp, startServer } from "./server/create-app.js";

package/src/server/cache-blob.js

@@ -53,6 +53,9 @@ export function encodeCacheValue(value) {
 }
 
 /**
+ * Senkron çözücü — küçük test / senkron yollar için. Hot path
+ * `decodeCacheValueAsync` kullanır (event loop'u brotli ile bloklamaz).
+ *
  * @param {Buffer | string} raw
  * @returns {unknown}
  */
@@ -68,3 +71,33 @@ export function decodeCacheValue(raw) {
   const text = Buffer.isBuffer(raw) ? raw.toString("utf8") : raw;
   return JSON.parse(text);
 }
+
+/**
+ * @param {Buffer | string} raw
+ * @returns {Promise<unknown>}
+ */
+export function decodeCacheValueAsync(raw) {
+  if (
+    Buffer.isBuffer(raw) &&
+    raw.length > CACHE_MAGIC.length &&
+    raw.subarray(0, CACHE_MAGIC.length).equals(CACHE_MAGIC)
+  ) {
+    const body = raw.subarray(CACHE_MAGIC.length);
+    return new Promise((resolve, reject) => {
+      zlib.brotliDecompress(body, (error, out) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        try {
+          resolve(JSON.parse(out.toString("utf8")));
+        } catch (parseError) {
+          reject(parseError);
+        }
+      });
+    });
+  }
+
+  const text = Buffer.isBuffer(raw) ? raw.toString("utf8") : raw;
+  return Promise.resolve(JSON.parse(text));
+}

package/src/server/create-app.js

@@ -247,6 +247,11 @@ export async function startServer(options = {}) {
 
   const app = await createApp(options);
 
+  // İlk istek TTFB'sine binmesin: şablon motoru + asset manifest burada ısınır.
+  // Sayfa prewarm değildir.
+  const { warmRenderEngine } = await import("./render.js");
+  await warmRenderEngine();
+
   // Varsayılan `::`, `0.0.0.0` değil: ikisi de "tüm arayüzler" demek, ama
   // yalnızca IPv6 soketi çift yığın çalışır ve `localhost`un `::1`e çözüldüğü
   // durumu da kapsar. Tarayıcılar `localhost` için önce `::1` deniyor; sıradan

package/src/server/data-cache.js

@@ -27,7 +27,7 @@ import { getConfig } from "../config/index.js";
 import { DATA_CACHE_BYTE_BUDGET, DEFAULT_DATA_CACHE } from "../config/defaults.js";
 import { recordDependency } from "./cache-deps.js";
 import { diskDrop, diskDropMatching, diskGetJson, diskSetJson, diskShares } from "./disk-cache.js";
-import { invalidateHtmlByDependency } from "./html-cache.js";
+import { earlyRefreshLeadMs, invalidateHtmlByDependency } from "./html-cache.js";
 import {
   cacheKey,
   onCacheEvent,
@@ -39,9 +39,12 @@ import {
 } from "./redis.js";
 
 /**
- * @typedef {{ value: unknown, expiresAt: number, staleUntil: number, bytes: number }} DataEntry
+ * @typedef {{ value: unknown, expiresAt: number, staleUntil: number, bytes: number,
+ *   produceMs: number }} DataEntry
  */
 
+const DEFAULT_PRODUCE_MS = 500;
+
 /** @type {Map<string, DataEntry>} */
 const store = new Map();
 
@@ -60,6 +63,14 @@ let byteBudgetOverride = null;
 /** @type {Map<string, Promise<unknown>>} */
 const inflight = new Map();
 
+/**
+ * L2 miss kısa belleği — boş Redis/disk turunu tekrarlamamak için.
+ * @type {Map<string, number>}
+ */
+const sharedMissUntil = new Map();
+const SHARED_MISS_TTL_MS = 2_000;
+const MAX_SHARED_MISS = 2_000;
+
 /**
  * Süreç ömrü boyunca biriken sayaçlar.
  *
@@ -106,9 +117,25 @@ function settings() {
   }
 }
 
+/**
+ * @param {DataEntry} entry
+ * @param {number} [now]
+ * @returns {boolean}
+ */
+function isEarly(entry, now = Date.now()) {
+  if (now >= entry.expiresAt) return false;
+  // `storedAt` yok; orijinal TTL = bayat penceresi / staleFactor.
+  const staleFactor = settings().staleFactor;
+  const staleWindow = Math.max(0, entry.staleUntil - entry.expiresAt);
+  const originalTtl =
+    staleFactor > 0 ? staleWindow / staleFactor : Math.max(staleWindow, entry.produceMs * 4);
+  const lead = earlyRefreshLeadMs(entry.produceMs ?? DEFAULT_PRODUCE_MS, originalTtl);
+  return now >= entry.expiresAt - lead;
+}
+
 /**
  * @param {string} key
- * @returns {{ value: unknown, stale: boolean } | null}
+ * @returns {{ value: unknown, stale: boolean, early: boolean } | null}
  */
 function read(key) {
   const entry = store.get(key);
@@ -124,7 +151,12 @@ function read(key) {
   store.delete(key);
   store.set(key, entry);
 
-  return { value: entry.value, stale: now >= entry.expiresAt };
+  const stale = now >= entry.expiresAt;
+  return {
+    value: entry.value,
+    stale,
+    early: !stale && isEarly(entry, now),
+  };
 }
 
 /**
@@ -200,8 +232,9 @@ function install(key, entry) {
  * @param {unknown} value
  * @param {number} ttlSeconds
  * @param {number} staleFactor
+ * @param {number} [produceMs]
  */
-function write(key, value, ttlSeconds, staleFactor) {
+function write(key, value, ttlSeconds, staleFactor, produceMs = DEFAULT_PRODUCE_MS) {
   const now = Date.now();
   const ttl = ttlSeconds * 1000;
 
@@ -211,8 +244,12 @@ function write(key, value, ttlSeconds, staleFactor) {
     expiresAt: now + ttl,
     staleUntil: now + ttl + ttl * staleFactor,
     bytes: valueBytes(value),
+    produceMs:
+      Number.isFinite(produceMs) && produceMs >= 0 ? Math.round(produceMs) : DEFAULT_PRODUCE_MS,
   };
 
+  sharedMissUntil.delete(key);
+
   // Bütçeye sığmayan değer Redis'e de yazılmaz: bir sonraki istek onu geri
   // alıp yine reddeder. Çağıran sonuç yine `producer`'ın döndürdüğüdür.
   if (!install(key, entry)) return;
@@ -236,9 +273,25 @@ function write(key, value, ttlSeconds, staleFactor) {
  */
 function promote(key, entry) {
   if (!entry.bytes) entry.bytes = valueBytes(entry.value);
+  if (!Number.isFinite(entry.produceMs) || entry.produceMs < 0) {
+    entry.produceMs = DEFAULT_PRODUCE_MS;
+  }
+  sharedMissUntil.delete(key);
   install(key, entry);
 }
 
+/**
+ * @param {string} key
+ * @returns {void}
+ */
+function rememberSharedMiss(key) {
+  if (sharedMissUntil.size >= MAX_SHARED_MISS) {
+    const oldest = sharedMissUntil.keys().next().value;
+    if (oldest !== undefined) sharedMissUntil.delete(oldest);
+  }
+  sharedMissUntil.set(key, Date.now() + SHARED_MISS_TTL_MS);
+}
+
 /**
  * Paylaşımlı kademeden okur.
  *
@@ -254,13 +307,24 @@ async function readShared(key) {
   const onDisk = diskShares("data");
   if (!onRedis && !onDisk) return null;
 
+  const missUntil = sharedMissUntil.get(key);
+  if (missUntil !== undefined) {
+    if (Date.now() < missUntil) return null;
+    sharedMissUntil.delete(key);
+  }
+
   const entry = onRedis ? await redisGetJson(cacheKey("data", key)) : await diskGetJson("data", key);
-  if (!entry || typeof entry.expiresAt !== "number") return null;
+  if (!entry || typeof entry.expiresAt !== "number") {
+    rememberSharedMiss(key);
+    return null;
+  }
   if (Date.now() >= entry.expiresAt) {
     if (onDisk) diskDrop("data", [key]);
+    rememberSharedMiss(key);
     return null;
   }
 
+  sharedMissUntil.delete(key);
   return /** @type {DataEntry} */ (entry);
 }
 
@@ -309,11 +373,13 @@ async function produce(key, ttlSeconds, producer, options, staleFactor) {
   }
 
   stats.produced += 1;
+  const startedAt = Date.now();
   const value = await producer();
+  const produceMs = Date.now() - startedAt;
 
   const empty = value === undefined || value === null;
   if (!empty || options.storeEmpty === true) {
-    write(key, value, ttlSeconds, staleFactor);
+    write(key, value, ttlSeconds, staleFactor, produceMs);
   }
 
   return value;
@@ -348,10 +414,9 @@ export async function withDataCache(key, ttlSeconds, producer, options = {}) {
     if (hit.stale) stats.stale += 1;
     else stats.hits += 1;
 
-    // Bayat girdi anında döner; tazeleme arkada yürür ve hatası bu isteği
-    // etkilemez — çağıran taraf bir şey beklemediği için upstream'in yavaş
-    // olması sayfaya yansımaz.
-    if (hit.stale) {
+    // Bayat veya erken penceredeki girdi anında döner; tazeleme arkada yürür
+    // — HTML cache ile aynı: TTL dolmadan upstream çağrısı bitsin.
+    if (hit.stale || hit.early) {
       void refresh(key, ttlSeconds, producer, options).catch((error) => {
         console.error(`[data-cache] background refresh failed: ${key}`, error);
       });
@@ -445,6 +510,7 @@ function clearLocal(prefix) {
     removed.push(...store.keys());
     store.clear();
     storedBytes = 0;
+    sharedMissUntil.clear();
   } else {
     for (const key of [...store.keys()]) {
       if (key.startsWith(prefix)) {

package/src/server/disk-cache.js

@@ -14,7 +14,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { getConfig } from "../config/index.js";
 import { getBuildId } from "./assets.js";
-import { decodeCacheValue, encodeCacheValue } from "./cache-blob.js";
+import { decodeCacheValueAsync, encodeCacheValue } from "./cache-blob.js";
 import { redisShares } from "./redis.js";
 
 /** @type {string | null} `null` → config'den çöz. Testler mutlak yol verir. */
@@ -137,7 +137,7 @@ export async function diskGetJson(kind, key) {
   try {
     const framed = unframe(await fs.readFile(file));
     if (!framed) return null;
-    return decodeCacheValue(framed.body);
+    return decodeCacheValueAsync(framed.body);
   } catch {
     return null;
   }

package/src/server/head-hints.js

@@ -24,15 +24,27 @@ let cached = null;
 export function preconnectHints() {
   if (cached != null) return cached;
 
-  cached = getConfig()
-    .preconnect.map((origin) => {
-      try {
-        return `<link rel="preconnect" href="${esc(new URL(origin).origin)}">`;
-      } catch {
-        console.warn(`[head] invalid preconnect URL, skipped: ${origin}`);
-        return "";
-      }
-    })
+  /** @type {Set<string>} */
+  const origins = new Set();
+
+  for (const origin of getConfig().preconnect) {
+    try {
+      origins.add(new URL(origin).origin);
+    } catch {
+      console.warn(`[head] invalid preconnect URL, skipped: ${origin}`);
+    }
+  }
+
+  // CDN asset prefix config'e yazılmadan da preconnect alsın.
+  try {
+    const prefix = getConfig().build?.assets?.prefix;
+    if (prefix) origins.add(new URL(prefix).origin);
+  } catch {
+    /* geçersiz prefix — config zaten uyarmış olabilir */
+  }
+
+  cached = [...origins]
+    .map((origin) => `<link rel="preconnect" href="${esc(origin)}">`)
     .join("");
 
   return cached;

package/src/server/html-cache.js

@@ -39,6 +39,7 @@ 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 { encodeText } from "./middleware/compression.js";
 import {
   cacheKey,
   onCacheEvent,
@@ -57,8 +58,9 @@ import {
  * yine sorulur; cevabı bu alan taşıyor.
  *
  * `sharedEncodings`: Redis'e en son kaç sıkıştırılmış gövde yazıldığı.
- * `encoded` haritası yanıt yolunda (`sendHtml`) doluyor, yani yazma anında
- * boş; `storeEncoded` açıkken harita büyüdüğünde girdi yeniden paylaşılır.
+ * `encoded` yazmadan sonra arka planda brotli ile doldurulur (ve `sendHtml`
+ * ilk yanıtta da yazabilir); `storeEncoded` açıkken harita büyüdüğünde girdi
+ * yeniden paylaşılır.
  *
  * `produceMs`: son başarılı üretimin süresi. Erken tazeleme penceresi bundan
  * türetilir; Redis'ten gelen kopyada yoksa varsayılan kullanılır.
@@ -196,6 +198,19 @@ const purgedDeps = new Map();
 
 const MAX_PURGED_DEPS = 1000;
 
+/**
+ * L2'de bulunamayan anahtarlar — kısa süre `readShared` atlanır (boş Redis/
+ * disk round-trip + timeout maliyeti). Yazınca düşer.
+ *
+ * @type {Map<string, number>}
+ */
+const sharedMissUntil = new Map();
+
+/** @type {number} */
+const SHARED_MISS_TTL_MS = 2_000;
+
+const MAX_SHARED_MISS = 2_000;
+
 /**
  * Erken tazeleme lead'i: son render süresinin 2 katı (en az 250 ms), TTL'in
  * yarısından fazla olamaz — kısa TTL'lerde sürekli refresh döngüsü olmasın.
@@ -337,9 +352,8 @@ function read(key) {
   store.delete(key);
   store.set(key, entry);
 
-  // `encoded` yanıt yolunda dolduğu için yazma anında paylaşılamıyor. Kontrol
-  // yalnızca `storeEncoded` açıkken yapılır; kapalıyken (varsayılan) bu satır
-  // tek bir karşılaştırmaya bile girmez.
+  // `encoded` yanıt yolunda büyüyebilir (gzip vb.). Kontrol yalnızca
+  // `storeEncoded` açıkken yapılır; kapalıyken bu satır karşılaştırmaya girmez.
   if (redisSharesEncoded() && entry.encoded.size !== entry.sharedEncodings) {
     share(key, entry);
   }
@@ -404,20 +418,43 @@ function share(key, entry) {
  * @param {string} key
  * @returns {Promise<HtmlEntry | null>}
  */
+/**
+ * @param {string} key
+ * @returns {void}
+ */
+function rememberSharedMiss(key) {
+  if (sharedMissUntil.size >= MAX_SHARED_MISS) {
+    const oldest = sharedMissUntil.keys().next().value;
+    if (oldest !== undefined) sharedMissUntil.delete(oldest);
+  }
+  sharedMissUntil.set(key, Date.now() + SHARED_MISS_TTL_MS);
+}
+
 async function readShared(key) {
   const onRedis = redisShares("html");
   const onDisk = diskShares("html");
   if (!onRedis && !onDisk) return null;
 
+  const missUntil = sharedMissUntil.get(key);
+  if (missUntil !== undefined) {
+    if (Date.now() < missUntil) return null;
+    sharedMissUntil.delete(key);
+  }
+
   const payload = onRedis
     ? await redisGetJson(cacheKey("html", key))
     : await diskGetJson("html", key);
-  if (!payload || typeof payload.html !== "string") return null;
+  if (!payload || typeof payload.html !== "string") {
+    rememberSharedMiss(key);
+    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]);
+    rememberSharedMiss(key);
     return null;
   }
+  sharedMissUntil.delete(key);
 
   const deps = new Set(Array.isArray(payload.deps) ? payload.deps.map(String) : []);
   const storedAt = Number(payload.storedAt) || 0;
@@ -466,8 +503,9 @@ async function readShared(key) {
  * @param {number} ttlSeconds
  * @param {Set<string> | null} deps Render sırasında okunan veri anahtarları.
  * @param {number} [produceMs] Son üretimin süresi (ms).
+ * @returns {Promise<void>}
  */
-function write(key, value, ttlSeconds, deps = null, produceMs = DEFAULT_PRODUCE_MS) {
+async function write(key, value, ttlSeconds, deps = null, produceMs = DEFAULT_PRODUCE_MS) {
   const now = Date.now();
 
   /** @type {HtmlEntry} */
@@ -487,7 +525,30 @@ function write(key, value, ttlSeconds, deps = null, produceMs = DEFAULT_PRODUCE_
 
   // Bütçeye sığmayan sayfa Redis'e de yazılmaz: bir sonraki istek onu
   // geri alıp yine reddeder, stringify ise o anki RSS'i şişirir.
-  if (install(key, entry)) share(key, entry);
+  sharedMissUntil.delete(key);
+  if (!install(key, entry)) return;
+
+  // MISS yanıtı br ile gidebilsin: encode bitmeden dönme. share encode sonrası
+  // (storeEncoded açıkken br L2'ye de gider).
+  await preencodeEntry(key, entry);
+  share(key, entry);
+}
+
+/**
+ * Yazılan HTML için brotli üretir.
+ *
+ * @param {string} key
+ * @param {HtmlEntry} entry
+ * @returns {Promise<void>}
+ */
+async function preencodeEntry(key, entry) {
+  try {
+    const buffer = await encodeText(entry.html, "br");
+    if (store.get(key) !== entry) return;
+    rememberHtmlEncoding(entry.encoded, "br", buffer);
+  } catch {
+    // Encode başarısızsa sonraki sendHtml dener; cache yazımı bozulmaz.
+  }
 }
 
 /**
@@ -522,10 +583,8 @@ function install(key, entry) {
 }
 
 /**
- * Sıkıştırılmış gövde `install()`'dan sonra, ilk brotli/gzip yanıtında
- * girdinin `encoded` haritasına eklenir. Sayacı delta ile büyütmek, o sıra
- * LRU'dan düşmüş bir haritaya yazınca bir daha inmeyen bir artık bırakır;
- * store'dan yeniden okumak o artığı taşımaz.
+ * Bayt sayacını store'dan yeniden hesaplar. Testler elle `encoded` doldurunca
+ * çağırır; hot path `rememberHtmlEncoding` delta kullanır.
  *
  * @returns {void}
  */
@@ -612,42 +671,94 @@ function extendStaleWhileRefreshing(key) {
  * @returns {Promise<{ html: string, status: number, degraded?: boolean,
  *   storable?: boolean }>}
  */
+/** L2 yanıtı bu sürede gelmezse local produce başlar (yavaş Redis TTFB'si). */
+const SHARED_WAIT_MS = 50;
+
 async function produce(key, ttlSeconds, producer, token) {
   const startedAt = Date.now();
 
-  // Başka bir node bu sayfayı zaten render ettiyse render hiç çalışmaz. Soğuk
-  // ayağa kalkan bir instance'ın sıcak önbellek bulmasının tek yolu bu.
-  const shared = await readShared(key);
-  if (shared && tokens.get(key) === token) {
-    install(key, shared);
-    return { html: shared.html, status: shared.status };
+  // L2 ile yarış: hızlı HIT kullan; yavaşsa local üret. Local hata L2'yi
+  // iptal etmez — disk/Redis decode 50 ms'yi aşabilir.
+  const sharedPromise = readShared(key);
+  const timedOut = await Promise.race([
+    sharedPromise.then((shared) => ({ shared, timeout: false })),
+    sleep(SHARED_WAIT_MS).then(() => ({ shared: null, timeout: true })),
+  ]);
+
+  if (timedOut.shared && tokens.get(key) === token) {
+    install(key, timedOut.shared);
+    return { html: timedOut.shared.html, status: timedOut.shared.status };
   }
 
-  // Bağımlılıklar tazelemede de toplanır, ilk üretimde değil sadece: sayfanın
-  // okuduğu anahtarlar zamanla değişir (yeni bir widget, kaldırılan bir blok).
   const deps = trackDependencies() ? new Set() : null;
+  const runLocal = () =>
+    deps ? collectDependencies(deps, producer) : producer();
+
+  /** @type {{ html: string, status: number, degraded?: boolean, storable?: boolean } | null} */
+  let value = null;
+
+  if (timedOut.timeout) {
+    const localSettled = runLocal().then(
+      (v) => /** @type {const} */ ({ ok: true, value: v }),
+      (err) => /** @type {const} */ ({ ok: false, err }),
+    );
+
+    const winner = await Promise.race([
+      sharedPromise.then((shared) =>
+        shared
+          ? /** @type {const} */ ({ source: "shared", shared })
+          : /** @type {const} */ ({ source: "miss" }),
+      ),
+      localSettled.then((result) =>
+        /** @type {const} */ ({ source: "local", result }),
+      ),
+    ]);
+
+    if (winner.source === "shared" && tokens.get(key) === token) {
+      install(key, winner.shared);
+      return { html: winner.shared.html, status: winner.shared.status };
+    }
+
+    if (winner.source === "miss") {
+      const result = await localSettled;
+      if (!result.ok) throw result.err;
+      value = result.value;
+    } else {
+      // Local önce bitti; geç L2 HIT varsa onu tercih et (yazma yok).
+      const late = await sharedPromise;
+      if (late && tokens.get(key) === token) {
+        install(key, late);
+        return { html: late.html, status: late.status };
+      }
+      if (!winner.result.ok) throw winner.result.err;
+      value = winner.result.value;
+    }
+  } else {
+    // L2 miss (null) — local üret.
+    value = await runLocal();
+  }
 
-  const value = await (deps ? collectDependencies(deps, producer) : producer());
-
-  // `degraded`: upstream düştüğü için eksik veriyle üretilmiş HTML.
-  // Saklanırsa eksik içerik tüm TTL boyunca servis edilir.
-  //
-  // `storable: false`: çıktı kullanıcıya bağlı (cookie/Authorization
-  // okundu). Anahtar yalnızca yol + query olduğu için saklamak, bir
-  // kullanıcının HTML'ini bir başkasına servis etmek olur. Paylaşımlı
-  // kademede bunun bedeli daha da ağır — bir kullanıcının HTML'i tüm kümeye
-  // dağılırdı — bu yüzden kontrol Redis yazımından önce, `write()` içinde.
-  //
-  // Token uyuşmuyorsa bu tur, sonucu geçersiz kılan bir invalidation'ın
-  // öncesinde başlamış demektir; yazmak az önce düşürüleni geri koyardı.
   const valid = tokens.get(key) === token && !readsPurgedData(deps, startedAt);
-  if (valid && value.status === 200 && !value.degraded && value.storable !== false) {
-    write(key, value, ttlSeconds, deps, Date.now() - startedAt);
+  if (
+    value &&
+    valid &&
+    value.status === 200 &&
+    !value.degraded &&
+    value.storable !== false
+  ) {
+    await write(key, value, ttlSeconds, deps, Date.now() - startedAt);
   }
 
   return value;
 }
 
+/** @param {number} ms */
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms).unref?.();
+  });
+}
+
 /**
  * @param {string} key
  * @param {number} ttlSeconds 0 → cache yok
@@ -705,6 +816,7 @@ function clearLocal() {
   tokens.clear();
   invalidated.clear();
   purgedDeps.clear();
+  sharedMissUntil.clear();
 }
 
 export function getHtmlCacheSize() {
@@ -1127,7 +1239,8 @@ export function isHtmlCacheKeyFresh(key) {
 
 /**
  * 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.
+ * yerini alır; ham HTML kalır. Bayt sayacı delta ile güncellenir — harita
+ * LRU'dan düşmüşse (store'da yok) sayaç oynatılmaz.
  *
  * @param {Map<string, Buffer>} encoded
  * @param {string} encoding
@@ -1135,11 +1248,28 @@ export function isHtmlCacheKeyFresh(key) {
  * @returns {void}
  */
 export function rememberHtmlEncoding(encoded, encoding, buffer) {
-  for (const key of [...encoded.keys()]) {
-    if (key !== encoding) encoded.delete(key);
+  let removed = 0;
+  for (const [key, buf] of [...encoded.entries()]) {
+    if (key !== encoding) {
+      removed += buf.length;
+      encoded.delete(key);
+    }
   }
+  const previous = encoded.get(encoding);
+  if (previous) removed += previous.length;
   encoded.set(encoding, buffer);
-  noteHtmlCacheGrowth();
+
+  let owned = false;
+  for (const entry of store.values()) {
+    if (entry.encoded === encoded) {
+      owned = true;
+      break;
+    }
+  }
+  if (!owned) return;
+
+  storedBytes = Math.max(0, storedBytes - removed + buffer.length);
+  evictOverflow();
 }
 
 /**