jskelet 0.1.1 → 0.1.2

package/src/config/index.js

@@ -16,6 +16,9 @@
  *   redirects() → [{ source, destination, permanent?, statusCode? }]
  *   rewrites()  → [{ source, destination }] | { beforeFiles?, afterFiles? }
  *   cache()     → { html?: { [source]: saniye }, prewarm?: {...} }
+ *
+ * Fonksiyon olmayan bölümler (`brand`, `security`, `static`, `navigation`…)
+ * düz nesne olarak okunur.
  */
 import fs from "node:fs";
 import path from "node:path";
@@ -30,6 +33,7 @@ import {
   DEFAULT_NAVIGATION_EXCLUDE,
   DEFAULT_PREWARM,
   DEFAULT_PREWARM_SKIP,
+  DEFAULT_SECURITY,
   DEFAULT_STATIC,
 } from "./defaults.js";
 
@@ -68,6 +72,7 @@ const CONFIG_FILE = "jskelet.config.mjs";
  * @property {string[]} devGateBypass
  * @property {string[]} preconnect
  * @property {NavigationConfig} navigation
+ * @property {SecurityConfig} security
  * @property {string[]} prewarmSkip
  * @property {string[]} watch Dev sunucusunun izlediği ek dizinler.
  * @property {{ family: string, slug?: string, weights: number[] }[]} fonts
@@ -87,7 +92,7 @@ let config = null;
 function asArray(value, label) {
   if (value == null) return [];
   if (Array.isArray(value)) return value;
-  console.warn(`[config] ${label} bir dizi döndürmeli, yok sayıldı`);
+  console.warn(`[config] ${label} must return an array, ignoring it`);
   return [];
 }
 
@@ -201,7 +206,7 @@ function normalizeEagerness(value, fallback, label) {
   }
 
   console.warn(
-    `[config] navigation.${label} geçersiz (${String(value)}), varsayılana dönüldü`,
+    `[config] navigation.${label} is invalid (${String(value)}), falling back to the default`,
   );
   return fallback;
 }
@@ -240,6 +245,50 @@ function normalizeNavigation(raw, brand) {
   };
 }
 
