jskelet 0.5.4 → 0.6.0

package/types/config/index.d.ts

@@ -0,0 +1,299 @@
+import { DEFAULT_ADMIN, DEFAULT_CLOUDFLARE, DEFAULT_UPSTREAM_LIMIT } from "./defaults.js";
+/** Framework paketinin kökü — kendi şablonlarına ve varlıklarına erişir. */
+export declare const FRAMEWORK_ROOT: string;
+export type Eagerness = "conservative" | "moderate" | "eager";
+export type NavigationConfig = {
+    prefetch: false | Eagerness;
+    prerender: false | Eagerness;
+    viewTransition: boolean;
+    /**
+     * Spekülasyon dışı bırakılan href desenleri.
+     */
+    exclude: string[];
+};
+export type RedisConfig = {
+    enabled: boolean;
+    url: string | null;
+    namespace: string;
+    keyPrefix: string;
+    /**
+     * HTML gövdeleri paylaşılsın mı.
+     */
+    html: boolean;
+    /**
+     * Veri önbelleği paylaşılsın mı.
+     */
+    data: boolean;
+    /**
+     * Sıkıştırılmış gövdeler de paylaşılsın mı.
+     */
+    storeEncoded: boolean;
+    /**
+     * pub/sub invalidation yayını.
+     */
+    events: boolean;
+    commandTimeoutMs: number;
+};
+export type LogKind = "http" | "event" | "error";
+export type LogsConfig = {
+    /**
+     * Runtime http/event/error satırları stdout'a
+     * basılsın mı (banner/build satırları etkilenmez).
+     */
+    console: boolean;
+    /**
+     * Sink'lere giden kayıt türleri.
+     */
+    kinds: LogKind[];
+    file: {
+        enabled: boolean;
+        dir: string;
+        rotate: "daily";
+    };
+    s3: {
+        enabled: boolean;
+        bucket: string | null;
+        prefix: string;
+        region: string | null;
+        endpoint: string | null;
+        flushIntervalMs: number;
+        maxBatch: number;
+    };
+};
+export type CompiledPattern = import('./pattern.js').CompiledPattern;
+export type ResolvedConfig = {
+    /**
+     * Proje kökü (mutlak).
+     */
+    root: string;
+    /**
+     * Config dosyası okundu mu.
+     */
+    loaded: boolean;
+    /**
+     * Mutlak dizin yolları.
+     */
+    dirs: Record<string, string>;
+    headers: {
+        pattern: CompiledPattern;
+        headers: {
+            key: string;
+            value: string;
+        }[];
+    }[];
+    redirects: {
+        pattern: CompiledPattern;
+        destination: string;
+        statusCode: number;
+    }[];
+    rewrites: {
+        phase: "beforeFiles" | "afterFiles";
+        pattern: CompiledPattern;
+        destination: string;
+    }[];
+    html: {
+        pattern: CompiledPattern;
+        seconds: number;
+    }[];
+    /**
+     *   Yol deseni başına, HTML cache anahtarına girmesine izin verilen query
+     *   parametreleri. Eşleşen kural yoksa query'li istek cache'lenmez.
+     */
+    cacheQuery: {
+        pattern: CompiledPattern;
+        allow: true | string[];
+    }[];
+    /**
+     *   Anahtara eklenen sabit parçalar (query allowlist'ten bağımsız). Host'tan
+     *   locale üreten sitelerde `host: true` zorunlu.
+     */
+    cacheVary: {
+        host: boolean;
+        headers: string[];
+        fn: ((req: import('express').Request) => string | null | undefined) | null;
+    };
+    /**
+     * HTML önbelleğinin girdi sınırı.
+     */
+    htmlMaxEntries: number;
+    /**
+     * Upstream veri önbelleği ayarları.
+     */
+    data: Record<string, unknown>;
+    /**
+     * `fetch` sarılıp geçici hatalar otomatik bildirilsin mi.
+     */
+    trackUpstream: boolean;
+    /**
+     * Render'ın okuduğu veri anahtarları kaydedilsin mi.
+     */
+    trackDependencies: boolean;
+    transientRetry: {
+        attempts: number;
+        delayMs: number;
+    };
+    /**
+     * Opsiyonel Redis ikinci kademesi.
+     */
+    redis: RedisConfig;
+    /**
+     * Upstream hız freni.
+     */
+    upstream: typeof DEFAULT_UPSTREAM_LIMIT;
+    /**
+     * Kalıcı log sink'leri (dosya + S3).
+     */
+    logs: LogsConfig;
+    /**
+     * Framework yönetim paneli.
+     */
+    admin: typeof DEFAULT_ADMIN;
+    /**
+     * Cloudflare cache yüzeyi.
+     */
+    cloudflare: typeof DEFAULT_CLOUDFLARE;
+    prewarm: Record<string, unknown>;
+    prewarmPriority: {
+        source: string;
+        test: (pathname: string) => boolean;
+    }[];
+    brand: Record<string, unknown>;
+    auth: {
+        crossSubdomainHandoff: boolean | Record<string, unknown>;
+    };
+    hooks: Record<string, Function>;
+    /**
+     * Layout `.ejs` dosyasının mutlak yolu.
+     */
+    layout: string;
+    /**
+     * Açık route modülü listesi.
+     */
+    routes: string[] | null;
+    /**
+     * URL'ler `/` ile bitsin mi (Next `trailingSlash`).
+     */
+    trailingSlash: boolean;
+    static: {
+        extensions: Set<string>;
+        prefixes: string[];
+    };
+    devGateBypass: string[];
+    preconnect: string[];
+    navigation: NavigationConfig;
+    security: SecurityConfig;
+    prewarmSkip: string[];
+    /**
+     * Dev sunucusunun izlediği ek dizinler.
+     */
+    watch: string[];
+    fonts: {
+        family: string;
+        slug?: string;
+        weights: number[];
+    }[];
+    icons: {
+        scan?: string[];
+        dir: string;
+    } | false;
+    images: ImagesConfig | false;
+    /**
+     * Client bundle'a gömülecek env anahtarları.
+     */
+    clientEnv: string[];
+};
+export type ImagesRemoteConfig = {
+    enabled: boolean;
+    allowHosts: string[];
+    path: string;
+    maxWidth: number;
+    cacheMaxAge: number;
+    fetchTimeoutMs: number;
+    maxBytes: number;
+};
+export type ImagesConfig = {
+    widths: number[];
+    quality: number;
+    skip: string[];
+    remote: ImagesRemoteConfig | false;
+};
+/**
+ * `bucket`, `JSKELET_LOG_BUCKET` veya `JSKELET_S3_BUCKET` değeri
+ * `ayberkenis/jskelet/logs` gibi bir yol olabilir: ilk segment bucket adı,
+ * kalanı nesne öneki. Böylece tek env ile hem kova hem klasör verilmiş olur.
+ *
+ * @param {string | null} value
+ * @returns {{ bucket: string | null, prefix: string | null }}
+ *   `prefix` null → yol öneki taşımıyor; config/varsayılan kalsın.
+ */
+export declare function splitS3BucketPath(value: string | null): {
+    bucket: string | null;
+    prefix: string | null;
+};
+/**
+ * @returns {{ accessKeyId: string, secretAccessKey: string,
+ *   sessionToken: string | null } | null}
+ */
+export declare function readS3CredentialsFromEnv(): {
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken: string | null;
+} | null;
+/**
+ * Kalıcı log sink'leri. Bozuk bir `kinds` listesi siteyi düşürmemeli —
+ * bilinmeyen girdiler atılır; hiç geçerli tür kalmazsa varsayılana dönülür.
+ *
+ * @param {unknown} raw
+ * @returns {LogsConfig}
+ */
+export declare function normalizeLogs(raw: unknown): LogsConfig;
+export type SecurityConfig = {
+    trustProxy: boolean;
+    cookieSecret: string | null;
+    csrf: {
+        enabled: boolean;
+        token: boolean;
+        allowedOrigins: string[];
+        exclude: CompiledPattern[];
+        cookieName: string;
+        fieldName: string;
+        headerName: string;
+    };
+};
+/**
+ * Config'i okur, normalize eder ve modül durumuna yazar. Sunucu ve build
+ * süreçleri açılışta bir kez çağırır.
+ *
+ * Aynı süreçte ikinci çağrı önbelleğe düşer: `jskelet start` hem
+ * `ensure-build` hem `createApp` üzerinden çağırıyor ve config'i iki kez
+ * okuyup iki kez loglamanın hiçbir faydası yok. Yeniden okumak gerekiyorsa
+ * `force: true`.
+ *
+ * @param {{ root?: string, configFile?: string, force?: boolean }} [options]
+ * @returns {Promise<ResolvedConfig>}
+ */
+export declare function loadConfig(options?: {
+    root?: string;
+    configFile?: string;
+    force?: boolean;
+}): Promise<ResolvedConfig>;
+/**
+ * Çözümlenmiş config. `loadConfig()` çağrılmadan erişilirse boş bir proje
+ * kökü varsayımıyla çalışmak yerine hata verir: sessiz yanlış yol,
+ * "stylesheet neden yok" gibi teşhisi zor sorunlara dönüşüyor.
+ *
+ * @returns {ResolvedConfig}
+ */
+export declare function getConfig(): ResolvedConfig;
+/**
+ * Uygulamanın tanımladığı hook'u çalıştırır; yoksa `fallback` döner.
+ * Hook'un hata vermesi sayfayı düşürmemeli — framework kendi varsayılanına
+ * geri döner ve uyarır.
+ *
+ * @template T
+ * @param {string} name
+ * @param {T} fallback
+ * @param {unknown[]} args
+ * @returns {Promise<T>}
+ */
+export declare function hook<T>(name: string, fallback: T, ...args: unknown[]): Promise<T>;

