jskelet 0.1.4 → 0.1.6

package/src/server/dev/socket.js

@@ -0,0 +1,157 @@
+/**
+ * Dev araçlarının canlı kanalı: küçük bir WebSocket sunucusu.
+ *
+ * Overlay eskiden istatistikleri iki saniyede bir `GET /stats` ile çekiyordu;
+ * panel kapalıyken bile her sekme sürekli istek atıyor, dev sunucusunun istek
+ * günlüğünü de kirletiyordu. Artık sunucu değişiklik oldukça (istek, hata,
+ * ısıtma ilerlemesi, CSS/JS değişimi) tek bağlantı üzerinden itiyor.
+ *
+ * Bağımlılık eklemiyoruz: yalnızca sunucu→istemci metin çerçevesi yazmak ve
+ * istemcinin ping/close çerçevelerini anlamak gerekiyor; bu da RFC 6455'in
+ * küçük bir alt kümesi. `permessage-deflate` yok, parça (fragment) yok —
+ * gönderdiğimiz paketler için ikisi de gereksiz.
+ */
+import { createHash } from "node:crypto";
+
+/** RFC 6455'te sabitlenmiş el sıkışma tuzu. */
+const GUID = "258EAFA5-E914-47DA-95CA-5AB0DC85B39A";
+
+/** @type {Set<import('node:net').Socket>} */
+const sockets = new Set();
+
+/** @param {string} key */
+function accept(key) {
+  return createHash("sha1")
+    .update(key + GUID)
+    .digest("base64");
+}
+
+/**
+ * Tek parçalı metin çerçevesi. Maskeleme yalnızca istemci→sunucu yönünde
+ * zorunlu olduğu için burada yok.
+ *
+ * @param {string} text
+ * @returns {Buffer}
+ */
+function frame(text) {
+  const payload = Buffer.from(text, "utf8");
+  const length = payload.length;
+
+  /** @type {Buffer} */
+  let header;
+  if (length < 126) {
+    header = Buffer.from([0x81, length]);
+  } else if (length < 65536) {
+    header = Buffer.alloc(4);
+    header[0] = 0x81;
+    header[1] = 126;
+    header.writeUInt16BE(length, 2);
+  } else {
+    header = Buffer.alloc(10);
+    header[0] = 0x81;
+    header[1] = 127;
+    header.writeBigUInt64BE(BigInt(length), 2);
+  }
+
+  return Buffer.concat([header, payload]);
+}
+
+/**
+ * İstemciden gelen çerçeveleri ayıklar. İçerik bizi ilgilendirmiyor; amaç
+ * kapanışı ve ping'i doğru yanıtlamak, aksi hâlde tarayıcı bağlantıyı
+ * "protokol hatası" sayıp kapatıyor.
+ *
+ * @param {import('node:net').Socket} socket
+ */
+function readFrames(socket) {
+  let buffer = Buffer.alloc(0);
+
+  socket.on("data", (chunk) => {
+    buffer = Buffer.concat([buffer, chunk]);
+
+    while (buffer.length >= 2) {
+      const opcode = buffer[0] & 0x0f;
+      const masked = (buffer[1] & 0x80) !== 0;
+      let length = buffer[1] & 0x7f;
+      let offset = 2;
+
+      if (length === 126) {
+        if (buffer.length < offset + 2) return;
+        length = buffer.readUInt16BE(offset);
+        offset += 2;
+      } else if (length === 127) {
+        if (buffer.length < offset + 8) return;
+        length = Number(buffer.readBigUInt64BE(offset));
+        offset += 8;
+      }
+
+      if (masked) offset += 4;
+      if (buffer.length < offset + length) return;
+
+      buffer = buffer.subarray(offset + length);
+
+      // 0x8 close, 0x9 ping. Veri çerçeveleri yok sayılır: istemcinin bize
+      // söyleyeceği bir şey yok, kanal tek yönlü kullanılıyor.
+      if (opcode === 0x8) {
+        socket.end(Buffer.from([0x88, 0x00]));
+        return;
+      }
+      if (opcode === 0x9) socket.write(Buffer.from([0x8a, 0x00]));
+    }
+  });
+}
+
+/**
+ * HTTP upgrade isteğini WebSocket bağlantısına çevirir.
+ *
+ * @param {import('node:http').IncomingMessage} req
+ * @param {import('node:net').Socket} socket
+ * @param {(send: (payload: object) => void) => void} onOpen
+ *   Bağlantı kurulunca çağrılır; ilk paketi göndermek için kullanılır.
+ */
+export function upgradeToSocket(req, socket, onOpen) {
+  const key = req.headers["sec-websocket-key"];
+  if (!key) {
+    socket.destroy();
+    return;
+  }
+
+  socket.write(
+    "HTTP/1.1 101 Switching Protocols\r\n" +
+      "Upgrade: websocket\r\n" +
+      "Connection: Upgrade\r\n" +
+      `Sec-WebSocket-Accept: ${accept(String(key))}\r\n\r\n`,
+  );
+
+  // Küçük paketleri geciktirmenin anlamı yok; panel anlık görünmeli.
+  socket.setNoDelay(true);
+  // Bağlantı hataları (sekme kapanması, ağ) süreci düşürmemeli.
+  socket.on("error", () => socket.destroy());
+  socket.on("close", () => sockets.delete(socket));
+
+  readFrames(socket);
+  sockets.add(socket);
+
+  onOpen((payload) => {
+    if (!socket.destroyed) socket.write(frame(JSON.stringify(payload)));
+  });
+}
+
+/**
+ * Bağlı tüm panellere gönderir.
+ * @param {object} payload
+ */
+export function broadcastSocket(payload) {
+  if (!sockets.size) return;
+
+  const packet = frame(JSON.stringify(payload));
+  for (const socket of sockets) {
+    if (socket.destroyed) sockets.delete(socket);
+    else socket.write(packet);
+  }
+}
+
+/** @returns {number} açık panel sayısı */
+export function socketCount() {
+  return sockets.size;
+}

