jskelet 0.1.6 → 0.2.0

package/src/client/devtools/overlay.js

@@ -397,6 +397,15 @@ let restarts = 0;
  * yenileme yapılır; overlay durumu sekme belleğinde durduğu için panel açık
  * kalmaya devam eder.
  */
+/**
+ * Hiç açılmadan üst üste bu kadar denemeden sonra kanal yerine yedek yola
+ * geçilir. Tek bir başarısızlık yetmiyor: sayfa, sunucunun yeniden başlama
+ * penceresinde açılmış olabilir ve o an soket kurulamaz.
+ */
+const SOCKET_ATTEMPTS = 4;
+
+let socketFailures = 0;
+
 function connectSocket() {
   let socket;
   try {
@@ -408,12 +417,11 @@ function connectSocket() {
     return;
   }
 
-  // Soket hiç açılamazsa (proxy WebSocket'i geçirmiyor olabilir) eski
-  // SSE + yoklama yoluna düşülür; dev akışı bir ara katman yüzünden körelmesin.
   let opened = false;
 
   socket.addEventListener("open", () => {
     opened = true;
+    socketFailures = 0;
   });
 
   socket.addEventListener("message", (event) => {
@@ -421,18 +429,31 @@ function connectSocket() {
   });
 
   socket.addEventListener("close", () => {
-    if (!opened) {
-      startFallback();
-      return;
-    }
-
-    // Sunucu yeniden başlıyor: gösterge "bağlantı yok"a döner ve kısa aralıkla
+    // Sunucu yeniden başlıyor olabilir: gösterge "bağlantı yok"a döner ve
     // yeniden denenir. Açılışta gelen `hello` yeniden başlatmayı bildirir.
     if (!offline) {
       offline = true;
       render();
     }
-    setTimeout(connectSocket, 500);
+
+    if (opened) {
+      socketFailures = 0;
+      setTimeout(connectSocket, 500);
+      return;
+    }
+
+    socketFailures += 1;
+
+    // Kanal hiç kurulamıyorsa araya giren bir katman WebSocket'i geçirmiyor
+    // demektir; dev akışı bunun yüzünden körelmesin diye eski yola düşülür.
+    if (socketFailures >= SOCKET_ATTEMPTS) {
+      startFallback();
+      return;
+    }
+
+    // Yeniden başlatma birkaç saniye sürebiliyor; aralık kademeli açılır ki
+    // tarayıcı konsolu başarısız bağlantı satırlarıyla dolmasın.
+    setTimeout(connectSocket, socketFailures * 700);
   });
 }
 

package/src/config/defaults.js

@@ -120,6 +120,41 @@ export const DEFAULT_DATA_CACHE = {
   staleFactor: 10,
 };
 
+/**
+ * Opsiyonel Redis ikinci kademesi (L2).
+ *
+ * Redis **birincil store değil**: bellek içi önbellek (L1) aynen kalır, Redis
+ * iki iş yapar — L1'de bulunmayan bir sayfa için render'ı atlatmak ve
+ * invalidation'ı bütün node'lara yaymak. Tek instance çalışan bir kurulumda
+ * kazanç neredeyse yok; bu yüzden `enabled` varsayılan olarak kapalı.
+ *
+ * `storeEncoded` kapalı, çünkü sıkıştırılmış gövdeleri de paylaşmak girdi
+ * başına boyutu iki-üç katına çıkarır ve brotli'yi yeniden üretmek Redis'ten
+ * indirmekten çoğu zaman daha ucuz.
+ */
+export const DEFAULT_REDIS = {
+  enabled: false,
+  /** `redis://` ya da `rediss://`. Boşsa ioredis varsayılanı (localhost:6379). */
+  url: /** @type {string | null} */ (null),
+  /** Aynı Redis'i paylaşan birden fazla uygulamayı ayırır. */
+  namespace: "default",
+  keyPrefix: "_jskelet",
+  /** HTML gövdeleri paylaşılsın mı. */
+  html: true,
+  /** Veri önbelleği paylaşılsın mı. */
+  data: true,
+  /** Brotli/gzip gövdeleri de paylaşılsın mı. */
+  storeEncoded: false,
+  /** pub/sub üzerinden invalidation yayını. */
+  events: true,
+  /**
+   * Tek bir komutun en fazla bekletebileceği süre. Önbellek okuması isteği
+   * bloklayan bir adım: Redis takıldığında render'a düşmek, ağı beklemekten
+   * iyidir.
+   */
+  commandTimeoutMs: 200,
+};
+
 /** Oturuma bağlı sayfalar ısıtılmaz; uygulama kendi listesini verebilir. */
 export const DEFAULT_PREWARM_SKIP = ["/api/", "/_fragment/", "/__jskelet/"];
 

package/src/config/index.js

@@ -16,7 +16,7 @@
  *   redirects() → [{ source, destination, permanent?, statusCode? }]
  *   rewrites()  → [{ source, destination }] | { beforeFiles?, afterFiles? }
  *   cache()     → { html?: { [source]: saniye }, maxEntries?: number,
- *                   data?: {...}, prewarm?: {...} }
+ *                   data?: {...}, redis?: {...}, prewarm?: {...} }
  *
  * Fonksiyon olmayan bölümler (`brand`, `security`, `static`, `navigation`…)
  * düz nesne olarak okunur.
@@ -36,6 +36,7 @@ import {
   DEFAULT_NAVIGATION_EXCLUDE,
   DEFAULT_PREWARM,
   DEFAULT_PREWARM_SKIP,
+  DEFAULT_REDIS,
   DEFAULT_SECURITY,
   DEFAULT_STATIC,
   DEFAULT_TRANSIENT_RETRY,
@@ -56,6 +57,19 @@ const CONFIG_FILE = "jskelet.config.mjs";
  * @property {string[]} exclude Spekülasyon dışı bırakılan href desenleri.
  */
 
+/**
+ * @typedef {object} RedisConfig
+ * @property {boolean} enabled
+ * @property {string | null} url
+ * @property {string} namespace
+ * @property {string} keyPrefix
+ * @property {boolean} html HTML gövdeleri paylaşılsın mı.
+ * @property {boolean} data Veri önbelleği paylaşılsın mı.
+ * @property {boolean} storeEncoded Sıkıştırılmış gövdeler de paylaşılsın mı.
+ * @property {boolean} events pub/sub invalidation yayını.
+ * @property {number} commandTimeoutMs
+ */
+
 /**
  * @typedef {import('./pattern.js').CompiledPattern} CompiledPattern
  *
@@ -72,6 +86,7 @@ const CONFIG_FILE = "jskelet.config.mjs";
  * @property {boolean} trackUpstream `fetch` sarılıp geçici hatalar otomatik bildirilsin mi.
  * @property {boolean} trackDependencies Render'ın okuduğu veri anahtarları kaydedilsin mi.
  * @property {{ attempts: number, delayMs: number }} transientRetry
+ * @property {RedisConfig} redis Opsiyonel Redis ikinci kademesi.
  * @property {Record<string, unknown>} prewarm
  * @property {{ source: string, test: (pathname: string) => boolean }[]} prewarmPriority
  * @property {Record<string, unknown>} brand
@@ -207,12 +222,40 @@ function normalizePriority(raw) {
   return out;
 }
 
+/**
+ * Redis bölümü. Bozuk bir değer sunucuyu düşürmemeli: her alan tipine
+ * zorlanır ve `enabled` yalnızca açıkça `true` verildiğinde açılır.
+ *
+ * @param {unknown} raw
+ * @returns {RedisConfig}
+ */
+function normalizeRedis(raw) {
+  const source = /** @type {Record<string, any>} */ (raw ?? {});
+  const timeout = Number(source.commandTimeoutMs);
+
+  return {
+    enabled: source.enabled === true,
+    url: typeof source.url === "string" && source.url ? source.url : null,
+    namespace: String(source.namespace ?? DEFAULT_REDIS.namespace),
+    keyPrefix: String(source.keyPrefix ?? DEFAULT_REDIS.keyPrefix),
+    html: source.html !== false,
+    data: source.data !== false,
+    storeEncoded: source.storeEncoded === true,
+    events: source.events !== false,
+    commandTimeoutMs:
+      Number.isFinite(timeout) && timeout > 0
+        ? Math.floor(timeout)
+        : DEFAULT_REDIS.commandTimeoutMs,
+  };
+}
+
 /**
  * @param {unknown} raw
  * @returns {{ html: ResolvedConfig["html"], htmlMaxEntries: number,
  *   data: Record<string, unknown>, trackUpstream: boolean,
  *   trackDependencies: boolean,
  *   transientRetry: { attempts: number, delayMs: number },
+ *   redis: RedisConfig,
  *   prewarm: Record<string, unknown>,
  *   prewarmPriority: ResolvedConfig["prewarmPriority"] }}
  */
@@ -248,6 +291,7 @@ function normalizeCache(raw) {
       raw?.transientRetry === false
         ? { attempts: 0, delayMs: 0 }
         : { ...DEFAULT_TRANSIENT_RETRY, ...(raw?.transientRetry ?? {}) },
+    redis: normalizeRedis(raw?.redis),
     // Desenler derlenmiş hâlde ayrı alanda tutulur: `prewarm` sayısal
     // ayarların düz torbası olarak kalsın, her turda yeniden derlenmesin.
     prewarm,
@@ -465,6 +509,7 @@ export async function loadConfig(options = {}) {
     trackUpstream,
     trackDependencies,
     transientRetry,
+    redis,
     prewarm,
     prewarmPriority,
   } = normalizeCache(cache);
@@ -484,6 +529,7 @@ export async function loadConfig(options = {}) {
     trackUpstream,
     trackDependencies,
     transientRetry,
+    redis,
     prewarm,
     prewarmPriority,
     brand,

package/src/index.js

@@ -53,6 +53,9 @@ export {
   getDataCacheSize,
   withDataCache,
 } from "./server/data-cache.js";
+// Paylaşımlı önbellek kademesinin durumu. Bağlantı kurulmamışken de güvenle
+// çağrılır; healthcheck uçları bunu okuyor.
+export { getRedisStatus } from "./server/redis.js";
 export { prewarm, prewarmProgress } from "./server/prewarm.js";
 export { createProxy } from "./server/middleware/upstream-proxy.js";
 export { getConfig, loadConfig } from "./config/index.js";

package/src/server/assets.js

@@ -60,6 +60,34 @@ export function hasAsset(name) {
   return Boolean(state().manifest[name]);
 }
 
+/** @type {string | null} */
+let buildId = null;
+
+/**
+ * Bu build'i tanımlayan kısa kimlik (`build.json` → `id`).
+ *
+ * Paylaşımlı önbellek anahtarlarının isim alanı bu: saklanan HTML hash'li
+ * varlık yollarını gömdüğü için bir deploy'dan sonra eski HTML **geçersizdir**.
+ *
+ * Build çalışmadıysa `"dev"` döner — build çıktısı olmadan da ayağa kalkma
+ * kuralı burada da geçerli.
+ *
+ * @returns {string}
+ */
+export function getBuildId() {
+  if (!isDev && buildId) return buildId;
+
+  try {
+    const file = path.join(getConfig().dirs.generated, "build.json");
+    const id = JSON.parse(fs.readFileSync(file, "utf8")).id;
+    buildId = typeof id === "string" && id ? id : "dev";
+  } catch {
+    buildId = "dev";
+  }
+
+  return buildId;
+}
+
 /**
  * @typedef {{ width: number, height: number,
  *   variants: { width: number, url: string }[] }} OptimizedImage

package/src/server/create-app.js

@@ -33,8 +33,9 @@ import { IMMUTABLE_CACHE } from "../config/defaults.js";
 import { registerRoutes } from "./router.js";
 import { renderNotFound } from "./render.js";
 import { renderStatusPage, statusFromError } from "./status-page.js";
-import { startPrewarm } from "./prewarm.js";
+import { isPrewarmRequest, notePrewarmError, startPrewarm } from "./prewarm.js";
 import { trackUpstreamFetch } from "./upstream-tracking.js";
+import { connectRedis, disconnectRedis } from "./redis.js";
 import { isNotFoundError, isRedirectError } from "../http/control-flow.js";
 
 /**
@@ -51,6 +52,12 @@ export async function createApp(options = {}) {
   // ilk kurulduğu istek de kapsanmalı.
   if (config.trackUpstream) trackUpstreamFetch();
 
+  // Önbelleğin ikinci kademesi route'lardan önce kurulmalı: ilk istek de
+  // paylaşımlı kopyayı görebilsin. Bağlanamazsa uyarı basılır ve uygulama
+  // bellek içi önbellekle çalışmaya devam eder — middleware sırasına
+  // dokunmayan, tamamen opsiyonel bir adım.
+  await connectRedis(config);
+
   const app = express();
 
   app.disable("x-powered-by");
@@ -132,7 +139,11 @@ export async function createApp(options = {}) {
     }
 
     const status = statusFromError(error);
-    console.error(`[${status}] ${req.method} ${req.originalUrl}`, error);
+    // Isıtma turunun hataları tek tek loglanmaz; tur bitince özet olarak
+    // basılır. Yüzlerce yolu tarayan bir tur, upstream bir an tıksırdığında
+    // logu yığın izleriyle dolduruyordu.
+    if (isPrewarmRequest(req)) notePrewarmError(status, error);
+    else console.error(`[${status}] ${req.method} ${req.originalUrl}`, error);
 
     // Hata sayfası hiçbir katmanda saklanmamalı: geçici bir upstream arızası
     // CDN'de dakikalarca yaşayan bir 500 sayfasına dönüşmesin.
@@ -156,7 +167,14 @@ export async function createApp(options = {}) {
 export async function startServer(options = {}) {
   const app = await createApp(options);
   const port = Number(options.port ?? process.env.PORT ?? 3000);
-  const host = options.host ?? process.env.HOST ?? "0.0.0.0";
+
+  // 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
+  // isteklerde IPv4'e düşüyorlar ama WebSocket el sıkışması bu geri düşüşü
+  // yapmadan "failed" veriyordu. IPv6'sı olmayan bir makinede bağlama hata
+  // verir; aşağıda IPv4'e dönülür.
+  const host = options.host ?? process.env.HOST ?? null;
 
   // Tek bir istek hatası süreci düşürmesin; logla ve ayakta kal. Bir haber
   // sitesinde tek sayfanın hatası tüm siteyi indirmemeli.
@@ -176,17 +194,82 @@ export async function startServer(options = {}) {
       ? (await import("./dev/devtools.js")).attachDevSocket
       : null;
 
-  return new Promise((resolve) => {
-    const server = app.listen(port, host, () => {
-      // Bu satırın biçimi sözleşme: `jskelet dev` sunucunun hazır olduğunu
-      // buradan anlar ve özet satırını ona göre basar.
-      console.log(
-        `jskelet → http://localhost:${port} (${process.env.NODE_ENV ?? "production"})`,
-      );
-      startPrewarm({ port });
-      resolve(server);
-    });
+  return new Promise((resolve, reject) => {
+    /** @param {string} address */
+    const listen = (address) => {
+      const server = app.listen(port, address, () => {
+        // Bu satırın biçimi sözleşme: `jskelet dev` sunucunun hazır olduğunu
+        // buradan anlar ve özet satırını ona göre basar.
+        console.log(
+          `jskelet → http://localhost:${port} (${process.env.NODE_ENV ?? "production"})`,
+        );
+        startPrewarm({ port });
+        attachShutdown(server);
+        resolve(server);
+      });
+
+      server.on("error", (error) => {
+        // IPv6 desteklenmiyorsa yalnızca varsayılan adres için IPv4'e dönülür;
+        // kullanıcı bir adres verdiyse sessizce başkasını dinlemek yanlış olur.
+        if (!host && isAddressUnsupported(error)) {
+          listen("0.0.0.0");
+          return;
+        }
+        reject(error);
+      });
+
+      attachDevSocket?.(server);
+    };
 
-    attachDevSocket?.(server);
+    listen(host ?? "::");
   });
 }
+
+/**
+ * `SIGTERM`/`SIGINT` sonrası düzenli kapanış.
+ *
+ * Kapatılması gereken tek dış bağlantı Redis ve `quit` uçuştaki komutların
+ * bitmesini bekliyor; sert `disconnect` yarıda kalan bir `SET` bırakabiliyor.
+ *
+ * Açık HTTP bağlantıları **beklenmez**. `close()` tek başına yalnızca yeni
+ * bağlantıyı reddediyor; keep-alive bir istemci ya da dev panelinin
+ * WebSocket'i sunucuyu süresiz ayakta tutuyor ve Ctrl+C yanıt vermiyormuş gibi
+ * görünüyordu. Sinyal geldiğinde ters proxy zaten trafik göndermiyor.
+ *
+ * Yine de bir zamanlayıcı var: Redis kapanışı askıda kalırsa süreç `SIGKILL`
+ * beklemek zorunda kalmasın.
+ *
+ * @param {import('http').Server} server
+ */
+function attachShutdown(server) {
+  let closing = false;
+
+  const shutdown = () => {
+    // İkinci sinyal beklemeyi kısa kessin: kullanıcı Ctrl+C'ye tekrar bastıysa
+    // gerçekten çıkmak istiyor.
+    if (closing) process.exit(0);
+    closing = true;
+
+    const timer = setTimeout(() => process.exit(0), 3000);
+    timer.unref();
+
+    server.close();
+    server.closeAllConnections?.();
+
+    void disconnectRedis().finally(() => {
+      clearTimeout(timer);
+      process.exit(0);
+    });
+  };
+
+  process.once("SIGTERM", shutdown);
+  process.once("SIGINT", shutdown);
+}
+
+/**
+ * @param {NodeJS.ErrnoException} error
+ * @returns {boolean} adres ailesi bu makinede kullanılamıyor mu
+ */
+function isAddressUnsupported(error) {
+  return error.code === "EAFNOSUPPORT" || error.code === "EADDRNOTAVAIL";
+}

package/src/server/data-cache.js

@@ -16,11 +16,26 @@
  * genellikle `null` döner ve bunu saklamak, geçici bir 429'u TTL boyunca "veri
  * yok" hâline dondurmak olurdu. Boş cevabı bilinçli olarak saklamak isteyen
  * `storeEmpty: true` verir.
+ *
+ * `cache.redis` açıkken bu önbellek ikinci bir kademeye (L2) yaslanır. Redis'e
+ * en uygun katman burası: JSON küçük, sıkıştırılmış varyant sorunu yok ve
+ * kazanç doğrudan API kotasına yazılıyor — bir node'un çektiği veri hepsine
+ * yeter. Redis kapalı ya da erişilemez olduğunda bu modül birebir eskisi gibi
+ * çalışır.
  */
 import { getConfig } from "../config/index.js";
 import { DEFAULT_DATA_CACHE } from "../config/defaults.js";
 import { recordDependency } from "./cache-deps.js";
 import { invalidateHtmlByDependency } from "./html-cache.js";
+import {
+  cacheKey,
+  onCacheEvent,
+  publishCacheEvent,
+  redisDropMatching,
+  redisGetJson,
+  redisSetJson,
+  redisShares,
+} from "./redis.js";
 
 /**
  * @typedef {{ value: unknown, expiresAt: number, staleUntil: number }} DataEntry
@@ -74,6 +89,16 @@ function read(key) {
   return { value: entry.value, stale: now >= entry.expiresAt };
 }
 
+/** Girdi sınırını aşan en eski kayıtları düşürür. */
+function evict() {
+  const { maxEntries } = settings();
+  while (store.size > maxEntries) {
+    const oldest = store.keys().next().value;
+    if (oldest === undefined) break;
+    store.delete(oldest);
+  }
+}
+
 /**
  * @param {string} key
  * @param {unknown} value
@@ -84,18 +109,55 @@ function write(key, value, ttlSeconds, staleFactor) {
   const now = Date.now();
   const ttl = ttlSeconds * 1000;
 
-  store.set(key, {
+  /** @type {DataEntry} */
+  const entry = {
     value,
     expiresAt: now + ttl,
     staleUntil: now + ttl + ttl * staleFactor,
-  });
+  };
 
