@@ -0,0 +1,135 @@
+---
+description: "Kenapa Deserve membawa Basic Auth tapi tidak Bearer, dan cara menyusun auth token untuk skema apa pun."
+---
+
+# Bearer Auth
+
+Deserve membawa [Basic Auth](/id/middleware/basic-auth) tapi tidak ada middleware Bearer, dan pemisahan antara keduanya adalah intinya.
+
+## Kenapa Tidak Dibawa
+
+Bearer hanyalah sebuah amplop. Header [`Authorization: Bearer <token>`](https://datatracker.ietf.org/doc/html/rfc6750) membawa token, dan apa yang dianggap token valid berubah seiring ekosistem. Satu layanan memverifikasi tanda tangan [JWT](https://datatracker.ietf.org/doc/html/rfc7519), lain mengambil kunci publik berputar dari endpoint [JWKS](https://datatracker.ietf.org/doc/html/rfc7517), lain memanggil API introspeksi untuk token buram, dan algoritma penanda bisa RS256, ES256, atau HS256.
+
+Menanam salah satu pilihan itu akan mengunci setiap proyek ke satu skema. Ketika spesifikasi bergerak atau sebuah tim memutar kunci dengan cara berbeda, jawaban bawaan itu berubah jadi kandang ketimbang bantuan. Jadi keputusannya adalah membiarkan verifikasi terbuka dan membiarkan developer membawa skema yang dibutuhkan kasusnya.
+
+## Kenapa Basic Auth Dibawa Tapi Bearer Tidak
+
+[Basic Auth](/id/middleware/basic-auth) adalah satu skema tetap. Header membawa username dan password base64, pengecekannya adalah perbandingan waktu konstan terhadap sebuah daftar, dan tak ada yang perlu dipilih. Stabilitas itulah yang membuatnya cocok di dalam framework.
+
+Bearer sebaliknya. Format token, tanda tangan, dan sumber kepercayaan semuanya berbeda, jadi tak ada satu pengecekan untuk dibawa. Kedua skema membaca header `Authorization` yang sama, tapi hanya satu yang punya jawaban benar tunggal.
+
+## Bagian yang Sudah Ada
+
+Penjaga token adalah komposisi kecil di atas bagian yang sudah ada:
+
+- **Baca header** - [`ctx.header('authorization')`](/id/core-concepts/context-object#akses-data-request) mengembalikan nilai `Authorization` mentah.
+- **Jalan lebih awal** - [middleware global](/id/middleware/global) berjalan sebelum route handler dan bisa menghentikan request dengan mengembalikan `Response`.
+- **Tolak bersih** - [`ctx.handleError(401, ...)`](/id/core-concepts/context-object#penanganan-error) mengarah lewat [`router.catch()`](/id/error-handling/object-details) saat satu diatur.
+- **Bawa hasilnya** - [`ctx.state`](/id/core-concepts/context-object#berbagi-state) menyerahkan identitas terdekode ke handler di hilir.
+
+## Sebuah Penjaga Bearer
+
+Middleware ini menarik token dari header, memverifikasinya, dan menyimpan hasilnya untuk handler berikutnya. Placeholder `verifyToken` mewakili skema pilihan, sebuah pengecekan JWT, lookup JWKS, atau panggilan introspeksi.
+
+```typescript twoslash
+import type { Context } from '@neabyte/deserve'
+import { Router } from '@neabyte/deserve'
+
+const router = new Router()
+declare function verifyToken(token: string): Promise<{ userId: string } | null>
+// ---cut---
+router.use(async (ctx, next) => {
+  const header = ctx.header('authorization')
+  const spaceIndex = header ? header.indexOf(' ') : -1
+  const scheme = spaceIndex > 0 ? header!.slice(0, spaceIndex) : ''
+
+  // Tolak apa pun yang bukan Bearer
+  if (scheme.toLowerCase() !== 'bearer') {
+    return await ctx.handleError(401, new Error('Missing Bearer token'))
+  }
+
+  // Verifikasi dengan skema pilihan
+  const token = header!.slice(spaceIndex + 1).trim()
+  const claims = await verifyToken(token)
+  if (!claims) {
+    return await ctx.handleError(401, new Error('Invalid token'))
+  }
+
+  // Serahkan identitas ke handler
+  ctx.state.userId = claims.userId
+  return await next()
+})
+
+await router.serve(8000)
+```
+
+Handler lalu membaca identitas langsung dari state, tanpa parsing token sendiri.
+
+```typescript twoslash
+import type { Context } from '@neabyte/deserve'
+// ---cut---
+export function GET(ctx: Context): Response {
+  // Baca apa yang disimpan penjaga
+  const userId = ctx.state.userId
+  return ctx.send.json({ userId })
+}
+```
+
+## Mengarahkan Kegagalan Lewat Satu Handler
+
+Penjaga di atas mengembalikan `401` dari dalam middleware. Untuk mengirim setiap kegagalan auth lewat satu tempat, bungkus middleware dengan [`WrapMware`](/id/middleware/global#membungkus-middleware-dengan-penanganan-error) dan lempar saat ditolak, lalu bentuk balasannya dengan [`router.catch()`](/id/error-handling/object-details).
+
+```typescript twoslash
+import type { Context } from '@neabyte/deserve'
+import { Router, WrapMware } from '@neabyte/deserve'
+
+const router = new Router()
+declare function verifyToken(token: string): Promise<{ userId: string } | null>
+// ---cut---
+// Lemparan sampai router.catch saat dibungkus
+const bearer = WrapMware('Bearer', async (ctx: Context, next) => {
+  const header = ctx.header('authorization')
+  if (!header?.toLowerCase().startsWith('bearer ')) {
+    throw new Error('Missing Bearer token')
+  }
+  const claims = await verifyToken(header.slice(7).trim())
+  if (!claims) {
+    throw new Error('Invalid token')
+  }
+  ctx.state.userId = claims.userId
+  return await next()
+})
+
+// Terapkan penjaga dan bentuk error
+router.use(bearer)
+router.catch((ctx, err) => ctx.send.json({ error: err.error?.message }, { status: 401 }))
+```
+
+Ini pola pembungkusan yang sama dipakai [Basic Auth](/id/middleware/basic-auth) secara internal, kini membawa pengecekan token alih-alih perbandingan kredensial.
+
+## Menjaga Hanya Sebagian Rute
+
+Penjaga token sering cocok di prefix API sementara halaman publik tetap terbuka. Middleware per-path membatasi pengecekan ke satu prefix, bentuk yang sama ditunjukkan di [middleware global](/id/middleware/global#middleware-per-path).
+
+```typescript twoslash
+import type { Context } from '@neabyte/deserve'
+import { Router } from '@neabyte/deserve'
+
+const router = new Router()
+declare function verifyToken(token: string): Promise<{ userId: string } | null>
+// ---cut---
+// Jaga hanya rute /api
+router.use('/api', async (ctx, next) => {
+  const header = ctx.header('authorization')
+  const claims = header?.toLowerCase().startsWith('bearer ')
+    ? await verifyToken(header.slice(7).trim())
+    : null
+  if (!claims) {
+    return await ctx.handleError(401, new Error('Invalid token'))
+  }
+  ctx.state.userId = claims.userId
+  return await next()
+})
+```
+
+Untuk session sisi server yang ditandatangani framework alih-alih token, lihat [middleware session](/id/middleware/session).
@@ -0,0 +1,84 @@
+---
+description: "Kenapa Deserve tidak punya middleware cache, dan cara session stateless ditambah map memori polos memenuhi kebutuhan."
+---
+
+# Caching
+
+Deserve tidak membawa middleware cache, dan pipeline request tak menyimpan store tersembunyi sendiri. Itu menjaga perilaku memori tetap dapat ditebak, dan menyerahkan strategi caching ke developer.
+
+## Kenapa Tidak Dibawa
+
+Kebanyakan yang orang cari dari cache adalah menyimpan sedikit state per-pengguna lintas request. Tugas itu sudah ditangani. [Middleware session](/id/middleware/session) menyimpan data per-pengguna di cookie bertanda tangan, tanpa store sisi server yang tumbuh, kedaluwarsa, atau ter-evict. Untuk 80 persen yang umum, status login dan preferensi, datanya menumpang di klien dan server tetap stateless.
+
+Sebuah middleware cache umum harus memilih kebijakan eviksi, strategi kunci, dan anggaran memori untuk semua orang sekaligus, dan pilihan itu milik aplikasi, bukan framework. Jadi keputusannya adalah meninggalkan store dan membiarkan developer menyimpan persis yang dibutuhkan kasusnya.
+
+## Memori Tetap Bersih di Bawah Beban
+
+Sebuah cache bawaan terasa menggoda karena memori bisa merayap naik seiring waktu. Kekhawatiran itu tak berlaku pada framework itu sendiri. Pipeline request mengalokasi per request dan membiarkan tiap [Context](/id/core-concepts/context-object) keluar dari scope begitu response dikirim, jadi tak ada tabel internal yang tumbuh dengan trafik. Di bawah trafik beban-tinggi berkelanjutan framework tidak membocorkan apa pun lintas pipeline, dan runtime merebut kembali tiap request yang selesai sendiri.
+
+Garbage collection adalah tugas runtime, sejalan dengan [bangun di atas platform](/id/core-concepts/philosophy#bangun-di-atas-platform). Deno dan V8 memiliki heap dan kolektornya, dan Deserve tidak melawan maupun membungkusnya. Apa pun yang di-cache aplikasi tinggal di memori aplikasi, di mana umurnya adalah hak developer untuk memutuskan.
+
+## Menyimpan Data di Memori
+
+Ketika sebuah nilai memang perlu tinggal di server, sebuah `Map` polos yang dideklarasi di scope modul adalah seluruh polanya. Ia dibuat sekali dan dibagi ke setiap request ke modul itu.
+
+```typescript twoslash
+import type { Context } from '@neabyte/deserve'
+// ---cut---
+// Satu store dibagi lintas request
+const cache = new Map<string, unknown>()
+
+export async function GET(ctx: Context): Promise<Response> {
+  const key = ctx.pathname
+
+  // Sajikan nilai cache ketika ada
+  const hit = cache.get(key)
+  if (hit !== undefined) {
+    return ctx.send.json({ source: 'cache', data: hit })
+  }
+
+  // Bangun sekali, lalu simpan untuk lain kali
+  const data = await buildExpensiveData()
+  cache.set(key, data)
+  return ctx.send.json({ source: 'fresh', data })
+}
+
+declare function buildExpensiveData(): Promise<unknown>
+```
+
+## Membuat Entri Kedaluwarsa
+
+Sebuah `Map` tak pernah meng-evict sendiri, jadi cache yang berjalan lama butuh time-to-live. Simpan nilai dengan cap kedaluwarsa dan perlakukan entri lama sebagai miss.
+
+```typescript twoslash
+import type { Context } from '@neabyte/deserve'
+// ---cut---
+// Atur berapa lama entri tetap segar
+const ttlMs = 30_000
+const cache = new Map<string, { value: unknown, expiresAt: number }>()
+
+export function GET(ctx: Context): Response {
+  const key = ctx.pathname
+  const entry = cache.get(key)
+
+  // Entri segar menang, yang lama dibuang
+  if (entry && Date.now() < entry.expiresAt) {
+    return ctx.send.json({ source: 'cache', data: entry.value })
+  }
+
+  // Hitung ulang dan cap kedaluwarsa baru
+  const value = { time: Date.now() }
+  cache.set(key, { value, expiresAt: Date.now() + ttlMs })
+  return ctx.send.json({ source: 'fresh', data: value })
+}
+```
+
+Sebuah `Map` yang dikunci dengan data request tumbuh dengan tiap kunci berbeda, jadi batasi atau sapu entri kedaluwarsa di timer. Ketika kuncinya objek alih-alih string, sebuah `WeakMap` membiarkan runtime membuang entri begitu kuncinya hilang, yang cocok untuk metadata per-objek tanpa pembersihan manual.
+
+## Ketika Memori Tidak Cukup
+
+Dua kasus menuntut lebih dari map lokal-proses. Sebuah cache yang harus bertahan dari restart, atau dibagi lintas beberapa instance, cocok di store eksternal seperti [Redis](https://redis.io/), dicapai dengan klien biasa di dalam handler. Sebuah cache yang sekadar butuh ruang lebih bisa berjalan di memori setelah heap V8 dinaikkan saat startup. Ukuran heap adalah flag runtime, bukan setelan framework, jadi [dokumentasi Deno](https://docs.deno.com/runtime/) adalah tempat untuk invokasi persisnya.
+
+## Berbagi Per-Request
+
+Caching lintas request adalah satu kebutuhan, mengoper sebuah nilai sepanjang satu request adalah kebutuhan lain. Sebuah nilai yang dihitung di middleware dan dibaca handler tak masuk cache sama sekali, ia masuk [`ctx.state`](/id/core-concepts/context-object#berbagi-state), yang hidup persis satu request dan hilang saat response dikirim.
@@ -0,0 +1,71 @@
+---
+description: "Kenapa Deserve tidak punya middleware kompresi, karena Deno mengompresi response dan proxy menangani sisanya."
+---
+
+# Kompresi
+
+Deserve tidak membawa middleware kompresi, dan celah itu sudah terisi dua kali sebelum sebuah request menyentuh kode aplikasi.
+
+## Kenapa Tidak Dibawa
+
+Kompresi adalah urusan lapisan di sekitar handler, bukan di dalamnya. Runtime melakukannya saat keluar, dan di produksi sebuah proxy biasanya sudah melakukannya lebih dulu. Sebuah middleware yang mengulang pekerjaan yang sama hanya menambah biaya dan peluang bentrok dengan encoding yang sudah diatur lapisan itu.
+
+Dua lapisan sudah menanganinya:
+
+- **Runtime** - [`Deno.serve`](/id/getting-started/server-configuration) mengompresi body response sendiri, sejalan dengan [bangun di atas platform](/id/core-concepts/philosophy#bangun-di-atas-platform).
+- **Network edge** - kebanyakan aplikasi produksi berada di belakang proxy seperti [Cloudflare](https://developers.cloudflare.com/speed/optimization/content/compression/) atau [nginx](https://docs.nginx.com/nginx/admin-guide/web-server/compression/), di mana kompresi adalah tugas lapisan jaringan, bukan aplikasi.
+
+Jadi middleware kompresi baru berguna hanya di localhost telanjang tanpa proxy di depan, dan bahkan di sana runtime sudah menanganinya.
+
+## Yang Deno Lakukan Sendiri
+
+`Deno.serve` membaca header `Accept-Encoding` dari request dan mengompresi body response ketika hal ini berlaku:
+
+- Header mengiklankan `br` untuk Brotli atau `gzip`, dan preferensi nilai kualitas dihormati.
+- `Content-Type` response termasuk salah satu tipe yang bisa dikompresi.
+- Body response lebih besar dari 64 byte.
+
+Ketika mengompresi, runtime mengatur `Content-Encoding` ke skema yang dipilih dan menyesuaikan header `Vary` supaya cache memakai encoding sebagai kunci. Tidak ada di handler yang perlu meminta ini.
+
+Sebuah response dibiarkan tanpa kompresi ketika salah satu dari ini hadir, yang merupakan runtime sengaja menyingkir:
+
+- Header `Content-Encoding`, berarti body sudah ter-encode.
+- Header `Content-Range`, berarti ada request rentang.
+- Header `Cache-Control: no-transform`, berarti tak ada lapisan yang boleh menulis ulang body.
+
+## Membiarkan Runtime Mengompresi
+
+Jalur default adalah mengirim response biasa dan membiarkan encoding apa adanya. Body JSON atau teks polos mengalir lewat, dan runtime mengompresinya ketika klien mendukung.
+
+```typescript twoslash
+import type { Context } from '@neabyte/deserve'
+// ---cut---
+export function GET(ctx: Context): Response {
+  // Kirim polos, runtime kompresi bila bisa
+  return ctx.send.json({ message: 'compressed by the runtime' })
+}
+```
+
+## Mengeluarkan Satu Response
+
+Untuk menjaga satu response tetap tanpa kompresi, atur header yang diperlakukan runtime sebagai sinyal berhenti. Sebuah `Cache-Control: no-transform` memberi tahu runtime dan proxy hilir untuk tidak menyentuh body.
+
+```typescript twoslash
+import type { Context } from '@neabyte/deserve'
+// ---cut---
+export function GET(ctx: Context): Response {
+  // Larang lapisan apa pun menulis ulang body
+  ctx.setHeader('Cache-Control', 'no-transform')
+  return ctx.send.json({ message: 'sent verbatim' })
+}
+```
+
+Mengatur header lewat [`ctx.setHeader`](/id/core-concepts/context-object#header-response) adalah jalur yang sama dipakai di tempat lain, jadi opt-out ini terbaca seperti header lain.
+
+## Body yang Sudah Ter-encode
+
+Body yang datang sudah terkompresi, seperti aset `.gz` tersimpan, membawa `Content-Encoding`-nya sendiri. Runtime melihat header itu dan melewati kompresi ulang, jadi byte dikirim apa adanya. Untuk file di disk ini ditangani oleh [penyajian statis](/id/static-file/basic), yang mengatur tipe dan membiarkan runtime memutuskan.
+
+## Di Belakang Proxy
+
+Di deployment yang difrontkan Cloudflare atau nginx, proxy menegosiasikan kompresi dengan klien di edge, sering sebelum request mencapai origin. Origin tetap bisa mengirim response biasa, dan lapisan-lapisan sepakat soal encoding lewat header `Accept-Encoding` dan `Vary`. Aplikasi tetap di luar urusan ini, yang memang intinya.
@@ -0,0 +1,57 @@
+---
+description: "Kenapa Deserve tidak punya middleware HTTPS redirect, karena TLS ada di edge dan redirect paksa di aplikasi bisa berputar."
+---
+
+# HTTPS Redirect
+
+Deserve tidak punya middleware HTTPS redirect, dan memaksakannya di dalam aplikasi adalah lapisan yang salah untuk pekerjaan itu. TLS diterminasi di edge, jadi aplikasi jarang melihat skema asli sejak awal.
+
+## Kenapa Tidak Dibawa
+
+Sebuah HTTPS redirect paksa mengirim request `http://` apa pun kembali sebagai `https://`. Masalahnya ada di mana TLS sebenarnya berada. Di produksi sertifikat duduk di proxy atau load balancer seperti [Cloudflare](https://www.cloudflare.com/learning/ssl/what-is-ssl/) atau [nginx](https://nginx.org/en/docs/http/configuring_https_servers.html), yang menterminasi TLS dan meneruskan HTTP polos ke origin. Aplikasi lalu melihat `http`, meski klien terhubung lewat `https`, jadi redirect yang dibangun dari skema lokal akan memantulkan request yang sudah aman.
+
+Begitulah redirect loop terjadi. Proxy bicara HTTPS ke klien, origin melihat HTTP dan redirect ke HTTPS, proxy meneruskan HTTP lagi, dan loop tak pernah berakhir. Tempat aman untuk menegakkan HTTPS adalah lapisan yang memiliki sertifikat, sejalan dengan [bangun di atas platform](/id/core-concepts/philosophy#bangun-di-atas-platform).
+
+## Di Mana HTTPS Berada
+
+Redirect-nya sendiri adalah satu baris konfigurasi proxy, bukan kode aplikasi:
+
+- **Di proxy** - [Cloudflare](https://developers.cloudflare.com/ssl/edge-certificates/additional-options/always-use-https/) dan [nginx](https://nginx.org/en/docs/http/configuring_https_servers.html) redirect `http` ke `https` sebelum trafik mencapai origin, jadi aplikasi hanya pernah menyajikan request yang aman.
+- **Di browser** - header `Strict-Transport-Security` memberi tahu browser untuk memakai HTTPS sendiri pada kunjungan berikutnya, yang menghapus redirect setelah response aman pertama.
+
+Deserve sudah menangani separuh kedua. [Middleware security headers](/id/middleware/security-headers#stricttransportsecurity) mengatur HSTS lewat opsi `strictTransportSecurity`, mati secara default dan dimaksudkan menyala setelah server dicapai lewat HTTPS.
+
+```typescript twoslash
+import { Mware, Router } from '@neabyte/deserve'
+
+const router = new Router()
+// ---cut---
+// Suruh browser tetap pakai HTTPS
+router.use(
+  Mware.securityHeaders({
+    strictTransportSecurity: 'max-age=31536000; includeSubDomains'
+  })
+)
+
+await router.serve(8000)
+```
+
+## Membaca Skema Asli
+
+Ketika aplikasi memang perlu tahu apakah klien memakai HTTPS, jawabannya ada di header forwarded yang diatur proxy, bukan di koneksi lokal. Proxy tepercaya menambahkan [`X-Forwarded-Proto`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Forwarded-Proto), dibaca lewat [`ctx.header`](/id/core-concepts/context-object#akses-data-request).
+
+```typescript twoslash
+import type { Context } from '@neabyte/deserve'
+// ---cut---
+export function GET(ctx: Context): Response {
+  // Skema yang benar-benar dipakai klien
+  const proto = ctx.header('x-forwarded-proto') ?? 'http'
+  return ctx.send.json({ secure: proto === 'https' })
+}
+```
+
+Percayai header ini hanya di belakang proxy yang dikonfigurasi lewat [`trustProxy`](/id/getting-started/server-configuration#resolusi-ip-klien), batas kepercayaan yang sama diandalkan [`ctx.ip`](/id/by-design/request-id#ip-adalah-sumber-kebenaran). Klien yang tak tepercaya bisa mengatur header apa pun, jadi nilainya tak berarti tanpa batas itu.
+
+## Menyajikan HTTPS Langsung
+
+Server tanpa proxy di depan bisa menterminasi TLS sendiri dengan memberikan sertifikat dan kunci ke [`Deno.serve`](https://docs.deno.com/runtime/fundamentals/http_server/#https-support), runtime di bawah [konfigurasi server](/id/getting-started/server-configuration). Bahkan saat itu redirect dari `http` ke `https` adalah urusan listener terpisah, bukan middleware, jadi aplikasi tetap fokus pada request yang diterimanya.