jskelet 0.6.0 → 0.6.2

package/src/server/middleware/robots-txt.js

@@ -0,0 +1,341 @@
+/**
+ * Kullanıcının `robots.txt` gövdesinin altına framework uçlarını ekler.
+ *
+ * Panel, görsel proxy, auth handoff, dev araçları ve fragment parçaları
+ * sayfa değildir; bir crawler onları dizinine alırsa indeks parçalı HTML
+ * ve yönetim yollarıyla kirlenir. Uygulama dosyayı kendisi yazar (`public/`
+ * ya da bir route). Framework yalnızca başarılı metin yanıtının sonuna bir
+ * not ve `Disallow` grubu düşer — dosya yoksa uydurulmaz.
+ *
+ * Google, belirli bir user-agent grubunu `User-agent: *` ile birleştirmez;
+ * aynı ajanın ikinci grubunu birleştirir. Bu yüzden alttaki grup, dosyada
+ * adı geçen her ajanı tekrarlar. Aksi hâlde yalnızca `Googlebot` grubu olan
+ * bir dosyada ek hiç uygulanmazdı.
+ *
+ * Sıkıştırılmış kopyanın (`Content-Encoding` dolu) üzerine yazılmaz: ek,
+ * düz metnin sonuna konur, sıkıştırma dıştaki middleware'de olur.
+ */
+import crypto from "node:crypto";
+import { getConfig } from "../../config/index.js";
+
+/** İdempotency anahtarı. Marka adı değişse de ikinci kez eklenmez. */
+const NOTE_MARK = "framework endpoints, not for indexing";
+
+/** Framework'ün ayırdığı önekler. Özel bir yola taşınsalar da bunlar kalır. */
+const RESERVED_PREFIXES = ["/_jskelet/", "/__jskelet/", "/_fragment/"];
+
+/**
+ * @param {string} [brandName]
+ * @returns {string}
+ */
+export function frameworkRobotsNote(brandName = "JSkelet") {
+  const name = String(brandName || "JSkelet")
+    .replace(/[\r\n]+/g, " ")
+    .trim();
+  return `# ${name || "JSkelet"} — ${NOTE_MARK}`;
+}
+
+/**
+ * `robots.txt`'e yazılacak `Disallow` yolları.
+ *
+ * Üç önek her zaman vardır. Panel, uzak görsel ve handoff yalnızca
+ * gerçekten mount edildiklerinde ve öneklerin dışına taşındıklarında eklenir.
+ * Dev araçlarının özel yolu yalnızca development'ta yazılır: production'da
+ * o yol uygulamanın kendi sayfası olabilir.
+ *
+ * @param {object} [config]
+ * @param {{ dev?: boolean }} [options]
+ * @returns {string[]}
+ */
+export function frameworkDisallowPaths(config = {}, options = {}) {
+  /** @type {string[]} */
+  const paths = [...RESERVED_PREFIXES];
+  const dev = options.dev ?? process.env.NODE_ENV === "development";
+
+  /** @type {string[]} */
+  const extras = [];
+
+  const admin = /** @type {{ enabled?: boolean, basePath?: string }} */ (
+    config.admin
+  );
+  if (admin?.enabled && typeof admin.basePath === "string") {
+    extras.push(admin.basePath);
+  }
+
+  const images = /** @type {{ remote?: { enabled?: boolean, path?: string } | false } | false} */ (
+    config.images
+  );
+  const remote = images && images !== false ? images.remote : null;
+  if (remote && remote !== false && remote.enabled && typeof remote.path === "string") {
+    extras.push(remote.path);
+  }
+
+  const auth = /** @type {{ crossSubdomainHandoff?: boolean | { enabled?: boolean, path?: string } }} */ (
+    config.auth
+  );
+  const handoff = auth?.crossSubdomainHandoff;
+  const handoffOn =
+    handoff === true ||
+    (Boolean(handoff) &&
+      typeof handoff === "object" &&
+      handoff.enabled !== false);
+  if (handoffOn && handoff && typeof handoff === "object" && typeof handoff.path === "string") {
+    extras.push(handoff.path);
+  }
+
+  const brand = /** @type {{ devBasePath?: string }} */ (config.brand);
+  if (dev && typeof brand?.devBasePath === "string") {
+    extras.push(brand.devBasePath);
+  }
+
+  for (const raw of extras) {
+    const path = cleanDisallowPath(raw);
+    if (!path) continue;
+    if (paths.some((existing) => coveredBy(existing, path))) continue;
+    paths.push(path);
+  }
+
+  return paths;
+}
+
+/**
+ * @param {string} body
+ * @param {{ brandName?: string, paths: string[] }} options
+ * @returns {string}
+ */
+export function appendFrameworkRobots(body, options) {
+  const text = String(body ?? "").replace(/^\uFEFF/, "");
+  const paths = options.paths.filter((path) => cleanDisallowPath(path) || isReserved(path));
+  if (paths.length === 0 || text.includes(NOTE_MARK)) return text;
+
+  const agents = collectUserAgents(text);
+  const block = [
+    frameworkRobotsNote(options.brandName),
+    ...agents.map((agent) => `User-agent: ${agent}`),
+    ...paths.map((path) => `Disallow: ${path}`),
+    "",
+  ].join("\n");
+
+  const base = text.replace(/\s*$/, "");
+  return base ? `${base}\n\n${block}` : block;
+}
+
+/**
+ * @returns {import('express').RequestHandler}
+ */
+export function robotsTxtMiddleware() {
+  return function robotsTxt(req, res, next) {
+    if (req.method !== "GET" && req.method !== "HEAD") {
+      next();
+      return;
+    }
+
+    const pathname = req.path || "";
+    if (pathname !== "/robots.txt") {
+      next();
+      return;
+    }
+
+    // Handler'ın kendi ETag'i eklenmemiş gövdeye aittir. 304, crawler'ın
+    // framework bloğu olmayan kopyayı tutmasına yol açardı.
+    const previousEtag = req.headers["if-none-match"];
+    delete req.headers["if-none-match"];
+    delete req.headers["if-modified-since"];
+
+    /** @type {Buffer[]} */
+    const chunks = [];
+    const originalEnd = res.end;
+    let finished = false;
+
+    res.write = function write(chunk, encoding, callback) {
+      const enc = typeof encoding === "function" ? undefined : encoding;
+      const done = typeof encoding === "function" ? encoding : callback;
+      const buf = takeChunk(chunk, enc);
+      if (buf && buf.length) chunks.push(buf);
+      if (typeof done === "function") done();
+      return true;
+    };
+
+    res.end = function end(chunk, encoding, callback) {
+      if (finished) return originalEnd.call(this);
+      finished = true;
+
+      const enc = typeof encoding === "function" ? undefined : encoding;
+      const done =
+        typeof chunk === "function"
+          ? chunk
+          : typeof encoding === "function"
+            ? encoding
+            : callback;
+      const buf = takeChunk(chunk, enc);
+      if (buf && buf.length) chunks.push(buf);
+
+      const body = chunks.length === 0 ? Buffer.alloc(0) : Buffer.concat(chunks);
+
+      if (!shouldRewrite(req, res, body)) {
+        return typeof done === "function"
+          ? originalEnd.call(this, body, done)
+          : originalEnd.call(this, body);
+      }
+
+      const context = readRobotsContext();
+      const nextBody = Buffer.from(
+        appendFrameworkRobots(body.toString("utf8"), context),
+        "utf8",
+      );
+      const tag = `"${crypto.createHash("sha1").update(nextBody).digest("base64url")}"`;
+
+      if (previousEtag && etagMatches(previousEtag, tag)) {
+        res.statusCode = 304;
+        res.setHeader("ETag", tag);
+        res.setHeader("Content-Length", "0");
+        res.removeHeader("Last-Modified");
+        return originalEnd.call(this);
+      }
+
+      const type = String(res.getHeader("content-type") || "");
+      if (!/^text\/plain\b/i.test(type)) {
+        res.setHeader("Content-Type", "text/plain; charset=utf-8");
+      }
+      res.setHeader("ETag", tag);
+      res.setHeader("Content-Length", String(nextBody.length));
+      res.removeHeader("Last-Modified");
+
+      return typeof done === "function"
+        ? originalEnd.call(this, nextBody, done)
+        : originalEnd.call(this, nextBody);
+    };
+
+    next();
+  };
+}
+
+/**
+ * @returns {{ brandName: string, paths: string[] }}
+ */
+function readRobotsContext() {
+  try {
+    const config = getConfig();
+    const brand = /** @type {{ name?: string }} */ (config.brand);
+    return {
+      brandName: typeof brand?.name === "string" && brand.name ? brand.name : "JSkelet",
+      paths: frameworkDisallowPaths(config),
+    };
+  } catch {
+    return { brandName: "JSkelet", paths: frameworkDisallowPaths({}) };
+  }
+}
+
+/**
+ * @param {import('express').Request} req
+ * @param {import('express').Response} res
+ * @param {Buffer} body
+ * @returns {boolean}
+ */
+function shouldRewrite(req, res, body) {
+  if (req.method !== "GET") return false;
+  if (res.headersSent) return false;
+
+  const status = res.statusCode || 200;
+  if (status < 200 || status >= 300) return false;
+  if (res.getHeader("content-encoding")) return false;
+
+  const type = String(res.getHeader("content-type") || "");
+  if (type && !/^text\/(?:plain|html)\b/i.test(type)) return false;
+
+  const sample = body.subarray(0, 64).toString("utf8");
+  if (/^\s*<(!doctype|html)\b/i.test(sample)) return false;
+  return true;
+}
+
+/**
+ * @param {string | string[] | undefined} header
+ * @param {string} tag
+ * @returns {boolean}
+ */
+function etagMatches(header, tag) {
+  const value = Array.isArray(header) ? header.join(",") : String(header);
+  return value.split(",").some((part) => {
+    const token = part.trim().replace(/^W\//i, "");
+    return token === "*" || token === tag;
+  });
+}
+
+/**
+ * @param {unknown} chunk
+ * @param {unknown} encoding
+ * @returns {Buffer | null}
+ */
+function takeChunk(chunk, encoding) {
+  if (chunk == null || typeof chunk === "function") return null;
+  if (Buffer.isBuffer(chunk)) return chunk;
+  if (chunk instanceof Uint8Array) return Buffer.from(chunk);
+  if (typeof chunk === "string") {
+    const enc = typeof encoding === "string" ? encoding : "utf8";
+    return Buffer.from(chunk, /** @type {BufferEncoding} */ (enc));
+  }
+  return null;
+}
+
+/**
+ * @param {string} text
+ * @returns {string[]}
+ */
+function collectUserAgents(text) {
+  /** @type {string[]} */
+  const agents = [];
+  const seen = new Set();
+
+  for (const line of text.split(/\r?\n/)) {
+    const match = /^[ \t]*user-agent[ \t]*:[ \t]*(.*?)[ \t]*$/i.exec(line);
+    if (!match) continue;
+    const agent = match[1].trim();
+    if (!agent || /[\r\n]/.test(agent)) continue;
+    const key = agent.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    agents.push(agent);
+  }
+
+  const star = agents.findIndex((agent) => agent === "*");
+  if (star === -1) agents.unshift("*");
+  else if (star > 0) {
+    agents.splice(star, 1);
+    agents.unshift("*");
+  }
+
+  return agents;
+}
+
+/**
+ * @param {string} raw
+ * @returns {string | null}
+ */
+function cleanDisallowPath(raw) {
+  if (typeof raw !== "string") return null;
+  const pathOnly = raw.split("?")[0].trim();
+  if (!pathOnly.startsWith("/") || /[\s#]/.test(pathOnly)) return null;
+  const trimmed = pathOnly.replace(/\/+$/, "");
+  return trimmed || null;
+}
+
+/**
+ * @param {string} path
+ * @returns {boolean}
+ */
+function isReserved(path) {
+  return RESERVED_PREFIXES.includes(path);
+}
+
+/**
+ * @param {string} rule
+ * @param {string} candidate
+ * @returns {boolean}
+ */
+function coveredBy(rule, candidate) {
+  const ruleExact = rule.replace(/\/+$/, "");
+  const candExact = candidate.replace(/\/+$/, "");
+  if (candExact === ruleExact) return true;
+  const prefix = rule.endsWith("/") ? rule : `${ruleExact}/`;
+  return candidate.startsWith(prefix) || `${candExact}/`.startsWith(prefix);
+}

package/src/server/prewarm.js

@@ -17,9 +17,16 @@
  * middleware zinciri normal trafikle bire bir aynı olsun.
  */
 import process from "node:process";
+import { ON_VISIT_QUEUE_MAX } from "../config/defaults.js";
 import { getConfig, hook } from "../config/index.js";
 import { getRequestContext } from "../http/request-context.js";
-import { isHtmlCacheFresh, takeInvalidatedPaths, startEarlyExpirySweep } from "./html-cache.js";
+import { publicHost } from "./cache-vary.js";
+import {
+  isHtmlCacheFresh,
+  startEarlyExpirySweep,
+  takeInvalidatedPaths,
+  takeInvalidatedTargets,
+} from "./html-cache.js";
 import { getDataCacheStats } from "./data-cache.js";
 import { isTransientStatus } from "./upstream-tracking.js";
 import { upstreamCooldownMs } from "./upstream-limiter.js";
@@ -51,36 +58,39 @@ function resolvePrewarmOrigins(port) {
 }
 
 /**
- * Vary açıkken ısıtma isteği ziyaretçinin Host'unu taşısın — aksi halde
- * loopback anahtarı ısınır, gerçek locale host soğuk kalır.
+ * `vary.host` açıkken ısıtma isteğinin cache anahtarı ziyaretçinin public
+ * host'u olsun. Fetch'in kendi `Host` başlığı loopback'tir ve değiştirilemez;
+ * `x-forwarded-host` ise `publicHost` tarafından önce okunur. İsteği public
+ * origin'e yollamak ALB üzerinden döner ve `h=127.0.0.1` diye ikinci girdi açar.
  *
  * @param {{ get?: (name: string) => string | undefined,
- *   headers?: Record<string, unknown>, protocol?: string } | undefined} req
- * @param {string} fallback
+ *   headers?: Record<string, unknown> } | undefined} req
  * @returns {string}
  */
-function originFromRequest(req, fallback) {
-  if (!req) return fallback;
-
-  let vary;
+function forwardedHostFrom(req) {
+  if (!req) return "";
   try {
-    vary = getConfig().cacheVary;
+    if (!getConfig().cacheVary?.host) return "";
   } catch {
-    return fallback;
+    return "";
   }
-  if (!vary?.host && !vary?.headers?.length && !vary?.fn) return fallback;
-
-  const host =
-    req.get?.("host") ||
-    (typeof req.headers?.host === "string" ? req.headers.host : "");
-  if (!host) return fallback;
-
-  const forwarded = req.headers?.["x-forwarded-proto"];
-  const protoRaw = Array.isArray(forwarded)
-    ? forwarded[0]
-    : forwarded || req.protocol || "http";
-  const proto = String(protoRaw).split(",")[0].trim() || "http";
-  return `${proto}://${host}`;
+  return publicHost(req);
+}
+
+/**
+ * Tazelik kontrolü, ısıtma isteğinin göreceği host ile aynı öneki arasın.
+ *
+ * @param {string} host
+ * @returns {{ headers: Record<string, string>, get: (name: string) => string | undefined } | undefined}
+ */
+function requestForHost(host) {
+  if (!host) return undefined;
+  return {
+    headers: { host, "x-forwarded-host": host },
+    get(name) {
+      return this.headers[name];
+    },
+  };
 }
 
 /** Klasik turu yöneten env'ler; `onVisit` ile birlikte yasak. */
@@ -327,13 +337,19 @@ function createPacer(rps) {
 }
 
 /**
- * `DEV_TOKEN` ayarlıyken `devGate` token taşımayan her isteğe 404 döner.
- * Isıtma kendi sunucusuna istek attığı için token'ı çerez olarak taşımalı;
- * yoksa tüm sayfalar 404 alır ve önbellek hiç dolmaz.
+ * Gate açıkken token taşımayan her isteğe 404 döner. Isıtma kendi sunucusuna
+ * istek attığı için token'ı çerez olarak taşımalı; yoksa tüm sayfalar 404
+ * alır ve önbellek hiç dolmaz. Gate kapalıyken çerez gönderilmez.
  *
  * @returns {Record<string, string>}
  */
 function devGateHeader() {
+  try {
+    if (!getConfig().devGate) return {};
+  } catch {
+    return {};
+  }
+
   const token = process.env.DEV_TOKEN;
   if (!token) return {};
 
@@ -349,12 +365,20 @@ function devGateHeader() {
  *   Tur ilerlemesini `prewarmProgress`'e yazar. Tekrar turunda sayaçların
  *   anlamı değiştiği için çağıran taraf kendi formülünü verir.
  * @param {() => Promise<void>} [pace] İstek başına beklenen hız freni.
+ * @param {string} [forwardedHost] `vary.host` için `x-forwarded-host`.
  * @returns {Promise<{ ok: number, failed: number,
  *   failures: { path: string, status: number }[] }>}
  *   `failures` durum koduyla birlikte döner: tekrar turuna yalnızca geçici
  *   hatalar alınıyor, kalıcı olanı yeniden denemek boşa çağrı.
  */
-async function crawl(origin, paths, concurrency, report = undefined, pace = undefined) {
+async function crawl(
+  origin,
+  paths,
+  concurrency,
+  report = undefined,
+  pace = undefined,
+  forwardedHost = "",
+) {
   const { brand } = getConfig();
   const cacheHeader = brand.cacheHeader.toLowerCase();
 
@@ -379,6 +403,7 @@ async function crawl(origin, paths, concurrency, report = undefined, pace = unde
             // Sıkıştırılmış gövde de cache'lensin.
             "accept-encoding": "br, gzip",
             "user-agent": brand.prewarmUserAgent,
+            ...(forwardedHost ? { "x-forwarded-host": forwardedHost } : {}),
             ...devGateHeader(),
           },
         });
@@ -489,12 +514,14 @@ function upstreamUsage(before) {
 }
 
 /**
- * @param {{ origin: string, quiet?: boolean, paths?: string[] }} options
+ * @param {{ origin: string, quiet?: boolean, paths?: string[],
+ *   forwardedHost?: string }} options
  *   `paths` verilirse hook çağrılmaz, yalnızca o yollar ısıtılır (dev
- *   panelindeki "tekrar dene" bunu kullanır).
+ *   panelindeki "tekrar dene" bunu kullanır). `forwardedHost` loopback
+ *   isteğine public host'u taşır; cache anahtarı `h=127.0.0.1` olmasın.
  * @returns {Promise<{ ok: number, failed: number, total: number, elapsed: number }>}
  */
-export async function prewarm({ origin, quiet = false, paths: only }) {
+export async function prewarm({ origin, quiet = false, paths: only, forwardedHost = "" }) {
   const started = Date.now();
   const limit = setting("PREWARM_MAX", "max", 400);
   const isDev = process.env.NODE_ENV === "development";
@@ -560,6 +587,7 @@ export async function prewarm({ origin, quiet = false, paths: only }) {
       concurrency,
       undefined,
       pace,
+      forwardedHost,
     ));
 
     // Hatalar çoğunlukla upstream rate limit'i (429): ilk tur yüzlerce sayfayı
@@ -584,6 +612,7 @@ export async function prewarm({ origin, quiet = false, paths: only }) {
           prewarmProgress.failed = firstFailed - retriedOk;
         },
         pace,
+        forwardedHost,
       );
       recovered = retry.ok;
       ok += retry.ok;
@@ -736,6 +765,12 @@ function normalizeWarmPath(href, basePath = "/") {
 
 /** @type {string | null} */
 let visitOrigin = null;
+/**
+ * onVisit turunun `x-forwarded-host` değeri. Boşsa vary kapalıdır ve
+ * loopback anahtarı doğrudur.
+ * @type {string}
+ */
+let visitForwardedHost = "";
 /** @type {string[]} */
 const visitPending = [];
 /** @type {Set<string>} */
@@ -774,8 +809,9 @@ export function noteVisitWarm(html, context) {
     /** @type {string | undefined} */ (context.req?.headers?.["user-agent"]);
   if (ua && ua === getConfig().brand.prewarmUserAgent) return;
 
-  // Vary açıksa bu ziyaretin Host'u üzerinden ısıt — loopback anahtarı değil.
-  visitOrigin = originFromRequest(context.req, visitOrigin);
+  // Public origin'e çıkmak yerine loopback'te kal, host'u başlıkla taşı.
+  visitForwardedHost = forwardedHostFrom(context.req);
+  const freshReq = requestForHost(visitForwardedHost);
 
   const perPage = Number(getConfig().prewarm?.onVisit?.perPage) || 20;
   const links = extractSameOriginLinks(html, {
@@ -785,16 +821,29 @@ export function noteVisitWarm(html, context) {
 
   for (const path of links) {
     if (path === context.path) continue;
-    if (isHtmlCacheFresh(path)) continue;
-    if (visitQueued.has(path)) continue;
-    visitQueued.add(path);
-    visitPending.push(path);
+    if (isHtmlCacheFresh(path, freshReq)) continue;
+    if (!enqueueWarmPath(path)) break;
   }
 
   enqueueInvalidatedForVisit();
   if (visitPending.length) void drainVisitWarm();
 }
 
+/**
+ * Kuyruk tavanı dolunca yeni yol alınmaz. Birikmiş yüzlerce link, rps
+ * freni olsa bile task'ı uzun süre meşgul eder.
+ *
+ * @param {string} path
+ * @returns {boolean} Kuyruğa girdi mi.
+ */
+function enqueueWarmPath(path) {
+  if (visitPending.length >= ON_VISIT_QUEUE_MAX) return false;
+  if (visitQueued.has(path)) return false;
+  visitQueued.add(path);
+  visitPending.push(path);
+  return true;
+}
+
 /**
  * Invalidate edilmiş yolları da kuyruğa alır (klasik turdaki
  * `takeInvalidatedPaths` karşılığı).
@@ -802,10 +851,13 @@ export function noteVisitWarm(html, context) {
  * @returns {void}
  */
 function enqueueInvalidatedForVisit() {
-  for (const path of takeInvalidatedPaths()) {
-    if (visitQueued.has(path)) continue;
-    visitQueued.add(path);
-    visitPending.push(path);
+  // Başka locale'in anahtarını bu ziyaretçinin host'uyla ısıtma; süre
+  // dolumu onları kendi `x-forwarded-host` değeriyle alır.
+  for (const target of takeInvalidatedTargets(visitForwardedHost || undefined)) {
+    if (isHtmlCacheFresh(target.path, requestForHost(target.host || visitForwardedHost))) {
+      continue;
+    }
+    if (!enqueueWarmPath(target.path)) break;
   }
 }
 
@@ -822,17 +874,23 @@ async function drainVisitWarm() {
       const batch = visitPending.splice(0, 32);
       for (const path of batch) visitQueued.delete(path);
 
-      const cold = batch.filter((path) => !isHtmlCacheFresh(path));
+      const cold = batch.filter(
+        (path) => !isHtmlCacheFresh(path, requestForHost(visitForwardedHost)),
+      );
       if (!cold.length) continue;
 
       // Klasik `prewarm()` turunu yeniden kullan: retry, progress, UA aynı.
-      // onVisit.concurrency / rps verilmişse `visitWarmSettings` ile iner;
-      // yoksa `prewarm()` kendi (env → config → isDev) zincirine düşer.
+      // onVisit.concurrency / rps config tavanına çekilmiş hâlde iner.
       visitWarmSettings.concurrency = onVisit.concurrency;
       visitWarmSettings.rps = onVisit.rps;
 
       try {
-        await prewarm({ origin: visitOrigin, paths: cold, quiet: true });
+        await prewarm({
+          origin: visitOrigin,
+          paths: cold,
+          quiet: true,
+          forwardedHost: visitForwardedHost,
+        });
       } catch (error) {
         console.error("[prewarm] onVisit warm failed", error);
       } finally {
@@ -953,16 +1011,44 @@ function startExpiryWarmDrain(origins) {
 async function drainExpiryWarm() {
   if (expiryDraining || !expiryOrigins.length) return;
 
-  const paths = takeInvalidatedPaths();
-  if (!paths.length) return;
+  const targets = takeInvalidatedTargets();
+  if (!targets.length) return;
 
   expiryDraining = true;
   try {
-    const cold = paths.filter((path) => !isHtmlCacheFresh(path));
-    if (!cold.length) return;
+    /** @type {Map<string, string[]>} */
+    const byHost = new Map();
+    for (const target of targets) {
+      if (isHtmlCacheFresh(target.path, requestForHost(target.host))) continue;
+      const host = target.host || "";
+      const list = byHost.get(host);
+      if (list) list.push(target.path);
+      else byHost.set(host, [target.path]);
+    }
+    if (!byHost.size) return;
 
-    for (const origin of expiryOrigins) {
-      await prewarm({ origin, paths: cold, quiet: true });
+    // Vary kapalı: anahtarda host yok, her yapılandırılmış origin ısınır.
+    const bare = byHost.get("") ?? [];
+    if (bare.length && byHost.size === 1) {
+      for (const origin of expiryOrigins) {
+        await prewarm({ origin, paths: bare, quiet: true });
+      }
+      return;
+    }
+
+    // Host'lu anahtar loopback'e gider. `x-forwarded-host` cache anahtarını
+    // public host yapar; aksi hâlde `h=127.0.0.1|/yol` diye ikinci girdi
+    // açılır ve `maxEntries` slotunu yer.
+    const origin = expiryOrigins[0];
+    for (const [host, paths] of byHost) {
+      if (!paths.length) continue;
+      if (!host) {
+        for (const next of expiryOrigins) {
+          await prewarm({ origin: next, paths, quiet: true });
+        }
+        continue;
+      }
+      await prewarm({ origin, paths, quiet: true, forwardedHost: host });
     }
   } catch (error) {
     console.error("[prewarm] expiry warm failed", error);

package/src/server/render.js

@@ -17,7 +17,7 @@ import path from "node:path";
 import process from "node:process";
 import fs from "node:fs";
 import { pathToFileURL } from "node:url";
-import { withHtmlCache } from "./html-cache.js";
+import { noteHtmlCacheGrowth, withHtmlCache } from "./html-cache.js";
 import { buildVaryPrefix } from "./cache-vary.js";
 import { getConfig, hook, FRAMEWORK_ROOT } from "../config/index.js";
 import { matchPattern } from "../config/pattern.js";
@@ -700,6 +700,8 @@ async function sendHtml(req, res, body, encoded, options = {}) {
   if (!buffer) {
     buffer = await encodeText(body, encoding);
     encoded.set(encoding, buffer);
+    // Gövde L1 girdisine sonradan eklenir; bayt bütçesi ham HTML'i aşmasın.
+    noteHtmlCacheGrowth();
   }
 
   res.setHeader("Content-Encoding", encoding);