package/types/config/pattern.d.ts

@@ -0,0 +1,38 @@
+/**
+ * `next.config` `source`/`destination` sözdiziminin küçük bir derleyicisi.
+ *
+ * Desteklenen biçimler:
+ *   `/haber/:slug`      → tek segment yakalar
+ *   `/:path*`           → sıfır veya daha fazla segment yakalar
+ *   `/:path*.svg`       → joker + sabit son ek (uzantı kuralları böyle yazılır)
+ *   `/etiket-:slug`     → segment ortasında parametre
+ *
+ * Yakalanan değerler `destination` içindeki aynı adlı `:param`'lara yazılır.
+ * Next'in tam `path-to-regexp` yüzeyi değil; config'te fiilen kullanılan alt
+ * küme bilinçli olarak seçildi ve tanınmayan bir sözdizimi sessizce literal
+ * kabul edilmez, uyarı üretir.
+ */
+export type CompiledPattern = {
+    regex: RegExp;
+    keys: string[];
+    source: string;
+};
+/**
+ * @param {string} source
+ * @returns {CompiledPattern | null}
+ */
+export declare function compilePattern(source: string): CompiledPattern | null;
+/**
+ * @param {CompiledPattern} compiled
+ * @param {string} pathname
+ * @returns {Record<string, string> | null}
+ */
+export declare function matchPattern(compiled: CompiledPattern, pathname: string): Record<string, string> | null;
+/**
+ * `destination` içindeki `:param` yer tutucularını doldurur.
+ *
+ * @param {string} destination
+ * @param {Record<string, string>} params
+ * @returns {string}
+ */
+export declare function fillDestination(destination: string, params: Record<string, string>): string;

