@brightsideoy/kama 0.1.0-alpha.113 → 0.1.0-alpha.115

package/templates/astro-starter/src/middleware.ts

@@ -0,0 +1,306 @@
+// src/middleware.ts
+import { defineMiddleware } from "astro:middleware";
+import { env } from "cloudflare:workers";
+
+export const onRequest = defineMiddleware(async (context, next) => {
+    const pathname = context.url.pathname;
+    const locals = context.locals as any;
+    const cfContext = locals.cfContext;
+
+    // 🎯 Safely extract environment using Cloudflare Workers import or Node process fallback
+    const workerEnv = (typeof env !== "undefined" ? env : (process?.env || {})) as any;
+    const HTML_CACHE = workerEnv?.HTML_CACHE; // KV Namespace binding
+
+    // 🎯 0. DIRECT EDGE INTERCEPT FOR CACHE PURGE ENDPOINT
+    if (pathname === "/api/purge" || pathname === "/api/purge/") {
+        if (context.request.method !== "POST") {
+            return new Response(JSON.stringify({ error: "Method Not Allowed" }), {
+                status: 405,
+                headers: { "Content-Type": "application/json" },
+            });
+        }
+
+        const authHeader = context.request.headers.get("Authorization");
+        const expectedToken = workerEnv.CLOUDFLARE_API_TOKEN;
+
+        if (!expectedToken || authHeader !== `Bearer ${expectedToken}`) {
+            return new Response(JSON.stringify({ error: "Unauthorized Token Mismatch" }), {
+                status: 401,
+                headers: { "Content-Type": "application/json" },
+            });
+        }
+
+        try {
+            const body = await context.request.json();
+            const edgeCache = typeof caches !== "undefined" && caches.default ? caches.default : null;
+            const origin = context.url.origin;
+
+            // A. Purge Workers Caching Layer (Astro v6 cfContext)
+            if (typeof cfContext?.cache?.purge === 'function') {
+                try {
+                    await cfContext.cache.purge({ purgeEverything: true });
+                    console.log("✅ New Cloudflare Workers Cache Engine Purged");
+                } catch (e) {
+                    console.error("❌ Failed to purge new Workers Cache Engine", e);
+                }
+            }
+
+            // B. Version-Based Instant Invalidation (0ms KV Write)
+            if (HTML_CACHE) {
+                try {
+                    const now = Date.now().toString();
+
+                    if (body.purge_everything) {
+                        // 🎯 GLOBAL PURGE: Bumping site_version instantly invalidates ALL KV pages globally!
+                        await HTML_CACHE.put("site_version", now);
+                        console.log(`✅ [Version Tagging] Global site_version updated to ${now}`);
+                    } else if (Array.isArray(body.urls) && body.urls.length > 0) {
+                        // 🎯 SURGICAL PURGE: Parallel execution for page version bumps
+                        const purgeTasks = body.urls.map((targetUrl: string) => {
+                            const urlPath = new URL(targetUrl).pathname;
+                            const cleanPath = urlPath.replace(/\/$/, "") || "/";
+                            return HTML_CACHE.put(`v:${cleanPath}`, now);
+                        });
+                        await Promise.all(purgeTasks);
+                        console.log(`✅ [Version Tagging] Updated versions for ${body.urls.length} URLs`);
+                    }
+                } catch (kvErr) {
+                    console.error("❌ KV Version Tagging Error:", kvErr);
+                }
+            }
+
+            // C. Global Legacy Worker Cache Purge
+            if (body.purge_everything) {
+                if (edgeCache) {
+                    const rootUrls = [
+                        origin,
+                        `${origin}/`,
+                        `${origin}/home`,
+                        `${origin}/home/`
+                    ];
+
+                    for (const url of rootUrls) {
+                        await edgeCache.delete(new Request(url));
+                    }
+                }
+
+                return new Response(JSON.stringify({
+                    success: true,
+                    message: "All Worker Caches (Workers Cache, KV Version Tag & Legacy) Purged"
+                }), {
+                    status: 200,
+                    headers: { "Content-Type": "application/json" },
+                });
+            }
+
+            // D. Surgical Legacy Worker Cache Purge (For Updated Pages)
+            if (Array.isArray(body.urls) && body.urls.length > 0) {
+                const results = [];
+
+                for (const targetUrl of body.urls) {
+                    const cleanUrl = targetUrl.split('?')[0];
+                    const urlNoSlash = cleanUrl.replace(/\/$/, "");
+                    const urlWithSlash = urlNoSlash + "/";
+
+                    let p1 = false;
+                    let p2 = false;
+
+                    if (edgeCache) {
+                        p1 = await edgeCache.delete(new Request(urlNoSlash));
+                        p2 = await edgeCache.delete(new Request(urlWithSlash));
+                    }
+
+                    results.push({ url: targetUrl, purged: p1 || p2 });
+                }
+
+                return new Response(JSON.stringify({
+                    success: true,
+                    message: "URLs processed and version tags updated",
+                    results
+                }), {
+                    status: 200,
+                    headers: { "Content-Type": "application/json" },
+                });
+            }
+
+            // E. SURGICAL DELETION FOR DELETED PAGES
+            if (Array.isArray(body.deleted_urls) && body.deleted_urls.length > 0) {
+                const results: any[] = [];
+
+                const deleteTasks = body.deleted_urls.map(async (targetUrl: string) => {
+                    const urlPath = new URL(targetUrl).pathname;
+                    const cleanPath = urlPath.replace(/\/$/, "") || "/";
+
+                    let purgedKv = false;
+
+                    if (HTML_CACHE) {
+                        // 1. Fetch current version keys before removing pointers
+                        const [siteVer, pageVer] = await Promise.all([
+                            HTML_CACHE.get("site_version"),
+                            HTML_CACHE.get(`v:${cleanPath}`)
+                        ]);
+
+                        // 2. Delete the active HTML cache entry
+                        if (siteVer || pageVer) {
+                            const activeCacheKey = `${cleanPath}:v:${siteVer || "1"}:${pageVer || "1"}`;
+                            await HTML_CACHE.delete(activeCacheKey);
+                            purgedKv = true;
+                        }
+
+                        // 3. Delete the page version pointer key itself
+                        await HTML_CACHE.delete(`v:${cleanPath}`);
+                    }
+
+                    // 4. Purge legacy Worker Cache entries
+                    const cleanUrl = targetUrl.split('?')[0];
+                    const urlNoSlash = cleanUrl.replace(/\/$/, "");
+                    const urlWithSlash = urlNoSlash + "/";
+
+                    let p1 = false;
+                    let p2 = false;
+
+                    if (edgeCache) {
+                        p1 = await edgeCache.delete(new Request(urlNoSlash));
+                        p2 = await edgeCache.delete(new Request(urlWithSlash));
+                    }
+
+                    results.push({ url: targetUrl, purgedKv, purgedLegacy: p1 || p2 });
+                });
+
+                await Promise.all(deleteTasks);
+                console.log(`✅ [KV Deletion] Completely deleted KV keys for ${body.deleted_urls.length} URLs`);
+
+                return new Response(JSON.stringify({
+                    success: true,
+                    message: "Deleted URLs processed and KV keys permanently removed",
+                    results
+                }), {
+                    status: 200,
+                    headers: { "Content-Type": "application/json" },
+                });
+            }
+
+            return new Response(JSON.stringify({ error: "Invalid payload format" }), {
+                status: 400,
+                headers: { "Content-Type": "application/json" },
+            });
+
+        } catch (err: any) {
+            return new Response(JSON.stringify({ error: err.message }), {
+                status: 500,
+                headers: { "Content-Type": "application/json" },
+            });
+        }
+    }
+
+    // 🎯 1. KV STATIC "FILE" CACHE READ WITH VERSION TAGGING
+    const isWarmer = context.request.headers.get("X-Cache-Warmer") === "true";
+    const isHtmlPage = !pathname.includes('.') && !pathname.startsWith('/api/');
+    const cleanLookupPath = pathname.replace(/\/$/, "") || "/";
+
+    let activeCacheKey = cleanLookupPath;
+
+    if (isHtmlPage && HTML_CACHE && !isWarmer) {
+        try {
+            // Read active versions (Default to "1" if not set yet)
+            const [siteVer, pageVer] = await Promise.all([
+                HTML_CACHE.get("site_version"),
+                HTML_CACHE.get(`v:${cleanLookupPath}`)
+            ]);
+
+            activeCacheKey = `${cleanLookupPath}:v:${siteVer || "1"}:${pageVer || "1"}`;
+
+            const cachedHtml = await HTML_CACHE.get(activeCacheKey);
+            if (cachedHtml) {
+                return new Response(cachedHtml, {
+                    status: 200,
+                    headers: {
+                        "Content-Type": "text/html; charset=utf-8",
+                        "X-Cache-Status": "HIT-KV-STATICFILE",
+                        "X-Cache-Key": activeCacheKey,
+                        "Cache-Control": "no-store, no-cache, must-revalidate, proxy-revalidate"
+                    }
+                });
+            }
+        } catch (e) {
+            console.warn("[Middleware] KV lookup bypass:", e);
+        }
+    }
+
+    // Process downstream SSR routes
+    const response = await next();
+
+    // 🎯 2. KV STATIC "FILE" CACHE WRITE (Save HTML under active Version Key)
+    if (
+        isHtmlPage &&
+        HTML_CACHE &&
+        response.status === 200 &&
+        response.headers.get("content-type")?.includes("text/html")
+    ) {
+        const htmlText = await response.clone().text();
+
+        const writeTask = (async () => {
+            if (activeCacheKey === cleanLookupPath || isWarmer) {
+                const forcedVersion = Date.now().toString();
+
+                await HTML_CACHE.put(`v:${cleanLookupPath}`, forcedVersion);
+
+                const siteVer = await HTML_CACHE.get("site_version") || "1";
+
+                activeCacheKey = `${cleanLookupPath}:v:${siteVer}:${forcedVersion}`;
+            }
+
+            await HTML_CACHE.put(activeCacheKey, htmlText);
+            console.log(`✅ [Middleware] Saved HTML to KV under key: ${activeCacheKey}`);
+        })();
+
+        if (cfContext && typeof cfContext.waitUntil === 'function') {
+            cfContext.waitUntil(writeTask);
+        } else {
+            writeTask.catch((e: any) => console.error("KV write error:", e));
+        }
+    }
+
+    // 🎯 3. SERVE LLMS & LLXML ENDPOINTS
+    if (pathname === "/llms.txt" || pathname === "/llms-full.txt") {
+        response.headers.set("Content-Type", "text/plain; charset=utf-8");
+        response.headers.set("Cache-Control", "public, max-age=3600");
+        response.headers.set("Access-Control-Allow-Origin", "*");
+        return response;
+    }
+
+    if (pathname === "/llxml.txt") {
+        response.headers.set("Content-Type", "application/xml; charset=utf-8");
+        response.headers.set("Cache-Control", "public, max-age=3600");
+        response.headers.set("Access-Control-Allow-Origin", "*");
+        return response;
+    }
+
+    // 🎯 4. IMAGE & STATIC ASSET CACHING (ENVIRONMENT-AGNOSTIC)
+    if (
+        pathname.startsWith("/media/") ||
+        pathname.startsWith("/_image") ||
+        pathname.match(/\.(png|jpg|jpeg|webp|avif|svg|gif|ico|woff2?|css|js)$/i)
+    ) {
+        response.headers.set(
+            "Cache-Control",
+            "public, max-age=31536000, s-maxage=31536000, immutable"
+        );
+        response.headers.set("Access-Control-Allow-Origin", "*");
+        return response;
+    }
+
+    // 🎯 5. SECURITY HEADERS FOR HTML PAGES
+    if (response.headers.get("content-type")?.includes("text/html")) {
+        response.headers.set("Strict-Transport-Security", "max-age=31536000; includeSubDomains; preload");
+        response.headers.set("X-Frame-Options", "SAMEORIGIN");
+        response.headers.set("X-Content-Type-Options", "nosniff");
+        response.headers.set("Cross-Origin-Opener-Policy", "same-origin-allow-popups");
+        response.headers.set(
+            "Content-Security-Policy",
+            "default-src 'self' https: data: 'unsafe-inline' 'unsafe-eval'; img-src 'self' https: data: blob:; connect-src 'self' https:; frame-ancestors 'self';"
+        );
+    }
+
+    return response;
+});

