jskelet 0.5.5 → 0.6.1

package/src/server/auth/handoff.js

@@ -9,9 +9,12 @@
  *
  * Bilet süreç belleğinde; tek süreçte tüm locale host'ları servis eden
  * kurulumlar için yeterli. Değer kısa session id olmalı.
+ *
+ * Güvenlik: mint CSRF'den *sonra* mount edilir (create-app); cookie adı
+ * allowlist + RFC 6265 doğrulaması; bekleyen bilet ve IP başına mint sınırı.
  */
 import { getConfig } from "../../config/index.js";
-import { randomToken, setCookie } from "../../http/cookies.js";
+import { isValidCookieName, randomToken, setCookie } from "../../http/cookies.js";
 import {
   SHARED_COOKIE_WARN_BYTES,
   requestIsHttps,
@@ -22,11 +25,26 @@ import { resolveSharedCookieDomain } from "../../shared/cookie-domain.js";
 /** @type {Map<string, { name: string, value: string, maxAge?: number, exp: number }>} */
 const tickets = new Map();
 
+/** IP → { count, windowStart } — basit mint rate limit. */
+/** @type {Map<string, { count: number, windowStart: number }>} */
+const mintWindows = new Map();
+
 const DEFAULT_TTL_SECONDS = 60;
+const DEFAULT_MAX_PENDING = 256;
+const DEFAULT_MAX_MINTS_PER_IP = 30;
+const MINT_WINDOW_MS = 60_000;
 const HANDOFF_PATH = "/_jskelet/auth/handoff";
 
 /**
- * @returns {{ enabled: boolean, ttlSeconds: number, path: string, maxValueBytes: number }}
+ * @returns {{
+ *   enabled: boolean,
+ *   ttlSeconds: number,
+ *   path: string,
+ *   maxValueBytes: number,
+ *   allowedCookieNames: string[],
+ *   maxPendingTickets: number,
+ *   maxMintsPerIpPerMinute: number,
+ * }}
  */
 function settings() {
   const auth = getConfig().auth ?? {};
@@ -37,21 +55,26 @@ function settings() {
       ttlSeconds: DEFAULT_TTL_SECONDS,
       path: HANDOFF_PATH,
       maxValueBytes: SHARED_COOKIE_WARN_BYTES,
+      allowedCookieNames: [],
+      maxPendingTickets: DEFAULT_MAX_PENDING,
+      maxMintsPerIpPerMinute: DEFAULT_MAX_MINTS_PER_IP,
     };
   }
 
-  if (raw === true) {
-    return {
-      enabled: true,
-      ttlSeconds: DEFAULT_TTL_SECONDS,
-      path: HANDOFF_PATH,
-      maxValueBytes: SHARED_COOKIE_WARN_BYTES,
-    };
-  }
+  /** @type {Record<string, unknown>} */
+  const source = raw === true ? {} : /** @type {Record<string, unknown>} */ (raw);
 
-  const source = /** @type {Record<string, unknown>} */ (raw);
   const ttl = Number(source.ttlSeconds);
   const maxBytes = Number(source.maxValueBytes);
+  const maxPending = Number(source.maxPendingTickets);
+  const maxMints = Number(source.maxMintsPerIpPerMinute);
+
+  const namesRaw = source.allowedCookieNames;
+  /** @type {string[]} */
+  const allowedCookieNames = Array.isArray(namesRaw)
+    ? namesRaw.filter((n) => typeof n === "string" && isValidCookieName(n.trim())).map((n) => n.trim())
+    : [];
+
   return {
     enabled: source.enabled !== false,
     ttlSeconds:
@@ -64,6 +87,15 @@ function settings() {
       Number.isFinite(maxBytes) && maxBytes > 0
         ? Math.floor(maxBytes)
         : SHARED_COOKIE_WARN_BYTES,
+    allowedCookieNames,
+    maxPendingTickets:
+      Number.isFinite(maxPending) && maxPending > 0
+        ? Math.floor(maxPending)
+        : DEFAULT_MAX_PENDING,
+    maxMintsPerIpPerMinute:
+      Number.isFinite(maxMints) && maxMints > 0
+        ? Math.floor(maxMints)
+        : DEFAULT_MAX_MINTS_PER_IP,
   };
 }
 
@@ -74,6 +106,24 @@ function sweep() {
   }
 }
 