package/src/server/html-cache.js

@@ -6,14 +6,24 @@
  * render'ı beklemez; buna karşılık HTML'deki veri en fazla `revalidate + bir
  * tazeleme turu` kadar geride olabilir. Fiyat gibi canlı alanlar istemcide
  * WebSocket'ten güncellendiği için bu gecikme ekranda görünmez.
+ *
+ * TTL'in yanında ikinci bir tazelik kaynağı daha var: **hedefli
+ * invalidation**. Bir içerik güncellendiğinde tüm önbelleği boşaltmak
+ * (`clearHtmlCache()`) o an sıcak olan her sayfayı soğuk render'a çevirir;
+ * TTL'i beklemek ise güncellemeyi dakikalarca geciktirir.
+ * `invalidateHtmlCache()` ikisinin arasını açar ve varsayılan davranışı
+ * **bayatlatmaktır**: girdi silinmez, süresi geçmiş sayılır. Ziyaretçi eski
+ * HTML'i beklemeden alır, tazeleme arkada tek seferde koşar.
  */
 
 import { getConfig } from "../config/index.js";
 import { DEFAULT_HTML_CACHE_MAX_ENTRIES } from "../config/defaults.js";
+import { collectDependencies } from "./cache-deps.js";
+import { compilePattern, matchPattern } from "../config/pattern.js";
 
 /**
  * @typedef {{ html: string, status: number, expiresAt: number,
- *   staleUntil: number, encoded: Map<string, Buffer> }} HtmlEntry
+ *   staleUntil: number, encoded: Map<string, Buffer>, deps: Set<string> }} HtmlEntry
  */
 
 /**
@@ -34,6 +44,20 @@ function maxEntries() {
   }
 }
 
+/**
+ * Bağımlılık izleme kapatılabilir olmalı: `withDataCache` kullanmayan bir
+ * uygulamada hiçbir şey kaydedilmez ama bağlam kurma maliyeti kalır.
+ *
+ * @returns {boolean}
+ */
+function trackDependencies() {
+  try {
+    return getConfig().trackDependencies;
+  } catch {
+    return true;
+  }
+}
+
 /**
  * TTL dolduktan sonra eski HTML'in kaç TTL boyunca daha servis edilebileceği.
  * Tazeleme genelde ilk stale istekte tamamlandığı için bu pencere yalnızca
@@ -47,6 +71,86 @@ const store = new Map();
 /** @type {Map<string, Promise<{ html: string, status: number }>>} */
 const inflight = new Map();
 
