npm - jskelet - Versions diffs - 0.1.1 - Mend

jskelet 0.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (72) hide show

package/AGENTS.md +127 -0
package/CHANGELOG.md +40 -0
package/LICENSE +21 -0
package/README.md +342 -0
package/bin/jskelet.mjs +104 -0
package/docs/01-baslangic.md +285 -0
package/docs/02-mimari.md +287 -0
package/docs/03-routing.md +437 -0
package/docs/04-render-ve-sablonlar.md +490 -0
package/docs/05-islands.md +429 -0
package/docs/06-cache.md +409 -0
package/docs/07-yapilandirma.md +673 -0
package/docs/08-build.md +366 -0
package/docs/09-dev-araclari.md +302 -0
package/docs/10-dagitim.md +329 -0
package/docs/11-tasima.md +352 -0
package/docs/README.md +82 -0
package/package.json +97 -0
package/src/build/build.mjs +138 -0
package/src/build/ensure-build.mjs +15 -0
package/src/build/paths.mjs +118 -0
package/src/build/resolve-peer.mjs +36 -0
package/src/build/tasks/client.mjs +268 -0
package/src/build/tasks/css.mjs +124 -0
package/src/build/tasks/fonts.mjs +146 -0
package/src/build/tasks/icons.mjs +224 -0
package/src/build/tasks/images.mjs +244 -0
package/src/build/tasks/precompress.mjs +78 -0
package/src/client/devtools/overlay.js +1763 -0
package/src/client/devtools/report.html +185 -0
package/src/client/devtools/report.js +712 -0
package/src/client/dom.js +95 -0
package/src/client/index.js +26 -0
package/src/client/registry.js +223 -0
package/src/client/safe-image.js +91 -0
package/src/client/store.js +36 -0
package/src/config/defaults.js +102 -0
package/src/config/index.js +433 -0
package/src/config/pattern.js +107 -0
package/src/dev-server.mjs +383 -0
package/src/http/control-flow.js +56 -0
package/src/http/request-cache.js +46 -0
package/src/index.js +35 -0
package/src/init.mjs +220 -0
package/src/log.mjs +332 -0
package/src/logo.png +0 -0
package/src/runtime/alias-hooks.mjs +119 -0
package/src/runtime/register.mjs +4 -0
package/src/server/assets.js +119 -0
package/src/server/create-app.js +167 -0
package/src/server/dev/devtools.js +383 -0
package/src/server/dev/report.js +351 -0
package/src/server/head-hints.js +132 -0
package/src/server/html-cache.js +166 -0
package/src/server/metadata.js +102 -0
package/src/server/middleware/compression.js +205 -0
package/src/server/middleware/dev-gate.js +62 -0
package/src/server/middleware/headers.js +37 -0
package/src/server/middleware/redirects.js +32 -0
package/src/server/middleware/static-precompressed.js +100 -0
package/src/server/middleware/upstream-proxy.js +141 -0
package/src/server/prewarm.js +283 -0
package/src/server/render.js +356 -0
package/src/server/router.js +121 -0
package/src/server/status-page.js +164 -0
package/src/server/upstream-tracking.js +51 -0
package/src/start.mjs +7 -0
package/src/templates/layout.ejs +44 -0
package/src/version.mjs +17 -0
package/src/views/components/loader.js +85 -0
package/src/views/helpers/html.js +102 -0
package/src/views/helpers/tags.js +193 -0

package/src/server/metadata.js ADDED Viewed

