jskelet 0.6.0 → 0.6.2

package/src/config/index.js

@@ -37,10 +37,15 @@ import {
   DEFAULT_AUTH,
   DEFAULT_BRAND,
   DEFAULT_CLOUDFLARE,
+  DATA_CACHE_MAX_ENTRIES_CEILING,
   DEFAULT_DATA_CACHE,
   DEFAULT_DEV_GATE_BYPASS,
   DEFAULT_DIRS,
   DEFAULT_HTML_CACHE_MAX_ENTRIES,
+  HTML_CACHE_MAX_ENTRIES_CEILING,
+  ON_VISIT_CONCURRENCY_CEILING,
+  ON_VISIT_PER_PAGE_CEILING,
+  ON_VISIT_RPS_CEILING,
   DEFAULT_IMAGES,
   DEFAULT_LOGS,
   DEFAULT_NAVIGATION,
@@ -134,6 +139,8 @@ const CONFIG_FILE = "jskelet.config.mjs";
  * @property {string[] | null} routes Açık route modülü listesi.
  * @property {boolean} trailingSlash URL'ler `/` ile bitsin mi (Next `trailingSlash`).
  * @property {{ extensions: Set<string>, prefixes: string[] }} static
+ * @property {boolean} devGate `DEV_TOKEN` tek başına siteyi kilitlemez; gate
+ *   ancak bu bayrak veya `DEV_GATE=1` ile açılır.
  * @property {string[]} devGateBypass
  * @property {string[]} preconnect
  * @property {NavigationConfig} navigation
@@ -348,6 +355,22 @@ function normalizeUpstream(raw) {
   };
 }
 
