jskelet 0.7.3 → 0.7.4

package/CHANGELOG.md

@@ -10,6 +10,9 @@ one is listed under a **Breaking** heading.
 
 ### Changed
 
+- Redis HTML is stored as a small JSON meta key, a raw brotli `:body` key, and
+  optional `:enc:br` / `:enc:gzip` keys on a second connection. HTML command
+  timeouts use their own circuit breaker and no longer bypass the data cache.
 - `.jsk` codegen merges adjacent static HTML into fewer `+=` ops and drops
   template indentation (newline-only whitespace). A lone space between
   inline siblings is kept; `pre` / `textarea` / `script` / `style` / `code`
@@ -73,6 +76,9 @@ one is listed under a **Breaking** heading.
 
 ### Added
 
+- `cache().redis.htmlCommandTimeoutMs` (default `2000`) limits only the HTML
+  Redis connection. `commandTimeoutMs` stays `200` for data, publish, and scan.
+  The admin Redis card shows both timeouts.
 - `stylesheets({ blocking: false })` and `<Stylesheets :blocking="false" />`
   emit each stylesheet with `media="print"` and an `onload` that switches it
   to `all`, plus a `<noscript>` fallback, so the links do not block rendering.

package/docs/06-cache.md

@@ -831,9 +831,11 @@ npm install ioredis
 ```
 
 Kurulmadıysa ya da Redis'e bağlanılamıyorsa uyarı basılır ve site **bellek içi
-önbellekle çalışmaya devam eder**. Redis çalışırken düşerse aynı şey olur: bir
-devre kesici art arda beş hatadan sonra katmanı beş saniye baypas eder, böylece
-her istek ağ zaman aşımı beklemez.
+önbellekle çalışmaya devam eder**. Redis çalışırken düşerse aynı şey olur:
+veri ve HTML için ayrı devre kesiciler vardır. Art arda beş hata ilgili
+katmanı beş saniye baypas eder, böylece her istek ağ zaman aşımı beklemez.
+HTML zaman aşımı veri sayacına yazılmaz; yavaş bir sayfa küçük veri
+anahtarlarını kapatmaz.
 
 ### Ne kazanırsınız
 
@@ -852,6 +854,8 @@ her istek ağ zaman aşımı beklemez.
 
 ```
 _jskelet:{namespace}:{buildId}:html:{vary|}{yol}?{query}
+_jskelet:{namespace}:{buildId}:html:{vary|}{yol}?{query}:body
+_jskelet:{namespace}:{buildId}:html:{vary|}{yol}?{query}:enc:{br|gzip}
 _jskelet:{namespace}:{buildId}:data:{anahtar}
 _jskelet:{namespace}:events
 ```
@@ -867,12 +871,25 @@ anahtarlar TTL ile ölür — elle temizlik ya da `FLUSHDB` gerekmez. Build
 bilinçli olarak `buildId` **taşımaz**: deploy sırasında eski ve yeni sürüm yan
 yana koşuyor ve bir purge ikisine de ulaşmalı.
 
-1 KB ve üstü HTML ve veri girdileri düz JSON olarak durmaz: `JSK\x01` önekli
-brotli gövde yazılır (kalite 5, metin modu — yanıt sıkıştırmasıyla aynı ayar).
-L1 yine çözülmüş nesne tutar; sıkıştırma yalnızca L1 miss'ten sonraki
-paylaşımda, yanıtı bekletmeden çalışır. Daha küçük kayıtlar düz JSON kalır,
-eski düz JSON kayıtlar da okunur. zstd kullanılmaz: `node:zlib` içindeki zstd
-22.15'ten itibaren var, motor ise `>=22`.
+HTML üç parçaya yazılır. Meta anahtarı küçük bir JSON'dur (`status`,
+`storedAt`, `expiresAt`, `staleUntil`, `produceMs`, `deps`) ve gövde içermez.
+`:body` HTML'in brotli baytıdır; base64 yoktur ve bu bayt bir JSON'un içine
+ikinci kez sıkıştırılmaz. `storeEncoded` açıksa yanıt için üretilmiş brotli
+veya gzip gövdesi `:enc:br` / `:enc:gzip` anahtarına olduğu gibi yazılır.
+Okuma meta ile gövdeyi tek pipeline'da ister; parçalardan biri yoksa kayıt yok
+sayılır ve sayfa render edilir.
+
+Veri girdileri 1 KB ve üstünde düz JSON olarak durmaz: `JSK\x01` önekli brotli
+gövde yazılır (kalite 5, metin modu — yanıt sıkıştırmasıyla aynı ayar). Daha
+küçük veri kayıtları düz JSON kalır. HTML bu sarmalayıcıyı kullanmaz. zstd
+kullanılmaz: `node:zlib` içindeki zstd 22.15'ten itibaren var, motor ise
+`>=22`.
+
+`commandTimeoutMs` (varsayılan 200) veri, yayın ve `SCAN` komutlarına
+uygulanır. HTML okuma ve yazma ayrı bir bağlantıdadır; `htmlCommandTimeoutMs`
+(varsayılan 2000) yalnız o bağlantının komutlarını sınırlar. ioredis zaman
+aşımı istemci genelinde olduğu için iki süre tek bağlantıda ayrılamaz.
+Uygulama bu alanı vermezse framework 2000 kullanır.
 
 Redis kapalıyken (ya da bağlanamadığında) aynı gövde `.jskelet/cache/<buildId>/`
 altına dosya olarak yazılır. Süreç yeniden açılınca L1 boştur ama diskteki
@@ -889,8 +906,8 @@ bir sonraki yazışta siler. `clearHtmlCache()` ve invalidation dosyayı da dü
   dışındaki durum kodları da paylaşılmaz.
 - **Sıkıştırılmış gövdeler varsayılan olarak paylaşılır.** `storeEncoded`
   (varsayılan `true`) soğuk replica'nın L2 HIT'te yeniden brotli ödemesini
-  önler; girdi başına boyutu iki-üç katına çıkarır. L2 boyutunu kısıtlamak
-  için `storeEncoded: false` verin.
+  önler. Gövde `:enc:{br|gzip}` anahtarına ham bayt olarak yazılır; meta
+  JSON'unun içine base64 girmez. Kapatmak için `storeEncoded: false` verin.
 - **Yumuşak invalidation Redis kopyasını siler.** Bayatlatmanın Redis karşılığı
   her anahtar için oku-değiştir-yaz turu demek ve bir webhook binlerce anahtarı
   birden düşürüyor. Silmenin bedeli, o yolu hiç görmemiş bir kopyanın bir kez
@@ -917,16 +934,18 @@ app.get("/api/healthcheck", (req, res) => {
 ```
 
 Bağlantı kurulmamışken de güvenle çağrılır. Dönen nesne