package/templates/astro-starter/src/pages/404.astro

@@ -0,0 +1,46 @@
+---
+// src/pages/404.astro
+import Layout from "../layouts/Layout.astro";
+
+const node = {
+  title: "Page Not Found",
+  summary: "We couldn't find the page you were looking for.",
+};
+---
+
+<Layout
+  node={node}
+  isHomePage={false}
+  hasSidebar={false}
+  content={{}}
+  normalizedSlug="404"
+  headerBlocks={[]}
+>
+  <div class="error-page">
+    <h1>404</h1>
+    <h2>Page Not Found</h2>
+    <p>Sorry, the page you are looking for doesn't exist or has been moved.</p>
+    <a href="/" class="button">Go back home</a>
+  </div>
+</Layout>
+
+<style>
+  .error-page {
+    text-align: center;
+    padding: 100px 20px;
+  }
+  .error-page h1 {
+    font-size: 6rem;
+    margin-bottom: 0;
+    color: #0284c7;
+  }
+  .button {
+    display: inline-block;
+    margin-top: 24px;
+    padding: 12px 24px;
+    background: #0f172a;
+    color: white;
+    text-decoration: none;
+    border-radius: 4px;
+  }
+</style>

package/templates/astro-starter/src/pages/[...slug].astro

@@ -0,0 +1,234 @@
+---
+// src/pages/[...slug].astro
+import Layout from "../layouts/Layout.astro";
+import BlockRenderer from "../components/blocks/BlockRenderer.astro";
+import Breadcrumb from "../components/global/Breadcrumb.astro";
+import { getNodeByPath, getChannelId, getTree, getTreeId } from "../lib/cms";
+import type { NodeResponse, TreeNode } from "../lib/cms";
+import { env } from "cloudflare:workers";
+
+export const prerender = false;
+
+const { slug } = Astro.params;
+
+Astro.response.headers.set(
+  "Cache-Control",
+  "no-store, no-cache, must-revalidate, proxy-revalidate",
+);
+
+// 1. STATIC ASSET CHECK
+const staticExts = [
+  ".ico",
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".svg",
+  ".txt",
+  ".xml",
+  ".webmanifest",
+];
+const slugStr = String(slug || "");
+const isStaticAsset =
+  !slugStr.includes("/") &&
+  staticExts.some(ext => slugStr.toLowerCase().endsWith(ext));
+
+if (isStaticAsset) {
+  return new Response(null, { status: 404 });
+}
+
+// 2. PATH RESOLUTION
+const rawSlug = Array.isArray(slug) ? slug.join("/") : slugStr;
+const pathParts = rawSlug.split("/").filter(part => part.trim() !== "");
+const pathToFetch = pathParts.length > 0 ? pathParts.join("/") : "home";
+
+// 3. ENV & WORKER RESOLUTION
+const locals = (Astro.locals as any) || {};
+// 🎯 SAFELY EXTRACT WORKER ENV USING THE CLOUDFLARE MODULE (Astro v6 / Adapter v12)
+const workerEnv = env || process.env || {};
+const cmsWorker = locals.cfContext?.env?.CMS_WORKER || workerEnv.CMS_WORKER;
+
+// 🎯 CRITICAL FIX: Flattened to single line to bypass Rolldown parser bug
+const envApiUrl = import.meta.env.PUBLIC_API_URL;
+const workerApiUrl = workerEnv.PUBLIC_API_URL;
+const baseApiUrl = String(envApiUrl || workerApiUrl || "http://localhost:8787");
+
+const cleanApiUrl = baseApiUrl.endsWith("/")
+  ? baseApiUrl.slice(0, -1)
+  : baseApiUrl;
+
+const customFetch = async (input: RequestInfo | URL, init?: RequestInit) => {
+  let urlStr = input instanceof URL ? input.toString() : String(input);
+  if (urlStr.startsWith("/")) urlStr = `${cleanApiUrl}${urlStr}`;
+
+  const urlObj = new URL(urlStr);
+  urlObj.searchParams.set("_t", Date.now().toString());
+  urlStr = urlObj.toString();
+
+  const req = new Request(urlStr, {
+    ...init,
+    cache: "no-store",
+    headers: {
+      ...init?.headers,
+      "X-Bypass-Cache": "true",
+      "Cache-Control": "no-cache, no-store, must-revalidate",
+    },
+  });
+
+  if (cmsWorker && typeof cmsWorker.fetch === "function") {
+    return cmsWorker.fetch(req);
+  }
+  return fetch(req);
+};
+
+const channelId = getChannelId();
+const treeId = getTreeId();
+
+let pageData: NodeResponse | null = null;
+let navTree: TreeNode[] = [];
+
+try {
+  const [fetchedPage, fetchedTree] = await Promise.all([
+    getNodeByPath(pathToFetch, channelId, false, customFetch),
+    getTree(treeId, channelId, customFetch),
+  ]);
+  pageData = fetchedPage;
+  navTree = fetchedTree;
+} catch (err) {
+  console.error(
+    `❌ [SSR Error] Failed to fetch data for path "${pathToFetch}":`,
+    err,
+  );
+}
+
+if (!pageData || !pageData.node) {
+  return new Response("Page Not Found", { status: 404 });
+}
+
+const node = pageData.node;
+const content = pageData.content || {};
+
+const isHomePage =
+  pathToFetch === "home" || node?.path === "/" || pathToFetch === "";
+const normalizedSlug = isHomePage ? "" : pathToFetch;
+
+const headerBlocks = content?.header || [];
+const mainBlocks = content?.content || [];
+const sidebarBlocks = content?.sidebar || [];
+const hasSidebar = sidebarBlocks.length > 0;
+---
+
+<Layout
+  node={node}
+  content={content}
+  normalizedSlug={normalizedSlug}
+  isHomePage={isHomePage}
+  hasSidebar={hasSidebar}
+  headerBlocks={headerBlocks}
+  tree={navTree}
+>
+  {
+    headerBlocks.length > 0 && (
+      <section class="region-header">
+        <BlockRenderer
+          blocks={headerBlocks}
+          contentMap={content}
+          region="header"
+        />
+      </section>
+    )
+  }
+
+  {
+    !isHomePage && (
+      <div class="breadcrumb-wrapper">
+        <Breadcrumb title={node?.title || "Page"} slug={normalizedSlug} />
+      </div>
+    )
+  }
+
+  <div class:list={["content-layout", { "has-sidebar": hasSidebar }]}>
+    <div class="main-column">
+      {
+        mainBlocks.length > 0 ? (
+          <section class="region-main">
+            <BlockRenderer
+              blocks={mainBlocks}
+              contentMap={content}
+              region="main"
+            />
+          </section>
+        ) : (
+          <div class="empty-content">
+            <p>{node?.summary || "No content available for this page."}</p>
+          </div>
+        )
+      }
+    </div>
+
+    {
+      hasSidebar && (
+        <aside class="sidebar-column">
+          <section class="region-sidebar">
+            <BlockRenderer
+              blocks={sidebarBlocks}
+              contentMap={content}
+              region="sidebar"
+            />
+          </section>
+        </aside>
+      )
+    }
+  </div>
+</Layout>
+
+<style>
+  .region-header {
+    margin-bottom: 24px;
+  }
+  .breadcrumb-wrapper {
+    margin-bottom: 24px;
+  }
+  .content-layout {
+    width: 100%;
+    display: block;
+  }
+  .main-column {
+    width: 100%;
+    min-width: 0;
+  }
+  @media (min-width: 768px) {
+    .content-layout.has-sidebar {
+      display: grid !important;
+      grid-template-columns: calc(100% - 360px) 310px !important;
+      column-gap: 48px !important;
+      align-items: start !important;
+    }
+    .main-column {
+      grid-column: 1 / 2 !important;
+    }
+    .sidebar-column {
+      grid-column: 2 / 3 !important;
+      position: sticky;
+      top: 32px;
+    }
+  }
+  .sidebar-column {
+    background: #f8fafc;
+    border: 1px solid #e2e8f0;
+    padding: 28px;
+    box-sizing: border-box;
+  }
+  @media (max-width: 767px) {
+    .sidebar-column {
+      margin-top: 40px;
+    }
+  }
+  .empty-content {
+    padding: 32px;
+    border: 1px dashed #cbd5e1;
+    background: #f8fafc;
+    color: #64748b;
+    font-size: 0.95rem;
+    text-align: center;
+  }
+</style>