+/**
+ * @typedef {object} SecurityConfig
+ * @property {boolean} trustProxy
+ * @property {string | null} cookieSecret
+ * @property {{ enabled: boolean, token: boolean, allowedOrigins: string[],
+ *   exclude: CompiledPattern[], cookieName: string, fieldName: string,
+ *   headerName: string }} csrf
+ */
+
+/**
+ * Güvenlik bölümü. `csrf.exclude` desenleri burada derlenir: her istekte
+ * yeniden derlemek gereksiz, ve bozuk bir desen sunucuyu düşürmemeli.
+ *
+ * @param {unknown} raw
+ * @returns {SecurityConfig}
+ */
+function normalizeSecurity(raw) {
+  const source = /** @type {Record<string, any>} */ (raw ?? {});
+  const csrf = { ...DEFAULT_SECURITY.csrf, ...(source.csrf ?? {}) };
+
+  const exclude = asArray(csrf.exclude, "security.csrf.exclude")
+    .map((entry) => compilePattern(entry))
+    .filter((pattern) => pattern !== null);
+
+  return {
+    trustProxy: source.trustProxy !== false,
+    cookieSecret:
+      typeof source.cookieSecret === "string" && source.cookieSecret
+        ? source.cookieSecret
+        : null,
+    csrf: {
+      enabled: csrf.enabled !== false,
+      token: csrf.token === true,
+      allowedOrigins: asArray(csrf.allowedOrigins, "security.csrf.allowedOrigins")
+        .filter((entry) => typeof entry === "string")
+        .map(String),
+      exclude: /** @type {CompiledPattern[]} */ (exclude),
+      cookieName: String(csrf.cookieName ?? DEFAULT_SECURITY.csrf.cookieName),
+      fieldName: String(csrf.fieldName ?? DEFAULT_SECURITY.csrf.fieldName),
+      headerName: String(csrf.headerName ?? DEFAULT_SECURITY.csrf.headerName).toLowerCase(),
+    },
+  };
+}
+
 /**
  * Dizin adlarını mutlak yola çevirir. `styles` bir dosya yolu olduğu için
  * de aynı çözümlemeden geçer; ayrı bir alan tutmaya değmez.
@@ -307,7 +356,7 @@ export async function loadConfig(options = {}) {
 
   if (!fs.existsSync(configPath)) {
     console.warn(
-      `[config] ${configFile} bulunamadı — yerleşik varsayılanlarla devam ediliyor.`,
+      `[config] ${configFile} not found — continuing with built-in defaults.`,
     );
   } else {
     try {
@@ -316,7 +365,7 @@ export async function loadConfig(options = {}) {
       source = module.default ?? module;
       loaded = true;
     } catch (error) {
-      console.warn(`[config] ${configFile} yüklenemedi, yok sayıldı`, error);
+      console.warn(`[config] ${configFile} failed to load, ignoring it`, error);
     }
   }
 
@@ -327,7 +376,7 @@ export async function loadConfig(options = {}) {
     try {
       return typeof value === "function" ? await value.call(source) : value;
     } catch (error) {
-      console.warn(`[config] ${name}() hata verdi, yok sayıldı`, error);
+      console.warn(`[config] ${name}() threw, ignoring it`, error);
       return null;
     }
   };
@@ -363,6 +412,7 @@ export async function loadConfig(options = {}) {
     devGateBypass: source.devGateBypass ?? DEFAULT_DEV_GATE_BYPASS,
     preconnect: source.preconnect ?? [],
     navigation: normalizeNavigation(source.navigation, brand),
+    security: normalizeSecurity(source.security),
     prewarmSkip: source.prewarmSkip ?? DEFAULT_PREWARM_SKIP,
     // `routes`, `views` ve `lib` zaten izlenir; buraya yalnızca ek dizinler.
     watch: source.watch ?? [],
@@ -377,15 +427,20 @@ export async function loadConfig(options = {}) {
   // Dev'de build ve sunucu ayrı alt süreçler; üçü de aynı özeti basınca satır
   // banner'ın ve build bloğunun arasına üç kez giriyor. Özeti dış süreç basar.
   if (loaded && !process.env.JSKELET_CHILD) {
+    /** @param {number} count @param {string} singular @param {string} plural */
+    const label = (count, singular, plural) =>
+      `${count} ${count === 1 ? singular : plural}`;
+
     const counts = [
-      config.headers.length && `${config.headers.length} header`,
-      config.redirects.length && `${config.redirects.length} redirect`,
-      config.rewrites.length && `${config.rewrites.length} rewrite`,
-      config.html.length && `${config.html.length} cache kuralı`,
+      config.headers.length && label(config.headers.length, "header", "headers"),
+      config.redirects.length &&
+        label(config.redirects.length, "redirect", "redirects"),
+      config.rewrites.length && label(config.rewrites.length, "rewrite", "rewrites"),
+      config.html.length && label(config.html.length, "cache rule", "cache rules"),
     ].filter(Boolean);
 
     if (counts.length) {
-      console.log(`[config] ${configFile} yüklendi — ${counts.join(", ")}`);
+      console.log(`[config] ${configFile} loaded — ${counts.join(", ")}`);
     }
   }
 