@@ -0,0 +1,102 @@
+/**
+ * Metadata → `<head>` etiketleri. Next.js'in Metadata API'sinin karşılığı.
+ *
+ * Controller `metadata` döndürür, framework onu etiketlere çevirir. Şema
+ * bilinçli olarak küçük: title/description/canonical/robots ve OpenGraph +
+ * Twitter kartları. Daha fazlası gerekirse `extraTags` ile ham HTML eklenir,
+ * böylece framework her yeni meta türü için sürüm çıkarmak zorunda kalmaz.
+ *
+ * @typedef {object} Metadata
+ * @property {string} [title]
+ * @property {string} [titleTemplate] `"%s | Site"` — `title` buna gömülür.
+ * @property {string} [description]
+ * @property {string} [canonical] Mutlak ya da göreli URL.
+ * @property {string} [siteUrl] Göreli canonical'ı mutlaklaştırmak için.
+ * @property {{ index?: boolean, follow?: boolean }} [robots]
+ * @property {string} [locale]
+ * @property {object} [openGraph] `{ title, description, url, type, siteName, image, imageWidth, imageHeight }`
+ * @property {object} [twitter] `{ card, site, creator, title, description, image }`
+ * @property {string[]} [extraTags] Olduğu gibi basılacak ham etiketler.
+ */
+import { attrs, esc } from "../views/helpers/html.js";
+/**
+ * @param {string} name
+ * @param {unknown} content
+ * @returns {string}
+ */
+function meta(name, content) {
+  if (content == null || content === "") return "";
+  return `<meta${attrs({ name, content })}>`;
+}
+/**
+ * OpenGraph `property` kullanır, `name` değil — bazı kazıyıcılar `name` ile
+ * yazılmış og etiketlerini görmezden geliyor.
+ *
+ * @param {string} property
+ * @param {unknown} content
+ * @returns {string}
+ */
+function og(property, content) {
+  if (content == null || content === "") return "";
+  return `<meta${attrs({ property, content })}>`;
+}
+/**
+ * @param {string} [canonical]
+ * @param {string} [siteUrl]
+ * @returns {string | undefined}
+ */
+function absoluteUrl(canonical, siteUrl) {
+  if (!canonical) return undefined;
+  if (/^https?:\/\//.test(canonical)) return canonical;
+  if (!siteUrl) return canonical;
+  return new URL(canonical, siteUrl).href;
+}
+/**
+ * @param {Metadata} [metadata]
+ * @returns {string}
+ */
+export function renderHeadMeta(metadata = {}) {
+  const title = metadata.titleTemplate && metadata.title
+    ? metadata.titleTemplate.replace("%s", metadata.title)
+    : metadata.title;
+  const url = absoluteUrl(metadata.canonical, metadata.siteUrl);
+  const robots = metadata.robots ?? {};
+  // Varsayılan indekslenebilir: bir sayfayı gizlemek açık bir karar olmalı.
+  const robotsValue = [
+    robots.index === false ? "noindex" : "index",
+    robots.follow === false ? "nofollow" : "follow",
+  ].join(", ");
+  const graph = metadata.openGraph ?? {};
+  const card = metadata.twitter ?? {};
+  return [
+    title ? `<title>${esc(title)}</title>` : "",
+    meta("description", metadata.description),
+    url ? `<link${attrs({ rel: "canonical", href: url })}>` : "",
+    meta("robots", robotsValue),
+    og("og:type", graph.type ?? "website"),
+    og("og:title", graph.title ?? title),
+    og("og:description", graph.description ?? metadata.description),
+    og("og:url", graph.url ?? url),
+    og("og:site_name", graph.siteName),
+    og("og:locale", metadata.locale),
+    og("og:image", graph.image),
+    og("og:image:width", graph.imageWidth),
+    og("og:image:height", graph.imageHeight),
+    meta("twitter:card", card.card ?? (graph.image ? "summary_large_image" : "summary")),
+    meta("twitter:site", card.site),
+    meta("twitter:creator", card.creator),
+    meta("twitter:title", card.title ?? graph.title ?? title),
+    meta("twitter:description", card.description ?? metadata.description),
+    meta("twitter:image", card.image ?? graph.image),
+    ...(metadata.extraTags ?? []),
+  ]
+    .filter(Boolean)
+    .join("");
+}

package/src/server/middleware/compression.js ADDED Viewed

@@ -0,0 +1,205 @@
+/**
+ * Yanıt sıkıştırma — Next.js'in varsayılan `compress: true` davranışının yerine.
+ *
+ * `compression` paketi brotli desteklemiyor ve yedi geçişli bağımlılık
+ * getiriyor; `node:zlib` ile brotli + gzip pazarlığı yapmak yeterli.
+ * Brotli tercih edilir: ana sayfa HTML'inde gzip'e göre ~%35 daha küçük.
+ */
+import zlib from "node:zlib";
+import { Writable } from "node:stream";
+/** Bu eşiğin altındaki gövdelerde sıkıştırma kazancı yok. */
+const THRESHOLD_BYTES = 1024;
+const COMPRESSIBLE =
+  /^(?:text\/|application\/(?:json|javascript|xml|xhtml\+xml|rss\+xml|atom\+xml|ld\+json|manifest\+json)|image\/svg\+xml)/i;
+const BROTLI_OPTIONS = {
+  params: {
+    // Metin için 5, varsayılan 11'e göre çok daha hızlı ve neredeyse aynı boyut.
+    [zlib.constants.BROTLI_PARAM_QUALITY]: 5,
+    [zlib.constants.BROTLI_PARAM_MODE]: zlib.constants.BROTLI_MODE_TEXT,
+  },
+};
+/**
+ * @param {string} header
+ * @returns {"br" | "gzip" | null}
+ */
+function negotiate(header) {
+  if (!header) return null;
+  /** @type {Map<string, number>} */
+  const weights = new Map();
+  for (const part of header.split(",")) {
+    const [name, ...params] = part.trim().split(";");
+    const q = params
+      .map((p) => p.trim())
+      .find((p) => p.startsWith("q="));
+    weights.set(name.toLowerCase(), q ? Number(q.slice(2)) : 1);
+  }
+  if ((weights.get("br") ?? 0) > 0) return "br";
+  if ((weights.get("gzip") ?? 0) > 0) return "gzip";
+  return null;
+}
+/**
+ * İçeriği bir kez sıkıştırıp saklamak isteyen çağıranlar için (HTML cache).
+ *
+ * @param {string | undefined} acceptEncoding
+ * @returns {"br" | "gzip" | null}
+ */
+export function negotiateEncoding(acceptEncoding) {
+  return negotiate(acceptEncoding ?? "");
+}
+/**
+ * @param {string} text
+ * @param {"br" | "gzip"} encoding
+ * @returns {Promise<Buffer>}
+ */
+export function encodeText(text, encoding) {
+  const input = Buffer.from(text, "utf8");
+  return new Promise((resolve, reject) => {
+    const done = (error, result) => (error ? reject(error) : resolve(result));
+    if (encoding === "br") zlib.brotliCompress(input, BROTLI_OPTIONS, done);
+    else zlib.gzip(input, done);
+  });
+}
+/**
+ * @param {import('http').ServerResponse} res
+ * @returns {boolean}
+ */
+function shouldCompress(res) {
+  if (res.getHeader("content-encoding")) return false;
+  if (res.getHeader("cache-control")?.toString().includes("no-transform")) {
+    return false;
+  }
+  const type = res.getHeader("content-type")?.toString() ?? "";
+  if (type.includes("text/event-stream")) return false;
+  if (!COMPRESSIBLE.test(type)) return false;
+  const length = Number(res.getHeader("content-length"));
+  return Number.isNaN(length) || length >= THRESHOLD_BYTES;
+}
+/**
+ * @returns {import('express').RequestHandler}
+ */
+export function compression() {
+  return (req, res, next) => {
+    // HEAD gövdesi yok; zaten sıkışık ikili içerik boşuna CPU yakar.
+    const encoding = req.method === "HEAD" ? null : negotiate(req.headers["accept-encoding"]);
+    const originalWrite = res.write.bind(res);
+    const originalEnd = res.end.bind(res);
+    /** @type {import('zlib').Gzip | import('zlib').BrotliCompress | null} */
+    let stream = null;
+    let decided = false;
+    let passthrough = false;
+    function decide() {
+      if (decided) return;
+      decided = true;
+      // SSE gibi akışlar başlıkları kendileri yazar (`writeHead`); bu noktada
+      // başlık eklemek çökme sebebi olur, sıkıştırma da anlamsızdır.
+      if (res.headersSent) {
+        passthrough = true;
+        return;
+      }
+      // Vary her durumda: aynı URL farklı encoding ile cache'lenebilir.
+      res.setHeader("Vary", appendVary(res.getHeader("Vary"), "Accept-Encoding"));
+      if (!encoding || !shouldCompress(res)) {
+        passthrough = true;
+        return;
+      }
+      res.setHeader("Content-Encoding", encoding);
+      res.removeHeader("Content-Length");
+      stream =
+        encoding === "br"
+          ? zlib.createBrotliCompress(BROTLI_OPTIONS)
+          : zlib.createGzip({ level: 6 });
+      // Sıkıştırılmış çıktıyı sokete geri baskıya saygı duyarak aktar.
+      stream.pipe(
+        new Writable({
+          write(chunk, chunkEncoding, callback) {
+            originalWrite(chunk, chunkEncoding, callback);
+          },
+          final(callback) {
+            originalEnd();
+            callback();
+          },
+        }),
+      );
+      // `express.static` gövdeyi `pipe` ile yazar ve `res.write()` false
+      // dönerse `drain` bekler; zlib doldu-boşaldı sinyalini yansıtmazsak
+      // aktarım sessizce askıda kalır.
+      stream.on("drain", () => res.emit("drain"));
+      stream.on("error", () => originalEnd());
+    }
+    res.write = function write(chunk, encodingArg, callback) {
+      decide();
+      if (passthrough) return originalWrite(chunk, encodingArg, callback);
+      if (!chunk) return true;
+      return stream.write(toBuffer(chunk, encodingArg), callback);
+    };
+    res.end = function end(chunk, encodingArg, callback) {
+      decide();
+      if (passthrough) return originalEnd(chunk, encodingArg, callback);
+      if (chunk && typeof chunk !== "function") {
+        stream.end(toBuffer(chunk, encodingArg), callback);
+      } else {
+        stream.end();
+      }
+      return res;
+    };
+    next();
+  };
+}
+/**
+ * @param {unknown} chunk
+ * @param {unknown} encodingArg
+ * @returns {Buffer}
+ */
+function toBuffer(chunk, encodingArg) {
+  if (Buffer.isBuffer(chunk)) return chunk;
+  return Buffer.from(
+    /** @type {string} */ (chunk),
+    typeof encodingArg === "string" ? /** @type {BufferEncoding} */ (encodingArg) : "utf8",
+  );
+}
+/**
+ * @param {unknown} current
+ * @param {string} field
+ * @returns {string}
+ */
+function appendVary(current, field) {
+  const existing = current ? String(current) : "";
+  if (!existing) return field;
+  const parts = existing.split(",").map((p) => p.trim().toLowerCase());
+  return parts.includes(field.toLowerCase()) ? existing : `${existing}, ${field}`;
+}

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

@@ -0,0 +1,62 @@
+/**
+ * Yayına açılmamış bir ortamı gizler: `DEV_TOKEN` ayarlıyken token taşımayan
+ * her isteğe 404 döner. 403 değil 404 — 403 ortamın var olduğunu doğrular,
+ * 404 hiç yokmuş gibi davranır.
+ *
+ * Token bir kez `?dev_token=…` ile gelirse çereze yazılır, böylece link
+ * paylaşımı yeterli olur. `DEV_TOKEN` yoksa middleware tamamen devre dışıdır
+ * ve üretimde hiçbir maliyeti olmaz.
+ */
+import process from "node:process";
+import { getConfig } from "../../config/index.js";
+const COOKIE_MAX_AGE_SECONDS = 60 * 60 * 24 * 14;
+/**
+ * @param {import('http').IncomingMessage} req
+ * @param {string} name
+ * @returns {string | undefined}
+ */
+function readCookie(req, name) {
+  const header = req.headers.cookie;
+  if (!header) return undefined;
+  for (const part of header.split(";")) {
+    const eq = part.indexOf("=");
+    if (eq === -1) continue;
+    if (part.slice(0, eq).trim() !== name) continue;
+    return decodeURIComponent(part.slice(eq + 1).trim());
+  }
+  return undefined;
+}
+/** @returns {import('express').RequestHandler} */
+export function devGate() {
+  const { devGateBypass, brand } = getConfig();
+  const bypass = new Set(devGateBypass);
+  const cookieName = brand.devTokenCookie;
+  return (req, res, next) => {
+    const devToken = process.env.DEV_TOKEN;
+    if (!devToken) return next();
+    if (bypass.has(req.path)) return next();
+    const fromQuery = req.query?.[cookieName];
+    const tokenFromQuery = Array.isArray(fromQuery) ? fromQuery[0] : fromQuery;
+    const tokenFromCookie = readCookie(req, cookieName);
+    if (tokenFromQuery !== devToken && tokenFromCookie !== devToken) {
+      res.status(404).type("text/plain").send("Not Found");
+      return;
+    }
+    if (tokenFromQuery === devToken) {
+      res.setHeader(
+        "Set-Cookie",
+        `${cookieName}=${encodeURIComponent(devToken)}; Max-Age=${COOKIE_MAX_AGE_SECONDS}; Path=/; SameSite=Lax`,
+      );
+    }
+    next();
+  };
+}

package/src/server/middleware/headers.js ADDED Viewed

@@ -0,0 +1,37 @@
+/**
+ * `jskelet.config.mjs` → `headers()` uygulayıcısı.
+ *
+ * İki katman var. Framework yalnızca statik dosyalara uzun ömürlü cache
+ * yazar — bu, hash'li çıktı için her projede doğru olan tek varsayılan.
+ * Bunun dışındaki her başlık (CSP, COOP, HSTS, X-Frame-Options…) config'ten
+ * gelir ve varsayılanların üstüne biner: aynı başlığı yeniden tanımlarsan
+ * config kazanır.
+ */
+import { getConfig } from "../../config/index.js";
+import { matchPattern } from "../../config/pattern.js";
+import { IMMUTABLE_CACHE } from "../../config/defaults.js";
+/** @returns {import('express').RequestHandler} */
+export function headersMiddleware() {
+  const { static: staticRules, headers: rules } = getConfig();
+  return (req, res, next) => {
+    const pathname = req.path ?? "";
+    const dot = pathname.lastIndexOf(".");
+    const ext = dot === -1 ? "" : pathname.slice(dot).toLowerCase();
+    if (
+      staticRules.extensions.has(ext) ||
+      staticRules.prefixes.some((prefix) => pathname.startsWith(prefix))
+    ) {
+      res.setHeader("Cache-Control", IMMUTABLE_CACHE);
+    }
+    for (const rule of rules) {
+      if (!matchPattern(rule.pattern, pathname)) continue;
+      for (const { key, value } of rule.headers) res.setHeader(key, value);
+    }
+    next();
+  };
+}

package/src/server/middleware/redirects.js ADDED Viewed

@@ -0,0 +1,32 @@
+/**
+ * `jskelet.config.mjs` → `redirects()` uygulayıcısı.
+ *
+ * İlk eşleşen kural kazanır, sonrası denenmez — sıralama config'teki yazım
+ * sırasıdır. Query string korunur: `/eski?utm=x` → `/yeni?utm=x`, çünkü
+ * yönlendirme kampanya parametrelerini düşürürse trafik kaynağı kaybolur.
+ */
+import { getConfig } from "../../config/index.js";
+import { fillDestination, matchPattern } from "../../config/pattern.js";
+/** @returns {import('express').RequestHandler} */
+export function redirects() {
+  const rules = getConfig().redirects;
+  if (!rules.length) return (req, res, next) => next();
+  return (req, res, next) => {
+    const query = req.originalUrl.slice(req.path.length);
+    for (const rule of rules) {
+      const params = matchPattern(rule.pattern, req.path);
+      if (!params) continue;
+      res.redirect(
+        rule.statusCode,
+        `${fillDestination(rule.destination, params)}${query}`,
+      );
+      return;
+    }
+    next();
+  };
+}

package/src/server/middleware/static-precompressed.js ADDED Viewed

@@ -0,0 +1,100 @@
+/**
+ * Build'de üretilmiş `.br` / `.gz` kopyalarını servis eder.
+ *
+ * `express.static`ten önce çalışır: istemcinin kabul ettiği bir kopya varsa
+ * istek yolunu ona çevirir ve doğru `Content-Type` / `Content-Encoding`
+ * başlıklarını kendisi kurar. Böylece hash'li varlıklar istek başına yeniden
+ * sıkıştırılmaz ve build'deki kalite 11 brotli kullanılır.
+ *
+ * Kopya yoksa istek olduğu gibi `express.static`e devredilir.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { negotiateEncoding } from "./compression.js";
+import { IMMUTABLE_CACHE } from "../../config/defaults.js";
+/** @type {Record<string, string>} */
+const CONTENT_TYPES = {
+  ".css": "text/css; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".json": "application/json; charset=utf-8",
+  ".xml": "application/xml; charset=utf-8",
+  ".txt": "text/plain; charset=utf-8",
+  ".map": "application/json; charset=utf-8",
+};
+/**
+ * @param {string} publicDir
+ * @returns {import('express').RequestHandler}
+ */
+export function staticPrecompressed(publicDir) {
+  const root = path.resolve(publicDir);
+  return (req, res, next) => {
+    if (req.method !== "GET" && req.method !== "HEAD") {
+      next();
+      return;
+    }
+    const type = CONTENT_TYPES[path.extname(req.path).toLowerCase()];
+    if (!type) {
+      next();
+      return;
+    }
+    const encoding = negotiateEncoding(req.headers["accept-encoding"]);
+    if (!encoding) {
+      next();
+      return;
+    }
+    let decoded;
+    try {
+      decoded = decodeURIComponent(req.path);
+    } catch {
+      next();
+      return;
+    }
+    const target = path.resolve(root, `.${decoded}`);
+    // Path traversal koruması: çözülen yol public/ dışına çıkamaz.
+    if (target !== root && !target.startsWith(root + path.sep)) {
+      next();
+      return;
+    }
+    const file = `${target}${encoding === "br" ? ".br" : ".gz"}`;
+    let stat;
+    try {
+      stat = fs.statSync(file);
+    } catch {
+      next();
+      return;
+    }
+    if (!stat.isFile()) {
+      next();
+      return;
+    }
+    res.setHeader("Content-Type", type);
+    res.setHeader("Content-Encoding", encoding);
+    res.setHeader("Content-Length", String(stat.size));
+    res.setHeader("Vary", "Accept-Encoding");
+    if (req.path.startsWith("/assets/")) {
+      res.setHeader("Cache-Control", IMMUTABLE_CACHE);
+    }
+    if (req.method === "HEAD") {
+      res.end();
+      return;
+    }
+    fs.createReadStream(file).on("error", () => res.end()).pipe(res);
+  };
+}

package/src/server/middleware/upstream-proxy.js ADDED Viewed

@@ -0,0 +1,141 @@
+/**
+ * `jskelet.config.mjs` → `rewrites()` uygulayıcısı ve yeniden kullanılabilir
+ * reverse proxy.
+ *
+ * Harici paket yok; native `fetch` ile stream eden ince bir proxy. `duplex:
+ * "half"` gövdeli isteklerde şart, `redirect: "manual"` olmadan upstream'in
+ * 302'si burada tüketilir ve tarayıcı hiç görmez.
+ *
+ * Tipik kullanım: `/api/*` yolunu backend'e taşımak. Bunu tarayıcı
+ * same-origin çağırdığı için CORS ve third-party cookie sorunları oluşmaz.
+ */
+import { Readable } from "node:stream";
+import { getConfig } from "../../config/index.js";
+import { fillDestination, matchPattern } from "../../config/pattern.js";
+/** Hop-by-hop header'lar proxy edilmez. */
+const STRIPPED_REQUEST_HEADERS = new Set([
+  "host",
+  "connection",
+  "content-length",
+  "accept-encoding",
+]);
+const STRIPPED_RESPONSE_HEADERS = new Set([
+  "content-encoding",
+  "content-length",
+  "transfer-encoding",
+  "connection",
+]);
+/**
+ * Rewrite hedefini istek nesnesinde taşımak için; string bir alan adı
+ * uygulamanın kendi alanlarıyla çakışabilir.
+ */
+const REWRITE_TARGET = Symbol("jskelet.rewriteTarget");
+/**
+ * @param {import('express').Request} req
+ * @returns {Record<string, string>}
+ */
+function forwardHeaders(req) {
+  /** @type {Record<string, string>} */
+  const out = {};
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (STRIPPED_REQUEST_HEADERS.has(key)) continue;
+    if (value === undefined) continue;
+    out[key] = Array.isArray(value) ? value.join(", ") : String(value);
+  }
+  return out;
+}
+/**
+ * Hedefi isteğe göre hesaplayan proxy üretir. `resolveTarget` fırlatırsa
+ * istek proxy'lenmez ve zincire devam eder — hedef origin yapılandırılmamış
+ * bir kurulumda 500 yerine normal 404 almak daha doğru.
+ *
+ * @param {(req: import('express').Request) => string} resolveTarget
+ * @returns {import('express').RequestHandler}
+ */
+export function createProxy(resolveTarget) {
+  return async (req, res, next) => {
+    let target;
+    try {
+      target = resolveTarget(req);
+    } catch {
+      next();
+      return;
+    }
+    if (!target) {
+      next();
+      return;
+    }
+    const hasBody = req.method !== "GET" && req.method !== "HEAD";
+    try {
+      const upstream = await fetch(target, {
+        method: req.method,
+        headers: forwardHeaders(req),
+        body: hasBody ? Readable.toWeb(req) : undefined,
+        duplex: hasBody ? "half" : undefined,
+        redirect: "manual",
+      });
+      res.status(upstream.status);
+      upstream.headers.forEach((value, key) => {
+        if (STRIPPED_RESPONSE_HEADERS.has(key.toLowerCase())) return;
+        res.setHeader(key, value);
+      });
+      if (!upstream.body) {
+        res.end();
+        return;
+      }
+      Readable.fromWeb(upstream.body).pipe(res);
+    } catch (error) {
+      next(error);
+    }
+  };
+}
+/**
+ * Config'teki `rewrites()` kuralları.
+ *
+ * Hedef mutlaksa (http/https) istek proxy ile dışa taşınır; göreliyse
+ * yalnızca `req.url` değiştirilir ve istek kendi route tablosunda devam eder.
+ * İki faz var: `beforeFiles` statik dosyalardan önce, `afterFiles` statik
+ * denendikten sonra sayfalardan önce.
+ *
+ * @param {"beforeFiles" | "afterFiles"} phase
+ * @returns {import('express').RequestHandler}
+ */
+export function configRewrites(phase) {
+  const rules = getConfig().rewrites.filter((rule) => rule.phase === phase);
+  if (!rules.length) return (req, res, next) => next();
+  const proxy = createProxy((req) => req[REWRITE_TARGET]);
+  return (req, res, next) => {
+    for (const rule of rules) {
+      const params = matchPattern(rule.pattern, req.path);
+      if (!params) continue;
+      const query = req.originalUrl.slice(req.path.length);
+      const destination = fillDestination(rule.destination, params);
+      if (/^https?:\/\//.test(destination)) {
+        req[REWRITE_TARGET] = `${destination}${query}`;
+        proxy(req, res, next);
+        return;
+      }
+      req.url = `${destination}${query}`;
+      break;
+    }
+    next();
+  };
+}