jskelet 0.2.1 → 0.2.3

package/src/client/devtools/overlay.js

@@ -704,6 +704,21 @@ const CSS = `
   border-radius: 6px; padding: 1px 6px; font-family: ui-monospace, monospace;
 }
 
+/* Yüklü sürüm ve kayıt defterindeki son sürüm. */
+.ver {
+  display: inline-flex; align-items: center; gap: 6px;
+  font-size: 10.5px; font-weight: 600; color: var(--muted);
+  border: 1px solid var(--line); border-radius: 999px; padding: 2px 8px;
+  font-family: ui-monospace, SFMono-Regular, monospace;
+  font-variant-numeric: tabular-nums;
+}
+.ver .cur { color: #dbe2ea; }
+.ver .state { text-transform: uppercase; letter-spacing: .05em; font-size: 9.5px; }
+.ver.latest .state { color: var(--good); }
+.ver.outdated { border-color: rgba(251,191,36,.35); }
+.ver.outdated .state { color: var(--mid); }
+.ver .next { color: var(--mid); }
+
 .rail {
   display: flex; flex-direction: column; gap: 4px; padding: 14px 10px;
   border-inline-end: 1px solid var(--line); background: rgba(0,0,0,.22);
@@ -893,6 +908,7 @@ const SKELETON = `
         <div class="head">
           <img src="${BASE}/logo.png" alt="">
           <span class="title">JSkelet Dev</span>
+          <span class="ver" data-part="version" hidden></span>
           <span class="pill"><span class="dot"></span><span data-part="pill"></span></span>
           <span class="spacer"></span>
           <span class="kbd">Alt+D</span>
@@ -1291,6 +1307,7 @@ function serverTab() {
           ]
         : []),
     ])}