@@ -402,8 +457,8 @@ export async function loadConfig(options = {}) {
 export function getConfig() {
   if (!config) {
     throw new Error(
-      "[config] loadConfig() çağrılmadan getConfig() kullanıldı. " +
-        "Sunucuyu `jskelet` CLI ile ya da createApp() üzerinden başlatın.",
+      "[config] getConfig() was used before loadConfig(). " +
+        "Start the server with the `jskelet` CLI or through createApp().",
     );
   }
   return config;
@@ -427,7 +482,7 @@ export async function hook(name, fallback, ...args) {
   try {
     return await fn(...args);
   } catch (error) {
-    console.warn(`[config] hooks.${name}() hata verdi, varsayılan kullanıldı`, error);
+    console.warn(`[config] hooks.${name}() threw, using the default`, error);
     return fallback;
   }
 }

package/src/config/pattern.js

@@ -28,7 +28,7 @@ function escapeLiteral(text) {
  */
 export function compilePattern(source) {
   if (typeof source !== "string" || !source.startsWith("/")) {
-    console.warn(`[config] geçersiz source (\`/\` ile başlamalı): ${source}`);
+    console.warn(`[config] invalid source (must start with \`/\`): ${source}`);
     return null;
   }
 

package/src/dev-server.mjs

@@ -350,7 +350,7 @@ function watchSources() {
       });
     } catch {
       log.warn(
-        `${path.relative(ROOT, target)} izlenemedi; bu dizinde otomatik restart olmayacak.`,
+        `could not watch ${path.relative(ROOT, target)}; no auto restart for this directory.`,
       );
     }
   }

package/src/http/control-flow.js

@@ -14,7 +14,7 @@ export class NotFoundError extends Error {
 export class RedirectError extends Error {
   /**
    * @param {string} location
-   * @param {301 | 302 | 307 | 308} [statusCode]
+   * @param {301 | 302 | 303 | 307 | 308} [statusCode]
    */
   constructor(location, statusCode = 307) {
     super(`Redirect to ${location}`);
@@ -45,6 +45,21 @@ export function redirect(location) {
   throw new RedirectError(location, 307);
 }
 
+/**
+ * POST sonrası yönlendirme (303 See Other).
+ *
+ * `redirect()` 307 kullanır ve 307 **metodu korur**: bir POST handler'ından
+ * çağrıldığında tarayıcı hedefe yeniden POST eder. Form gönderiminden sonra
+ * sayfayı GET olarak açmak — yani geri tuşunun formu yeniden göndermediği
+ * klasik "post/redirect/get" akışı — 303 gerektiriyor.
+ *
+ * @param {string} location
+ * @returns {never}
+ */
+export function seeOther(location) {
+  throw new RedirectError(location, 303);
+}
+
 /** @param {unknown} error */
 export function isNotFoundError(error) {
   return error instanceof NotFoundError;

package/src/http/cookies.js

@@ -0,0 +1,257 @@
+/**
+ * Cookie okuma/yazma ve HMAC ile imzalama.
+ *
+ * Neden framework'te: kişiye özel her sayfa bir oturum cookie'sine dayanıyor
+ * ve bunu elle yazan her proje aynı üç hatayı tekrar ediyor — `HttpOnly`
+ * unutmak, imzasız değere güvenmek, karşılaştırmayı `===` ile yapmak.
+ * Burada varsayılanlar güvenli tarafta ve imza doğrulaması sabit zamanlı.
+ *
+ * Framework **kimlik sağlamaz**: oturumun içinde ne olduğu, ne kadar
+ * yaşadığı ve kimin verdiği uygulamanın kararı. Buradaki yüzey yalnızca
+ * "bu değeri ben yazdım, kurcalanmamış" garantisini veriyor.
+ *
+ * Bağımlılık eklenmez; `node:crypto` yeterli.
+ */
+import crypto from "node:crypto";
+import process from "node:process";
+import { getConfig } from "../config/index.js";
+import { markTainted } from "./request-context.js";
+
+/** Ayrıştırılmış cookie'ler istek başına bir kez hesaplanır. */
+const PARSED = Symbol("jskelet.cookies");
+
+/**
+ * @param {string} value
+ * @returns {string}
+ */
+function base64url(value) {
+  return Buffer.from(value, "utf8").toString("base64url");
+}
+
+/**
+ * @param {string} value
+ * @returns {string | null}
+ */
+function fromBase64url(value) {
+  try {
+    return Buffer.from(value, "base64url").toString("utf8");
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * İmza sırrı. `security.cookieSecret` ya da `JSKELET_SECRET`.
+ *
+ * Yokluğunda imzasız cookie yazmak en kötü sonuç olurdu: uygulama kendini
+ * güvende sanar, değer kurcalanabilir. Bu yüzden imzalı API sır olmadan
+ * hata verir — config hatasının siteyi düşürmemesi kuralı burada geçmez,
+ * çünkü sessiz alternatif bir güvenlik açığı.
+ *
+ * @returns {string}
+ */
+function getSecret() {
+  /** @type {string | null} */
+  let configured = null;
+
+  try {
+    configured = getConfig().security.cookieSecret;
+  } catch {
+    // Config yüklenmemiş olabilir (script, test); env yine de geçerli.
+    configured = null;
+  }
+
+  const secret = configured ?? process.env.JSKELET_SECRET ?? null;
+
+  if (!secret) {
+    throw new Error(
+      "[cookies] a secret is required for signed cookies. Set " +
+        "`security.cookieSecret` in `jskelet.config.mjs` or the JSKELET_SECRET environment variable.",
+    );
+  }
+
+  return secret;
+}
+
+/**
+ * @param {string} value
+ * @returns {string}
+ */
+function sign(value) {
+  return crypto.createHmac("sha256", getSecret()).update(value).digest("base64url");
+}
+
+/**
+ * Sabit zamanlı karşılaştırma: imza doğrulamasında erken çıkış, saldırganın
+ * baytları tek tek tahmin etmesine kapı aralar.
+ *
+ * @param {string} a
+ * @param {string} b
+ * @returns {boolean}
+ */
+export function safeEqual(a, b) {
+  const left = Buffer.from(String(a));
+  const right = Buffer.from(String(b));
+  if (left.length !== right.length) return false;
+  return crypto.timingSafeEqual(left, right);
+}
+
+/**
+ * `Cookie` başlığını ayrıştırır.
+ *
+ * Okuma çıktının kullanıcıya bağlı olduğunu bildirir: bu sayfa artık public
+ * HTML cache'ine yazılamaz.
+ *
+ * @param {import('http').IncomingMessage} req
+ * @returns {Record<string, string>}
+ */
+export function parseCookies(req) {
+  markTainted("parseCookies(req)");
+
+  const cached = /** @type {any} */ (req)[PARSED];
+  if (cached) return cached;
+
+  /** @type {Record<string, string>} */
+  const out = {};
+  const header = req.headers?.cookie;
+
+  if (header) {
+    for (const part of header.split(";")) {
+      const index = part.indexOf("=");
+      if (index === -1) continue;
+
+      const name = part.slice(0, index).trim();
+      if (!name) continue;
+
+      try {
+        out[name] = decodeURIComponent(part.slice(index + 1).trim());
+      } catch {
+        // Bozuk yüzde kodlaması tüm başlığı çöpe atmamalı.
+        out[name] = part.slice(index + 1).trim();
+      }
+    }
+  }
+
+  /** @type {any} */ (req)[PARSED] = out;
+  return out;
+}
+
+/**
+ * @typedef {object} CookieOptions
+ * @property {string} [path] Varsayılan `/`.
+ * @property {string} [domain]
+ * @property {number} [maxAge] Saniye.
+ * @property {Date} [expires]
+ * @property {boolean} [httpOnly] Varsayılan `true`.
+ * @property {boolean} [secure] Varsayılan: development dışında `true`.
+ * @property {"Strict" | "Lax" | "None"} [sameSite] Varsayılan `Lax`.
+ */
+
+/**
+ * Varsayılanlar bilinçli olarak kısıtlayıcı: `HttpOnly` ile JS okuyamaz,
+ * `SameSite=Lax` ile çapraz site POST'larında gönderilmez (CSRF'nin büyük
+ * kısmını kapatan tek satır), `Secure` üretimde açık.
+ *
+ * @param {string} name
+ * @param {string} value
+ * @param {CookieOptions} [options]
+ * @returns {string}
+ */
+export function serializeCookie(name, value, options = {}) {
+  const parts = [`${name}=${encodeURIComponent(value)}`];
+
+  parts.push(`Path=${options.path ?? "/"}`);
+  if (options.domain) parts.push(`Domain=${options.domain}`);
+  if (options.maxAge !== undefined) parts.push(`Max-Age=${Math.floor(options.maxAge)}`);
+  if (options.expires) parts.push(`Expires=${options.expires.toUTCString()}`);
+  if (options.httpOnly !== false) parts.push("HttpOnly");
+  if (options.secure ?? process.env.NODE_ENV !== "development") parts.push("Secure");
+  parts.push(`SameSite=${options.sameSite ?? "Lax"}`);
+
+  return parts.join("; ");
+}
+
+/**
+ * @param {import('http').ServerResponse} res
+ * @param {string} name
+ * @param {string} value
+ * @param {CookieOptions} [options]
+ */
+export function setCookie(res, name, value, options = {}) {
+  const existing = res.getHeader("Set-Cookie");
+  const serialized = serializeCookie(name, value, options);
+
+  /** @type {string[]} */
+  const all = existing
+    ? Array.isArray(existing)
+      ? [...existing.map(String)]
+      : [String(existing)]
+    : [];
+
+  all.push(serialized);
+  res.setHeader("Set-Cookie", all);
+}
+
+/**
+ * @param {import('http').ServerResponse} res
+ * @param {string} name
+ * @param {CookieOptions} [options]
+ */
+export function clearCookie(res, name, options = {}) {
+  setCookie(res, name, "", { ...options, maxAge: 0, expires: new Date(0) });
+}
+
+/**
+ * İmzalı cookie yazar. Değer okunabilir kalır (şifreleme değil, imza);
+ * gizli kalması gereken veriyi cookie'ye koymayın, kimliğini koyun.
+ *
+ * @param {import('http').ServerResponse} res
+ * @param {string} name
+ * @param {string} value
+ * @param {CookieOptions} [options]
+ */
+export function setSignedCookie(res, name, value, options = {}) {
+  const encoded = base64url(value);
+  setCookie(res, name, `${encoded}.${sign(encoded)}`, options);
+}
+
+/**
+ * İmzalı cookie okur. İmza uymuyorsa `null` — bozuk imza, yok sayılmalı,
+ * "belki geçerlidir" diye kullanılmamalı.
+ *
+ * @param {import('http').IncomingMessage} req
+ * @param {string} name
+ * @returns {string | null}
+ */
+export function getSignedCookie(req, name) {
+  const raw = parseCookies(req)[name];
+  if (!raw) return null;
+
+  const index = raw.lastIndexOf(".");
+  if (index <= 0) return null;
+
+  const encoded = raw.slice(0, index);
+  const signature = raw.slice(index + 1);
+
+  let expected;
+  try {
+    expected = sign(encoded);
+  } catch {
+    // Sır yoksa imzalı okuma sessizce başarısız olur: sunucu ayakta kalır
+    // ama hiçbir oturum geçerli sayılmaz.
+    return null;
+  }
+
+  if (!safeEqual(signature, expected)) return null;
+  return fromBase64url(encoded);
+}
+
+/**
+ * Kriptografik rastgele token. CSRF token'ı ve oturum kimliği için.
+ *
+ * @param {number} [bytes]
+ * @returns {string}
+ */
+export function randomToken(bytes = 32) {
+  return crypto.randomBytes(bytes).toString("base64url");
+}

package/src/http/request-context.js

@@ -0,0 +1,162 @@
+/**
+ * İstek başına yaşayan bağlam.
+ *
+ * `request-cache.js` ile aynı desen: `AsyncLocalStorage`, bağlam yoksa her şey
+ * sessizce devre dışı. Ayrı bir modül olmasının sebebi, taşıdığı bilginin
+ * memoizasyondan farklı olması — burada tutulanlar bir isteğin **cache'lenip
+ * cache'lenemeyeceğine** dair kararlar:
+ *
+ *   private  → route açıkça "bu sayfa kişiye özel" dedi
+ *   tainted  → controller cookie/Authorization okudu, yani çıktı kullanıcıya
+ *              bağlı olabilir; HTML cache'e yazmak sızıntı olur
+ *   csrfToken → bu istek için üretilmiş token; `csrfField()` şablonda basar
+ *   res      → token cookie'sini yazabilmek için; başka hiçbir şey için
+ *              kullanılmaz, şablonlara yanıt nesnesi sızmaz
+ *
+ * `tainted` bir tahmin değil, gözlem: `markTainted()` yalnızca gerçekten
+ * kimliğe dokunan bir erişimden sonra çağrılır (bkz. `guardRequest`).
+ */
+import { AsyncLocalStorage } from "node:async_hooks";
+
+/**
+ * @typedef {object} RequestContext
+ * @property {boolean} private Route `private: true` ile mi kaydedildi.
+ * @property {boolean} tainted Kimliğe bağlı bir veri okundu mu.
+ * @property {string[]} taintReasons Hangi erişimler işaretledi (teşhis için).
+ * @property {string | null} csrfToken
+ * @property {import('express').Response | null} res
+ */
+
+/** @type {AsyncLocalStorage<RequestContext>} */
+const storage = new AsyncLocalStorage();
+
+/**
+ * @param {{ private?: boolean, res?: import('express').Response }} [initial]
+ * @returns {RequestContext}
+ */
+export function createRequestContext(initial = {}) {
+  return {
+    private: initial.private === true,
+    tainted: false,
+    taintReasons: [],
+    csrfToken: null,
+    res: initial.res ?? null,
+  };
+}
+
+/**
+ * İsteği verilen bağlam içinde çalıştırır.
+ *
+ * @template T
+ * @param {RequestContext} context
+ * @param {() => T} run
+ * @returns {T}
+ */
+export function withRequestContext(context, run) {
+  return storage.run(context, run);
+}
+
+/**
+ * @returns {RequestContext | undefined}
+ */
+export function getRequestContext() {
+  return storage.getStore();
+}
+
+/**
+ * Çıktının kullanıcıya bağlı olduğunu bildirir. Bağlam yoksa (script, build,
+ * fragment dışı kullanım) sessizce yok sayılır.
+ *
+ * @param {string} reason Teşhis mesajında görünecek erişim adı.
+ */
+export function markTainted(reason) {
+  const context = storage.getStore();
+  if (!context) return;
+
+  context.tainted = true;
+  if (!context.taintReasons.includes(reason)) {
+    context.taintReasons.push(reason);
+  }
+}
+
+
+/** Okunması çıktıyı kullanıcıya bağlayan başlıklar. */
+const SENSITIVE_HEADERS = new Set([
+  "cookie",
+  "authorization",
+  "proxy-authorization",
+]);
+
+/** Okunması çıktıyı kullanıcıya bağlayan `req` alanları. */
+const SENSITIVE_PROPS = new Set(["cookies", "signedCookies", "session", "user"]);
+
+/**
+ * @param {Record<string, unknown>} headers
+ * @returns {Record<string, unknown>}
+ */
+function guardHeaders(headers) {
+  return new Proxy(headers, {
+    get(target, prop, receiver) {
+      if (typeof prop === "string" && SENSITIVE_HEADERS.has(prop.toLowerCase())) {
+        markTainted(`req.headers.${prop}`);
+      }
+      return Reflect.get(target, prop, receiver);
+    },
+  });
+}
+
+/**
+ * Controller'a giden `req`'i kimliğe dokunan erişimleri işaretleyen bir Proxy
+ * ile sarar.
+ *
+ * Neden gerekli: HTML cache anahtarı yalnızca yol + query. Cookie okuyan bir
+ * controller cache'lenebilir bir route'a bağlanmışsa bir kullanıcının HTML'i
+ * bir başkasına servis edilir ve bu hiçbir yerde hata olarak görünmez.
+ * İşaretleme, sessiz sızıntıyı gürültülü bir uyarıya çeviriyor.
+ *
+ * Kapsam bilinçli olarak dar: yalnızca *okuma* yakalanır, yazma ve metot
+ * çağrıları hedefe dokunulmadan geçer. Proxy'nin prototipi korunduğu için
+ * `req instanceof IncomingMessage` gibi kontroller etkilenmez.
+ *
+ * @param {import('express').Request} req
+ * @returns {import('express').Request}
+ */
+export function guardRequest(req) {
+  /** @type {Record<string, unknown> | null} */
+  let headersProxy = null;
+
+  return new Proxy(req, {
+    get(target, prop, receiver) {
+      if (prop === "headers" || prop === "headersDistinct") {
+        const raw = Reflect.get(target, prop, receiver);
+        if (!raw || typeof raw !== "object") return raw;
+        if (prop === "headers") {
+          headersProxy ??= guardHeaders(/** @type {Record<string, unknown>} */ (raw));
+          return headersProxy;
+        }
+        return guardHeaders(/** @type {Record<string, unknown>} */ (raw));
+      }
+
+      if (prop === "get" || prop === "header") {
+        const original = Reflect.get(target, prop, receiver);
+        if (typeof original !== "function") return original;
+        return function guardedHeaderLookup(/** @type {string} */ name) {
+          if (typeof name === "string" && SENSITIVE_HEADERS.has(name.toLowerCase())) {
+            markTainted(`req.get("${name}")`);
+          }
+          return original.call(target, name);
+        };
+      }
+
+      if (typeof prop === "string" && SENSITIVE_PROPS.has(prop)) {
+        markTainted(`req.${prop}`);
+      }
+
+      const value = Reflect.get(target, prop, receiver);
+      // Express metotları kendi iç alanlarına `this` üzerinden erişiyor;
+      // proxy'yi receiver olarak bırakmak bu erişimleri de yakalayıp
+      // gereksiz işaretlemeye yol açar.
+      return typeof value === "function" ? value.bind(target) : value;
+    },
+  });
+}

package/src/index.js

@@ -5,19 +5,36 @@
  * controller'lar bu yüzeyi kullanır. Alt yollardan (`jskelet/server`)
  * ithal etmek de mümkün; buradaki liste "kararlı" sayılan yüzeydir.
  */
-export { route, renderPage, renderView, renderNotFound } from "./server/render.js";
+export {
+  route,
+  fragment,
+  renderPage,
+  renderView,
+  renderNotFound,
+} from "./server/render.js";
 export { renderStatusPage, statusFromError } from "./server/status-page.js";
 export { createApp, startServer } from "./server/create-app.js";
 export {
   notFound,
   redirect,
   permanentRedirect,
+  seeOther,
   isNotFoundError,
   isRedirectError,
   NotFoundError,
   RedirectError,
 } from "./http/control-flow.js";
 export { cache, withRequestCache } from "./http/request-cache.js";
+export {
+  clearCookie,
+  getSignedCookie,
+  parseCookies,
+  randomToken,
+  safeEqual,
+  serializeCookie,
+  setCookie,
+  setSignedCookie,
+} from "./http/cookies.js";
 export { reportUpstreamFailure } from "./server/upstream-tracking.js";
 export { asset, hasAsset, optimizedImage, getSpriteIds } from "./server/assets.js";
 export { headHints } from "./server/head-hints.js";
@@ -32,4 +49,4 @@ export { prewarm, prewarmProgress } from "./server/prewarm.js";
 export { createProxy } from "./server/middleware/upstream-proxy.js";
 export { getConfig, loadConfig } from "./config/index.js";
 export { attrs, cn, cx, esc, jsonScript } from "./views/helpers/html.js";
-export { icon, image, link, preloadImage } from "./views/helpers/tags.js";
+export { csrfField, icon, image, link, preloadImage } from "./views/helpers/tags.js";