package/types/http/control-flow.d.ts

@@ -0,0 +1,45 @@
+/**
+ * `next/navigation` içindeki notFound/redirect kontrol akışının karşılığı.
+ * Derinlerdeki bir fonksiyon throw eder, Express error handler yakalar.
+ */
+export declare class NotFoundError extends Error {
+    statusCode: number;
+    constructor(message?: string);
+}
+export declare class RedirectError extends Error {
+    location: string;
+    statusCode: 301 | 302 | 303 | 307 | 308;
+    /**
+     * @param {string} location
+     * @param {301 | 302 | 303 | 307 | 308} [statusCode]
+     */
+    constructor(location: string, statusCode?: 301 | 302 | 303 | 307 | 308);
+}
+/** @returns {never} */
+export declare function notFound(): never;
+/**
+ * @param {string} location
+ * @returns {never}
+ */
+export declare function permanentRedirect(location: string): never;
+/**
+ * @param {string} location
+ * @returns {never}
+ */
+export declare function redirect(location: string): never;
+/**
+ * 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 declare function seeOther(location: string): never;
+/** @param {unknown} error */
+export declare function isNotFoundError(error: unknown): error is NotFoundError;
+/** @param {unknown} error */
+export declare function isRedirectError(error: unknown): error is RedirectError;

package/types/http/cookies-entry.d.ts

@@ -0,0 +1,5 @@
+/**
+ * `jskelet/cookies` paket girişi — imzalı cookie + paylaşımlı Domain yüzeyi.
+ */
+export { clearCookie, getSignedCookie, isValidCookieName, parseCookies, randomToken, safeEqual, serializeCookie, setCookie, setSignedCookie, } from "./cookies.js";
+export { clearSharedCookie, requestIsHttps, resolveSharedCookieDomain, SHARED_COOKIE_WARN_BYTES, writeSharedCookie, } from "./shared-cookie.js";

package/types/http/cookies.d.ts