+/**
+ * Uçuştaki her tazelemenin kimliği. Bir girdi tazelenirken invalidate
+ * edilirse o tazelemenin sonucu **artık geçersizdir**: render, purge'den önce
+ * okunmuş veriyle üretildi. Token silinince `write()` atlanır ve bir sonraki
+ * istek yeni bir tur başlatır.
+ *
+ * @type {Map<string, object>}
+ */
+const tokens = new Map();
+
+/**
+ * Ters indeks: veri anahtarı → onu okumuş HTML anahtarları. `clearDataCache()`
+ * bunu okuyup etkilenen sayfaları bayatlatır.
+ *
+ * @type {Map<string, Set<string>>}
+ */
+const dependents = new Map();
+
+/**
+ * Invalidate edilmiş ama henüz kimsenin istemediği yollar. Isıtma turu bunları
+ * kuyruğun başına alır: "içerik güncellendi" bilgisi geldiğinde sayfa,
+ * ziyaretçi gelmesini beklemeden tazelenir.
+ *
+ * Sınırlı tutulur — kimse ısıtma yapmıyorsa bu küme sessizce büyümemeli.
+ *
+ * @type {Set<string>}
+ */
+const invalidated = new Set();
+
+const MAX_INVALIDATED = 500;
+
+/**
+ * Son zamanlarda düşürülen veri anahtarları ve düşürülme zamanları.
+ *
+ * Bir webhook, sayfa **render edilirken** gelirse ters indeks henüz o sayfayı
+ * tanımıyor (bağımlılıklar yazma anında kaydediliyor) ve render, purge'den
+ * önce okunmuş veriyle önbelleğe girerdi. Yazma anında bu haritaya bakmak,
+ * "doğduğu anda bayat" girdiyi engeller.
+ *
+ * Render'lar saniyeler sürdüğü için harita kısa tutulur; sınır aşılınca en
+ * eski kayıt düşer.
+ *
+ * @type {Map<string, number>}
+ */
+const purgedDeps = new Map();
+
+const MAX_PURGED_DEPS = 1000;
+
+/**
+ * Girdiyi ters indeksten söker. Bu adım atlanırsa indeks, düşen girdilerin
+ * anahtarlarını tutmaya devam eder ve sessizce sızar.
+ *
+ * @param {string} key
+ * @param {HtmlEntry} entry
+ */
+function unlink(key, entry) {
+  for (const dep of entry.deps) {
+    const set = dependents.get(dep);
+    if (!set) continue;
+    set.delete(key);
+    if (!set.size) dependents.delete(dep);
+  }
+}
+
+/**
+ * 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.
+ *
+ * @param {string} key
+ * @returns {boolean} Girdi var mıydı.
+ */
+function drop(key) {
+  const entry = store.get(key);
+  if (!entry) return false;
+
+  unlink(key, entry);
+  store.delete(key);
+  return true;
+}
+
 /**
  * @param {string} key
  * @returns {{ html: string, status: number, encoded: Map<string, Buffer>,
@@ -58,7 +162,7 @@ function read(key) {
 
   const now = Date.now();
   if (now >= entry.staleUntil) {
-    store.delete(key);
+    drop(key);
     return null;
   }
 
@@ -78,10 +182,15 @@ function read(key) {
  * @param {string} key
  * @param {{ html: string, status: number }} value
  * @param {number} ttlSeconds
+ * @param {Set<string> | null} deps Render sırasında okunan veri anahtarları.
  */