package/templates/astro-starter/src/pages/media/[...path].ts

@@ -0,0 +1,113 @@
+// src/pages/media/[...path].ts
+import type { APIRoute } from "astro";
+import { env } from "cloudflare:workers";
+
+function getMimeType(filePath: string): string {
+    const ext = filePath.split(".").pop()?.toLowerCase();
+    switch (ext) {
+        case "jpg":
+        case "jpeg": return "image/jpeg";
+        case "png": return "image/png";
+        case "webp": return "image/webp";
+        case "avif": return "image/avif";
+        case "svg": return "image/svg+xml";
+        case "gif": return "image/gif";
+        case "pdf": return "application/pdf";
+        case "mp4": return "video/mp4";
+        case "webm": return "video/webm";
+        default: return "application/octet-stream";
+    }
+}
+
+export const GET: APIRoute = async ({ request, params, url }) => {
+    // 🎯 Detect if Astro is requesting a resized variant
+    const hasResizeParams = url.searchParams.has('w') || url.searchParams.has('h') || url.searchParams.has('q') || url.searchParams.has('f');
+
+    // 1. Cloudflare Edge Cache API
+    let edgeCache: Cache | null = null;
+    try {
+        if (typeof caches !== "undefined" && caches.default) {
+            edgeCache = caches.default;
+            const cachedResponse = await edgeCache.match(request);
+            if (cachedResponse) return cachedResponse;
+        }
+    } catch (err) {
+        console.warn("[Media Proxy] Edge cache match failed:", err);
+    }
+
+    const rawPath = params.path || "";
+    const cleanPath = rawPath.replace(/^\/+|\/+$/g, "");
+
+    // 2. Direct R2 Lookup (ONLY IF NO RESIZING PARAMS ARE PRESENT AND WE ARE IN PROD)
+    const mediaBucket = env.MEDIA_BUCKET;
+    if (mediaBucket && cleanPath && !hasResizeParams) {
+        try {
+            let r2Object = await mediaBucket.get(cleanPath);
+            if (!r2Object) r2Object = await mediaBucket.get(cleanPath.startsWith("media/") ? cleanPath.replace(/^media\//, "") : `media/${cleanPath}`);
+
+            if (r2Object) {
+                if (request.headers.get("if-none-match") === r2Object.httpEtag) {
+                    return new Response(null, { status: 304 });
+                }
+
+                const headers = new Headers();
+                r2Object.writeHttpMetadata(headers);
+                headers.set("etag", r2Object.httpEtag);
+                headers.set("Cache-Control", "public, max-age=31536000, immutable");
+                headers.set("Access-Control-Allow-Origin", "*");
+                if (!headers.get("content-type") || headers.get("content-type") === "application/octet-stream") {
+                    headers.set("content-type", getMimeType(cleanPath));
+                }
+
+                const r2Response = new Response(r2Object.body, { status: 200, headers });
+                if (edgeCache) c.executionCtx?.waitUntil(edgeCache.put(request, r2Response.clone()));
+                return r2Response;
+            }
+        } catch (r2Err) {
+            console.warn("[Media Proxy] R2 lookup error:", r2Err);
+        }
+    }
+
+    // 3. Forward to Backend (Handles Local Sharp Resizing AND Cloudflare Images Resizing)
+    try {
+        let backendResponse: Response;
+
+        // A. Production Mode (Cloudflare Service Binding)
+        if (env.CMS_WORKER) {
+            backendResponse = await env.CMS_WORKER.fetch(request);
+        }
+        // B. Local Dev Mode (Standard HTTP Fetch to local Hono Server)
+        else {
+            const cmsUrl = import.meta.env.PUBLIC_CMS_URL || 'http://localhost:8787';
+            const targetUrl = `${cmsUrl}${url.pathname}${url.search}`;
+
+            // Forward request headers (like Accept for WebP/AVIF negotiation)
+            backendResponse = await fetch(targetUrl, {
+                headers: {
+                    'Accept': request.headers.get('Accept') || 'image/webp,image/avif,image/*,*/*;q=0.8'
+                }
+            });
+        }
+
+        if (backendResponse.ok) {
+            const newHeaders = new Headers(backendResponse.headers);
+            newHeaders.set("Cache-Control", "public, max-age=31536000, immutable");
+            newHeaders.set("Access-Control-Allow-Origin", "*");
+
+            const proxyResponse = new Response(backendResponse.body, {
+                status: backendResponse.status,
+                statusText: backendResponse.statusText,
+                headers: newHeaders,
+            });
+
+            if (edgeCache) edgeCache.put(request, proxyResponse.clone());
+            return proxyResponse;
+        }
+
+        return backendResponse;
+    } catch (error) {
+        console.error("❌ Media Proxy Forwarding Error:", error);
+    }
+
+    return new Response("Not found", { status: 404 });
+};