@@ -0,0 +1,113 @@
+/**
+ * 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 declare function safeEqual(a: string, b: string): boolean;
+/**
+ * `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 declare function parseCookies(req: import('http').IncomingMessage): Record<string, string>;
+export type CookieOptions = {
+    /**
+     * Varsayılan `/`.
+     */
+    path?: string;
+    domain?: string;
+    /**
+     * Saniye.
+     */
+    maxAge?: number;
+    expires?: Date;
+    /**
+     * Varsayılan `true`.
+     */
+    httpOnly?: boolean;
+    /**
+     * Varsayılan: development dışında `true`.
+     * `writeSharedCookie` protokole bakarak ezer (`https` → Secure).
+     */
+    secure?: boolean;
+    /**
+     * Varsayılan `Lax`.
+     */
+    sameSite?: "Strict" | "Lax" | "None";
+};
+/**
+ * @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`.
+ *   `writeSharedCookie` protokole bakarak ezer (`https` → Secure).
+ * @property {"Strict" | "Lax" | "None"} [sameSite] Varsayılan `Lax`.
+ */
+/**
+ * RFC 6265 cookie-name (token). `;`, boşluk, CRLF gibi karakterler
+ * Set-Cookie enjeksiyonuna yol açardı — reddedilir.
+ *
+ * @param {unknown} name
+ * @returns {boolean}
+ */
+export declare function isValidCookieName(name: unknown): boolean;
+/**
+ * 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 declare function serializeCookie(name: string, value: string, options?: CookieOptions): string;
+/**
+ * @param {import('http').ServerResponse} res
+ * @param {string} name
+ * @param {string} value
+ * @param {CookieOptions} [options]
+ */
+export declare function setCookie(res: import('http').ServerResponse, name: string, value: string, options?: CookieOptions): void;
+/**
+ * @param {import('http').ServerResponse} res
+ * @param {string} name
+ * @param {CookieOptions} [options]
+ */
+export declare function clearCookie(res: import('http').ServerResponse, name: string, options?: CookieOptions): void;
+/**
+ * İ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 declare function setSignedCookie(res: import('http').ServerResponse, name: string, value: string, options?: CookieOptions): void;
+/**
+ * İ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 declare function getSignedCookie(req: import('http').IncomingMessage, name: string): string | null;
+/**
+ * Kriptografik rastgele token. CSRF token'ı ve oturum kimliği için.
+ *
+ * @param {number} [bytes]
+ * @returns {string}
+ */
+export declare function randomToken(bytes?: number): string;

package/types/http/request-cache.d.ts

@@ -0,0 +1,13 @@
+/**
+ * İsteği bir memo bağlamı içinde çalıştırır.
+ * @param {() => T} run
+ * @returns {T}
+ * @template T
+ */
+export declare function withRequestCache<T>(run: () => T): T;
+/**
+ * @param {F} fn
+ * @returns {F}
+ * @template {(...args: any[]) => any} F
+ */
+export declare function cache<F extends (...args: any[]) => any>(fn: F): F;

package/types/http/request-context.d.ts