-`{ enabled, connected, keyPrefix, buildId, errors, bypassed }`; `bypassed` devre
-kesicinin açık olduğunu, `errors` toplam komut hatasını gösterir. Aynı özet dev
-panelinin raporunda da var ([09-dev-araclari.md](./09-dev-araclari.md)).
+`{ enabled, connected, keyPrefix, buildId, errors, bypassed, htmlErrors, htmlBypassed }`.
+`bypassed` veri katmanının, `htmlBypassed` HTML katmanının baypasta olduğunu
+gösterir. `errors` veri komutlarının, `htmlErrors` HTML komutlarının toplam
+hatasıdır. Aynı özet dev panelinin raporunda da var
+([09-dev-araclari.md](./09-dev-araclari.md)).
 
 İki teşhis yüzeyi daha var:
 
 | Çağrı | Ne der |
 | --- | --- |
 | `getRedisDetails()` | Bağlantının **nereye** kurulduğu: adres, TLS, veritabanı, `namespace`, hangi türlerin paylaşıldığı, purge yayınına abone olunup olunmadığı. Şifre asla dönmez — bağlantı URL'i sır taşıyor olabilir. |
-| `inspectRedis()` | Paylaşımlı kademede gerçekten ne durduğu: tür başına anahtar sayısı, `DBSIZE` ve `used_memory`. Bir `SCAN` turu olduğu için **istek yolunda çağrılmaz**; yönetim panelinde de ayrı bir düğmeye bağlı. |
+| `inspectRedis()` | Paylaşımlı kademede gerçekten ne durduğu: tür başına kayıt sayısı (HTML'de gövde ve kodlama parçaları tek sayfa sayılır), `DBSIZE` ve `used_memory`. Bir `SCAN` turu olduğu için **istek yolunda çağrılmaz**; yönetim panelinde de ayrı bir düğmeye bağlı. |
 
 Ayarların tam listesi: [07-yapilandirma.md](./07-yapilandirma.md).
 
@@ -1029,7 +1048,7 @@ değil.
 | Clear HTML cache | `clearHtmlCache()` |
 | Clear data cache (önek opsiyonel) | `clearDataCache(prefix)` |
 | Drop shared keys | Redis'teki `html` ya da `data` isim alanını tarar ve düşürür |
-| Count keys in Redis | `inspectRedis()` — tür başına anahtar sayısı, `DBSIZE` ve `used_memory` |
+| Count keys in Redis | `inspectRedis()` — tür başına kayıt (HTML parçaları tek sayfa sayılır), `DBSIZE` ve `used_memory` |
 | Prewarm | `prewarm()` — tur arkada koşar, ilerleme kartta görünür |
 | Cloudflare purge (her şey / bellekteki URL'ler / prefix / host / tag) | `purgeCloudflare()` |
 | Cloudflare ayarı ya da özelliği değiştirmek | Zone ayarları ve Tiered Cache / Cache Reserve |

package/docs/07-yapilandirma.md

@@ -960,15 +960,17 @@ kurulmadıysa ya da bağlanılamıyorsa uyarı basılır ve site bellek içi ön
 | `keyPrefix` | `string` | `"_jskelet"` | Anahtar düzeninin kökü |
 | `html` | `boolean` | `true` | HTML gövdeleri paylaşılsın mı |
 | `data` | `boolean` | `true` | `withDataCache` girdileri paylaşılsın mı |
-| `storeEncoded` | `boolean` | `true` | Brotli/gzip gövdeleri de paylaşılsın mı; girdi başına boyutu iki-üç katına çıkarır |
+| `storeEncoded` | `boolean` | `true` | Brotli/gzip gövdeleri ayrı `:enc:` anahtarına yazılsın mı |
 | `events` | `boolean` | `true` | pub/sub üzerinden invalidation yayını |
-| `commandTimeoutMs` | `number` | `200` | Tek bir komutun en fazla bekletebileceği süre |
-
-Anahtarlar `_jskelet:{namespace}:{buildId}:html:{yol}?{query}` biçiminde yaşar.
-`buildId` her build'de değişir, böylece deploy sonrası eski HTML kendiliğinden
-geçersiz olur. Kişiye özel (`storable: false`), `degraded` ve 200 dışındaki
-yanıtlar paylaşımlı kademeye hiç yazılmaz. Takaslar ve teşhis:
-[06-cache.md](./06-cache.md).
+| `commandTimeoutMs` | `number` | `200` | Veri, yayın ve `SCAN` için tek komutun tavanı |
+| `htmlCommandTimeoutMs` | `number` | `2000` | Yalnızca HTML bağlantısının komut tavanı. Verilmezse 2000 |
+
+Anahtarlar parçalıdır: `_jskelet:{namespace}:{buildId}:html:{yol}?{query}` küçük
+meta JSON'u, aynı anahtarın `:body` soneki HTML'in brotli baytını, `:enc:br`
+ve `:enc:gzip` ise yanıt kodlamasını tutar. `buildId` her build'de değişir,
+böylece deploy sonrası eski HTML kendiliğinden geçersiz olur. Kişiye özel
+(`storable: false`), `degraded` ve 200 dışındaki yanıtlar paylaşımlı kademeye
+hiç yazılmaz. Takaslar ve teşhis: [06-cache.md](./06-cache.md).
 
 ```js
 redis: {

package/docs/en/06-caching.md

@@ -849,8 +849,10 @@ npm install ioredis
 
 If it is not installed, or Redis cannot be reached, a warning is printed and the
 site **keeps running on the in-process cache**. The same happens if Redis goes
-down while running: a circuit breaker bypasses the tier for five seconds after
-five consecutive failures, so requests do not each wait for a network timeout.
+down while running: data and HTML have separate circuit breakers. Five
+consecutive failures bypass that tier for five seconds, so requests do not each
+wait for a network timeout. An HTML timeout is not charged to the data counter,
+so a slow page does not shut the small data keys.
 
 ### What you get
 
@@ -870,6 +872,8 @@ five consecutive failures, so requests do not each wait for a network timeout.
 
 ```
 _jskelet:{namespace}:{buildId}:html:{vary|}{path}?{query}
+_jskelet:{namespace}:{buildId}:html:{vary|}{path}?{query}:body
+_jskelet:{namespace}:{buildId}:html:{vary|}{path}?{query}:enc:{br|gzip}
 _jskelet:{namespace}:{buildId}:data:{key}
 _jskelet:{namespace}:events
 ```
@@ -885,13 +889,25 @@ build has not been run the id is `dev`.
 deliberately does **not** carry `buildId`: during a deploy the old and the new
 version run side by side and a purge has to reach both.
 
-HTML and data entries of 1 KB or more are not stored as plain JSON. The shared
-tier receives a brotli body prefixed with `JSK\x01` (quality 5, text mode — the
-same settings as response compression). L1 still holds the decoded value;
-compression runs only when sharing after an L1 miss, and it does not delay the
-response. Smaller records stay plain JSON, and older plain JSON records are
-still read. zstd is not used: `node:zlib` gained it in 22.15, while the engine
-range is `>=22`.
+HTML is stored as three parts. The meta key is a small JSON document
+(`status`, `storedAt`, `expiresAt`, `staleUntil`, `produceMs`, `deps`) and does
+not contain the body. `:body` is the brotli bytes of the HTML: no base64, and
+those bytes are not compressed again inside JSON. When `storeEncoded` is on,
+the brotli or gzip body produced for the response is written as-is to
+`:enc:br` / `:enc:gzip`. A read pipelines meta and body; if either part is
+missing the record counts as absent and the page is rendered.
+
+Data entries of 1 KB or more are not stored as plain JSON. They are a brotli
+body prefixed with `JSK\x01` (quality 5, text mode — the same settings as
+response compression). Smaller data records stay plain JSON. HTML does not use
+that wrapper. zstd is not used: `node:zlib` gained it in 22.15, while the
+engine range is `>=22`.
+
+`commandTimeoutMs` (default 200) applies to data, publish, and `SCAN`. HTML
+reads and writes use a second connection; `htmlCommandTimeoutMs` (default
+2000) limits only that connection. ioredis applies `commandTimeout` to the
+whole client, so the two budgets cannot share one connection. When an
+application omits the field, the framework uses 2000.
 
 When Redis is off, or cannot connect, the same body is written under
 `.jskelet/cache/<buildId>/`. After a restart L1 is empty, but a fresh file
@@ -908,8 +924,9 @@ file too.
   tier: a leak would mean serving one user's HTML to the whole cluster.
   `degraded` renders and non-200 status codes are not shared either.
 - **Compressed bodies are shared by default.** `storeEncoded` (default `true`)
-  keeps a cold replica from paying brotli again on an L2 HIT; it doubles or
-  triples the size per entry. Set `storeEncoded: false` to keep L2 lean.
+  keeps a cold replica from paying brotli again on an L2 HIT. The body is
+  stored as raw bytes on an `:enc:{br|gzip}` key; it is not base64 inside the
+  meta JSON. Set `storeEncoded: false` to skip those keys.
 - **A soft invalidation deletes the Redis copy.** Staling in Redis would mean a
   read-modify-write round per key, and a webhook drops thousands of keys at
   once. The cost of deleting is one render on a replica that never saw that
@@ -936,9 +953,10 @@ app.get("/api/healthcheck", (req, res) => {
 ```
 
 Safe to call even with no connection. The returned object is
-`{ enabled, connected, keyPrefix, buildId, errors, bypassed }`; `bypassed` tells
-you the circuit breaker is open and `errors` is the total command failure count.
-The same summary is in the dev panel report
+`{ enabled, connected, keyPrefix, buildId, errors, bypassed, htmlErrors, htmlBypassed }`.
+`bypassed` means the data tier is in its bypass window and `htmlBypassed` means
+the HTML connection is. `errors` counts data-command failures and `htmlErrors`
+counts HTML-command failures. The same summary is in the dev panel report
 ([09-dev-tools.md](./09-dev-tools.md)).
 
 Two more diagnostic surfaces:
@@ -946,7 +964,7 @@ Two more diagnostic surfaces:
 | Call | What it tells you |
 | --- | --- |
 | `getRedisDetails()` | **Where** the connection points: address, TLS, database, `namespace`, which kinds are shared, whether the purge channel is subscribed. The password is never returned — a connection URL may carry one. |
-| `inspectRedis()` | What is actually in the shared tier: keys per kind, `DBSIZE` and `used_memory`. It runs a `SCAN`, so **never call it on the request path**; in the admin panel it sits behind its own button. |
+| `inspectRedis()` | What is actually in the shared tier: records per kind (HTML body and encoding fragments count as one page), `DBSIZE` and `used_memory`. It runs a `SCAN`, so **never call it on the request path**; in the admin panel it sits behind its own button. |
 
 The full list of settings: [07-configuration.md](./07-configuration.md).
 
@@ -1030,7 +1048,7 @@ export content.
 | Clear HTML cache | `clearHtmlCache()` |
 | Clear data cache (optional prefix) | `clearDataCache(prefix)` |
 | Drop shared keys | Scans and unlinks the `html` or `data` namespace in Redis |
-| Count keys in Redis | `inspectRedis()` — keys per kind, `DBSIZE` and `used_memory` |
+| Count keys in Redis | `inspectRedis()` — records per kind (HTML fragments count as one page), `DBSIZE` and `used_memory` |
 | Prewarm | `prewarm()` — the pass runs in the background, progress shows in the card |
 | Cloudflare purge (everything / URLs held here / prefix / host / tag) | `purgeCloudflare()` |
 | Change a Cloudflare setting or feature | Zone settings and Tiered Cache / Cache Reserve |

package/docs/en/07-configuration.md

@@ -979,12 +979,15 @@ the site keeps running on the in-process cache.
 | `keyPrefix` | `string` | `"_jskelet"` | Root of the key layout |
 | `html` | `boolean` | `true` | Whether HTML bodies are shared |
 | `data` | `boolean` | `true` | Whether `withDataCache` entries are shared |
-| `storeEncoded` | `boolean` | `true` | Whether brotli/gzip bodies are shared too; doubles or triples the size per entry |
+| `storeEncoded` | `boolean` | `true` | Whether brotli/gzip bodies are written to their own `:enc:` keys |
 | `events` | `boolean` | `true` | Invalidation broadcast over pub/sub |
-| `commandTimeoutMs` | `number` | `200` | At most how long a single command may block |
+| `commandTimeoutMs` | `number` | `200` | Per-command ceiling for data, publish, and `SCAN` |
+| `htmlCommandTimeoutMs` | `number` | `2000` | Per-command ceiling for the HTML connection only. `2000` when omitted |
 
-Keys live as `_jskelet:{namespace}:{buildId}:html:{path}?{query}`. `buildId`
-changes with every build, so old HTML becomes invalid on its own after a deploy.
+Keys are split: `_jskelet:{namespace}:{buildId}:html:{path}?{query}` is the
+small meta JSON, the `:body` suffix is the brotli bytes of the HTML, and
+`:enc:br` / `:enc:gzip` hold the response encoding. `buildId` changes with
+every build, so old HTML becomes invalid on its own after a deploy.
 Personalised (`storable: false`), `degraded` and non-200 responses are never
 written to the shared tier. Trade-offs and diagnosis:
 [06-caching.md](./06-caching.md).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jskelet",
-  "version": "0.7.3",
+  "version": "0.7.4",
   "description": "A framework that feels like no framework: Express 5 + build-time .jsk SSR (optional EJS peer), vanilla JS islands, Tailwind v4 and an in-process HTML TTL cache.",
   "type": "module",
   "license": "MIT",

package/src/client/admin/i18n.js

@@ -90,7 +90,9 @@ export const MESSAGES = {
     "redis.broadcast.publish": "publish only",
     "redis.broadcast.local": "local only",
     "redis.timeout": "Command timeout",
+    "redis.htmlTimeout": "HTML command timeout",
     "redis.errors": "Command errors",
+    "redis.htmlErrors": "HTML command errors",
     "redis.tier": "Tier",
     "redis.tier.inProcess": "in-process only",
     "redis.replicas": "Replicas sharing this cache",
@@ -394,7 +396,9 @@ export const MESSAGES = {
     "redis.broadcast.publish": "yalnızca yayın",
     "redis.broadcast.local": "yalnızca yerel",
     "redis.timeout": "Komut zaman aşımı",
+    "redis.htmlTimeout": "HTML komut zaman aşımı",
     "redis.errors": "Komut hatası",
+    "redis.htmlErrors": "HTML komut hatası",
     "redis.tier": "Kademe",
     "redis.tier.inProcess": "yalnızca süreç içi",
     "redis.replicas": "Bu önbelleği paylaşan kopya",

package/src/client/admin/panel.js

@@ -556,8 +556,12 @@ function renderRedis(redis, state) {
         [t("redis.buildId"), redis.buildId || "dev"],
         [
           t("redis.sharesHtml"),
-          redis.html ? t("state.yes") : t("state.no"),
-          redis.html ? "on" : "off",
+          !redis.html
+            ? t("state.no")
+            : redis.htmlBypassed
+              ? t("state.bypassed")
+              : t("state.yes"),
+          redis.html && !redis.htmlBypassed ? "on" : "off",
         ],
         [
           t("redis.sharesData"),
@@ -579,7 +583,9 @@ function renderRedis(redis, state) {
           redis.events && redis.subscribed ? "on" : "off",
         ],
         [t("redis.timeout"), `${redis.commandTimeoutMs} ${t("unit.ms")}`],
+        [t("redis.htmlTimeout"), `${redis.htmlCommandTimeoutMs} ${t("unit.ms")}`],
         [t("redis.errors"), String(redis.errors), redis.errors ? "bad" : "on"],
+        [t("redis.htmlErrors"), String(redis.htmlErrors ?? 0), redis.htmlErrors ? "bad" : "on"],
       ]
     : [
         [t("redis.tier"), t("redis.tier.inProcess")],

package/src/config/defaults.js

@@ -297,11 +297,19 @@ export const DEFAULT_REDIS = {
   /** pub/sub üzerinden invalidation yayını. */
   events: true,
   /**
-   * Tek bir komutun en fazla bekletebileceği süre. Önbellek okuması isteği
+   * Veri, yayın ve SCAN için tek komut tavanı. Önbellek okuması isteği
    * bloklayan bir adım: Redis takıldığında render'a düşmek, ağı beklemekten
-   * iyidir.
+   * iyidir. HTML gövdesi bu süreye sığmaz; o bağlantının tavanı
+   * `htmlCommandTimeoutMs`.
    */
   commandTimeoutMs: 200,
+  /**
+   * Yalnızca HTML bağlantısı. ioredis `commandTimeout` istemci genelinde
+   * olduğu için gövde ayrı bağlantıda durur. Verilmezse 2000: uygulama
+   * config'i değiştirmek zorunda kalmasın. Parçalı yazma normalde bunun
+   * altında biter; tavan, gövde beklenmedik büyürse diye durur.
+   */
+  htmlCommandTimeoutMs: 2000,
 };
 
 /**

package/src/config/index.js

@@ -95,7 +95,8 @@ const CONFIG_FILE = "jskelet.config.mjs";
  * @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
+ * @property {number} commandTimeoutMs Veri, yayın ve SCAN tavanı.
+ * @property {number} htmlCommandTimeoutMs Yalnızca HTML bağlantısının tavanı.
  */
 
 /**
@@ -340,6 +341,7 @@ function normalizePriority(raw) {
 function normalizeRedis(raw) {
   const source = /** @type {Record<string, any>} */ (raw ?? {});
   const timeout = Number(source.commandTimeoutMs);
+  const htmlTimeout = Number(source.htmlCommandTimeoutMs);
 
   return {
     enabled: source.enabled === true,
@@ -354,6 +356,10 @@ function normalizeRedis(raw) {
       Number.isFinite(timeout) && timeout > 0
         ? Math.floor(timeout)
         : DEFAULT_REDIS.commandTimeoutMs,
+    htmlCommandTimeoutMs:
+      Number.isFinite(htmlTimeout) && htmlTimeout > 0
+        ? Math.floor(htmlTimeout)
+        : DEFAULT_REDIS.htmlCommandTimeoutMs,
   };
 }
 

package/src/server/html-cache.js

@@ -46,8 +46,8 @@ import {
   publishCacheEvent,
   redisDrop,
   redisDropMatching,
-  redisGetJson,
-  redisSetJson,
+  redisGetHtml,
+  redisShareHtml,
   redisShares,
   redisSharesEncoded,
 } from "./redis.js";
@@ -372,6 +372,10 @@ function read(key) {
  * Girdiyi paylaşımlı kademeye yazar. Ateşle-unut: yanıt yolunda beklenmez,
  * L1 kopyası bu isteği zaten karşılıyor.
  *
+ * Redis'te gövde meta JSON'unun içinde durmaz. 1 MB HTML + base64 kodlama
+ * tek SET'te `commandTimeoutMs`'i aşıyordu ve zaman aşımı veri sayacını da
+ * kapatıyordu. Meta küçük kalır; brotli bayt ayrı anahtardadır.
+ *
  * @param {string} key
  * @param {HtmlEntry} entry
  */
@@ -383,8 +387,12 @@ function share(key, entry) {
   const ttlMs = entry.staleUntil - Date.now();
   if (ttlMs <= 0) return;
 
-  /** @type {Record<string, unknown>} */
-  const payload = {
+  if (onRedis) {
+    shareOnRedis(key, entry, ttlMs);
+    return;
+  }
+
+  diskSetJson("html", key, {
     html: entry.html,
     status: entry.status,
     storedAt: entry.storedAt,
@@ -392,20 +400,41 @@ function share(key, entry) {
     staleUntil: entry.staleUntil,
     produceMs: entry.produceMs,
     deps: [...entry.deps],
+  });
+}
+
+/**
+ * @param {string} key
+ * @param {HtmlEntry} entry
+ * @param {number} ttlMs
+ */
+function shareOnRedis(key, entry, ttlMs) {
+  /** @type {Record<string, unknown>} */
+  const meta = {
+    status: entry.status,
+    storedAt: entry.storedAt,
+    expiresAt: entry.expiresAt,
+    staleUntil: entry.staleUntil,
+    produceMs: entry.produceMs,
+    deps: [...entry.deps],
   };
 
-  if (onRedis && redisSharesEncoded() && entry.encoded.size) {
-    /** @type {Record<string, string>} */
-    const encoded = {};
-    for (const [encoding, buffer] of entry.encoded) {
-      encoded[encoding] = buffer.toString("base64");
-    }
-    payload.encoded = encoded;
-    entry.sharedEncodings = entry.encoded.size;
+  // Yanıt brotli'si HTML brotli'si ile aynı bayt (kalite 5, metin). İkinci
+  // sıkıştırma yok; `enc:br` storeEncoded açıksa bu tamponun kopyasıdır.
+  const encoded = redisSharesEncoded() && entry.encoded.size ? entry.encoded : null;
+  if (encoded) entry.sharedEncodings = entry.encoded.size;
+
+  const ready = entry.encoded.get("br");
+  if (ready) {
+    redisShareHtml(key, meta, ready, encoded, ttlMs);
+    return;
   }
 
-  if (onRedis) redisSetJson(cacheKey("html", key), payload, ttlMs);
-  else diskSetJson("html", key, payload);
+  encodeText(entry.html, "br")
+    .then((body) => redisShareHtml(key, meta, body, encoded, ttlMs))
+    .catch(() => {
+      // Gövdesiz meta okununca kayıt yok sayılır; yarım yazmanın faydası yok.
+    });
 }
 
 /**
@@ -441,16 +470,24 @@ async function readShared(key) {
     sharedMissUntil.delete(key);
   }
 
-  const payload = onRedis
-    ? await redisGetJson(cacheKey("html", key))
-    : await diskGetJson("html", key);
+  const payload = onRedis ? await redisGetHtml(key) : await diskGetJson("html", key);
+  return finishShared(key, payload, !onRedis);
+}
+
+/**
+ * @param {string} key
+ * @param {any} payload
+ * @param {boolean} fromDisk
+ * @returns {HtmlEntry | null}
+ */
+function finishShared(key, payload, fromDisk) {
   if (!payload || typeof payload.html !== "string") {
     rememberSharedMiss(key);
     return null;
   }
   if (typeof payload.expiresAt !== "number" || Date.now() >= payload.expiresAt) {
     // Dosyanın TTL'i yok; süresi dolmuş kopya okununca silinir.
-    if (onDisk) diskDrop("html", [key]);
+    if (fromDisk) diskDrop("html", [key]);
     rememberSharedMiss(key);
     return null;
   }
@@ -464,23 +501,7 @@ async function readShared(key) {
   // etmek olurdu.
   if (readsPurgedData(deps, storedAt)) return null;
 
-  /** @type {Map<string, Buffer>} */
-  const encoded = new Map();
-  if (payload.encoded && typeof payload.encoded === "object") {
-    for (const [encoding, base64] of Object.entries(payload.encoded)) {
-      if (typeof base64 === "string") {
-        encoded.set(encoding, Buffer.from(base64, "base64"));
-      }
-    }
-    // Eski bir replica iki kodlama yazmış olabilir. L1 tek kopya tutar;
-    // brotli varsa o kalır.
-    if (encoded.size > 1) {
-      const keep = encoded.has("br") ? "br" : encoded.keys().next().value;
-      const buffer = keep ? encoded.get(keep) : undefined;
-      encoded.clear();
-      if (keep && buffer) encoded.set(keep, buffer);
-    }
-  }
+  const encoded = normalizeEncoded(payload.encoded);
 
   return {
     html: payload.html,
@@ -497,6 +518,40 @@ async function readShared(key) {
   };
 }
 
+/**
+ * Disk hâlâ base64 taşır. Redis `Map<string, Buffer>` döner. L1 tek kodlama
+ * tutar; brotli varsa o kalır.
+ *
+ * @param {unknown} raw
+ * @returns {Map<string, Buffer>}
+ */
+function normalizeEncoded(raw) {
+  /** @type {Map<string, Buffer>} */
+  const encoded = new Map();
+
+  if (raw instanceof Map) {
+    for (const [encoding, buffer] of raw) {
+      if (typeof encoding === "string" && Buffer.isBuffer(buffer) && buffer.length) {
+        encoded.set(encoding, buffer);
+      }
+    }
+  } else if (raw && typeof raw === "object") {
+    for (const [encoding, value] of Object.entries(raw)) {
+      if (typeof value === "string") encoded.set(encoding, Buffer.from(value, "base64"));
+      else if (Buffer.isBuffer(value) && value.length) encoded.set(encoding, value);
+    }
+  }
+
+  if (encoded.size > 1) {
+    const keep = encoded.has("br") ? "br" : encoded.keys().next().value;
+    const buffer = keep ? encoded.get(keep) : undefined;
+    encoded.clear();
+    if (keep && buffer) encoded.set(keep, buffer);
+  }
+
+  return encoded;
+}
+
 /**
  * @param {string} key
  * @param {{ html: string, status: number }} value

package/src/server/redis.js

@@ -19,6 +19,7 @@
  * fırlatmaz; okuma `null`, yazma sessiz no-op'a döner.
  */
 import crypto from "node:crypto";
+import zlib from "node:zlib";
 import { DEFAULT_REDIS } from "../config/defaults.js";
 import { tryImportFromApp } from "../build/resolve-peer.mjs";
 import { getBuildId } from "./assets.js";
@@ -32,6 +33,14 @@ import { decodeCacheValueAsync, encodeCacheValue } from "./cache-blob.js";
 
 /** @type {any} */
 let client = null;
+/**
+ * HTML GET/SET. `commandTimeout` ioredis'te istemci genelinde: gövde yazması
+ * veri okumasının 200 ms tavanını paylaşırsa yavaş sayfa küçük anahtarları da
+ * bekletir. Ayrı bağlantı bu yüzden var.
+ *
+ * @type {any}
+ */
+let htmlClient = null;
 /** @type {any} */
 let subscriber = null;
 
@@ -53,18 +62,27 @@ const originId = crypto.randomUUID();
 const listeners = [];
 
 let errors = 0;
+let htmlErrors = 0;
 
 /**
  * Devre kesici. Redis düştüğünde her istek `commandTimeoutMs` beklemesin:
  * art arda gelen hatalardan sonra istemci bir süre baypas edilir. Süre
  * dolduğunda tek bir komut denenir ve başarılıysa sayaç sıfırlanır.
+ *
+ * HTML'in sayacı ayrı. Gövde zaman aşımı `consecutiveFailures`'a yazılmaz:
+ * beş yavaş sayfa, veri önbelleğini beş saniye kapatmasın.
  */
 let consecutiveFailures = 0;
 let bypassUntil = 0;
+let htmlConsecutiveFailures = 0;
+let htmlBypassUntil = 0;
 
 const MAX_FAILURES = 5;
 const BYPASS_MS = 5000;
 
+/** Yanıt için saklanan kodlamalar. Okuma bunları aynı pipeline'a koyar. */
+const HTML_RESPONSE_ENCODINGS = ["br", "gzip"];
+
 /** @returns {boolean} */
 function usable() {
   if (!client) return false;
@@ -72,6 +90,13 @@ function usable() {
   return true;
 }
 
+/** @returns {boolean} */
+function htmlUsable() {
+  if (!htmlClient) return false;
+  if (htmlBypassUntil && Date.now() < htmlBypassUntil) return false;
+  return true;
+}
+
 /**
  * @param {string} action
  * @param {unknown} error
@@ -101,6 +126,36 @@ function noteSuccess() {
   bypassUntil = 0;
 }
 
+/**
+ * HTML bağlantısının hataları. Veri sayacına dokunmaz.
+ *
+ * @param {string} action
+ * @param {unknown} error
+ */
+function noteHtmlFailure(action, error) {
+  htmlErrors += 1;
+  htmlConsecutiveFailures += 1;
+
+  if (htmlConsecutiveFailures >= MAX_FAILURES && !htmlBypassUntil) {
+    htmlBypassUntil = Date.now() + BYPASS_MS;
+    console.warn(
+      `[redis] ${MAX_FAILURES} consecutive html failures — bypassing html for ${BYPASS_MS}ms`,
+    );
+  }
+
+  if (htmlConsecutiveFailures <= MAX_FAILURES) {
+    console.warn(
+      `[redis] html ${action} failed`,
+      error instanceof Error ? error.message : error,
+    );
+  }
+}
+
+function noteHtmlSuccess() {
+  htmlConsecutiveFailures = 0;
+  htmlBypassUntil = 0;
+}
+
 /**
  * Bağlantıyı kurar. `createApp()` config yüklendikten sonra bir kez çağırır.
  *
@@ -135,6 +190,7 @@ export async function connectRedis(config) {
     // ayağa kalkmalı, sadece L2 devre dışı kalır.
     lazyConnect: true,
     // Tek bir komut isteği bloklayan adım; kuyrukta birikmesine izin verilmez.
+    // Bu tavan veri, yayın ve SCAN içindir. HTML ayrı bağlantıda.
     commandTimeout: redis.commandTimeoutMs,
     maxRetriesPerRequest: 1,
     enableOfflineQueue: false,
@@ -165,12 +221,52 @@ export async function connectRedis(config) {
   // sürüm yan yana koşuyor ve purge mesajı ikisine de ulaşmalı.
   channel = `${redis.keyPrefix}:${redis.namespace}:events`;
 
+  if (redis.html) await connectHtml(Redis, redis, options);
   if (redis.events) await subscribe(Redis, redis, options);
 
   console.log(`[redis] connected — keys under \`${prefix}:\``);
   return true;
 }
 
+/**
+ * HTML gövdesi için ayrı bağlantı. `duplicate` host, şifre ve db'yi kopyalar;
+ * `commandTimeout` ise bu istemciye özel kalır.
+ *
+ * Bağlanamazsa veri katmanı ayakta kalır — HTML L1'de durur.
+ *
+ * @param {Function} Redis
+ * @param {RedisConfig} redis
+ * @param {Record<string, unknown>} options
+ */
+async function connectHtml(Redis, redis, options) {
+  const htmlOptions = { ...options, commandTimeout: redis.htmlCommandTimeoutMs };
+
+  try {
+    htmlClient =
+      typeof client.duplicate === "function"
+        ? client.duplicate({ commandTimeout: redis.htmlCommandTimeoutMs })
+        : redis.url
+          ? new Redis(redis.url, htmlOptions)
+          : new Redis(htmlOptions);
+
+    htmlClient.on("error", (error) => noteHtmlFailure("connection", error));
+    if (htmlClient.status !== "ready" && htmlClient.status !== "connecting") {
+      await htmlClient.connect();
+    }
+  } catch (error) {
+    console.warn(
+      "[redis] html connection failed — HTML stays in-process:",
+      error instanceof Error ? error.message : error,
+    );
+    try {
+      htmlClient?.disconnect();
+    } catch {
+      // Zaten kopmuş olabilir.
+    }
+    htmlClient = null;
+  }
+}
+
 /**
  * pub/sub için ikinci bir bağlantı: abone olmuş bir istemci normal komut
  * kabul etmez.
@@ -264,7 +360,8 @@ export function publishCacheEvent(event) {
  * @returns {boolean}
  */
 export function redisShares(kind) {
-  return usable() && settings[kind] === true;
+  if (settings[kind] !== true) return false;
+  return kind === "html" ? htmlUsable() : usable();
 }
 
 /** @returns {boolean} */
@@ -281,6 +378,192 @@ export function cacheKey(kind, key) {
   return `${prefix}:${kind}:${key}`;
 }
 
+/**
+ * HTML kaydını parçalı yazar. Meta küçük JSON'dur; gövde ham brotli baytıdır
+ * (base64 yok, JSON içinde ikinci brotli yok). `encoded` varsa her kodlama
+ * `:enc:` anahtarına olduğu gibi gider.
+ *
+ * Ateşle-unut ve tek sayaç adımı: üç SET'ten biri düşerse bu bir hatadır,
+ * veri devre kesicisine yazılmaz.
+ *
+ * @param {string} key Önbellek anahtarı (`yol?query`), öneksiz.
+ * @param {Record<string, unknown>} meta
+ * @param {Buffer} body
+ * @param {Map<string, Buffer> | null} encoded
+ * @param {number} ttlMs
+ */
+export function redisShareHtml(key, meta, body, encoded, ttlMs) {
+  if (!htmlUsable() || !(ttlMs > 0)) return;
+
+  /** @type {string} */
+  let json;
+  try {
+    json = JSON.stringify(meta);
+  } catch (error) {
+    noteHtmlFailure("serialize", error);
+    return;
+  }
+
+  const base = cacheKey("html", key);
+  const px = Math.ceil(ttlMs);
+  /** @type {Promise<unknown>[]} */
+  const writes = [
+    htmlClient.set(base, json, "PX", px),
+    htmlClient.set(`${base}:body`, body, "PX", px),
+  ];
+
+  if (encoded) {
+    for (const [encoding, buffer] of encoded) {
+      if (!encoding || !Buffer.isBuffer(buffer) || !buffer.length) continue;
+      writes.push(htmlClient.set(`${base}:enc:${encoding}`, buffer, "PX", px));
+    }
+  }
+
+  Promise.all(writes)
+    .then(() => noteHtmlSuccess())
+    .catch((error) => noteHtmlFailure("set", error));
+}
+
+/**
+ * Meta + gövde (+ açıksa kodlamalar) tek pipeline. Parça eksikse kayıt yok
+ * sayılır; bu bir hata değildir. Bağlantı hatası HTML sayacına yazılır.
+ *
+ * @param {string} key Önbellek anahtarı (`yol?query`), öneksiz.
+ * @returns {Promise<{ html: string, status: unknown, storedAt: unknown,
+ *   expiresAt: unknown, staleUntil: unknown, produceMs: unknown, deps: unknown,
+ *   encoded: Map<string, Buffer> } | null>}
+ */
+export async function redisGetHtml(key) {
+  if (!htmlUsable()) return null;
+
+  const base = cacheKey("html", key);
+  /** @type {string[]} */
+  const keys = [base, `${base}:body`];
+  if (settings.storeEncoded === true) {
+    for (const encoding of HTML_RESPONSE_ENCODINGS) keys.push(`${base}:enc:${encoding}`);
+  }
+
+  try {
+    const values = await readHtmlBuffers(keys);
+    noteHtmlSuccess();
+
+    const metaRaw = values[0];
+    const bodyRaw = values[1];
+    if (metaRaw == null || bodyRaw == null) return null;
+
+    const metaText = asText(metaRaw);
+    if (!metaText) return null;
+    const meta = JSON.parse(metaText);
+    if (!meta || typeof meta !== "object") return null;
+
+    const html = await inflateBrotli(bodyRaw);
+    /** @type {Map<string, Buffer>} */
+    const encoded = new Map();
+    if (settings.storeEncoded === true) {
+      HTML_RESPONSE_ENCODINGS.forEach((encoding, index) => {
+        const buffer = asBuffer(values[2 + index]);
+        if (buffer?.length) encoded.set(encoding, buffer);
+      });
+    }
+
+    return {
+      status: meta.status,
+      storedAt: meta.storedAt,
+      expiresAt: meta.expiresAt,
+      staleUntil: meta.staleUntil,
+      produceMs: meta.produceMs,
+      deps: meta.deps,
+      html,
+      encoded,
+    };
+  } catch (error) {
+    noteHtmlFailure("get", error);
+    return null;
+  }
+}
+
+/**
+ * @param {string[]} keys
+ * @returns {Promise<(Buffer | string | null)[]>}
+ */
+async function readHtmlBuffers(keys) {
+  if (typeof htmlClient.pipeline === "function") {
+    const pipe = htmlClient.pipeline();
+    const getter = typeof pipe.getBuffer === "function" ? "getBuffer" : "get";
+    for (const key of keys) pipe[getter](key);
+    const rows = await pipe.exec();
+    if (!Array.isArray(rows)) return keys.map(() => null);
+    return rows.map((row) => {
+      if (!row) return null;
+      const [error, value] = row;
+      if (error) throw error;
+      return value ?? null;
+    });
+  }
+
+  const getter = typeof htmlClient.getBuffer === "function" ? "getBuffer" : "get";
+  return Promise.all(keys.map((key) => htmlClient[getter](key)));
+}
+
+/**
+ * @param {unknown} value
+ * @returns {string | null}
+ */
+function asText(value) {
+  if (typeof value === "string") return value;
+  if (Buffer.isBuffer(value)) return value.toString("utf8");
+  return null;
+}
+
+/**
+ * @param {unknown} value
+ * @returns {Buffer | null}
+ */
+function asBuffer(value) {
+  if (Buffer.isBuffer(value)) return value;
+  if (typeof value === "string") return Buffer.from(value);
+  return null;
+}
+
+/**
+ * `:body` JSK sarmalayıcısı taşımaz; tamamı brotli'dir.
+ *
+ * @param {unknown} raw
+ * @returns {Promise<string>}
+ */
+function inflateBrotli(raw) {
+  const body = asBuffer(raw);
+  if (!body?.length) return Promise.reject(new Error("empty html body"));
+
+  return new Promise((resolve, reject) => {
+    zlib.brotliDecompress(body, (error, out) => {
+      if (error) reject(error);
+      else resolve(out.toString("utf8"));
+    });
+  });
+}
+
+/**
+ * `:body` ve `:enc:*` sayfa kaydı değil, gövde parçasıdır.
+ *
+ * @param {string} key
+ * @returns {boolean}
+ */
+function isHtmlFragmentKey(key) {
+  return key.endsWith(":body") || key.endsWith(":enc:br") || key.endsWith(":enc:gzip");
+}
+
+/**
+ * @param {string} key
+ * @returns {boolean}
+ */
+function isHtmlMetaKey(key) {
+  // `data` anahtarı da `:html:` metnini taşıyabilir; tür segmenti önekten hemen
+  // sonra gelir. Parça anahtarları (`:body`, `:enc:`) ayrıca düşürülür.
+  if (!prefix || !key.startsWith(`${prefix}:html:`)) return false;
+  return !isHtmlFragmentKey(key);
+}
+
 /**
  * @param {string} key
  * @returns {Promise<any | null>} Girdi yoksa, ayrıştırılamıyorsa ya da Redis
@@ -348,13 +631,41 @@ export function redisSetJson(key, value, ttlMs) {
  * @param {string[]} keys
  */
 export function redisDrop(keys) {
-  if (!usable() || !keys.length) return;
+  if (!keys.length) return;
+
+  /** @type {string[]} */
+  const dataKeys = [];
+  /** @type {string[]} */
+  const htmlKeys = [];
+
+  for (const key of keys) {
+    if (isHtmlMetaKey(key)) {
+      // Gövde ve kodlama anahtarları meta ile birlikte düşmezse 1 MB'lık
+      // parça TTL'e kadar kalır. Eksik anahtarda UNLINK no-op'tur.
+      htmlKeys.push(key, `${key}:body`, `${key}:enc:br`, `${key}:enc:gzip`);
+    } else if (!isHtmlFragmentKey(key)) {
+      dataKeys.push(key);
+    }
+  }
 
+  if (dataKeys.length && usable()) unlinkKeys(client, dataKeys, noteFailure, noteSuccess);
+  if (htmlKeys.length && htmlUsable()) {
+    unlinkKeys(htmlClient, htmlKeys, noteHtmlFailure, noteHtmlSuccess);
+  }
+}
+
+/**
+ * @param {any} connection
+ * @param {string[]} keys
+ * @param {(action: string, error: unknown) => void} fail
+ * @param {() => void} succeed
+ */
+function unlinkKeys(connection, keys, fail, succeed) {
   // `UNLINK` silmeyi arka plana atar: bir webhook binlerce anahtar
   // düşürdüğünde `DEL` sunucuyu bloklar.
-  Promise.resolve(client.unlink(...keys))
-    .then(noteSuccess)
-    .catch((error) => noteFailure("unlink", error));
+  Promise.resolve(connection.unlink(...keys))
+    .then(() => succeed())
+    .catch((error) => fail("unlink", error));
 }
 
 /**
@@ -409,7 +720,8 @@ export async function redisDropMatching(kind, match) {
  * Dev raporu için durum özeti. Bağlantı yoksa da güvenle çağrılabilir.
  *
  * @returns {{ enabled: boolean, connected: boolean, keyPrefix: string,
- *   buildId: string, errors: number, bypassed: boolean }}
+ *   buildId: string, errors: number, bypassed: boolean, htmlErrors: number,
+ *   htmlBypassed: boolean }}
  */
 export function getRedisStatus() {
   const [, , buildId = ""] = prefix ? prefix.split(":") : [];
@@ -421,6 +733,8 @@ export function getRedisStatus() {
     buildId,
     errors,
     bypassed: Boolean(bypassUntil && Date.now() < bypassUntil),
+    htmlErrors,
+    htmlBypassed: Boolean(htmlBypassUntil && Date.now() < htmlBypassUntil),
   };
 }
 
@@ -435,7 +749,7 @@ export function getRedisStatus() {
  * @returns {{ address: string, secure: boolean, db: string | null,
  *   namespace: string, keyPrefix: string, html: boolean, data: boolean,
  *   storeEncoded: boolean, events: boolean, commandTimeoutMs: number,
- *   subscribed: boolean }}
+ *   htmlCommandTimeoutMs: number, subscribed: boolean }}
  */
 export function getRedisDetails() {
   let address = "localhost:6379 (ioredis default)";
@@ -466,6 +780,7 @@ export function getRedisDetails() {
     storeEncoded: settings.storeEncoded === true,
     events: settings.events === true,
     commandTimeoutMs: settings.commandTimeoutMs,
+    htmlCommandTimeoutMs: settings.htmlCommandTimeoutMs,
     subscribed: Boolean(subscriber),
   };
 }
@@ -526,7 +841,7 @@ async function count(kind) {
       500,
     );
     cursor = next;
-    total += keys.length;
+    total += kind === "html" ? keys.filter((key) => !isHtmlFragmentKey(key)).length : keys.length;
   } while (cursor !== "0");
 
   return total;
@@ -539,8 +854,9 @@ async function count(kind) {
  * @returns {Promise<void>}
  */
 export async function disconnectRedis() {
-  const open = [subscriber, client].filter(Boolean);
+  const open = [...new Set([subscriber, htmlClient, client].filter(Boolean))];
   client = null;
+  htmlClient = null;
   subscriber = null;
 
   await Promise.all(
@@ -564,16 +880,22 @@ export async function disconnectRedis() {
  *
  * @param {any} fake `null` → katman kapatılır.
  * @param {Partial<RedisConfig>} [overrides]
+ * @param {any} [htmlFake] Verilmezse `fake` hem veri hem HTML istemcisidir.
+ *   HTML zaman aşımını veri sayacından ayırmak için ayrı bir sahte verilir.
  */
-export function setRedisClientForTests(fake, overrides = {}) {
+export function setRedisClientForTests(fake, overrides = {}, htmlFake = fake) {
   client = fake;
+  htmlClient = htmlFake;
   subscriber = null;
   settings = { ...DEFAULT_REDIS, enabled: Boolean(fake), ...overrides };
   prefix = fake ? `${settings.keyPrefix}:${settings.namespace}:test` : "";
   channel = `${settings.keyPrefix}:${settings.namespace}:events`;
   errors = 0;
+  htmlErrors = 0;
   consecutiveFailures = 0;
+  htmlConsecutiveFailures = 0;
   bypassUntil = 0;
+  htmlBypassUntil = 0;
 }
 
 /**

package/types/config/defaults.d.ts

@@ -260,11 +260,19 @@ export declare const DEFAULT_REDIS: {
     /** pub/sub üzerinden invalidation yayını. */
     events: boolean;
     /**
-     * Tek bir komutun en fazla bekletebileceği süre. Önbellek okuması isteği
+     * Veri, yayın ve SCAN için tek komut tavanı. Önbellek okuması isteği
      * bloklayan bir adım: Redis takıldığında render'a düşmek, ağı beklemekten
-     * iyidir.
+     * iyidir. HTML gövdesi bu süreye sığmaz; o bağlantının tavanı
+     * `htmlCommandTimeoutMs`.
      */
     commandTimeoutMs: number;
+    /**
+     * Yalnızca HTML bağlantısı. ioredis `commandTimeout` istemci genelinde
+     * olduğu için gövde ayrı bağlantıda durur. Verilmezse 2000: uygulama
+     * config'i değiştirmek zorunda kalmasın. Parçalı yazma normalde bunun
+     * altında biter; tavan, gövde beklenmedik büyürse diye durur.
+     */
+    htmlCommandTimeoutMs: number;
 };
 /**
  * Kalıcı log sink'leri (dosya + S3).

package/types/config/index.d.ts

@@ -34,7 +34,14 @@ export type RedisConfig = {
      * pub/sub invalidation yayını.
      */
     events: boolean;
+    /**
+     * Veri, yayın ve SCAN tavanı.
+     */
     commandTimeoutMs: number;
+    /**
+     * Yalnızca HTML bağlantısının tavanı.
+     */
+    htmlCommandTimeoutMs: number;
 };
 export type LogKind = "http" | "event" | "error";
 export type LogsConfig = {

package/types/server/dev/report.d.ts

@@ -210,6 +210,8 @@ export declare function buildReport(devtools: {
             buildId: string;
             errors: number;
             bypassed: boolean;
+            htmlErrors: number;
+            htmlBypassed: boolean;
         };
     };
     upstream: {

package/types/server/redis.d.ts

@@ -48,6 +48,40 @@ export declare function redisSharesEncoded(): boolean;
  * @returns {string}
  */
 export declare function cacheKey(kind: "html" | "data", key: string): string;
+/**
+ * HTML kaydını parçalı yazar. Meta küçük JSON'dur; gövde ham brotli baytıdır
+ * (base64 yok, JSON içinde ikinci brotli yok). `encoded` varsa her kodlama
+ * `:enc:` anahtarına olduğu gibi gider.
+ *
+ * Ateşle-unut ve tek sayaç adımı: üç SET'ten biri düşerse bu bir hatadır,
+ * veri devre kesicisine yazılmaz.
+ *
+ * @param {string} key Önbellek anahtarı (`yol?query`), öneksiz.
+ * @param {Record<string, unknown>} meta
+ * @param {Buffer} body
+ * @param {Map<string, Buffer> | null} encoded
+ * @param {number} ttlMs
+ */
+export declare function redisShareHtml(key: string, meta: Record<string, unknown>, body: Buffer, encoded: Map<string, Buffer> | null, ttlMs: number): void;
+/**
+ * Meta + gövde (+ açıksa kodlamalar) tek pipeline. Parça eksikse kayıt yok
+ * sayılır; bu bir hata değildir. Bağlantı hatası HTML sayacına yazılır.
+ *
+ * @param {string} key Önbellek anahtarı (`yol?query`), öneksiz.
+ * @returns {Promise<{ html: string, status: unknown, storedAt: unknown,
+ *   expiresAt: unknown, staleUntil: unknown, produceMs: unknown, deps: unknown,
+ *   encoded: Map<string, Buffer> } | null>}
+ */
+export declare function redisGetHtml(key: string): Promise<{
+    html: string;
+    status: unknown;
+    storedAt: unknown;
+    expiresAt: unknown;
+    staleUntil: unknown;
+    produceMs: unknown;
+    deps: unknown;
+    encoded: Map<string, Buffer>;
+} | null>;
 /**
  * @param {string} key
  * @returns {Promise<any | null>} Girdi yoksa, ayrıştırılamıyorsa ya da Redis
@@ -85,7 +119,8 @@ export declare function redisDropMatching(kind: "html" | "data", match?: (key: s
  * Dev raporu için durum özeti. Bağlantı yoksa da güvenle çağrılabilir.
  *
  * @returns {{ enabled: boolean, connected: boolean, keyPrefix: string,
- *   buildId: string, errors: number, bypassed: boolean }}
+ *   buildId: string, errors: number, bypassed: boolean, htmlErrors: number,
+ *   htmlBypassed: boolean }}
  */
 export declare function getRedisStatus(): {
     enabled: boolean;
@@ -94,6 +129,8 @@ export declare function getRedisStatus(): {
     buildId: string;
     errors: number;
     bypassed: boolean;
+    htmlErrors: number;
+    htmlBypassed: boolean;
 };
 /**
  * Bağlantının **nereye** kurulduğu ve hangi ayarlarla çalıştığı.
@@ -106,7 +143,7 @@ export declare function getRedisStatus(): {
  * @returns {{ address: string, secure: boolean, db: string | null,
  *   namespace: string, keyPrefix: string, html: boolean, data: boolean,
  *   storeEncoded: boolean, events: boolean, commandTimeoutMs: number,
- *   subscribed: boolean }}
+ *   htmlCommandTimeoutMs: number, subscribed: boolean }}
  */
 export declare function getRedisDetails(): {
     address: string;
@@ -119,6 +156,7 @@ export declare function getRedisDetails(): {
     storeEncoded: boolean;
     events: boolean;
     commandTimeoutMs: number;
+    htmlCommandTimeoutMs: number;
     subscribed: boolean;
 };
 /**
@@ -152,8 +190,10 @@ export declare function disconnectRedis(): Promise<void>;
  *
  * @param {any} fake `null` → katman kapatılır.
  * @param {Partial<RedisConfig>} [overrides]
+ * @param {any} [htmlFake] Verilmezse `fake` hem veri hem HTML istemcisidir.
+ *   HTML zaman aşımını veri sayacından ayırmak için ayrı bir sahte verilir.
  */
-export declare function setRedisClientForTests(fake: any, overrides?: Partial<RedisConfig>): void;
+export declare function setRedisClientForTests(fake: any, overrides?: Partial<RedisConfig>, htmlFake?: any): void;
 /**
  * Testler için: abone kanalından gelmiş gibi olay besler. `originId`
  * verilmezse uzak bir node varsayılır; kendi kimliğini taşıyan bir yayını