+/**
+ * @param {string} ip
+ * @param {number} limit
+ * @returns {boolean} true ise mint'e izin var
+ */
+function allowMint(ip, limit) {
+  const now = Date.now();
+  const key = ip || "unknown";
+  const entry = mintWindows.get(key);
+  if (!entry || now - entry.windowStart >= MINT_WINDOW_MS) {
+    mintWindows.set(key, { count: 1, windowStart: now });
+    return true;
+  }
+  if (entry.count >= limit) return false;
+  entry.count += 1;
+  return true;
+}
+
 /**
  * @param {string} next
  * @param {import('express').Request} req
@@ -146,6 +196,7 @@ function redeem(ticketId) {
 
 /**
  * Handoff uçlarını mount eder. `auth.crossSubdomainHandoff` kapalıysa no-op.
+ * create-app CSRF'den *sonra* çağırmalıdır.
  *
  * @param {import('express').Express} app
  * @returns {void}
@@ -154,9 +205,27 @@ export function mountAuthHandoff(app) {
   const cfg = settings();
   if (!cfg.enabled) return;
 
+  if (cfg.allowedCookieNames.length === 0) {
+    console.warn(
+      "[auth.handoff] enabled but allowedCookieNames is empty — " +
+        "POST mint will return 400 until you list cookie names in " +
+        "auth.crossSubdomainHandoff.allowedCookieNames",
+    );
+  }
+
   app.post(cfg.path, (req, res) => {
     sweep();
 
+    if (!allowMint(String(req.ip || ""), cfg.maxMintsPerIpPerMinute)) {
+      res.status(429).json({ ok: false, error: "too many handoff requests" });
+      return;
+    }
+
+    if (tickets.size >= cfg.maxPendingTickets) {
+      res.status(503).json({ ok: false, error: "handoff ticket store is full" });
+      return;
+    }
+
     const name = typeof req.body?.name === "string" ? req.body.name.trim() : "";
     const value = typeof req.body?.value === "string" ? req.body.value : "";
     const next = typeof req.body?.next === "string" ? req.body.next.trim() : "";
@@ -170,6 +239,19 @@ export function mountAuthHandoff(app) {
       return;
     }
 
+    if (!isValidCookieName(name)) {
+      res.status(400).json({ ok: false, error: "invalid cookie name" });
+      return;
+    }
+
+    if (cfg.allowedCookieNames.length === 0 || !cfg.allowedCookieNames.includes(name)) {
+      res.status(400).json({
+        ok: false,
+        error: "cookie name is not in allowedCookieNames",
+      });
+      return;
+    }
+
     if (Buffer.byteLength(value, "utf8") > cfg.maxValueBytes) {
       res.status(400).json({
         ok: false,
@@ -218,6 +300,7 @@ export function mountAuthHandoff(app) {
 /** @returns {void} */
 export function _resetHandoffTickets() {
   tickets.clear();
+  mintWindows.clear();
 }
 
 /** @returns {number} */

package/src/server/create-app.js

@@ -12,6 +12,9 @@
  *      açık kurallar istenen yolu önce görür.
  *   3b. access log (açıksa) — tamamlanan yanıtların süresi; admin/prewarm
  *      içeride elenir.
+ *   3c. robots.txt — statikten önce, compression'ın içinde: kullanıcının
+ *      gövdesine framework Disallow bloğu eklenir. Sıkıştırılmış kopyanın
+ *      (Content-Encoding dolu) üzerine yazılmaz.
  *   4. staticPrecompressed → express.static — build'de üretilmiş `.br`/`.gz`
  *      kopyalar varsa onlar servis edilir (kalite 11), yoksa istek altındaki
  *      static'e düşer ve middleware anında sıkıştırır (kalite 5).
@@ -21,18 +24,18 @@
  *      body parser'dan önce, admin ile aynı katmanda.
  *   5. body parser'lar — statikten sonra: görsel isteklerinde gövde ayrıştırma
  *      maliyeti ödenmesin.
- *   5b. auth handoff (açıksa) — POST bilet + `?handoff=` redeem; csrf'den
- *      önce değil sonra: JSON gövde parser'ı hazır olsun. Redeem GET route
- *      render'ından önce olmalı.
- *   6. csrf — body parser'lardan sonra olmalı: token form alanından okunuyor.
+ *   5b. csrf — body parser'lardan sonra: token form alanından okunuyor.
  *      Rewrite'lardan önce, çünkü kontrol istemcinin gördüğü yola bakar.