@@ -0,0 +1,67 @@
+export type RequestContext = {
+    /**
+     * Route `private: true` ile mi kaydedildi.
+     */
+    private: boolean;
+    /**
+     * Kimliğe bağlı bir veri okundu mu.
+     */
+    tainted: boolean;
+    /**
+     * Hangi erişimler işaretledi (teşhis için).
+     */
+    taintReasons: string[];
+    csrfToken: string | null;
+    res: import('express').Response | null;
+    /**
+     * Devtools: bu isteğin sayfa yolu (SSR
+     * sırasında upstream hatasına "hangi sayfa" bağlamak için).
+     */
+    pathname: string | null;
+};
+/**
+ * @param {{ private?: boolean, res?: import('express').Response, pathname?: string | null }} [initial]
+ * @returns {RequestContext}
+ */
+export declare function createRequestContext(initial?: {
+    private?: boolean;
+    res?: import('express').Response;
+    pathname?: string | null;
+}): RequestContext;
+/**
+ * İsteği verilen bağlam içinde çalıştırır.
+ *
+ * @template T
+ * @param {RequestContext} context
+ * @param {() => T} run
+ * @returns {T}
+ */
+export declare function withRequestContext<T>(context: RequestContext, run: () => T): T;
+/**
+ * @returns {RequestContext | undefined}
+ */
+export declare function getRequestContext(): RequestContext | undefined;
+/**
+ * Çı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 declare function markTainted(reason: string): void;
+/**
+ * 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 declare function guardRequest(req: import('express').Request): import('express').Request;

package/types/http/shared-cookie.d.ts

@@ -0,0 +1,73 @@
+export { SHARED_COOKIE_WARN_BYTES, resolveSharedCookieDomain, stripHostPort, } from "../shared/cookie-domain.js";
+/**
+ * @param {{ secure?: boolean, protocol?: string,
+ *   headers?: Record<string, unknown>, get?: (name: string) => string | undefined }} [req]
+ * @returns {boolean}
+ */
+export declare function requestIsHttps(req?: {
+    secure?: boolean;
+    protocol?: string;
+    headers?: Record<string, unknown>;
+    get?: (name: string) => string | undefined;
+}): boolean;
+export type CookieOptions = import('./cookies.js').CookieOptions;
+export type SharedCookieResult = {
+    /**
+     * Domain seçildi ve Set-Cookie yazıldı.
+     */
+    ok: boolean;
+    /**
+     * Yazılan Domain ya da null.
+     */
+    domain: string | null;
+    /**
+     * ok değilse çağıran handoff denemeli.
+     */
+    handoff: boolean;
+    /**
+     * Teşhis.
+     */
+    reason?: string;
+};
+/**
+ * @typedef {import('./cookies.js').CookieOptions} CookieOptions
+ *
+ * @typedef {object} SharedCookieResult
+ * @property {boolean} ok Domain seçildi ve Set-Cookie yazıldı.
+ * @property {string | null} domain Yazılan Domain ya da null.
+ * @property {boolean} handoff ok değilse çağıran handoff denemeli.
+ * @property {string} [reason] Teşhis.
+ */
+/**
+ * Paylaşımlı Domain ile cookie yazar.
+ *
+ * @param {import('http').ServerResponse & { req?: import('http').IncomingMessage }} res
+ * @param {string} name
+ * @param {string} value Kısa session id — JWT değil.
+ * @param {CookieOptions & { req?: import('http').IncomingMessage, roots?: string[],
+ *   host?: string }} [options]
+ * @returns {SharedCookieResult}
+ */
+export declare function writeSharedCookie(res: import('http').ServerResponse & {
+    req?: import('http').IncomingMessage;
+}, name: string, value: string, options?: CookieOptions & {
+    req?: import('http').IncomingMessage;
+    roots?: string[];
+    host?: string;
+}): SharedCookieResult;
+/**
+ * Aynı Domain ile cookie siler.
+ *
+ * @param {import('http').ServerResponse & { req?: import('http').IncomingMessage }} res
+ * @param {string} name
+ * @param {CookieOptions & { req?: import('http').IncomingMessage, roots?: string[],
+ *   host?: string }} [options]
+ * @returns {SharedCookieResult}
+ */
+export declare function clearSharedCookie(res: import('http').ServerResponse & {
+    req?: import('http').IncomingMessage;
+}, name: string, options?: CookieOptions & {
+    req?: import('http').IncomingMessage;
+    roots?: string[];
+    host?: string;
+}): SharedCookieResult;

package/types/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * JSkelet sunucu tarafı genel API'si.
+ *
+ * `import { route, notFound } from "jskelet"` — route dosyaları ve
+ * 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, 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 { clearSharedCookie, requestIsHttps, resolveSharedCookieDomain, SHARED_COOKIE_WARN_BYTES, writeSharedCookie, } from "./http/shared-cookie.js";
+export { reportUpstreamFailure } from "./server/upstream-tracking.js";
+export { asset, hasAsset, optimizedImage, getSpriteIds } from "./server/assets.js";
+export { remoteImageUrl, parseAllowedRemoteUrl } from "./server/image-optimizer.js";
+export { ImageResponse, OG_SIZE, buildOgSvg, escapeXml, ogHandler, ogImage, sendOgImage, wrapText, } from "./server/og-image.js";
+export { headHints } from "./server/head-hints.js";
+export { renderHeadMeta } from "./server/metadata.js";
+export { clearHtmlCache, dropHtmlCacheKey, getHtmlCacheEntries, getHtmlCacheSize, invalidateHtmlCache, withHtmlCache, } from "./server/html-cache.js";
+export { clearDataCache, dataCache, dropDataCacheKey, getDataCacheEntries, getDataCacheSize, getDataCacheStats, withDataCache, } from "./server/data-cache.js";
+export { getRedisDetails, getRedisStatus, inspectRedis } from "./server/redis.js";
+export { cloudflareConfigured, fetchCacheAnalytics, fetchCloudflareOverview, fetchPathEdges, getCloudflareStatus, purgeCloudflare, toCloudflareUrls, } from "./server/cloudflare.js";
+export { getUpstreamLimiterStatus } from "./server/upstream-limiter.js";
+export { prewarm, prewarmProgress, extractSameOriginLinks, isOnVisitPrewarm } 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 { csrfField, icon, image, link, preloadImage } from "./views/helpers/tags.js";