+/**
+ * Dev gate. `DEV_TOKEN` ortamda durması siteyi kilitlemez: paylaşılan bir
+ * task tanımı production'a da aynı değişkeni taşır ve herkese 404 olur.
+ * Gate ancak `devGate: true` ya da `DEV_GATE=1` ile açılır. `DEV_GATE=0`
+ * config'teki açığı da kapatır.
+ *
+ * @param {Record<string, any>} source
+ * @returns {boolean}
+ */
+function normalizeDevGate(source) {
+  const env = process.env.DEV_GATE;
+  if (env === "0" || env === "false") return false;
+  if (env === "1" || env === "true") return true;
+  return source.devGate === true;
+}
+
 /**
  * Yönetim paneli. `enabled` yalnızca açıkça `true` verildiğinde ya da
  * `JSKELET_ADMIN` ortam değişkeni ayarlandığında açılır: paneli yanlışlıkla
@@ -701,16 +724,24 @@ function normalizeCache(raw) {
   const prewarm = normalizePrewarm(raw?.prewarm);
   const queryRules = normalizeQueryRules(raw?.query);
   const maxEntries = Number(raw?.maxEntries);
+  let htmlMaxEntries =
+    Number.isFinite(maxEntries) && maxEntries > 0
+      ? Math.floor(maxEntries)
+      : DEFAULT_HTML_CACHE_MAX_ENTRIES;
+  if (htmlMaxEntries > HTML_CACHE_MAX_ENTRIES_CEILING) {
+    console.warn(
+      `[config] cache().maxEntries ${htmlMaxEntries} exceeds the ceiling of ` +
+        `${HTML_CACHE_MAX_ENTRIES_CEILING}; using ${HTML_CACHE_MAX_ENTRIES_CEILING}`,
+    );
+    htmlMaxEntries = HTML_CACHE_MAX_ENTRIES_CEILING;
+  }
 
   return {
     html,
     cacheQuery: queryRules,
     cacheVary: normalizeVary(raw?.vary),
-    htmlMaxEntries:
-      Number.isFinite(maxEntries) && maxEntries > 0
-        ? Math.floor(maxEntries)
-        : DEFAULT_HTML_CACHE_MAX_ENTRIES,
-    data: { ...DEFAULT_DATA_CACHE, ...(raw?.data ?? {}) },
+    htmlMaxEntries,
+    data: normalizeDataCache(raw?.data),
     // Otomatik upstream izleme kapatılabilir olmalı: `fetch`i kendisi saran
     // bir uygulama (ölçüm, retry, circuit breaker) çakışma yaşayabilir.
     trackUpstream: raw?.trackUpstream !== false,
@@ -732,14 +763,110 @@ function normalizeCache(raw) {
   };
 }
 
+/**
+ * İstenen pozitif tamsayı tavanı aşıyorsa uyarı basıp tavana çeker.
+ *
+ * @param {string} field
+ * @param {number} requested
+ * @param {number} ceiling
+ * @returns {number}
+ */
+function clampCeiling(field, requested, ceiling) {
+  if (requested <= ceiling) return requested;
+  console.warn(
+    `[config] ${field} ${requested} exceeds the ceiling of ${ceiling}; using ${ceiling}`,
+  );
+  return ceiling;
+}
+
+/**
+ * Veri önbelleği JSON tutar; sınır HTML'den yüksek olabilir ama sonsuz değil.
+ *
+ * @param {unknown} raw
+ * @returns {{ maxEntries: number, staleFactor: number }}
+ */
+function normalizeDataCache(raw) {
+  const source =
+    raw && typeof raw === "object" && !Array.isArray(raw)
+      ? /** @type {Record<string, unknown>} */ (raw)
+      : {};
+  const requested = Number(source.maxEntries);
+  let maxEntries =
+    Number.isFinite(requested) && requested > 0
+      ? Math.floor(requested)
+      : DEFAULT_DATA_CACHE.maxEntries;
+  maxEntries = clampCeiling(
+    "cache().data.maxEntries",
+    maxEntries,
+    DATA_CACHE_MAX_ENTRIES_CEILING,
+  );
+
+  const stale = Number(source.staleFactor);
+  return {
+    maxEntries,
+    staleFactor:
+      Number.isFinite(stale) && stale >= 0 ? stale : DEFAULT_DATA_CACHE.staleFactor,
+  };
+}
+
+/**
+ * onVisit sürekli çalışır. Klasik turdaki `rps: 0` (sınırsız) burada her
+ * ziyaretçide yeniden crawl demek; boş, `0` ve tavanın üstü 2'ye çekilir.
+ *
+ * @param {Record<string, unknown>} source
+ * @returns {{ enabled: boolean } & typeof DEFAULT_PREWARM_ON_VISIT}
+ */
+function resolveOnVisitLimits(source) {
+  const perPageRaw = Number(source.perPage);
+  const perPage = clampCeiling(
+    "cache().prewarm.onVisit.perPage",
+    Number.isFinite(perPageRaw) && perPageRaw > 0
+      ? Math.floor(perPageRaw)
+      : DEFAULT_PREWARM_ON_VISIT.perPage,
+    ON_VISIT_PER_PAGE_CEILING,
+  );
+
+  const concurrencyRaw = Number(source.concurrency);
+  const concurrency = clampCeiling(
+    "cache().prewarm.onVisit.concurrency",
+    Number.isFinite(concurrencyRaw) && concurrencyRaw > 0
+      ? Math.floor(concurrencyRaw)
+      : ON_VISIT_CONCURRENCY_CEILING,
+    ON_VISIT_CONCURRENCY_CEILING,
+  );
+
+  const rpsRaw = Number(source.rps);
+  let rps = ON_VISIT_RPS_CEILING;
+  if (source.rps != null && source.rps !== "") {
+    if (!Number.isFinite(rpsRaw) || rpsRaw <= 0) {
+      console.warn(
+        `[config] cache().prewarm.onVisit.rps ${source.rps} is not a positive rate; ` +
+          `using ${ON_VISIT_RPS_CEILING}`,
+      );
+    } else {
+      rps = clampCeiling(
+        "cache().prewarm.onVisit.rps",
+        rpsRaw,
+        ON_VISIT_RPS_CEILING,
+      );
+    }
+  }
+
+  return {
+    ...DEFAULT_PREWARM_ON_VISIT,
+    enabled: source.enabled !== false,
+    perPage,
+    concurrency,
+    rps,
+  };
+}
+
 /**
  * @param {unknown} raw
  * @returns {{ enabled: boolean } & typeof DEFAULT_PREWARM_ON_VISIT}
  */
 function normalizeOnVisit(raw) {
-  if (raw === true) {
-    return { ...DEFAULT_PREWARM_ON_VISIT, enabled: true };
-  }
+  if (raw === true) return resolveOnVisitLimits({});
 
   if (raw == null || raw === false) {
     return { ...DEFAULT_PREWARM_ON_VISIT, enabled: false };
@@ -751,24 +878,7 @@ function normalizeOnVisit(raw) {
     );
   }
 
-  const source = /** @type {Record<string, unknown>} */ (raw);
-  const perPage = Number(source.perPage);
-  const concurrency = Number(source.concurrency);
-  const rps = Number(source.rps);
-
-  return {
-    ...DEFAULT_PREWARM_ON_VISIT,
-    enabled: source.enabled !== false,
-    perPage:
-      Number.isFinite(perPage) && perPage > 0
-        ? Math.floor(perPage)
-        : DEFAULT_PREWARM_ON_VISIT.perPage,
-    concurrency:
-      Number.isFinite(concurrency) && concurrency > 0
-        ? Math.floor(concurrency)
-        : null,
-    rps: Number.isFinite(rps) && rps >= 0 ? rps : null,
-  };
+  return resolveOnVisitLimits(/** @type {Record<string, unknown>} */ (raw));
 }
 
 /**
@@ -1255,6 +1365,7 @@ export async function loadConfig(options = {}) {
       extensions: new Set(source.static?.extensions ?? DEFAULT_STATIC.extensions),
       prefixes: source.static?.prefixes ?? DEFAULT_STATIC.prefixes,
     },
+    devGate: normalizeDevGate(source),
     devGateBypass: source.devGateBypass ?? DEFAULT_DEV_GATE_BYPASS,
     preconnect: source.preconnect ?? [],
     navigation: normalizeNavigation(source.navigation, brand),

package/src/server/create-app.js

@@ -12,6 +12,9 @@
  *      açık kurallar istenen yolu önce görür.
  *   3b. access log (açıksa) — tamamlanan yanıtların süresi; admin/prewarm
  *      içeride elenir.
+ *   3c. robots.txt — statikten önce, compression'ın içinde: kullanıcının
+ *      gövdesine framework Disallow bloğu eklenir. Sıkıştırılmış kopyanın
+ *      (Content-Encoding dolu) üzerine yazılmaz.
  *   4. staticPrecompressed → express.static — build'de üretilmiş `.br`/`.gz`
  *      kopyalar varsa onlar servis edilir (kalite 11), yoksa istek altındaki
  *      static'e düşer ve middleware anında sıkıştırır (kalite 5).
@@ -32,6 +35,7 @@ import path from "node:path";
 import process from "node:process";
 import express from "express";
 import { compression } from "./middleware/compression.js";
+import { robotsTxtMiddleware } from "./middleware/robots-txt.js";
 import { headersMiddleware } from "./middleware/headers.js";
 import { csrf } from "./middleware/csrf.js";
 import { staticPrecompressed } from "./middleware/static-precompressed.js";
@@ -109,6 +113,11 @@ export async function createApp(options = {}) {
     app.use(accessLogMiddleware());
   }
 
+  // Kullanıcının robots.txt'i statik dosya da olabilir, route da. İkisi de
+  // bu sarmalayıcıdan geçer. compression'dan sonra durur: ek, sıkıştırılmış
+  // baytların değil düz metnin sonuna yazılır.
+  app.use(robotsTxtMiddleware());
+
   app.use(staticPrecompressed(config.dirs.public));
   app.use(
     express.static(config.dirs.public, {

package/src/server/html-cache.js

@@ -31,10 +31,13 @@
  */
 
 import { getConfig } from "../config/index.js";
