jskelet 0.5.5 → 0.6.1

package/src/server/port-guard.js

@@ -0,0 +1,255 @@
+/**
+ * Dinlenecek port doluysa başlamadan önce net bir hata verilir; `--murder`
+ * verilmişse o porttaki dinleyici süreçler öldürülüp bağlama denenir.
+ *
+ * Windows: `netstat` + `taskkill`. Unix: `lsof` (yoksa `ss`) + `process.kill`.
+ * Bu süreçlerin PID'lerini okumak için yerleşik bir Node API'si yok.
+ */
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import process from "node:process";
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * @param {number} ms
+ * @returns {Promise<void>}
+ */
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * `netstat -ano -p tcp` çıktısından LISTENING PID'lerini çıkarır.
+ * `3000` ile `30001` karışmasın diye porttan sonra rakam olmamalı.
+ *
+ * @param {string} stdout
+ * @param {number} port
+ * @returns {number[]}
+ */
+export function parseWindowsNetstat(stdout, port) {
+  const re = new RegExp(
+    String.raw`TCP\s+\S*:${port}(?!\d)\s+\S+\s+LISTENING\s+(\d+)`,
+    "gi",
+  );
+  /** @type {number[]} */
+  const pids = [];
+  for (const match of stdout.matchAll(re)) {
+    pids.push(Number(match[1]));
+  }
+  return pids;
+}
+
+/**
+ * `lsof -t` çıktısı: satır başına bir PID.
+ *
+ * @param {string} stdout
+ * @returns {number[]}
+ */
+export function parseLsofPids(stdout) {
+  return stdout
+    .split(/\r?\n/)
+    .map((line) => Number(line.trim()))
+    .filter((pid) => Number.isInteger(pid) && pid > 0);
+}
+
+/**
+ * `ss -H -lptn` satırlarından `pid=` değerlerini alır.
+ *
+ * @param {string} stdout
+ * @returns {number[]}
+ */
+export function parseSsPids(stdout) {
+  /** @type {number[]} */
+  const pids = [];
+  for (const match of stdout.matchAll(/pid=(\d+)/g)) {
+    pids.push(Number(match[1]));
+  }
+  return pids;
+}
+
+/**
+ * Bu süreç ve ebeveyni öldürülmesin: `--murder` yenilemede kendi CLI'sını
+ * ya da henüz dinlemeyen kendisini vurmasın.
+ *
+ * @param {number} pid
+ * @returns {boolean}
+ */
+function isSafeToKill(pid) {
+  return pid > 0 && pid !== process.pid && pid !== process.ppid;
+}
+
+/**
+ * @param {number} port
+ * @returns {Promise<number[]>}
+ */
+async function listWindows(port) {
+  const { stdout } = await execFileAsync("netstat", ["-ano", "-p", "tcp"], {
+    windowsHide: true,
+    maxBuffer: 10 * 1024 * 1024,
+  });
+  return parseWindowsNetstat(stdout, port);
+}
+
+/**
+ * @param {number} port
+ * @returns {Promise<number[]>}
+ */
+async function listUnix(port) {
+  try {
+    const { stdout } = await execFileAsync(
+      "lsof",
+      ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-t"],
+      { maxBuffer: 1024 * 1024 },
+    );
+    return parseLsofPids(stdout);
+  } catch (error) {
+    // lsof yoksa (exit 1 = dinleyen yok; ENOENT = komut yok) ss'e düş.
+    if (/** @type {NodeJS.ErrnoException} */ (error).code === "ENOENT") {
+      return listUnixSs(port);
+    }
+    const status = /** @type {{ status?: number | null }} */ (error).status;
+    if (status === 1) return [];
+    throw error;
+  }
+}
+
+/**
+ * @param {number} port
+ * @returns {Promise<number[]>}
+ */
+async function listUnixSs(port) {
+  try {
+    const { stdout } = await execFileAsync(
+      "ss",
+      ["-H", "-lptn", `sport = :${port}`],
+      { maxBuffer: 1024 * 1024 },
+    );
+    return parseSsPids(stdout);
+  } catch (error) {
+    if (/** @type {NodeJS.ErrnoException} */ (error).code === "ENOENT") {
+      return [];
+    }
+    const status = /** @type {{ status?: number | null }} */ (error).status;
+    if (status === 1) return [];
+    throw error;
+  }
+}
+
+/**
+ * Portu dinleyen yabancı süreçlerin PID listesi.
+ *
+ * @param {number} port
+ * @returns {Promise<number[]>}
+ */
+export async function listListeningPids(port) {
+  const raw =
+    process.platform === "win32"
+      ? await listWindows(port)
+      : await listUnix(port);
+  return [...new Set(raw)].filter(isSafeToKill);
+}
+
+/**
+ * @param {number} pid
+ * @returns {Promise<void>}
+ */
+async function killPid(pid) {
+  if (process.platform === "win32") {
+    try {
+      await execFileAsync("taskkill", ["/PID", String(pid), "/F"], {
+        windowsHide: true,
+      });
+    } catch (error) {
+      // Süreç zaten gitmiş olabilir.
+      const status = /** @type {{ status?: number | null }} */ (error).status;
+      if (status === 128 || status === 1) return;
+      throw error;
+    }
+    return;
+  }
+
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch (error) {
+    if (/** @type {NodeJS.ErrnoException} */ (error).code === "ESRCH") return;
+    throw error;
+  }
+
+  await sleep(200);
+  try {
+    process.kill(pid, 0);
+    process.kill(pid, "SIGKILL");
+  } catch {
+    // ESRCH: SIGTERM yetmiş.
+  }
+}
+
+/**
+ * Porttaki dinleyicileri öldürür ve soketin boşalmasını kısa süre bekler.
+ *
+ * @param {number} port
+ * @returns {Promise<number[]>} öldürülen PID'ler
+ */
+export async function murderPort(port) {
+  const pids = await listListeningPids(port);
+  for (const pid of pids) {
+    await killPid(pid);
+  }
+
+  const deadline = Date.now() + 3000;
+  while (Date.now() < deadline) {
+    const still = await listListeningPids(port);
+    if (still.length === 0) return pids;
+    await sleep(50);
+  }
+
+  return pids;
+}
+
+/**
+ * Port doluysa ya net hata fırlatır ya da `--murder` ile temizler.
+ *
+ * Dinleyici listesi alınamazsa (araç yok / yetki) sessizce geçer; asıl bağlama
+ * `EADDRINUSE` ile yine düşer.
+ *
+ * @param {number} port
+ * @param {{ murder?: boolean }} [options]
+ * @returns {Promise<void>}
+ */
+export async function ensurePortFree(port, options = {}) {
+  const murder = options.murder === true;
+
+  /** @type {number[]} */
+  let pids;
+  try {
+    pids = await listListeningPids(port);
+  } catch {
+    return;
+  }
+
+  if (pids.length === 0) return;
+
+  if (!murder) {
+    const error = new Error(
+      `port ${port} is already in use (pid ${pids.join(", ")}). ` +
+        `Pass --murder to kill it and start, or set PORT to another value.`,
+    );
+    /** @type {NodeJS.ErrnoException} */ (error).code = "EADDRINUSE";
+    throw error;
+  }
+
+  console.error(
+    `[jskelet] port ${port} in use by pid ${pids.join(", ")} — killing (--murder)`,
+  );
+  await murderPort(port);
+
+  const still = await listListeningPids(port);
+  if (still.length > 0) {
+    const error = new Error(
+      `port ${port} still in use after --murder (pid ${still.join(", ")})`,
+    );
+    /** @type {NodeJS.ErrnoException} */ (error).code = "EADDRINUSE";
+    throw error;
+  }
+}

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