-  const { maxEntries } = settings();
-  while (store.size > maxEntries) {
-    const oldest = store.keys().next().value;
-    if (oldest === undefined) break;
-    store.delete(oldest);
+  store.set(key, entry);
+
+  // Redis kopyası ateşle-unut: çağıran taraf beklemez. Anahtarın Redis ömrü
+  // bayat penceresinin sonuna kadar, çünkü bayat veri de işe yarıyor.
+  if (redisShares("data")) {
+    redisSetJson(cacheKey("data", key), entry, entry.staleUntil - now);
   }
+
+  evict();
+}
+
+/**
+ * Başka bir node'un yazdığı girdiyi L1'e alır. TTL yeniden başlatılmaz:
+ * mutlak zamanlar olduğu gibi korunur, yoksa girdi node'dan node'a atlayarak
+ * süresiz tazelik kazanır.
+ *
+ * @param {string} key
+ * @param {DataEntry} entry
+ */
+function promote(key, entry) {
+  store.set(key, entry);
+  evict();
+}
+
+/**
+ * Paylaşımlı kademeden okur.
+ *
+ * Yalnızca **taze** girdi kabul edilir. Bayat bir kopyayı L1'e almak
+ * tazelemeyi sonsuza kadar ertelerdi: girdi bayat kalır, her tazeleme turu
+ * yine Redis'i okur ve `producer` hiç çalışmaz.
+ *
+ * @param {string} key
+ * @returns {Promise<DataEntry | null>}
+ */
+async function readShared(key) {
+  if (!redisShares("data")) return null;
+
+  const entry = await redisGetJson(cacheKey("data", key));
+  if (!entry || typeof entry.expiresAt !== "number") return null;
+  if (Date.now() >= entry.expiresAt) return null;
+
+  return /** @type {DataEntry} */ (entry);
 }
 
 /**
@@ -113,23 +175,41 @@ function refresh(key, ttlSeconds, producer, options) {
 
   const staleFactor = options.staleFactor ?? settings().staleFactor;
 
-  const task = Promise.resolve()
-    .then(producer)
-    .then((value) => {
-      const empty = value === undefined || value === null;
-      if (!empty || options.storeEmpty === true) {
-        write(key, value, ttlSeconds, staleFactor);
-      }
-      return value;
-    })
-    .finally(() => {
-      inflight.delete(key);
-    });
+  const task = produce(key, ttlSeconds, producer, options, staleFactor).finally(() => {
+    inflight.delete(key);
+  });
 
   inflight.set(key, task);
   return task;
 }
 
+/**
+ * @param {string} key
+ * @param {number} ttlSeconds
+ * @param {() => Promise<unknown>} producer
+ * @param {{ storeEmpty?: boolean, staleFactor?: number }} options
+ * @param {number} staleFactor
+ * @returns {Promise<unknown>}
+ */
+async function produce(key, ttlSeconds, producer, options, staleFactor) {
+  // Başka bir node bu anahtarı çoktan tazelediyse upstream'e hiç gitmeyiz.
+  // Kotayı koruyan `inflight` birleştirmesinin küme çapındaki karşılığı bu.
+  const shared = await readShared(key);
+  if (shared) {
+    promote(key, shared);
+    return shared.value;
+  }
+
+  const value = await producer();
+
+  const empty = value === undefined || value === null;
+  if (!empty || options.storeEmpty === true) {
+    write(key, value, ttlSeconds, staleFactor);
+  }
+
+  return value;
+}
+
 /**
  * Veriyi önbellekten döner, gerekiyorsa `producer` ile üretir.
  *
@@ -212,10 +292,38 @@ export function dataCache(fn, options) {
  * uygulamanın ayrıca `invalidateHtmlCache()` çağırması gerekmez ve aynı veriyi
  * gösteren liste sayfalarını unutmak mümkün değildir (bkz. `cache-deps.js`).
  *
+ * `cache.redis` açıkken çağrı ayrıca paylaşımlı kademeden siler ve diğer
+ * node'lara duyurulur — bugün bir webhook yalnızca isteği alan node'un
+ * önbelleğini tazeliyor, diğerleri TTL'i bekliyordu.
+ *
  * @param {string} [prefix] Verilmezse tüm önbellek boşaltılır.
  * @returns {number} Silinen girdi sayısı.
  */
 export function clearDataCache(prefix) {
+  const removed = clearLocal(prefix);
+
+  if (redisShares("data")) {
+    void redisDropMatching(
+      "data",
+      prefix === undefined ? undefined : (key) => key.startsWith(prefix),
+    );
+  }
+
+  // Yayın yerel silmeden **sonra** yapılır; diğer node'lar kendi anahtarlarını
+  // kendileri tarar, çünkü hangi anahtarın nerede sıcak olduğu node'a bağlı.
+  publishCacheEvent({ type: "data:clear", prefix: prefix ?? null });
+
+  return removed;
+}
+
+/**
+ * Silmenin yerel kısmı. Uzaktan gelen olay bunu çağırır: yeniden yayın yapan
+ * bir dinleyici iki node arasında sonsuz mesaj döngüsü üretir.
+ *
+ * @param {string} [prefix]
+ * @returns {number}
+ */
+function clearLocal(prefix) {
   /** @type {string[]} */
   const removed = [];
 
@@ -235,6 +343,13 @@ export function clearDataCache(prefix) {
   return removed.length;
 }
 
+// Uzak bir node veri düşürdüğünde bu proses de kendi L1'ini temizler; zincir
+// `invalidateHtmlByDependency` üzerinden etkilenen sayfalara kadar gider.
+onCacheEvent((event) => {
+  if (event.type !== "data:clear") return;
+  clearLocal(typeof event.prefix === "string" ? event.prefix : undefined);
+});
+
 /** @returns {number} */
 export function getDataCacheSize() {
   return store.size;

package/src/server/dev/devtools.js

@@ -461,11 +461,11 @@ export function mountDevtools(app) {
 export function attachDevSocket(server) {
   const endpoint = `${getConfig().brand.devBasePath}/ws`;
 
-  server.on("upgrade", (req, socket) => {
+  server.on("upgrade", (req, socket, head) => {
     // Uygulamanın kendi WebSocket uçları olabilir; yalnızca bizimkini alırız.
     if ((req.url ?? "").split("?")[0] !== endpoint) return;
 
-    upgradeToSocket(req, socket, (send) => {
+    upgradeToSocket(req, socket, head, (send) => {
       send({ type: "hello", boot: BOOT_ID });
       send(statsPayload());
     });

package/src/server/dev/report.js

@@ -14,6 +14,7 @@ import path from "node:path";
 import zlib from "node:zlib";
 import { getHtmlCacheEntries, getHtmlCacheSize } from "../html-cache.js";
 import { getDataCacheSize } from "../data-cache.js";
+import { getRedisStatus } from "../redis.js";
 import { prewarmProgress } from "../prewarm.js";
 import { getConfig } from "../../config/index.js";
 
@@ -350,6 +351,9 @@ export function buildReport(devtools) {
       // Veri önbelleğinden yalnızca sayaç: uzun kuyruklu bir sitede on
       // binlerce anahtar oluyor ve dökümü rapora koymak faydasız bir yük.
       data: getDataCacheSize(),
+      // Paylaşımlı kademe kapalıyken de basılır: "Redis'i açtım ama neden
+      // çalışmıyor" sorusunun cevabı en çok burada aranıyor.
+      redis: getRedisStatus(),
     },
     prewarm: { ...prewarmProgress },
     requests: devtools.requests,