-import { DEFAULT_HTML_CACHE_MAX_ENTRIES } from "../config/defaults.js";
+import {
+  DEFAULT_HTML_CACHE_MAX_ENTRIES,
+  HTML_CACHE_BYTE_BUDGET,
+} from "../config/defaults.js";
 import { collectDependencies } from "./cache-deps.js";
 import { compilePattern, matchPattern } from "../config/pattern.js";
-import { pathOfCacheKey } from "./cache-vary.js";
+import { pathOfCacheKey, publicHost } from "./cache-vary.js";
 import {
   cacheKey,
   onCacheEvent,
@@ -118,6 +121,19 @@ const EARLY_SWEEP_INTERVAL_MS = 1000;
 /** @type {Map<string, HtmlEntry>} */
 const store = new Map();
 
+/**
+ * `store` içindeki HTML string + sıkıştırılmış gövdelerin toplamı.
+ * Her `drop` / `install` bunu günceller; sıkıştırma sonradan eklendiğinde
+ * `noteHtmlCacheGrowth` artışı yazar. Tam tarama yapmamak için tutulur.
+ */
+let storedBytes = 0;
+
+/**
+ * Testler tahliyeyi küçük bir bütçeyle doğrular. `null` → üretim tavanı.
+ * @type {number | null}
+ */
+let byteBudgetOverride = null;
+
 /** @type {Map<string, Promise<{ html: string, status: number }>>} */
 const inflight = new Map();
 
@@ -237,8 +253,45 @@ function unlink(key, entry) {
 }
 
 /**
- * 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.
+ * Ham HTML + sıkıştırılmış gövdeler. Bayt bütçesi girdi sayısından bağımsız
+ * bu ağırlığa bakar.
+ *
+ * @param {HtmlEntry} entry
+ * @returns {number}
+ */
+function entryBytes(entry) {
+  let bytes = Buffer.byteLength(entry.html);
+  for (const buffer of entry.encoded.values()) bytes += buffer.length;
+  return bytes;
+}
+
+/**
+ * @returns {number}
+ */
+function activeByteBudget() {
+  return byteBudgetOverride ?? HTML_CACHE_BYTE_BUDGET;
+}
+
+/**
+ * Sayı tavanı veya bayt bütçesi aşılınca en eski girdiden düşer. Tek başına
+ * bütçeyi aşan girdi de gider: yanıt o istekte zaten üretilmiştir, L1'de
+ * durması süreci şişirir.
+ */
+function evictOverflow() {
+  const limit = maxEntries();
+  const budget = activeByteBudget();
+
+  while (store.size > 0 && (store.size > limit || storedBytes > budget)) {
+    const oldest = store.keys().next().value;
+    if (oldest === undefined) break;
+    if (!drop(oldest)) break;
+  }
+}
+
+/**
+ * Store'dan silmenin **tek** yolu. Ters indeks ve bayt sayacı buraya bağlı;
+ * hiçbir yerde doğrudan `store.delete()` çağrılmaz. `read()` içindeki
+ * sil-yaz yalnızca LRU sırası içindir, sayacı değiştirmez.
  *
  * @param {string} key
  * @returns {boolean} Girdi var mıydı.
@@ -248,6 +301,7 @@ function drop(key) {
   if (!entry) return false;
 
   unlink(key, entry);
+  storedBytes = Math.max(0, storedBytes - entryBytes(entry));
   store.delete(key);
   return true;
 }
@@ -406,8 +460,9 @@ function write(key, value, ttlSeconds, deps = null, produceMs = DEFAULT_PRODUCE_
     produceMs: normalizeProduceMs(produceMs),
   };
 
-  install(key, entry);
-  share(key, entry);
+  // Bütçeye sığmayan sayfa Redis'e de yazılmaz: bir sonraki istek onu
+  // geri alıp yine reddeder, stringify ise o anki RSS'i şişirir.
+  if (install(key, entry)) share(key, entry);
 }
 
 /**
@@ -416,13 +471,20 @@ function write(key, value, ttlSeconds, deps = null, produceMs = DEFAULT_PRODUCE_
  *
  * @param {string} key
  * @param {HtmlEntry} entry
+ * @returns {boolean} Girdi L1'e girdi mi.
  */
 function install(key, entry) {
   // Aynı anahtarın eski girdisi ters indekste kalmasın: bağımlılıklar
   // tazelemeden tazelemeye değişebilir.
   drop(key);
 
+  const weight = entryBytes(entry);
+  // Tek sayfa bütçeden büyükse saklama. Eski kopya da düştü; bu yanıt
+  // üreticinin döndürdüğü HTML ile gider, L1'e girmez.
+  if (weight > activeByteBudget()) return false;
+
   store.set(key, entry);
+  storedBytes += weight;
 
   for (const dep of entry.deps) {
     let set = dependents.get(dep);
@@ -430,12 +492,35 @@ function install(key, entry) {
     set.add(key);
   }
 
-  const limit = maxEntries();
-  while (store.size > limit) {
-    const oldest = store.keys().next().value;
-    if (oldest === undefined) break;
-    drop(oldest);
-  }
+  evictOverflow();
+  return store.has(key);
+}
+
+/**
+ * Sıkıştırılmış gövde `install()`'dan sonra, ilk brotli/gzip yanıtında
+ * girdinin `encoded` haritasına eklenir. Sayacı delta ile büyütmek, o sıra
+ * LRU'dan düşmüş bir haritaya yazınca bir daha inmeyen bir artık bırakır;
+ * store'dan yeniden okumak o artığı taşımaz.
+ *
+ * @returns {void}
+ */
+export function noteHtmlCacheGrowth() {
+  let bytes = 0;
+  for (const entry of store.values()) bytes += entryBytes(entry);
+  storedBytes = bytes;
+  evictOverflow();
+}
+
+/**
+ * Bellek freninin bayt tavanını geçici olarak değiştirir. Testler LRU
+ * tahliyesini küçük bir değerle doğrular; `null` üretim tavanına döner.
+ *
+ * @param {number | null} bytes
+ * @returns {void}
+ */
+export function setHtmlCacheByteBudget(bytes) {
+  byteBudgetOverride = bytes == null ? null : bytes;
+  evictOverflow();
 }
 
 /**
@@ -589,6 +674,7 @@ export function clearHtmlCache() {
  */
 function clearLocal() {
   store.clear();
+  storedBytes = 0;
   dependents.clear();
   tokens.clear();
   invalidated.clear();
@@ -877,27 +963,65 @@ function dropLocalKey(key) {
 }
 
 /**
- * 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.
+ * Vary önekinden `h=` parçasını okur. Önek yoksa boş string.
  *
- * Vary öneki (`h=…|`) düşülür — HTTP ısıtması yalnızca yolu ister; host
- * ayrımı `prewarm.origins` / istek Host'u ile yapılır.
+ * @param {string} key
+ * @returns {string}
+ */
+function hostOfCacheKey(key) {
+  const sep = key.indexOf("|/");
+  if (sep === -1) return "";
+  const prefix = key.slice(0, sep);
+  for (const part of prefix.split("&")) {
+    if (part.startsWith("h=")) return part.slice(2);
+  }
+  return "";
+}
+
+/**
+ * @param {string} key
+ * @returns {string}
+ */
+function pathWithQuery(key) {
+  const pathname = pathOfCacheKey(key);
+  const q = key.indexOf("?");
+  if (q === -1) return pathname;
+  const query = key.slice(q + 1);
+  return query ? `${pathname}?${query}` : pathname;
+}
+
+/**
+ * Invalidate edilmiş yollar. Okuma yıkıcıdır; iki tur aynı yolu tekrar
+ * ısıtmasın. `onlyHost` verilirse başka host'ların anahtarları kuyrukta
+ * kalır — süre dolumu onları kendi host'uyla ısıtır, `127.0.0.1` anahtarı
+ * açılmaz.
  *
- * @returns {string[]}
+ * @param {string} [onlyHost]
+ * @returns {{ path: string, host: string }[]}
  */
-export function takeInvalidatedPaths() {
+export function takeInvalidatedTargets(onlyHost) {
   if (!invalidated.size) return [];
 
-  const paths = [...invalidated];
-  invalidated.clear();
-  return paths.map((key) => {
-    const pathname = pathOfCacheKey(key);
-    const q = key.indexOf("?");
-    if (q === -1) return pathname;
-    const query = key.slice(q + 1);
-    return query ? `${pathname}?${query}` : pathname;
-  });
+  /** @type {{ path: string, host: string }[]} */
+  const taken = [];
+
+  for (const key of [...invalidated]) {
+    const host = hostOfCacheKey(key);
+    if (onlyHost && host && host !== onlyHost) continue;
+    invalidated.delete(key);
+    taken.push({ path: pathWithQuery(key), host });
+  }
+
+  return taken;
+}
+
+/**
+ * Yol listesi. Vary öneki düşülür; host ayrımı `takeInvalidatedTargets`.
+ *
+ * @returns {string[]}
+ */
+export function takeInvalidatedPaths() {
+  return takeInvalidatedTargets().map((target) => target.path);
 }
 
 /**
@@ -926,14 +1050,36 @@ export function getHtmlCacheEntries() {
  * Yol (query'siz) için taze bir HTML girdisi var mı? Ziyaret ısıtması yalnızca
  * soğuk / bayat hedefleri kuyruğa alır; HIT'leri yeniden çekmez.
  *
+ * Gerçek anahtar `h=host|/yol?` biçimindedir: düz `store.get(pathname)` hem
+ * vary önekini hem sondaki `?` işaretini kaçırır ve sıcak sayfayı yeniden
+ * ısıtır. `vary.host` açıkken yalnızca bu isteğin host'u sayılır; diğer
+ * locale'in kopyası bu yolu sıcak yapmaz.
+ *
  * @param {string} pathname
+ * @param {{ headers?: Record<string, unknown>, get?: (name: string) => string | undefined }} [req]
  * @returns {boolean}
  */
-export function isHtmlCacheFresh(pathname) {
+export function isHtmlCacheFresh(pathname, req) {
   if (typeof pathname !== "string" || !pathname.startsWith("/")) return false;
-  const entry = store.get(pathname);
-  if (!entry) return false;
-  return Date.now() < entry.expiresAt;
+
+  let host = "";
+  try {
+    if (getConfig().cacheVary?.host && req) host = publicHost(req);
+  } catch {
+    // Config yokken (testler) önek aranmaz; yol eşleşmesi yeter.
+  }
+
+  const now = Date.now();
+  for (const [key, entry] of store) {
+    if (now >= entry.expiresAt) continue;
+    if (pathOfCacheKey(key) !== pathname) continue;
+    const q = key.indexOf("?");
+    if (q !== -1 && key.slice(q + 1)) continue;
+    if (host && hostOfCacheKey(key) !== host) continue;
+    return true;
+  }
+
+  return false;
 }
 
 /**

package/src/server/middleware/dev-gate.js

@@ -1,11 +1,12 @@
 /**
- * Yayına açılmamış bir ortamı gizler: `DEV_TOKEN` ayarlıyken token taşımayan
- * her isteğe 404 döner. 403 değil 404 — 403 ortamın var olduğunu doğrular,
- * 404 hiç yokmuş gibi davranır.
+ * Yayına açılmamış bir ortamı gizler. Gate kapalıyken (varsayılan) `DEV_TOKEN`
+ * olsa bile istekler geçer: değişkenin task ortamında unutulması production'u
+ * kilitlemesin. Açmak için `devGate: true` ya da `DEV_GATE=1` gerekir; o zaman
+ * token taşımayan her isteğe 404 döner. 403 değil 404 — 403 ortamın var
+ * olduğunu doğrular, 404 hiç yokmuş gibi davranır.
  *
  * Token bir kez `?dev_token=…` ile gelirse çereze yazılır, böylece link
- * paylaşımı yeterli olur. `DEV_TOKEN` yoksa middleware tamamen devre dışıdır
- * ve üretimde hiçbir maliyeti olmaz.
+ * paylaşımı yeterli olur. Token boşsa gate açık olsa da kimse kilitlenmez.
  */
 import process from "node:process";
 import { getConfig } from "../../config/index.js";
@@ -32,13 +33,25 @@ function readCookie(req, name) {
 
 /** @returns {import('express').RequestHandler} */
 export function devGate() {
-  const { devGateBypass, brand } = getConfig();
+  const { devGate: enabled, devGateBypass, brand } = getConfig();
   const bypass = new Set(devGateBypass);
   const cookieName = brand.devTokenCookie;
+  const devToken = process.env.DEV_TOKEN;
+
+  // Unutulmuş bir değişken sessizce herkese 404 kesmesin; operatör görsün.
+  if (!enabled && devToken) {
+    console.warn(
+      "[dev-gate] DEV_TOKEN is set but the gate is off, so the site stays public. " +
+        "Set devGate: true or DEV_GATE=1 to require the token.",
+    );
+  } else if (enabled && !devToken) {
+    console.warn(
+      "[dev-gate] the gate is on but DEV_TOKEN is empty; requests are not blocked.",
+    );
+  }
 
   return (req, res, next) => {
-    const devToken = process.env.DEV_TOKEN;
-    if (!devToken) return next();
+    if (!enabled || !devToken) return next();
     if (bypass.has(req.path)) return next();
 
     const fromQuery = req.query?.[cookieName];