@@ -1,5 +1,6 @@
 /**
- * EJS render katmanı + HTML TTL cache (ISR ikamesi).
+ * Render katmanı + HTML TTL cache (ISR ikamesi).
+ * Varsayılan şablon yolu derlenmiş `.jsk`; EJS opsiyonel legacy peer.
  *
  * Controller sözleşmesi:
  *   async (ctx) => { view, data?, metadata?, status?, revalidate?, head?,
@@ -16,10 +17,9 @@ import path from "node:path";
 import process from "node:process";
 import fs from "node:fs";
 import { pathToFileURL } from "node:url";
-import ejs from "ejs";
-import { withHtmlCache } from "./html-cache.js";
+import { noteHtmlCacheGrowth, withHtmlCache } from "./html-cache.js";
 import { buildVaryPrefix } from "./cache-vary.js";
-import { getConfig, hook } from "../config/index.js";
+import { getConfig, hook, FRAMEWORK_ROOT } from "../config/index.js";
 import { matchPattern } from "../config/pattern.js";
 import { encodeText, negotiateEncoding } from "./middleware/compression.js";
 import { navigationHints, preconnectHints } from "./head-hints.js";
@@ -48,15 +48,16 @@ import {
   getComponentDirs,
   getViewRoots,
 } from "../compile/index.js";
+import { renderEjsFile } from "./ejs-adapter.js";
 
 const isDev = process.env.NODE_ENV === "development";
 
 /**
- * Şablonlara otomatik geçen yardımcılar ve EJS ayarları. Bileşen taraması
- * dosya sistemine dokunduğu için bir kez yapılır; config yüklenmeden
+ * Şablonlara otomatik geçen yardımcılar ve (legacy) EJS ayarları. Bileşen
+ * taraması dosya sistemine dokunduğu için bir kez yapılır; config yüklenmeden
  * hesaplanamaz, bu yüzden ilk render'da kurulur.
  *
- * @type {{ helpers: Record<string, unknown>, options: ejs.Options,
+ * @type {{ helpers: Record<string, unknown>, options: Record<string, unknown>,
  *   viewsDir: string, viewRoots: string[], layout: string,
  *   compiled: Map<string, (data: object, helpers: object) => string>,
  *   layoutRender: ((data: object, helpers: object) => string) | null
@@ -89,6 +90,9 @@ async function getEngine() {
     Icon: (props) => tags.icon(props),
     CsrfField: () => tags.csrfField(),
     PreloadImage: (props) => tags.preloadImage(props),
+    Stylesheets: (props) => tags.stylesheets(props),
+    BodyScripts: (props) => tags.bodyScripts(props),
+    JsonLd: (props) => tags.jsonLd(props),
   };
 
   // camelCase JS bileşenlerini PascalCase etiket adıyla da erişilebilir yap.
@@ -99,7 +103,21 @@ async function getEngine() {
     if (!(pascal in helpers)) helpers[pascal] = value;
   }
 
-  const { compiled, layoutRender } = await loadCompiledTemplates(config, helpers);
+  const { compiled, layoutRender: appLayoutRender } = await loadCompiledTemplates(
+    config,
+    helpers,
+  );
+
+  // Yalnızca framework varsayılan layout'una düşüldüğünde hazır modülü kullan;
+  // uygulamanın kendi layout.jsk'si derlenmemişse sessizce framework'e kayma.
+  let layoutRender = appLayoutRender;
+  if (!layoutRender) {
+    const fwLayout = path.join(FRAMEWORK_ROOT, "src", "templates", "layout.jsk");
+    if (path.resolve(config.layout) === path.resolve(fwLayout)) {
+      const fw = await import("../templates/layout.render.js");
+      if (typeof fw.render === "function") layoutRender = fw.render;
+    }
+  }
 
   engine = {
     viewsDir,
@@ -212,7 +230,7 @@ export async function renderView(view, data = {}) {
   const file =
     findEjsView(viewRoots.length ? viewRoots : [viewsDir], view) ??
     path.join(viewsDir, `${view}.ejs`);
-  return ejs.renderFile(file, { ...helpers, ...data }, options);
+  return renderEjsFile(file, { ...helpers, ...data }, options);
 }
 
 /**
@@ -277,7 +295,7 @@ export async function renderPage(page) {
     );
   }
 
-  return ejs.renderFile(layout, locals, options);
+  return renderEjsFile(layout, locals, options);
 }
 
 /**
@@ -682,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);