-function write(key, value, ttlSeconds) {
+function write(key, value, ttlSeconds, deps = null) {
   const now = Date.now();
 
+  // Aynı anahtarın eski girdisi ters indekste kalmasın: bağımlılıklar
+  // tazelemeden tazelemeye değişebilir.
+  drop(key);
+
   store.set(key, {
     html: value.html,
     status: value.status,
@@ -90,14 +199,40 @@ function write(key, value, ttlSeconds) {
     encoded: new Map(),
     expiresAt: now + ttlSeconds * 1000,
     staleUntil: now + ttlSeconds * 1000 * (1 + STALE_FACTOR),
+    deps: deps ?? new Set(),
   });
 
+  if (deps) {
+    for (const dep of deps) {
+      let set = dependents.get(dep);
+      if (!set) dependents.set(dep, (set = new Set()));
+      set.add(key);
+    }
+  }
+
   const limit = maxEntries();
   while (store.size > limit) {
     const oldest = store.keys().next().value;
     if (oldest === undefined) break;
-    store.delete(oldest);
+    drop(oldest);
+  }
+}
+
+/**
+ * Bu render, başladıktan sonra düşürülmüş bir veriyi mi okudu.
+ *
+ * @param {Set<string> | null} deps
+ * @param {number} startedAt
+ * @returns {boolean}
+ */
+function readsPurgedData(deps, startedAt) {
+  if (!deps) return false;
+
+  for (const dep of deps) {
+    const purgedAt = purgedDeps.get(dep);
+    if (purgedAt !== undefined && purgedAt >= startedAt) return true;
   }
+  return false;
 }
 
 /**
@@ -112,7 +247,15 @@ function refresh(key, ttlSeconds, producer) {
   const pending = inflight.get(key);
   if (pending) return pending;
 
-  const task = producer()
+  const token = {};
+  tokens.set(key, token);
+  const startedAt = Date.now();
+
+  // 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 task = (deps ? collectDependencies(deps, producer) : producer())
     .then((value) => {
       // `degraded`: upstream düştüğü için eksik veriyle üretilmiş HTML.
       // Saklanırsa eksik içerik tüm TTL boyunca servis edilir.
@@ -120,13 +263,18 @@ function refresh(key, ttlSeconds, producer) {
       // `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.
-      if (value.status === 200 && !value.degraded && value.storable !== false) {
-        write(key, value, ttlSeconds);
+      //
+      // 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);
       }
       return value;
     })
     .finally(() => {
       inflight.delete(key);
+      if (tokens.get(key) === token) tokens.delete(key);
     });
 
   inflight.set(key, task);
@@ -152,6 +300,7 @@ export async function withHtmlCache(key, ttlSeconds, producer) {
     // Süresi geçmiş girdi anında döner; tazeleme arkada yürür ve hatası
     // isteği etkilemez (eski HTML stale penceresi boyunca geçerli kalır).
     if (hit.stale) {
+      invalidated.delete(key);
       void refresh(key, ttlSeconds, producer).catch((error) => {
         console.error(`[html-cache] background refresh failed: ${key}`, error);
       });
@@ -159,24 +308,177 @@ export async function withHtmlCache(key, ttlSeconds, producer) {
     return { ...hit, cached: true };
   }
 
+  invalidated.delete(key);
   const value = await refresh(key, ttlSeconds, producer);
   return { ...value, encoded: store.get(key)?.encoded, cached: false };
 }
 
+/**
+ * Store'u tamamen boşaltır. Dev sunucusu manifest her değiştiğinde bunu
+ * çağırır: saklanan HTML artık var olmayan hash'li varlıkları işaret ediyor,
+ * yani gerçekten **geçersiz** — bayatlatmak yetmez.
+ */
 export function clearHtmlCache() {
   store.clear();
+  dependents.clear();
+  tokens.clear();
+  invalidated.clear();
+  purgedDeps.clear();
 }
 
 export function getHtmlCacheSize() {
   return store.size;
 }
 
+/**
+ * Verilen hedefi HTML anahtarının yol kısmıyla eşleştiren bir eşleyici üretir.
+ *
+ * Üç biçim kabul edilir:
+ *   `"/haber/abc"`     → o yol ve altındaki her şey (`/haber/abc/yorumlar`)
+ *   `"/haber/:slug"`   → config'in her yerinde geçerli desen sözdizimi
+ *   `/-yorumlar$/`     → desen sözdiziminin karşılamadığı kurallar için
+ *
+ * Düz string'te "önek" bilinçli olarak **segment sınırında** kesilir: `/haber`
+ * kuralı `/haberler`i düşürmemeli.
+ *
+ * @param {string | RegExp} target
+ * @returns {((pathname: string) => boolean) | null}
+ */
+function toMatcher(target) {
+  if (target instanceof RegExp) return (pathname) => target.test(pathname);
+
+  if (typeof target !== "string" || !target.startsWith("/")) {
+    console.warn(`[html-cache] invalid invalidation target (must start with \`/\`): ${target}`);
+    return null;
+  }
+
+  if (target.includes(":")) {
+    const compiled = compilePattern(target);
+    if (!compiled) return null;
+    return (pathname) => matchPattern(compiled, pathname) !== null;
+  }
+
+  const prefix = target.endsWith("/") ? target : `${target}/`;
+  return (pathname) => pathname === target || pathname.startsWith(prefix);
+}
+
+/**
+ * Etkilenen girdiyi bayatlatır ya da düşürür.
+ *
+ * @param {string} key
+ * @param {boolean} hard
+ */
+function invalidateKey(key, hard) {
+  // Uçuştaki tazeleme bu invalidation'dan önce başladıysa sonucu eski veriyle
+  // üretilmiş demektir; token'ı düşürmek onu yazılamaz hâle getirir. Girdi
+  // henüz hiç yazılmamış olsa bile (ilk render sürüyor) bu geçerli.
+  tokens.delete(key);
+
+  const entry = store.get(key);
+  if (entry) {
+    // Bayat penceresi de dolmuşsa girdi zaten ölü: bayatlatmanın etkisi olmaz.
+    if (hard || Date.now() >= entry.staleUntil) drop(key);
+    else entry.expiresAt = 0;
+  }
+
+  if (invalidated.size < MAX_INVALIDATED) invalidated.add(key);
+}
+
+/**
+ * Hedefli invalidation: TTL'i beklemeden, ama tüm önbelleği boşaltmadan.
+ *
+ * Varsayılan **yumuşaktır** (`hard: false`): girdi silinmez, süresi geçmiş
+ * sayılır. Bir webhook beş yüz sayfayı birden düşürdüğünde sert silme, tam da
+ * içeriğin güncellendiği anda beş yüz soğuk render başlatır ve upstream'i
+ * döver. Bayatlatmada ise ziyaretçi eski HTML'i beklemeden alır, tazeleme
+ * arkada ve anahtar başına tek seferde koşar. `hard: true` yalnızca eski
+ * HTML'in gerçekten geçersiz olduğu durumlar için.
+ *
+ * Anahtar `yol?query` olduğundan eşleştirme **yol kısmına** yapılır: bir
+ * yolun bütün query varyantları (`?utm_source=…` dahil) tek çağrıyla düşer.
+ *
+ * @param {string | RegExp | (string | RegExp)[]} target
+ * @param {{ hard?: boolean }} [options]
+ * @returns {number} Etkilenen girdi sayısı (uçuştaki render'lar dahil).
+ */
+export function invalidateHtmlCache(target, options = {}) {
+  const matchers = (Array.isArray(target) ? target : [target])
+    .map(toMatcher)
+    .filter((matcher) => matcher !== null);
+
+  if (!matchers.length) return 0;
+
+  const hard = options.hard === true;
+  let count = 0;
+
+  // Uçuştaki render'lar da hedeflenir: henüz yazılmamış bir tur, purge'den
+  // önce okunmuş veriyle önbelleğe girmemeli. Anahtarlar kopyalanır, çünkü
+  // `invalidateKey` sert modda store'dan siliyor.
+  for (const key of new Set([...store.keys(), ...tokens.keys()])) {
+    const mark = key.indexOf("?");
+    const pathname = mark === -1 ? key : key.slice(0, mark);
+    if (!matchers.some((matcher) => matcher(pathname))) continue;
+    invalidateKey(key, hard);
+    count += 1;
+  }
+
+  return count;
+}
+
+/**
+ * Verilen veri anahtarlarını render sırasında okumuş sayfaları bayatlatır.
+ * `clearDataCache()` bunu çağırır; uygulamanın hiçbir şey bildirmesi gerekmez.
+ *
+ * @param {Iterable<string>} dataKeys
+ * @returns {number} Etkilenen HTML girdisi sayısı.
+ */
+export function invalidateHtmlByDependency(dataKeys) {
+  /** @type {Set<string>} */
+  const keys = new Set();
+  const now = Date.now();
+
+  for (const dep of dataKeys) {
+    // Şu anda render edilen bir sayfa bu veriyi okuduysa ters indekste henüz
+    // görünmüyor; yazma anındaki kontrol için zaman damgası bırakılır.
+    purgedDeps.set(dep, now);
+
+    const set = dependents.get(dep);
+    if (set) for (const key of set) keys.add(key);
+  }
+
+  while (purgedDeps.size > MAX_PURGED_DEPS) {
+    const oldest = purgedDeps.keys().next().value;
+    if (oldest === undefined) break;
+    purgedDeps.delete(oldest);
+  }
+
+  for (const key of keys) invalidateKey(key, false);
+  return keys.size;
+}
+
+/**
+ * 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.
+ *
+ * @returns {string[]}
+ */
+export function takeInvalidatedPaths() {
+  if (!invalidated.size) return [];
+
+  const paths = [...invalidated];
+  invalidated.clear();
+  // Anahtar `yol?query`; query boşsa sondaki `?` atılır.
+  return paths.map((key) => (key.endsWith("?") ? key.slice(0, -1) : key));
+}
+
 /**
  * Dev raporu için önbellek dökümü: hangi sayfa ne kadar HTML tutuyor, ne
- * zaman bayatlıyor. HTML gövdesi dönmez, yalnızca boyutu.
+ * zaman bayatlıyor, kaç veri anahtarına bağlı. HTML gövdesi dönmez, yalnızca
+ * boyutu.
  *
  * @returns {{ key: string, bytes: number, status: number, stale: boolean,
- *   expiresIn: number, encodings: string[] }[]}
+ *   expiresIn: number, encodings: string[], deps: number }[]}
  */
 export function getHtmlCacheEntries() {
   const now = Date.now();
@@ -188,5 +490,6 @@ export function getHtmlCacheEntries() {
     stale: now >= entry.expiresAt,
     expiresIn: Math.round((entry.expiresAt - now) / 1000),
     encodings: [...entry.encoded.keys()],
+    deps: entry.deps.size,
   }));
 }