+    ${upstreamSection()}
     <h4>Recent requests</h4>
     ${
       requests.length
@@ -1309,6 +1326,39 @@ function serverTab() {
   `;
 }
 
+/**
+ * Upstream hız freninin durumu. Fren kapalıysa (varsayılan) hiçbir şey
+ * basılmaz; açıkken 429 fırtınasında hızın nereye indiğini görmek, ayarı
+ * körlemesine yapmamanın tek yolu.
+ *
+ * @returns {string}
+ */
+function upstreamSection() {
+  const hosts = serverStats?.upstream ?? [];
+  if (!hosts.length) return "";
+
+  return `
+    <h4>Upstream rate limit</h4>
+    <div class="rows">${hosts
+      .map((host) => {
+        const throttled = host.rate < host.maxRate;
+        const state = host.bypassed
+          ? "bypassed"
+          : host.blockedMs
+            ? `waiting ${Math.ceil(host.blockedMs / 1000)} s`
+            : `${host.active} in flight`;
+
+        return `<div class="row">
+          <span class="status ${host.bypassed ? "bad" : throttled ? "warn" : ""}">${host.rate}/s</span>
+          <span class="path">${escapeHtml(host.host)}</span>
+          <span class="hint">${escapeHtml(state)}</span>
+          <span class="${host.throttled ? "mid" : ""}">${host.throttled} × 429</span>
+        </div>`;
+      })
+      .join("")}</div>
+  `;
+}
+
 function warmTab() {
   const warm = serverStats?.prewarm;
 
@@ -1647,6 +1697,40 @@ function paintPrewarm(root) {
   if (!warm.active) setTimeout(render, WARM_LINGER_MS);
 }
 
+/**
+ * Başlıktaki sürüm göstergesi: solda yüklü sürüm, sağda kayıt defterindeki
+ * durum. Kontrol kapalıysa ya da kayıt defterine ulaşılamadıysa (`latest`
+ * boş) yalnızca yüklü sürüm yazılır; "bilinmiyor" etiketi gürültü olurdu.
+ *
+ * @param {ShadowRoot} root
+ * @param {{ current: string, latest: string | null, outdated: boolean } | undefined} version
+ */
+function paintVersion(root, version) {
+  const node = root.querySelector("[data-part='version']");
+
+  if (!version?.current) {
+    node.hidden = true;
+    return;
+  }
+
+  const { current, latest, outdated } = version;
+  node.hidden = false;
+  node.className = `ver ${latest ? (outdated ? "outdated" : "latest") : ""}`;
+  node.title = latest
+    ? outdated
+      ? `Installed ${current}, npm has ${latest}. Run: npm install jskelet@latest`
+      : `Installed ${current} — up to date with npm`
+    : `Installed ${current}. The npm registry could not be reached.`;
+
+  node.innerHTML =
+    `<span class="cur">v${escapeHtml(current)}</span>` +
+    (latest
+      ? outdated
+        ? `<span class="state">outdated</span><span class="next">→ v${escapeHtml(latest)}</span>`
+        : `<span class="state">latest</span>`
+      : "");
+}
+
 function paint() {
   const root = ensureRoot();
 
@@ -1690,6 +1774,7 @@ function paint() {
   chip.textContent = String(errorCount);
 
   const version = serverStats?.version;
+  paintVersion(root, version);
   const versionChip = root.querySelector("[data-part='version-chip']");
   versionChip.hidden = !version?.outdated;
   if (version?.outdated) versionChip.title = `JSkelet ${version.latest} is available`;

package/src/client/devtools/report.js

@@ -228,6 +228,19 @@ function overview() {
         tone: apiErrors ? "bad" : "good",
         sub: apiErrors ? `${apiErrors} errors` : "no errors",
       },
+      // Upstream kotasının nasıl harcandığı: okumaların kaçı önbellekten
+      // döndü. Oran düşükse `withDataCache` TTL'i kısa demektir.
+      {
+        label: "Data cache",
+        value: data.cache?.dataStats?.reads
+          ? `${Math.round(data.cache.dataStats.hitRatio * 100)}%`
+          : "—",
+        ratio: data.cache?.dataStats?.hitRatio ?? null,
+        tone: "good",
+        sub: data.cache?.dataStats?.reads
+          ? `${data.cache.dataStats.produced} upstream / ${data.cache.dataStats.reads} reads`
+          : "no reads yet",
+      },
       {
         label: "Prewarm",
         value: data.prewarm?.total

package/src/config/defaults.js

@@ -120,6 +120,42 @@ export const DEFAULT_DATA_CACHE = {
   staleFactor: 10,
 };
 
+/**
+ * Upstream API'ye giden isteklerin host başına hız freni.
+ *
+ * Varsayılan **kapalı** (`rate: 0`): fren, kotasını bilen bir uygulamanın
+ * bilinçli kararı. Açıldığında `rate` bir tavan olur ve gerçek hız 429
+ * cevaplarına göre kendini aşağı çeker (bkz. `src/server/upstream-limiter.js`).
+ *
+ * `hosts` ile tek tek uçlar ayrılabilir; API'lerin kotası aynı olmak zorunda
+ * değil:
+ *
+ *   upstream: { rate: 10, hosts: { "api.example.com": { rate: 3 } } }
+ */
+export const DEFAULT_UPSTREAM_LIMIT = {
+  /** Saniyedeki en fazla çağrı. 0 → fren tamamen kapalı. */
+  rate: 0,
+  /** Kova boyu; verilmezse bir saniyelik bütçe kadar patlamaya izin verilir. */
+  burst: 0,
+  /** Aynı anda uçabilecek çağrı. Ortalama hızdan bağımsız: anlık baskıyı bağlar. */
+  concurrency: 8,
+  /** Azalmanın dibi: hız buranın altına inmez, yoksa site tamamen durur. */
+  minRate: 0.5,
+  /** Toplamsal artışın adımı (çağrı/saniye) ve periyodu. */
+  increaseStep: 1,
+  increaseIntervalMs: 5000,
+  /**
+   * İki azalma arasındaki en kısa süre. Aynı anda uçan on çağrının hepsi 429
+   * dönerse hız on kez yarılanıp dibe vurmasın.
+   */
+  decreaseIntervalMs: 1000,
+  /** Devre kesici: art arda kaç 429'dan sonra host'a hiç gidilmeyeceği. */
+  breakerFailures: 5,
+  breakerCooldownMs: 10_000,
+  /** @type {Record<string, Record<string, number>>} */
+  hosts: {},
+};
+
 /**
  * Opsiyonel Redis ikinci kademesi (L2).
  *
@@ -155,8 +191,68 @@ export const DEFAULT_REDIS = {
   commandTimeoutMs: 200,
 };
 
+/**
+ * Önbellek yönetim paneli.
+ *
+ * `enabled` varsayılan olarak **kapalı** ve ortama bakmaz: panel açıldığında
+ * production'da da çalışır, ama açılması bilinçli bir karar olmalı. Kapalıyken
+ * router hiç mount edilmez — yolun kendisi de yok, yani 404 dönen bir uç bile
+ * ortaya çıkmaz.
+ *
+ * Şifre her süreç başlangıcında yeniden üretilir (bkz.
+ * `src/server/cache-panel.js`): panelin ömrü sürecin ömrü kadardır ve bir
+ * deploy eski erişimi otomatik olarak iptal eder. Bu yüzden config'te şifre
+ * alanı yok.
+ */
+export const DEFAULT_CACHE_PANEL = {
+  enabled: false,
+  basePath: "/_jskelet/cache",
+  /** Kaç başarısız denemeden sonra IP yasaklanır. */
+  banAttempts: 3,
+  /** Yasağın süresi. */
+  banHours: 24,
+  /** Oturumun ömrü; süreç yeniden başladığında zaten sıfırlanır. */
+  sessionHours: 12,
+};
+
+/**
+ * Cloudflare cache yüzeyi.
+ *
+ * JSkelet'in önbelleği origin önbelleği; ziyaretçinin gördüğü kopya CDN'de.
+ * Bu bölüm ikisini aynı panelden yönetilebilir kılar (bkz.
+ * `src/server/cloudflare.js`).
+ *
+ * Token **config'e yazılmamalı**: `JSKELET_CLOUDFLARE_KEY` env'i önceliklidir
+ * ve önerilen yol odur. Zone kimliği sır değil, ama o da env'den okunabilir
+ * (`JSKELET_CLOUDFLARE_ZONE_ID`).
+ *
+ * Gereken token izinleri: purge için `Zone.Cache Purge`, ayarlar için
+ * `Zone.Zone Settings`, analitik için `Zone.Analytics` (salt okunur).
+ */
+export const DEFAULT_CLOUDFLARE = {
+  /** `false` verilirse env'de token olsa bile yüzey kapalı kalır. */
+  enabled: true,
+  /** @type {string | null} */
+  zoneId: null,
+  /** @type {string | null} Env tercih edilir; burada tutmak sırrı repoya sokar. */
+  apiToken: null,
+  /**
+   * Purge, tam URL istiyor; panel elinde yalnızca yol tutuyor. Site adı
+   * verilmezse purge isteğinin geldiği istek origin'i kullanılır.
+   * @type {string | null}
+   */
+  hostname: null,
+  /** Analitik penceresi (saat). Cloudflare'in izin verdiği aralıkla sınırlı. */
+  analyticsHours: 24,
+};
+
 /** Oturuma bağlı sayfalar ısıtılmaz; uygulama kendi listesini verebilir. */
-export const DEFAULT_PREWARM_SKIP = ["/api/", "/_fragment/", "/__jskelet/"];
+export const DEFAULT_PREWARM_SKIP = [
+  "/api/",
+  "/_fragment/",
+  "/__jskelet/",
+  "/_jskelet/",
+];
 
 /**
  * Site içi gezinme ipuçları (Speculation Rules + view transition).
@@ -182,7 +278,7 @@ export const DEFAULT_NAVIGATION = {
  * hedefi olmayan uçların spekülatif istekle tetiklenmesi gerçek bir hata
  * kaynağı; uygulama kendi listesini `navigation.exclude` ile ekler.
  */
-export const DEFAULT_NAVIGATION_EXCLUDE = ["/api/*", "/_fragment/*"];
+export const DEFAULT_NAVIGATION_EXCLUDE = ["/api/*", "/_fragment/*", "/_jskelet/*"];
 
 /**
  * Güvenlik ayarları.

package/src/config/index.js

@@ -15,8 +15,10 @@
  *   headers()   → [{ source, headers: [{ key, value }] }]
  *   redirects() → [{ source, destination, permanent?, statusCode? }]
  *   rewrites()  → [{ source, destination }] | { beforeFiles?, afterFiles? }
- *   cache()     → { html?: { [source]: saniye }, maxEntries?: number,
- *                   data?: {...}, redis?: {...}, prewarm?: {...} }
+ *   cache()     → { html?: { [source]: saniye },
+ *                   query?: { [source]: string[] | true }, maxEntries?: number,
+ *                   data?: {...}, redis?: {...}, prewarm?: {...},
+ *                   panel?: {...} }
  *
  * Fonksiyon olmayan bölümler (`brand`, `security`, `static`, `navigation`…)
  * düz nesne olarak okunur.
@@ -28,6 +30,8 @@ import { pathToFileURL } from "node:url";
 import { compilePattern, matchPattern } from "./pattern.js";
 import {
   DEFAULT_BRAND,
+  DEFAULT_CACHE_PANEL,
+  DEFAULT_CLOUDFLARE,
   DEFAULT_DATA_CACHE,
   DEFAULT_DEV_GATE_BYPASS,
   DEFAULT_DIRS,
@@ -40,6 +44,7 @@ import {
   DEFAULT_SECURITY,
   DEFAULT_STATIC,
   DEFAULT_TRANSIENT_RETRY,
+  DEFAULT_UPSTREAM_LIMIT,
 } from "./defaults.js";
 
 /** Framework paketinin kökü — kendi şablonlarına ve varlıklarına erişir. */
@@ -81,12 +86,18 @@ const CONFIG_FILE = "jskelet.config.mjs";
  * @property {{ pattern: CompiledPattern, destination: string, statusCode: number }[]} redirects
  * @property {{ phase: "beforeFiles" | "afterFiles", pattern: CompiledPattern, destination: string }[]} rewrites
  * @property {{ pattern: CompiledPattern, seconds: number }[]} html
+ * @property {{ pattern: CompiledPattern, allow: true | string[] }[]} cacheQuery
+ *   Yol deseni başına, HTML cache anahtarına girmesine izin verilen query
+ *   parametreleri. Eşleşen kural yoksa query'li istek cache'lenmez.
  * @property {number} htmlMaxEntries HTML önbelleğinin girdi sınırı.
  * @property {Record<string, unknown>} data Upstream veri önbelleği ayarları.
  * @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 {typeof DEFAULT_UPSTREAM_LIMIT} upstream Upstream hız freni.
+ * @property {typeof DEFAULT_CACHE_PANEL} cachePanel Önbellek yönetim paneli.
+ * @property {typeof DEFAULT_CLOUDFLARE} cloudflare Cloudflare cache yüzeyi.
  * @property {Record<string, unknown>} prewarm
  * @property {{ source: string, test: (pathname: string) => boolean }[]} prewarmPriority
  * @property {Record<string, unknown>} brand
@@ -249,13 +260,171 @@ function normalizeRedis(raw) {
   };
 }
 
+/**
+ * Upstream hız freni. Sayısal alanlar tipine zorlanır; bozuk bir değer freni
+ * yanlış ayarlamak yerine varsayılana döner.
+ *
+ * @param {unknown} raw
+ * @returns {typeof DEFAULT_UPSTREAM_LIMIT}
+ */
+function normalizeUpstream(raw) {
+  const source = /** @type {Record<string, any>} */ (raw ?? {});
+  const merged = { ...DEFAULT_UPSTREAM_LIMIT, ...source };
+
+  /** @param {string} key */
+  const positive = (key) => {
+    const value = Number(merged[key]);
+    return Number.isFinite(value) && value >= 0
+      ? value
+      : /** @type {any} */ (DEFAULT_UPSTREAM_LIMIT)[key];
+  };
+
+  /** @type {Record<string, Record<string, number>>} */
+  const hosts = {};
+  for (const [host, override] of Object.entries(merged.hosts ?? {})) {
+    if (override && typeof override === "object") hosts[host] = override;
+  }
+
+  return {
+    ...merged,
+    rate: positive("rate"),
+    burst: positive("burst"),
+    concurrency: Math.max(1, Math.floor(positive("concurrency"))),
+    minRate: positive("minRate"),
+    increaseStep: positive("increaseStep"),
+    increaseIntervalMs: positive("increaseIntervalMs"),
+    decreaseIntervalMs: positive("decreaseIntervalMs"),
+    breakerFailures: Math.floor(positive("breakerFailures")),
+    breakerCooldownMs: positive("breakerCooldownMs"),
+    hosts,
+  };
+}
+
+/**
+ * Önbellek panelinin bölümü.
+ *
+ * `enabled` yalnızca açıkça `true` verildiğinde ya da `JSKELET_CACHE_PANEL`
+ * ortam değişkeni ayarlandığında açılır: paneli yanlışlıkla açmanın bedeli,
+ * önbelleği boşaltabilen bir ucu internete koymak.
+ *
+ * Ortam değişkeni config'in **üstünde** duruyor, çünkü paneli genelde bir
+ * arıza sırasında tek seferlik açmak isteniyor ve o an config dosyasını
+ * değiştirip yeniden dağıtmak istenmiyor. `JSKELET_CACHE_PANEL=0` aynı
+ * mantıkla config'te açık olan paneli kapatır.
+ *
+ * @param {unknown} raw
+ * @returns {typeof DEFAULT_CACHE_PANEL}
+ */
+function normalizeCachePanel(raw) {
+  const source = /** @type {Record<string, any>} */ (raw ?? {});
+  const env = process.env.JSKELET_CACHE_PANEL;
+
+  const basePath =
+    typeof source.basePath === "string" && source.basePath.startsWith("/")
+      ? source.basePath.replace(/\/+$/, "")
+      : DEFAULT_CACHE_PANEL.basePath;
+
+  /** @param {string} key @param {number} min */
+  const positive = (key, min) => {
+    const value = Number(source[key]);
+    return Number.isFinite(value) && value >= min
+      ? value
+      : /** @type {any} */ (DEFAULT_CACHE_PANEL)[key];
+  };
+
+  return {
+    enabled:
+      env === undefined
+        ? source.enabled === true
+        : env !== "0" && env !== "false" && env !== "",
+    basePath: basePath || DEFAULT_CACHE_PANEL.basePath,
+    banAttempts: Math.floor(positive("banAttempts", 1)),
+    banHours: positive("banHours", 0),
+    sessionHours: positive("sessionHours", 0),
+  };
+}
+
+/**
+ * Cloudflare bölümü. Token burada da verilebiliyor ama önerilen yol env;
+ * normalizasyon sadece tipleri sabitler, sırrı okumak `cloudflare.js`'in işi.
+ *
+ * @param {unknown} raw
+ * @returns {typeof DEFAULT_CLOUDFLARE}
+ */
+function normalizeCloudflare(raw) {
+  const source = /** @type {Record<string, any>} */ (raw ?? {});
+  const hours = Number(source.analyticsHours);
+
+  /** @param {unknown} value */
+  const text = (value) => (typeof value === "string" && value ? value : null);
+
+  return {
+    enabled: source.enabled !== false,
+    zoneId: text(source.zoneId),
+    apiToken: text(source.apiToken),
+    // Şema yazılırsa purge URL'i `https://https://…` olur; baştaki şema atılır.
+    hostname: text(source.hostname)?.replace(/^https?:\/\//, "") ?? null,
+    analyticsHours:
+      Number.isFinite(hours) && hours > 0
+        ? Math.min(72, Math.floor(hours))
+        : DEFAULT_CLOUDFLARE.analyticsHours,
+  };
+}
+
+/**
+ * `cache().query` → yol deseni başına, cache anahtarına girmesine izin verilen
+ * query parametreleri.
+ *
+ * Varsayılan bilinçli olarak "query varsa sayfa dinamik": bir yolun bütün
+ * query varyantlarını cache'lemek, `?utm_source=…` gibi sonsuz sayıda anahtar
+ * üretip LRU'daki gerçek sayfaları dışarı atıyor. Hangi parametrenin çıktıyı
+ * gerçekten değiştirdiğini yalnızca uygulama bilir, o yüzden izin listesi
+ * config'ten gelir.
+ *
+ * Bir desen `true` ile eşlenirse bütün parametreler anahtara girer (eski
+ * davranış), `[]` ile eşlenirse hiçbiri girmez — yani query yok sayılır ve
+ * bütün varyantlar query'siz sürümün HTML'ini paylaşır.
+ *
+ * @param {unknown} raw
+ * @returns {ResolvedConfig["cacheQuery"]}
+ */
+function normalizeQueryRules(raw) {
+  /** @type {ResolvedConfig["cacheQuery"]} */
+  const out = [];
+
+  for (const [source, value] of Object.entries(raw ?? {})) {
+    const pattern = compilePattern(source);
+    if (!pattern) continue;
+
+    if (value === true) {
+      out.push({ pattern, allow: true });
+      continue;
+    }
+    if (value === false) continue;
+
+    const allow = asArray(
+      typeof value === "string" ? [value] : value,
+      `cache().query["${source}"]`,
+    )
+      .filter((name) => typeof name === "string" && name)
+      .map(String);
+    out.push({ pattern, allow });
+  }
+
+  return out;
+}
+
 /**
  * @param {unknown} raw
- * @returns {{ html: ResolvedConfig["html"], htmlMaxEntries: number,
+ * @returns {{ html: ResolvedConfig["html"],
+ *   cacheQuery: ResolvedConfig["cacheQuery"], htmlMaxEntries: number,
  *   data: Record<string, unknown>, trackUpstream: boolean,
  *   trackDependencies: boolean,
  *   transientRetry: { attempts: number, delayMs: number },
  *   redis: RedisConfig,
+ *   upstream: typeof DEFAULT_UPSTREAM_LIMIT,
+ *   cachePanel: typeof DEFAULT_CACHE_PANEL,
+ *   cloudflare: typeof DEFAULT_CLOUDFLARE,
  *   prewarm: Record<string, unknown>,
  *   prewarmPriority: ResolvedConfig["prewarmPriority"] }}
  */
@@ -271,10 +440,12 @@ function normalizeCache(raw) {
   }
 
   const prewarm = { ...DEFAULT_PREWARM, ...(raw?.prewarm ?? {}) };
+  const queryRules = normalizeQueryRules(raw?.query);
   const maxEntries = Number(raw?.maxEntries);
 
   return {
     html,
+    cacheQuery: queryRules,
     htmlMaxEntries:
       Number.isFinite(maxEntries) && maxEntries > 0
         ? Math.floor(maxEntries)
@@ -292,6 +463,9 @@ function normalizeCache(raw) {
         ? { attempts: 0, delayMs: 0 }
         : { ...DEFAULT_TRANSIENT_RETRY, ...(raw?.transientRetry ?? {}) },
     redis: normalizeRedis(raw?.redis),
+    upstream: normalizeUpstream(raw?.upstream),
+    cachePanel: normalizeCachePanel(raw?.panel),
+    cloudflare: normalizeCloudflare(raw?.cloudflare),
     // Desenler derlenmiş hâlde ayrı alanda tutulur: `prewarm` sayısal
     // ayarların düz torbası olarak kalsın, her turda yeniden derlenmesin.
     prewarm,
@@ -504,12 +678,16 @@ export async function loadConfig(options = {}) {
 
   const {
     html,
+    cacheQuery,
     htmlMaxEntries,
     data,
     trackUpstream,
     trackDependencies,
     transientRetry,
     redis,
+    upstream,
+    cachePanel,
+    cloudflare,
     prewarm,
     prewarmPriority,
   } = normalizeCache(cache);
@@ -524,12 +702,16 @@ export async function loadConfig(options = {}) {
     redirects: normalizeRedirects(redirects),
     rewrites: normalizeRewrites(rewrites),
     html,
+    cacheQuery,
     htmlMaxEntries,
     data,
     trackUpstream,
     trackDependencies,
     transientRetry,
     redis,
+    upstream,
+    cachePanel,
+    cloudflare,
     prewarm,
     prewarmPriority,
     brand,

package/src/index.js

@@ -41,6 +41,7 @@ export { headHints } from "./server/head-hints.js";
 export { renderHeadMeta } from "./server/metadata.js";
 export {
   clearHtmlCache,
+  dropHtmlCacheKey,
   getHtmlCacheEntries,
   getHtmlCacheSize,
   invalidateHtmlCache,
@@ -49,13 +50,32 @@ export {
 export {
   clearDataCache,
   dataCache,
+  dropDataCacheKey,
   getDataCacheEntries,
   getDataCacheSize,
+  getDataCacheStats,
   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";
+// `getRedisDetails()` bağlantının nereye kurulduğunu ve hangi türleri
+// paylaştığını söyler (şifre asla dönmez); `inspectRedis()` tür başına anahtar
+// sayar — bir `SCAN` turu olduğu için istek yolunda çağrılmamalı.
+export { getRedisDetails, getRedisStatus, inspectRedis } from "./server/redis.js";
+// CDN kademesi. JSkelet'in önbelleği origin önbelleği; ziyaretçinin gördüğü
+// kopya edge'de duruyor. Bir içeriği gerçekten tazelemek için ikisini birlikte
+// düşürmek gerekiyor: `invalidateHtmlCache()` + `purgeCloudflare()`.
+export {
+  cloudflareConfigured,
+  fetchCacheAnalytics,
+  fetchCloudflareOverview,
+  fetchPathEdges,
+  getCloudflareStatus,
+  purgeCloudflare,
+  toCloudflareUrls,
+} from "./server/cloudflare.js";
+// Upstream hız freninin host başına durumu: healthcheck ve teşhis uçları için.
+export { getUpstreamLimiterStatus } from "./server/upstream-limiter.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/log.mjs

@@ -284,6 +284,31 @@ function truncate(text, max) {
 /** Kutunun içi sabit genişlikte; uzun satırlar kırpılır. */
 const BOX = 52;
 
+/**
+ * Çerçeveli bilgi kutusu.
+ *
+ * Açılış logunda kaybolmaması gereken tek şey sır: önbellek panelinin şifresi
+ * her restart'ta değişiyor ve kullanıcı onu bir kez, akışın içinde görüyor.
+ * Genişlik içeriğe göre büyür — bir URL'i ya da 32 haneli bir şifreyi
+ * kırpmak kutunun bütün amacını bozar.
+ *
+ * @param {{ title: string, lines: string[],
+ *   tint?: (value: string) => string }} info `lines` içinde boş string ayırıcı
+ *   satır olur. Satırlar **düz metin** olmalı: bir ANSI dizisi `length`e
+ *   sayıldığı için hizalamayı bozar, rengi çerçeve taşır.
+ */
+export function box({ title, lines, tint = c.cyan }) {
+  const width = Math.max(BOX, title.length + 4, ...lines.map((text) => text.length + 4));
+  const top = `┌─ ${title} ${"─".repeat(width - title.length - 3)}┐`;
+  const bottom = `└${"─".repeat(width)}┘`;
+
+  write(`\n${tint(top)}\n`);
+  for (const text of ["", ...lines, ""]) {
+    write(`${tint("│")}  ${text}${" ".repeat(width - 4 - text.length)}  ${tint("│")}\n`);
+  }
+  write(`${tint(bottom)}\n\n`);
+}
+
 /**
  * Çerçeveli hata kutusu — kendi framework'ünü geliştirirken hatanın
  * akış içinde kaybolmaması için.