- *   7. rewrites(afterFiles) — statik denendikten sonra, sayfalardan önce.
- *   8. route'lar → 404 → hata yönetimi.
+ *   5c. auth handoff (açıksa) — CSRF'den *sonra*: mint POST origin koruması
+ *      görsün. Redeem GET güvenli metot; route render'ından önce kalır.
+ *   6. rewrites(afterFiles) — statik denendikten sonra, sayfalardan önce.
+ *   7. route'lar → 404 → hata yönetimi.
  */
 import path from "node:path";
 import process from "node:process";
 import express from "express";
 import { compression } from "./middleware/compression.js";
+import { robotsTxtMiddleware } from "./middleware/robots-txt.js";
 import { headersMiddleware } from "./middleware/headers.js";
 import { csrf } from "./middleware/csrf.js";
 import { staticPrecompressed } from "./middleware/static-precompressed.js";
@@ -51,6 +54,7 @@ import { configureUpstreamLimiter } from "./upstream-limiter.js";
 import { connectRedis, disconnectRedis } from "./redis.js";
 import { configureLogs, flushLogs, closeLogs } from "./logs/pipeline.js";
 import { isNotFoundError, isRedirectError } from "../http/control-flow.js";
+import { ensurePortFree } from "./port-guard.js";
 
 /**
  * @param {{ root?: string, configFile?: string }} [options]
@@ -109,6 +113,11 @@ export async function createApp(options = {}) {
     app.use(accessLogMiddleware());
   }
 
+  // Kullanıcının robots.txt'i statik dosya da olabilir, route da. İkisi de
+  // bu sarmalayıcıdan geçer. compression'dan sonra durur: ek, sıkıştırılmış
+  // baytların değil düz metnin sonuna yazılır.
+  app.use(robotsTxtMiddleware());
+
   app.use(staticPrecompressed(config.dirs.public));
   app.use(
     express.static(config.dirs.public, {
@@ -152,6 +161,8 @@ export async function createApp(options = {}) {
   app.use(express.urlencoded({ extended: false, limit: "64kb" }));
   app.use(express.json({ limit: "256kb" }));
 
+  app.use(csrf());
+
   const handoff = config.auth?.crossSubdomainHandoff;
   if (
     handoff === true ||
@@ -163,8 +174,6 @@ export async function createApp(options = {}) {
     mountAuthHandoff(app);
   }
 
-  app.use(csrf());
-
   app.use(configRewrites("afterFiles"));
 
   await registerRoutes(app);
@@ -222,12 +231,21 @@ export async function createApp(options = {}) {
  * Uygulamayı kurup dinlemeye başlar. CLI `jskelet start` bunu çağırır;
  * gömülü kullanımda `createApp()` tercih edilir.
  *
- * @param {{ root?: string, configFile?: string, port?: number, host?: string }} [options]
+ * Port doluysa başlamaz. `murder: true` veya argv'de `--murder` varsa
+ * dinleyen süreç öldürülüp bağlama denenir.
+ *
+ * @param {{ root?: string, configFile?: string, port?: number, host?: string, murder?: boolean }} [options]
  * @returns {Promise<import('http').Server>}
  */
 export async function startServer(options = {}) {
-  const app = await createApp(options);
   const port = Number(options.port ?? process.env.PORT ?? 3000);
+  const murder =
+    options.murder === true || process.argv.includes("--murder");
+
+  // createApp pahalı; dolu portta uygulama kurmadan önce net hata ver.
+  await ensurePortFree(port, { murder });
+
+  const app = await createApp(options);
 
   // 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üğü
@@ -276,6 +294,15 @@ export async function startServer(options = {}) {
           listen("0.0.0.0");
           return;
         }
+        if (error.code === "EADDRINUSE") {
+          const hint = murder
+            ? `port ${port} is still in use after --murder`
+            : `port ${port} is already in use. Pass --murder to kill it and start, or set PORT to another value.`;
+          const wrapped = new Error(hint);
+          /** @type {NodeJS.ErrnoException} */ (wrapped).code = "EADDRINUSE";
+          reject(wrapped);
+          return;
+        }
         reject(error);
       });
 

