jskelet 0.7.0 → 0.7.2

package/CHANGELOG.md

@@ -8,8 +8,64 @@ one is listed under a **Breaking** heading.
 
 ## [Unreleased]
 
+### Changed
+
+- `.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`
+  preserve whitespace. Framework default `layout.render.js` regenerated.
+- `.jsk` page layout no longer copies the full helpers object into `data`
+  each render (EJS layouts still receive helpers as locals).
+- `esc()` skips the regex replace when the string has no special characters;
+  `attrs()` builds the attribute string without an intermediate array.
+- Compiled templates and JS components load with parallel `import` on first
+  render; production skips the `.jsk` mtime scan when a template manifest
+  already exists.
+- `icon()` caches the sprite URL in production; `Image` `fill` without an
+  extra `class` skips `twMerge`; `optimizedImage()` materializes CDN-prefixed
+  variant URLs once at load time.
+- `scripts/measure-ssr.mjs` microbench for fixture `renderView` /
+  `renderPage` and live cache MISS/HIT timings against a running app.
+- HTML cache awaits brotli on write so the MISS response can reuse it;
+  `rememberHtmlEncoding` updates the byte budget by delta instead of
+  rescanning the store. Short negative cache skips empty L2 (Redis/disk)
+  lookups after a miss.
+- Data cache early-refreshes near TTL (same lead formula as HTML) and skips
+  repeated empty L2 reads the same way; `produceMs` is stored on entries.
+- Image optimizer coalesces concurrent work for the same `url+w+q` and caches
+  DNS safety checks for 60s.
+- Disk/Redis L2 decode uses async brotli (no sync decompress on the event
+  loop). `cache()` skips `JSON.stringify` for a single primitive argument.
+- `preconnectHints()` adds `build.assets.prefix` origin automatically. Build
+  runs Fonts and Icon sprite in parallel; precompress writes `.br`/`.gz` in
+  parallel per file.
+- Cold SSR without prewarm: `warmRenderEngine()` runs before listen; page
+  `.jsk` templates load lazily (layout + `components/*` stay eager); production
+  `ensureTemplatesCompiled` returns on manifest without walking sources.
+- L2 read races a 50ms budget then produces locally; Redis `storeEncoded`
+  defaults to on.
+- `renderPage` runs the body with `page.metadata` in parallel with the
+  `metadata` hook + `layoutContext` chain.
+- `sendHtml` always negotiates brotli/gzip for HTML (including
+  `fragment` / `private`), instead of relying on compression middleware.
+- Transient upstream `notFound()` defaults to an immediate 503 with
+  background retry (`cache().transientRetry.background`; set `false` for the
+  old sync loop). `warmRenderEngine` / `resetRenderEngine` are exported.
+
+### Breaking
+
+- Redis `storeEncoded` defaults to `true` (was `false`). Opt out with
+  `cache().redis.storeEncoded: false` if L2 size must stay minimal.
+- Transient retry no longer delays the visitor by default
+  (`background: true`). Set `cache().transientRetry.background: false` to
+  wait for sync retries before responding.
+
 ### Fixed
 
+- `hydrate()` mounts zero-box hosts (`hidden` / no layout box) through
+  `mountWhenReady()` instead of calling `mountIsland()` immediately, so
+  `data-island-idle` on a hidden host still waits for `load` plus idle time.
+  `data-island-eager` is unchanged (mounts right away).
 - S3 PutObject uses path-style URLs for bucket names that contain dots
   (e.g. `static.investvio.dev`). Virtual-hosted
   `bucket.s3.region.amazonaws.com` fails TLS because the cert only covers

package/docs/04-render-ve-sablonlar.md

@@ -15,17 +15,18 @@ route(controller)
  └─ produce()
      ├─ controller(ctx)  → sayfa tanımı
      └─ renderPage(page)