package/src/server/prewarm.js

@@ -20,6 +20,7 @@
  */
 import process from "node:process";
 import { getConfig, hook } from "../config/index.js";
+import { takeInvalidatedPaths } from "./html-cache.js";
 
 /**
  * Isıtmanın canlı durumu. Dev araçları bunu okuyup ilerlemeyi gösterir;
@@ -286,24 +287,35 @@ async function crawl(origin, paths, concurrency, report = undefined, pace = unde
 export async function prewarm({ origin, quiet = false, paths: only }) {
   const started = Date.now();
   const limit = setting("PREWARM_MAX", "max", 400);
-  // Dev'de daha az paralellik: tarama, o an tarayıcıda açtığın sayfanın
-  // render'ıyla CPU için yarışmasın.
-  const concurrency = setting(
-    "PREWARM_CONCURRENCY",
-    "concurrency",
-    process.env.NODE_ENV === "development" ? 2 : 4,
-  );
+  const isDev = process.env.NODE_ENV === "development";
 
-  const rps = num(process.env.PREWARM_RPS, num(getConfig().prewarm?.rps, 0));
+  // Dev'de tek işçi: tarama, o an tarayıcıda açtığın sayfanın render'ıyla CPU
+  // için yarışmasın.
+  const concurrency = setting("PREWARM_CONCURRENCY", "concurrency", isDev ? 1 : 4);
+
+  // Render tek bir olay döngüsünde çalışıyor: aralıksız bir tur, geliştirme
+  // sırasında sayfa isteklerini ve dev panelinin kanalını arkasında bekletiyor.
+  // Dev'de varsayılan bir hız freni bu yüzden var; üretimde ısıtma bir kez
+  // olup bittiği için fren yalnızca istenirse (`prewarm.rps`) devreye girer.
+  const rps = num(process.env.PREWARM_RPS, num(getConfig().prewarm?.rps, isDev ? 4 : 0));
   const pace = createPacer(rps);
 
   const all = only?.length ? only : await collectPaths();
   // Elle verilen liste budanmaz ve sıralanmaz: çağıran tam olarak neyi
   // istediğini biliyor (dev panelindeki "tekrar dene" bunu kullanır).
-  const paths = only?.length
+  const selected = only?.length
     ? all
     : selectPrewarmPaths(all, limit, getConfig().prewarm?.rotate !== false);
 
+  // Invalidate edilmiş sayfalar kuyruğun önüne geçer: "içerik güncellendi"
+  // bilgisi geldiğinde sayfa, ziyaretçi gelmesini beklemeden tazelenir. Bu
+  // yollar `max` bütçesinin dışında tutulur — sayıları zaten gerçekleşen
+  // invalidation kadar ve rotasyonun sırasını bozmaları istenmez.
+  const pending = only?.length ? [] : takeInvalidatedPaths();
+  const paths = pending.length
+    ? [...new Set([...pending, ...selected])]
+    : selected;
+
   Object.assign(prewarmProgress, {
     active: true,
     done: 0,
@@ -363,13 +375,14 @@ export async function prewarm({ origin, quiet = false, paths: only }) {
   const elapsed = Date.now() - started;
 
   if (!quiet && paths.length) {
-    const skipped = all.length - paths.length;
+    const skipped = all.length - selected.length;
     // Rotasyon açıkken sınırın dışında kalan yollar kaybolmuyor, bir sonraki
     // tura kalıyor; log bunu ayırt etmeli, yoksa "400 yol atlandı" satırı
     // hatalı bir kurulum sanılıyor.
     const rotate = !only?.length && getConfig().prewarm?.rotate !== false;
     console.log(
       `[prewarm] warmed ${ok}/${paths.length} pages` +
+        `${pending.length ? `, ${pending.length} invalidated` : ""}` +
         `${failed ? `, ${failed} failed` : ""}` +
         `${recovered ? `, ${recovered} recovered on the retry pass` : ""}` +
         `${skipped > 0 ? `, ${skipped} ${rotate ? "deferred to the next pass" : "over the limit"}` : ""}` +