package/src/server/ejs-adapter.js

@@ -0,0 +1,59 @@
+/**
+ * Legacy EJS şablon motoru — opsiyonel peer.
+ *
+ * `.jsk`-only uygulamalar `ejs` kurmadan çalışır. Bir `.ejs` view veya layout
+ * istendiğinde bu modül uygulamadan (yoksa framework'ten) `ejs` yükler;
+ * paket yoksa göç yolunu gösteren net bir hata verir.
+ */
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+import path from "node:path";
+import { getConfig, FRAMEWORK_ROOT } from "../config/index.js";
+import { tryImportFromApp } from "../build/resolve-peer.mjs";
+
+/** @type {import('ejs') | null | undefined} */
+let cached;
+
+const MISSING =
+  "EJS templates require the optional peer dependency `ejs`. " +
+  "Install it (`npm i ejs`) or migrate the template to `.jsk`.";
+
+/**
+ * @returns {Promise<import('ejs')>}
+ */
+export async function loadEjs() {
+  if (cached) return cached;
+  if (cached === null) throw new Error(MISSING);
+
+  const config = getConfig();
+  let mod = await tryImportFromApp(config.root, "ejs");
+
+  // Framework kendi test/dev ortamında peer olarak tutuyor olabilir.
+  if (!mod) {
+    try {
+      const require = createRequire(path.join(FRAMEWORK_ROOT, "package.json"));
+      mod = await import(pathToFileURL(require.resolve("ejs")).href);
+    } catch {
+      mod = null;
+    }
+  }
+
+  if (!mod) {
+    cached = null;
+    throw new Error(MISSING);
+  }
+
+  cached = /** @type {import('ejs')} */ (mod.default ?? mod);
+  return cached;
+}
+
+/**
+ * @param {string} file
+ * @param {Record<string, unknown>} data
+ * @param {object} options
+ * @returns {Promise<string>}
+ */
+export async function renderEjsFile(file, data, options) {
+  const ejs = await loadEjs();
+  return ejs.renderFile(file, data, options);
+}

package/src/server/html-cache.js

@@ -31,10 +31,13 @@
  */
 
 import { getConfig } from "../config/index.js";
-import { DEFAULT_HTML_CACHE_MAX_ENTRIES } from "../config/defaults.js";
+import {
+  DEFAULT_HTML_CACHE_MAX_ENTRIES,
+  HTML_CACHE_BYTE_BUDGET,
+} from "../config/defaults.js";
 import { collectDependencies } from "./cache-deps.js";
 import { compilePattern, matchPattern } from "../config/pattern.js";