-         ├─ hooks.metadata(page) + page.metadata      → metadata
          ├─ Promise.all([
-         │     renderView(page.view, { …data, metadata }),   → body
-         │     hooks.layoutContext({ pathname, metadata }),  → context
+         │     renderView(page.view, { …data, page.metadata }),  → body
+         │     hooks.metadata(page) + page.metadata              → metadata
+         │       └─ hooks.layoutContext({ pathname, metadata })  → context
          │   ])
          └─ layout (.jsk derlenmiş veya .ejs)  → tam HTML
 ```
 
-Layout bağlamı ve gövde **paralel** üretilir. Sebebi ölçümden geliyor:
-navigasyon çoğu projede upstream'den geliyor ve gövde render'ıyla sırayla
-beklemek her sayfaya gereksiz gecikme ekliyor.
+Gövde, `hooks.metadata` + `layoutContext` zinciriyle **paralel** üretilir.
+Şablon locals'ında `metadata` önce controller'ın `page.metadata`'sıdır; layout
+birleşik (hook + sayfa) metadata'yı alır. Navigasyon çoğu projede upstream'den
+gelir — gövdeyi metadata zincirinin bitmesini bekletmek her MISS'e gecikme ekler.
 
 ## `.jsk` — build-time derlenmiş şablonlar
 
@@ -73,6 +74,12 @@ controller data → import edilmiş render(data, helpers) → HTML
 Atama, object literal ve rastgele fonksiyon çağrısı yok — mantık controller
 veya JS bileşende kalır.
 
+Derleyici bitişik statik HTML’i tek literal’de birleştirir ve **şablon
+girintisini** düşürür: satır sonu içeren salt-whitespace metin düğümleri
+çıktıya girmez; etiketler arasında yalnızca boşluk/tab varsa tek boşluk
+kalır (inline aralık). `pre`, `textarea`, `script`, `style` ve `code`
+içinde whitespace olduğu gibi korunur.
+
 #### Şablon mu, bileşen mi?
 
 EJS’den geçerken sınırı erken çizmek işe yarar:
@@ -199,11 +206,15 @@ Dikkat edilecek noktalar:
 | `lang` | `string` | `context.lang` → `brand.lang` → `"en"` |
 | `devtools` | `boolean` | `NODE_ENV === "development"` |
 | `devBasePath` | `string` | `brand.devBasePath`, varsayılan `/__jskelet/dev` |
-| `asset`, `hasAsset` | fonksiyon | Manifest erişimi |
-| html/tags yardımcıları | fonksiyon | `esc`, `attrs`, `cx`, `cn`, `jsonScript`, `link`, `image`, `icon`, `preloadImage`, `toKebab` |
-| `views/components/**` export'ları | fonksiyon | Otomatik kayıt |
+| `asset`, `hasAsset` | fonksiyon | Manifest erişimi (EJS local; `.jsk`’de ikinci `helpers` argümanı / yerleşik etiketler) |
+| html/tags yardımcıları | fonksiyon | `esc`, `attrs`, `cx`, `cn`, `jsonScript`, `link`, `image`, `icon`, `preloadImage`, `toKebab` — aynı ayrım |
+| `views/components/**` export'ları | fonksiyon | Otomatik kayıt (PascalCase etiket veya EJS local) |
 | `hooks.layoutContext()` çıktısındaki her alan | — | Doğrudan local olur |
 
+`.jsk` layout `(data, helpers)` aldığı için framework helpers nesnesini her
+render’da `data`’ya kopyalamaz; EJS layout hâlâ bare helper adlarını local
+olarak alır.
+
 `pathname`'in boş varsayılanı bilinçli: `"/"` yazmak her sayfayı ana sayfa
 sanıp logoyu `<h1>` olarak bastıran türde hatalara yol açıyor.
 

package/docs/05-islands.md

@@ -108,10 +108,14 @@ ve doğrudan boş zamana kaydırılır.
 `hidden` bir drawer ya da dialog'un düzen kutusu yoktur ve
 `IntersectionObserver` onu **asla** bildirmez. Bu yüzden `hydrate()` ölçümleri
 tek seferde okur (`getClientRects().length > 0`) ve kutusu olmayan elementleri
-gözlemciye vermek yerine doğrudan bağlar. Ölçümlerin tek seferde okunması da
-bilinçli: araya yazma girmediği için tek reflow olur.
-
-Pratik sonucu: bir modal'ı `hidden` başlatabilirsiniz, island'ı yine bağlanır.
+gözlemciye vermek yerine `mountWhenReady()` ile bağlar — yani
+`data-island-idle` gizli host'ta da geçerlidir (`load` + boş zaman); idle
+olmayanlar boş zamana kaydırılır. Ölçümlerin tek seferde okunması bilinçli:
+araya yazma girmediği için tek reflow olur. `data-island-eager` hâlâ hemen
+bağlanır.
+
+Pratik sonucu: bir modal'ı `hidden` başlatabilirsiniz, island'ı yine bağlanır;
+ağır bir gizli host için `data-island-idle` LCP ile yarışmayı keser.
 
 ## `client/` dizini
 

package/docs/06-cache.md

@@ -560,39 +560,40 @@ geçici bir kota sorunu TTL boyunca "bu sayfa yok" cevabına dönüşür. Arama
 için bu kalıcı bir kayıp.
 
 Framework bu durumu ayırır: render sırasında **geçici** bir upstream hatası
-varsa `notFound()` 404 olarak servis edilmez. Sırayla:
+varsa `notFound()` 404 olarak servis edilmez. Varsayılan (`background: true`):
 
-1. Sayfa kısa bir beklemeden sonra **yeniden denenir** (varsayılan bir kez,
-   300 ms sonra). Deneme kendi upstream ve istek içi cache bağlamında koşar;
-   ilk turun hatası da memoize edilmiş boş cevabı da ikinci turu etkilemez.
-2. İkinci tur sayfayı üretebilirse ziyaretçi **gerçek içeriği** görür ve çıktı
-   normal şekilde önbelleğe girer. Isıtma günlükleri bunun sık olduğunu
-   gösteriyor: aynı yol saniyeler sonra 200 dönüyor.
-3. Denemeler tükendiyse yanıt `503` olur — önbelleğe girmez, `Retry-After`
-   taşır, sonraki istek yine gerçek içeriği üretebilir.
+1. Ziyaretçiye hemen önbelleğe girmeyen bir `503` + `Retry-After` gider.
+2. Aynı yol arka planda yeniden denenir (varsayılan bir kez, 300 ms sonra).
+   Deneme kendi upstream ve istek içi cache bağlamında koşar; ilk turun hatası
+   da memoize edilmiş boş cevabı da ikinci turu etkilemez. Başarılı olursa
+   sonraki istek L1/L2 HIT alır.
+3. `background: false` eski senkron döngüyü açar: önce bekle + dene, başarısızsa
+   503; başarılıysa ziyaretçi gerçek içeriği görür.
 
 | Render sırasında | `notFound()` sonucu |
 | --- | --- |
-| Geçici hata var (`429`, `5xx`, ağ hatası) | Tekrar dene → başarılıysa sayfa; hâlâ olmuyorsa `503`, `Retry-After: 30`, `no-store` |
+| Geçici hata + `background: true` (varsayılan) | Hemen `503`, `Retry-After: 30`, `no-store`; retry arka planda |
+| Geçici hata + `background: false` | Tekrar dene → başarılıysa sayfa; değilse `503` |
 | Tekrar denemede upstream sağlam cevap verip "yok" dedi | Normal `404` |
 | Kalıcı hata var (`404`, `403`…) ya da hata yok | Normal `404`, tekrar denenmez |
 
 Log satırları:
 
 ```
-[render] /haber/x returned notFound() while upstream is failing (429 /api/...), retrying (1/1)
+[render] /haber/x returned notFound() while upstream is failing (429 /api/...), retrying in background (1×)
 [render] /haber/x could not be produced, upstream is still failing (429 /api/...), serving an uncached 503 instead of a 404
 ```
 
 Yani **var olan bir sayfa hiçbir koşulda 404'e dönüşmez**: ya gerçek içerik
-gelir, ya önbelleğe girmeyen bir 503. Hiçbir şey "yok" olarak dondurulmaz.
+gelir (senkron retry veya sonraki istek), ya önbelleğe girmeyen bir 503.
+Hiçbir şey "yok" olarak dondurulmaz.
 
 Tekrar denemenin maliyeti upstream'e binen ikinci bir istek turudur; bu yüzden
 varsayılan tek deneme. Ayar `cache().transientRetry`:
 
 ```js
 cache: {
-  transientRetry: { attempts: 2, delayMs: 500 },
+  transientRetry: { attempts: 2, delayMs: 500, background: true },
 }
 ```
 
@@ -886,9 +887,10 @@ bir sonraki yazışta siler. `clearHtmlCache()` ve invalidation dosyayı da dü
   bile geçerli olan bu kural paylaşımlı kademede daha da kritik: sızması, bir
   kullanıcının HTML'ini tüm kümeye servis etmek olur. `degraded` render ve 200
   dışındaki durum kodları da paylaşılmaz.
-- **Sıkıştırılmış gövdeler varsayılan olarak yerel kalır.** `storeEncoded: true`
-  ile açılabilir, ama girdi başına boyutu iki-üç katına çıkarır; brotli'yi
-  yeniden üretmek çoğu zaman Redis'ten indirmekten ucuzdur.
+- **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.
 - **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

package/docs/07-yapilandirma.md

@@ -772,7 +772,7 @@ Ayrıntı: [03-routing.md](./03-routing.md).
 **Tip:**
 `() => { html?: Record<string, number>, staleWhileRevalidate?: number, query?: Record<string, string[] | true>, vary?: { host?: boolean, headers?: string[], fn?: (req) => string | null }, maxEntries?: number, data?: object, trackUpstream?: boolean, trackDependencies?: boolean, transientRetry?: object | false, upstream?: object, redis?: object, prewarm?: false | object }` —
 **Varsayılan:**
-`{ html: {}, staleWhileRevalidate: 60, query: {}, vary: { host: false }, maxEntries: 500, data: { maxEntries: 10000, staleFactor: 10 }, trackUpstream: true, trackDependencies: true, transientRetry: { attempts: 1, delayMs: 300 }, upstream: { rate: 0 }, redis: { enabled: false }, prewarm: { enabled: true, mode: "classic", max: 400, intervalSeconds: 0, origins: [] } }` (veya `prewarm: false` → `mode: "off"`)
+`{ html: {}, staleWhileRevalidate: 60, query: {}, vary: { host: false }, maxEntries: 500, data: { maxEntries: 10000, staleFactor: 10 }, trackUpstream: true, trackDependencies: true, transientRetry: { attempts: 1, delayMs: 300, background: true }, upstream: { rate: 0 }, redis: { enabled: false, storeEncoded: true }, prewarm: { enabled: true, mode: "classic", max: 400, intervalSeconds: 0, origins: [] } }` (veya `prewarm: false` → `mode: "off"`)
 
 ### `cache().html`
 
@@ -902,13 +902,14 @@ kaydedilecek bir şey yok; kapatmak bağlam kurma maliyetini de kaldırır.
 
 ### `cache().transientRetry`
 
-**Tip:** `{ attempts?: number, delayMs?: number } | false` —
-**Varsayılan:** `{ attempts: 1, delayMs: 300 }`
+**Tip:** `{ attempts?: number, delayMs?: number, background?: boolean } | false` —
+**Varsayılan:** `{ attempts: 1, delayMs: 300, background: true }`
 
 Geçici bir upstream hatası yüzünden `notFound()` çağrılan sayfa kaç kez daha
-denenir. Amaç var olan bir sayfanın 404'e dönüşmemesi; denemeler tükenirse yanıt
-önbelleğe girmeyen bir 503 olur. `false` ya da `attempts: 0` tekrarı kapatır.
-Ayrıntı: [06-cache.md](./06-cache.md).
+denenir. Amaç var olan bir sayfanın 404'e dönüşmemesi. `background: true`
+(varsayılan) ziyaretçiye hemen 503 verir ve retry'yi arka planda koşturur;
+`false` eski senkron döngüyü açar (önce bekle + dene, sonra yanıt). `false` ya
+da `attempts: 0` tekrarı kapatır. Ayrıntı: [06-cache.md](./06-cache.md).
 
 ### `cache().upstream`
 
@@ -959,7 +960,7 @@ 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` | `false` | 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 de paylaşılsın mı; girdi başına boyutu iki-üç katına çıkarır |
 | `events` | `boolean` | `true` | pub/sub üzerinden invalidation yayını |
 | `commandTimeoutMs` | `number` | `200` | Tek bir komutun en fazla bekletebileceği süre |
 

package/docs/en/04-rendering.md

@@ -16,17 +16,19 @@ route(controller)
  └─ produce()
      ├─ controller(ctx)  → page definition
      └─ renderPage(page)
-         ├─ hooks.metadata(page) + page.metadata      → metadata
          ├─ Promise.all([
-         │     renderView(page.view, { …data, metadata }),   → body
-         │     hooks.layoutContext({ pathname, metadata }),  → context
+         │     renderView(page.view, { …data, page.metadata }),  → body
+         │     hooks.metadata(page) + page.metadata              → metadata
+         │       └─ hooks.layoutContext({ pathname, metadata })  → context
          │   ])
          └─ layout (.jsk compiled or .ejs)  → full HTML
 ```
 
-The layout context and the body are produced **in parallel**. The reason comes
-from measurement: in most projects navigation comes from upstream, and waiting
-for it in sequence with the body render adds needless latency to every page.
+The body runs **in parallel** with the `hooks.metadata` + `layoutContext`
+chain. Template locals see the controller's `page.metadata` first; the layout
+receives the merged (hook + page) metadata. Navigation often comes from
+upstream — waiting for the metadata chain before starting the body adds latency
+to every MISS.
 
 ## `.jsk` — build-time compiled templates
 
@@ -74,6 +76,12 @@ The expression language is intentionally small (access, compare, ternary,
 `.length`). No assignments, object literals, or arbitrary calls — keep logic in
 controllers or JS components.
 
+The compiler merges adjacent static HTML into fewer `+=` ops and strips
+**template indentation**: whitespace-only text nodes that contain a newline are
+dropped; a space/tab-only gap between siblings stays as a single space (inline
+separation). Inside `pre`, `textarea`, `script`, `style`, and `code`, whitespace
+is left unchanged.
+
 #### Template or component?
 
 When moving off EJS, draw the line early:
@@ -198,11 +206,15 @@ Points to watch:
 | `lang` | `string` | `context.lang` → `brand.lang` → `"en"` |
 | `devtools` | `boolean` | `NODE_ENV === "development"` |
 | `devBasePath` | `string` | `brand.devBasePath`, defaults to `/__jskelet/dev` |
-| `asset`, `hasAsset` | function | Manifest access |
-| html/tags helpers | function | `esc`, `attrs`, `cx`, `cn`, `jsonScript`, `link`, `image`, `icon`, `preloadImage`, `toKebab` |
-| exports of `views/components/**` | function | Automatic registration |
+| `asset`, `hasAsset` | function | Manifest access (EJS local; in `.jsk` the second `helpers` argument / built-in tags) |
+| html/tags helpers | function | `esc`, `attrs`, `cx`, `cn`, `jsonScript`, `link`, `image`, `icon`, `preloadImage`, `toKebab` — same split |
+| exports of `views/components/**` | function | Automatic registration (PascalCase tags or EJS locals) |
 | every field returned by `hooks.layoutContext()` | — | Becomes a local directly |
 
+Because a `.jsk` layout receives `(data, helpers)`, the framework does not copy
+the helpers object into `data` on every render; EJS layouts still get bare
+helper names as locals.
+
 The empty default for `pathname` is deliberate: writing `"/"` leads to the kind
 of bug where every page thinks it is the home page and renders the logo as an
 `<h1>`.

package/docs/en/05-islands.md

@@ -111,12 +111,16 @@ skipped and it is deferred straight to idle time.
 
 A `hidden` drawer or dialog has no layout box, and `IntersectionObserver`
 **never** reports it. That is why `hydrate()` reads its measurements in one go
-(`getClientRects().length > 0`) and mounts elements without a box directly
-instead of handing them to the observer. Reading the measurements in one go is
-deliberate too: since no write comes in between there is only a single reflow.
+(`getClientRects().length > 0`) and mounts zero-box elements via
+`mountWhenReady()` instead of handing them to the observer — so
+`data-island-idle` still applies on a hidden host (`load` plus idle time);
+non-idle hosts are deferred to idle time. Reading the measurements in one go
+is deliberate: since no write comes in between there is only a single reflow.
+`data-island-eager` still mounts immediately.
 
 The practical consequence: you can start a modal as `hidden` and its island
-will still mount.
+will still mount; use `data-island-idle` on a heavy hidden host so it does not
+compete with LCP.
 
 ## The `client/` directory
 

package/docs/en/06-caching.md

@@ -570,39 +570,41 @@ cache, a temporary quota problem becomes a "this page does not exist" answer for
 the whole TTL. For a search engine that is a permanent loss.
 
 The framework separates the two cases: if a **transient** upstream failure
-happened during the render, `notFound()` is not served as a 404. In order:
+happened during the render, `notFound()` is not served as a 404. Default
+(`background: true`):
 
-1. The page is **retried** after a short delay (once by default, after 300 ms).
+1. The visitor gets an immediate uncached `503` + `Retry-After`.
+2. The same path is retried in the background (once by default, after 300 ms).
    The retry runs in its own upstream and per-request cache scope, so neither
-   the first round's failure nor its memoized empty answers affect it.
-2. If the second round can produce the page, the visitor sees the **real
-   content** and the output is cached normally. Warm-up logs show this is
-   common: the same path returns 200 seconds later.
-3. If the retries are exhausted the response is a `503` — not cached, carrying
-   `Retry-After`, and the next request can still produce the real content.
+   the first round's failure nor its memoized empty answers affect it. On
+   success the next request is an L1/L2 HIT.
+3. `background: false` restores the old sync loop: wait + retry first; on
+   success the visitor sees real content, otherwise a 503.
 
 | During the render | Result of `notFound()` |
 | --- | --- |
-| A transient failure exists (`429`, `5xx`, network error) | Retry → the page if it succeeds; otherwise `503`, `Retry-After: 30`, `no-store` |
+| Transient failure + `background: true` (default) | Immediate `503`, `Retry-After: 30`, `no-store`; retry in background |
+| Transient failure + `background: false` | Retry → the page if it succeeds; otherwise `503` |
 | The retry got a clean answer saying "not there" | A normal `404` |
 | A permanent failure (`404`, `403`…) or no failure | A normal `404`, no retry |
 
 The log lines:
 
 ```
-[render] /news/x returned notFound() while upstream is failing (429 /api/...), retrying (1/1)
+[render] /news/x returned notFound() while upstream is failing (429 /api/...), retrying in background (1×)
 [render] /news/x could not be produced, upstream is still failing (429 /api/...), serving an uncached 503 instead of a 404
 ```
 
-So **an existing page never turns into a 404**: either the real content arrives,
-or an uncached 503 does. Nothing is frozen as "missing".
+So **an existing page never turns into a 404**: either the real content arrives
+(sync retry or the next request), or an uncached 503 does. Nothing is frozen as
+"missing".
 
 The cost of a retry is a second round of requests on upstream, which is why the
 default is a single attempt. The setting is `cache().transientRetry`:
 
 ```js
 cache: {
-  transientRetry: { attempts: 2, delayMs: 500 },
+  transientRetry: { attempts: 2, delayMs: 500, background: true },
 }
 ```
 
@@ -905,9 +907,9 @@ file too.
   rule already holds in a single process, but it matters far more in a shared
   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 stay local by default.** `storeEncoded: true` turns this
-  on, but it doubles or triples the size per entry; recomputing brotli is
-  usually cheaper than downloading it from Redis.
+- **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.
 - **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

package/docs/en/07-configuration.md

@@ -786,7 +786,7 @@ Details: [03-routing.md](./03-routing.md).
 **Type:**
 `() => { html?: Record<string, number>, staleWhileRevalidate?: number, query?: Record<string, string[] | true>, vary?: { host?: boolean, headers?: string[], fn?: (req) => string | null }, maxEntries?: number, data?: object, trackUpstream?: boolean, trackDependencies?: boolean, transientRetry?: object | false, upstream?: object, redis?: object, prewarm?: false | object }` —
 **Default:**
-`{ html: {}, staleWhileRevalidate: 60, query: {}, vary: { host: false }, maxEntries: 500, data: { maxEntries: 10000, staleFactor: 10 }, trackUpstream: true, trackDependencies: true, transientRetry: { attempts: 1, delayMs: 300 }, upstream: { rate: 0 }, redis: { enabled: false }, prewarm: { enabled: true, mode: "classic", max: 400, intervalSeconds: 0, origins: [] } }` (or `prewarm: false` → `mode: "off"`)
+`{ html: {}, staleWhileRevalidate: 60, query: {}, vary: { host: false }, maxEntries: 500, data: { maxEntries: 10000, staleFactor: 10 }, trackUpstream: true, trackDependencies: true, transientRetry: { attempts: 1, delayMs: 300, background: true }, upstream: { rate: 0 }, redis: { enabled: false, storeEncoded: true }, prewarm: { enabled: true, mode: "classic", max: 400, intervalSeconds: 0, origins: [] } }` (or `prewarm: false` → `mode: "off"`)
 
 ### `cache().html`
 
@@ -920,13 +920,15 @@ setting up the context.
 
 ### `cache().transientRetry`
 
-**Type:** `{ attempts?: number, delayMs?: number } | false` —
-**Default:** `{ attempts: 1, delayMs: 300 }`
+**Type:** `{ attempts?: number, delayMs?: number, background?: boolean } | false` —
+**Default:** `{ attempts: 1, delayMs: 300, background: true }`
 
 How many extra times a page is tried when `notFound()` was called because of a
 transient upstream failure. The point is that an existing page never turns into
-a 404; if the retries are exhausted the response is an uncached 503. `false` or
-`attempts: 0` disables the retry. Details: [06-caching.md](./06-caching.md).
+a 404. `background: true` (default) returns 503 immediately and runs the retry
+in the background; `false` restores the old sync loop (wait + retry, then
+respond). `false` or `attempts: 0` disables the retry. Details:
+[06-caching.md](./06-caching.md).
 
 ### `cache().upstream`
 
@@ -977,7 +979,7 @@ 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` | `false` | Whether brotli/gzip bodies are shared too; doubles or triples the size per entry |
+| `storeEncoded` | `boolean` | `true` | Whether brotli/gzip bodies are shared too; doubles or triples the size per entry |
 | `events` | `boolean` | `true` | Invalidation broadcast over pub/sub |
 | `commandTimeoutMs` | `number` | `200` | At most how long a single command may block |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jskelet",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "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/build/build.mjs

@@ -68,14 +68,29 @@ async function task(label, run) {
   }
 }
 
-if (config.fonts?.length) {
-  const { copyFonts } = await import("./tasks/fonts.mjs");
-  Object.assign(manifest, await task("Fonts", () => copyFonts(config)));
-}
-
-if (config.icons !== false) {
-  const { buildIconSprite } = await import("./tasks/icons.mjs");
-  Object.assign(manifest, await task("Icon sprite", () => buildIconSprite(config)));
+// Fonts ve icon sprite birbirine bağlı değil — paralel.
+{
+  /** @type {Promise<Record<string, string> | void>[]} */
+  const parallel = [];
+  if (config.fonts?.length) {
+    parallel.push(
+      (async () => {
+        const { copyFonts } = await import("./tasks/fonts.mjs");
+        return task("Fonts", () => copyFonts(config));
+      })(),
+    );
+  }
+  if (config.icons !== false) {
+    parallel.push(
+      (async () => {
+        const { buildIconSprite } = await import("./tasks/icons.mjs");
+        return task("Icon sprite", () => buildIconSprite(config));
+      })(),
+    );
+  }
+  for (const part of await Promise.all(parallel)) {
+    if (part) Object.assign(manifest, part);
+  }
 }
 
 if (fs.existsSync(config.dirs.styles)) {

package/src/build/tasks/precompress.mjs

@@ -49,6 +49,33 @@ function collect(dir) {
   return files;
 }
 
+/**
+ * @param {Buffer} source
+ * @param {object} options
+ * @returns {Promise<Buffer>}
+ */
+function brotli(source, options) {
+  return new Promise((resolve, reject) => {
+    zlib.brotliCompress(source, options, (error, out) => {
+      if (error) reject(error);
+      else resolve(out);
+    });
+  });
+}
+
+/**
+ * @param {Buffer} source
+ * @returns {Promise<Buffer>}
+ */
+function gzip(source) {
+  return new Promise((resolve, reject) => {
+    zlib.gzip(source, { level: 9 }, (error, out) => {
+      if (error) reject(error);
+      else resolve(out);
+    });
+  });
+}
+
 export async function precompressAssets() {
   // Önceki turdan kalan kopyalar kaynak değişince bayatlamasın.
   for (const file of collect(paths.assets)) {
@@ -57,21 +84,34 @@ export async function precompressAssets() {
     }
   }
 
-  let count = 0;
-  let saved = 0;
+  const candidates = collect(paths.assets).filter((file) => {
+    try {
+      return fs.statSync(file).size >= MIN_BYTES;
+    } catch {
+      return false;
+    }
+  });
 
-  for (const file of collect(paths.assets)) {
-    const source = fs.readFileSync(file);
-    if (source.length < MIN_BYTES) continue;
+  const results = await Promise.all(
+    candidates.map(async (file) => {
+      const source = await fs.promises.readFile(file);
+      if (source.length < MIN_BYTES) return { count: 0, saved: 0 };
 
-    const br = zlib.brotliCompressSync(source, BROTLI_OPTIONS);
-    const gz = zlib.gzipSync(source, { level: 9 });
+      const [br, gz] = await Promise.all([brotli(source, BROTLI_OPTIONS), gzip(source)]);
+      await Promise.all([
+        fs.promises.writeFile(`${file}.br`, br),
+        fs.promises.writeFile(`${file}.gz`, gz),
+      ]);
 
-    fs.writeFileSync(`${file}.br`, br);
-    fs.writeFileSync(`${file}.gz`, gz);
+      return { count: 1, saved: source.length - br.length };
+    }),
+  );
 
-    count += 1;
-    saved += source.length - br.length;
+  let count = 0;
+  let saved = 0;
+  for (const row of results) {
+    count += row.count;
+    saved += row.saved;
   }
 
   log.detail(`${count} files, ${log.size(saved)}`);

package/src/client/registry.js

@@ -16,6 +16,8 @@
  * `data-island-idle` görünür olsa bile sayfa sakinleşene (load + boş zaman)
  * kadar bekletir. İlk ekranda görünen ama kritik olmayan ağır modüller
  * (ör. grafik kütüphanesi çeken mini grafik) LCP ile yarışmasın diye.
+ * Gizli (zero-box) host'larda da aynı yol kullanılır — `hydrate()` onları
+ * `mountWhenReady` ile bağlar, hemen `mountIsland` çağırmaz.
  *
  * `data-island-props` JSON ise parse edilip props olarak geçer.
  */
@@ -263,13 +265,21 @@ export function hydrate(root = document) {
   const boxed = pending.map((node) => node.getClientRects().length > 0);
 
   pending.forEach((node, i) => {
-    // `hidden` bir drawer/dialog'un düzen kutusu yoktur ve IntersectionObserver
-    // onu asla bildirmez; bu yüzden gizli olanlar doğrudan bağlanır.
-    if ("islandEager" in node.dataset || !boxed[i]) {
+    // `data-island-eager`: görünürlük / idle yok — hemen bağla.
+    if ("islandEager" in node.dataset) {
       mountIsland(node);
       return;
     }
 
+    // `hidden` drawer/dialog'un düzen kutusu yoktur; IntersectionObserver
+    // onu asla bildirmez. Gözlemciye vermek yerine bağlarız, ama yol
+    // `mountWhenReady` — `data-island-idle` olan gizli host'lar `load` +
+    // boş zamana kadar bekler (LCP ile yarışmasın).
+    if (!boxed[i]) {
+      mountWhenReady(node);
+      return;
+    }
+
     getLazyObserver().observe(node);
   });
 }