-import { pathOfCacheKey } from "./cache-vary.js";
+import { pathOfCacheKey, publicHost } from "./cache-vary.js";
 import {
   cacheKey,
   onCacheEvent,
@@ -118,6 +121,19 @@ const EARLY_SWEEP_INTERVAL_MS = 1000;
 /** @type {Map<string, HtmlEntry>} */
 const store = new Map();
 
+/**
+ * `store` içindeki HTML string + sıkıştırılmış gövdelerin toplamı.
+ * Her `drop` / `install` bunu günceller; sıkıştırma sonradan eklendiğinde
+ * `noteHtmlCacheGrowth` artışı yazar. Tam tarama yapmamak için tutulur.
+ */
+let storedBytes = 0;
+
+/**
+ * Testler tahliyeyi küçük bir bütçeyle doğrular. `null` → üretim tavanı.
+ * @type {number | null}
+ */
+let byteBudgetOverride = null;
+
 /** @type {Map<string, Promise<{ html: string, status: number }>>} */
 const inflight = new Map();
 
@@ -237,8 +253,45 @@ function unlink(key, entry) {
 }
 
 /**
- * Store'dan silmenin **tek** yolu. Ters indeks bakımı buraya bağlı olduğu için
- * hiçbir yerde doğrudan `store.delete()` çağrılmaz.
+ * Ham HTML + sıkıştırılmış gövdeler. Bayt bütçesi girdi sayısından bağımsız
+ * bu ağırlığa bakar.
+ *
+ * @param {HtmlEntry} entry
+ * @returns {number}
+ */
+function entryBytes(entry) {
+  let bytes = Buffer.byteLength(entry.html);
+  for (const buffer of entry.encoded.values()) bytes += buffer.length;
+  return bytes;
+}
+
+/**
+ * @returns {number}
+ */
+function activeByteBudget() {
+  return byteBudgetOverride ?? HTML_CACHE_BYTE_BUDGET;
+}
+
+/**
+ * Sayı tavanı veya bayt bütçesi aşılınca en eski girdiden düşer. Tek başına
+ * bütçeyi aşan girdi de gider: yanıt o istekte zaten üretilmiştir, L1'de
+ * durması süreci şişirir.
+ */
+function evictOverflow() {
+  const limit = maxEntries();
+  const budget = activeByteBudget();
+
+  while (store.size > 0 && (store.size > limit || storedBytes > budget)) {
+    const oldest = store.keys().next().value;
+    if (oldest === undefined) break;
+    if (!drop(oldest)) break;
+  }
+}
+
+/**
+ * Store'dan silmenin **tek** yolu. Ters indeks ve bayt sayacı buraya bağlı;
+ * hiçbir yerde doğrudan `store.delete()` çağrılmaz. `read()` içindeki
+ * sil-yaz yalnızca LRU sırası içindir, sayacı değiştirmez.
  *
  * @param {string} key
  * @returns {boolean} Girdi var mıydı.
@@ -248,6 +301,7 @@ function drop(key) {
   if (!entry) return false;
 
   unlink(key, entry);
+  storedBytes = Math.max(0, storedBytes - entryBytes(entry));
   store.delete(key);
   return true;
 }
@@ -406,8 +460,9 @@ function write(key, value, ttlSeconds, deps = null, produceMs = DEFAULT_PRODUCE_
     produceMs: normalizeProduceMs(produceMs),
   };
 
-  install(key, entry);
-  share(key, entry);
+  // 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);
 }
 
 /**
@@ -416,13 +471,20 @@ function write(key, value, ttlSeconds, deps = null, produceMs = DEFAULT_PRODUCE_
  *
  * @param {string} key
  * @param {HtmlEntry} entry
+ * @returns {boolean} Girdi L1'e girdi mi.
  */
 function install(key, entry) {
   // Aynı anahtarın eski girdisi ters indekste kalmasın: bağımlılıklar
   // tazelemeden tazelemeye değişebilir.
   drop(key);
 
+  const weight = entryBytes(entry);
+  // Tek sayfa bütçeden büyükse saklama. Eski kopya da düştü; bu yanıt
+  // üreticinin döndürdüğü HTML ile gider, L1'e girmez.
+  if (weight > activeByteBudget()) return false;
+
   store.set(key, entry);
+  storedBytes += weight;
 
   for (const dep of entry.deps) {
     let set = dependents.get(dep);
@@ -430,12 +492,35 @@ function install(key, entry) {
     set.add(key);
   }
 
-  const limit = maxEntries();
-  while (store.size > limit) {
-    const oldest = store.keys().next().value;
-    if (oldest === undefined) break;
-    drop(oldest);
-  }
+  evictOverflow();
+  return store.has(key);
+}
+
+/**
+ * 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.
+ *
+ * @returns {void}
+ */
+export function noteHtmlCacheGrowth() {
+  let bytes = 0;
+  for (const entry of store.values()) bytes += entryBytes(entry);
+  storedBytes = bytes;
+  evictOverflow();
+}
+
+/**
+ * Bellek freninin bayt tavanını geçici olarak değiştirir. Testler LRU
+ * tahliyesini küçük bir değerle doğrular; `null` üretim tavanına döner.
+ *
+ * @param {number | null} bytes
+ * @returns {void}
+ */
+export function setHtmlCacheByteBudget(bytes) {
+  byteBudgetOverride = bytes == null ? null : bytes;
+  evictOverflow();
 }
 
 /**
@@ -589,6 +674,7 @@ export function clearHtmlCache() {
  */
 function clearLocal() {
   store.clear();
+  storedBytes = 0;
   dependents.clear();
   tokens.clear();
   invalidated.clear();
@@ -877,27 +963,65 @@ function dropLocalKey(key) {
 }
 
 /**
- * Invalidate edilmiş ve henüz kimsenin istemediği yolları döner ve kuyruğu
- * boşaltır. Isıtma turu bunları başa alır; iki tur aynı yolu tekrar
- * ısıtmasın diye okuma yıkıcıdır.
+ * Vary önekinden `h=` parçasını okur. Önek yoksa boş string.
  *
- * Vary öneki (`h=…|`) düşülür — HTTP ısıtması yalnızca yolu ister; host
- * ayrımı `prewarm.origins` / istek Host'u ile yapılır.
+ * @param {string} key
+ * @returns {string}
+ */
+function hostOfCacheKey(key) {
+  const sep = key.indexOf("|/");
+  if (sep === -1) return "";
+  const prefix = key.slice(0, sep);
+  for (const part of prefix.split("&")) {
+    if (part.startsWith("h=")) return part.slice(2);
+  }
+  return "";
+}
+
+/**
+ * @param {string} key
+ * @returns {string}
+ */
+function pathWithQuery(key) {
+  const pathname = pathOfCacheKey(key);
+  const q = key.indexOf("?");
+  if (q === -1) return pathname;
+  const query = key.slice(q + 1);
+  return query ? `${pathname}?${query}` : pathname;
+}
+
+/**
+ * Invalidate edilmiş yollar. Okuma yıkıcıdır; iki tur aynı yolu tekrar
+ * ısıtmasın. `onlyHost` verilirse başka host'ların anahtarları kuyrukta
+ * kalır — süre dolumu onları kendi host'uyla ısıtır, `127.0.0.1` anahtarı
+ * açılmaz.
  *
- * @returns {string[]}
+ * @param {string} [onlyHost]
+ * @returns {{ path: string, host: string }[]}
  */
-export function takeInvalidatedPaths() {
+export function takeInvalidatedTargets(onlyHost) {
   if (!invalidated.size) return [];
 
-  const paths = [...invalidated];
-  invalidated.clear();
-  return paths.map((key) => {
-    const pathname = pathOfCacheKey(key);
-    const q = key.indexOf("?");
-    if (q === -1) return pathname;
-    const query = key.slice(q + 1);
-    return query ? `${pathname}?${query}` : pathname;
-  });
+  /** @type {{ 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 });
+  }
+
+  return taken;
+}
+
+/**
+ * Yol listesi. Vary öneki düşülür; host ayrımı `takeInvalidatedTargets`.
+ *
+ * @returns {string[]}
+ */
+export function takeInvalidatedPaths() {
+  return takeInvalidatedTargets().map((target) => target.path);
 }
 
 /**
@@ -926,14 +1050,36 @@ export function getHtmlCacheEntries() {
  * Yol (query'siz) için taze bir HTML girdisi var mı? Ziyaret ısıtması yalnızca
  * soğuk / bayat hedefleri kuyruğa alır; HIT'leri yeniden çekmez.
  *
+ * Gerçek anahtar `h=host|/yol?` biçimindedir: düz `store.get(pathname)` hem
+ * vary önekini hem sondaki `?` işaretini kaçırır ve sıcak sayfayı yeniden
+ * ısıtır. `vary.host` açıkken yalnızca bu isteğin host'u sayılır; diğer
+ * locale'in kopyası bu yolu sıcak yapmaz.
+ *
  * @param {string} pathname
+ * @param {{ headers?: Record<string, unknown>, get?: (name: string) => string | undefined }} [req]
  * @returns {boolean}
  */
-export function isHtmlCacheFresh(pathname) {
+export function isHtmlCacheFresh(pathname, req) {
   if (typeof pathname !== "string" || !pathname.startsWith("/")) return false;
-  const entry = store.get(pathname);
-  if (!entry) return false;
-  return Date.now() < entry.expiresAt;
+
+  let host = "";
+  try {
+    if (getConfig().cacheVary?.host && req) host = publicHost(req);
+  } catch {
+    // Config yokken (testler) önek aranmaz; yol eşleşmesi yeter.
+  }
+
+  const now = Date.now();
+  for (const [key, entry] of store) {
+    if (now >= entry.expiresAt) continue;
+    if (pathOfCacheKey(key) !== pathname) continue;
+    const q = key.indexOf("?");
+    if (q !== -1 && key.slice(q + 1)) continue;
+    if (host && hostOfCacheKey(key) !== host) continue;
+    return true;
+  }
+
+  return false;
 }
 
 /**