reroute-js 0.25.2 → 0.26.0

package/elysia/index.js

@@ -1,5 +1,5 @@
 /**
- * reroute-js v0.25.2
+ * reroute-js v0.26.0
  *
  * @license MIT
  * @copyright 2025 stewones <hi@stewan.io>
@@ -193,6 +193,153 @@ var init_content = __esm(() => {
   init_metadata();
 });
 
+// packages/telemetry/src/server/instrumentation.ts
+import { context, SpanStatusCode, trace } from "@opentelemetry/api";
+function isOtelAvailable() {
+  if (otelAvailable !== undefined)
+    return otelAvailable;
+  try {
+    __require("@opentelemetry/api");
+    otelAvailable = true;
+    return true;
+  } catch {
+    otelAvailable = false;
+    return false;
+  }
+}
+
+class NoopSpan {
+  spanContext() {
+    return {
+      traceId: "",
+      spanId: "",
+      traceFlags: 0
+    };
+  }
+  setAttribute() {
+    return this;
+  }
+  setAttributes() {
+    return this;
+  }
+  addEvent() {
+    return this;
+  }
+  addLink() {
+    return this;
+  }
+  addLinks() {
+    return this;
+  }
+  setStatus() {
+    return this;
+  }
+  updateName() {
+    return this;
+  }
+  end() {}
+  isRecording() {
+    return false;
+  }
+  recordException() {}
+}
+async function withSpan(name, fn, attributes) {
+  if (!isOtelAvailable()) {
+    return fn(noopSpan);
+  }
+  const tracer = trace.getTracer("reroute");
+  return tracer.startActiveSpan(name, { attributes }, async (span) => {
+    try {
+      const result = await fn(span);
+      span.end();
+      return result;
+    } catch (error) {
+      span.recordException(error);
+      span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: error instanceof Error ? error.message : String(error)
+      });
+      span.end();
+      throw error;
+    }
+  });
+}
+function withSpanSync(name, fn, attributes) {
+  if (!isOtelAvailable()) {
+    return fn(noopSpan);
+  }
+  const tracer = trace.getTracer("reroute");
+  return tracer.startActiveSpan(name, { attributes }, (span) => {
+    try {
+      const result = fn(span);
+      span.end();
+      return result;
+    } catch (error) {
+      span.recordException(error);
+      span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: error instanceof Error ? error.message : String(error)
+      });
+      span.end();
+      throw error;
+    }
+  });
+}
+async function withParentSpan(parentSpan, fn) {
+  if (!(isOtelAvailable() && parentSpan)) {
+    return fn();
+  }
+  const ctx = trace.setSpan(context.active(), parentSpan);
+  return context.with(ctx, fn);
+}
+var otelAvailable, noopSpan;
+var init_instrumentation = __esm(() => {
+  noopSpan = new NoopSpan;
+});
+
+// packages/telemetry/src/server/plugin.ts
+import {
+  metrics,
+  SpanStatusCode as SpanStatusCode2,
+  trace as trace2
+} from "@opentelemetry/api";
+import { logs, SeverityNumber } from "@opentelemetry/api-logs";
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-proto";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-proto";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import {
+  BatchLogRecordProcessor,
+  LoggerProvider
+} from "@opentelemetry/sdk-logs";
+import {
+  MeterProvider,
+  PeriodicExportingMetricReader
+} from "@opentelemetry/sdk-metrics";
+import {
+  BatchSpanProcessor,
+  NodeTracerProvider
+} from "@opentelemetry/sdk-trace-node";
+import {
+  ATTR_SERVICE_NAME,
+  ATTR_SERVICE_VERSION
+} from "@opentelemetry/semantic-conventions";
+import { ATTR_HOST_NAME } from "@opentelemetry/semantic-conventions/incubating";
+var init_plugin = __esm(() => {
+  init_core();
+});
+
+// packages/telemetry/src/server/index.ts
+var init_server = __esm(() => {
+  init_instrumentation();
+  init_plugin();
+});
+
+// packages/telemetry/server.ts
+var init_server2 = __esm(() => {
+  init_server();
+});
+
 // packages/core/src/ssr/lib/cache.ts
 class SSRDataCache {
   cache = new Map;
@@ -2009,12 +2156,25 @@ function createSSRExportsScript(pathname) {
     return "";
   }
 }
-function createDataScript(ssrData, errorMsg, pathname) {
+function createTelemetryConfigScript(browserTelemetryConfig) {
+  if (!browserTelemetryConfig || Object.keys(browserTelemetryConfig).length === 0) {
+    return "";
+  }
+  try {
+    const configJson = escapeJsonForScript(JSON.stringify(browserTelemetryConfig));
+    return `<script>(function(){try{var w=(typeof window!=='undefined'?window:globalThis);w.__REROUTE_TELEMETRY_BROWSER__=${configJson};}catch(e){}})();</script>`;
+  } catch (error) {
+    console.error("[reroute] Failed to serialize browser telemetry config:", error);
+    return "";
+  }
+}
+function createDataScript(ssrData, errorMsg, pathname, browserTelemetryConfig) {
   let script = "";
   script += createContentCaptureScript();
   if (pathname) {
     script += createSSRExportsScript(pathname);
   }
+  script += createTelemetryConfigScript(browserTelemetryConfig);
   if (ssrData && Object.keys(ssrData).length > 0) {
     try {
       const duplicatedData = duplicateQueryParamData(ssrData);
@@ -2115,7 +2275,7 @@ async function performSSRSetup(options, streaming = false) {
   });
   try {
     return await Promise.race([
-      performSSRSetupInternal(options, streaming),
+      withParentSpan(options.parentSpan, () => performSSRSetupInternal(options, streaming)),
       timeoutPromise
     ]);
   } catch (error) {
@@ -2146,34 +2306,70 @@ async function performSSRSetupInternal(options, streaming) {
     searchParams,
     ogConfig
   } = options;
-  await seedSSRModuleForPath(pathname, clientDir, cwd, isWatchMode);
-  if (debug)
-    console.log(`[Setup] ${pathname} - seedModule: ${(performance.now() - t0).toFixed(2)}ms`);
+  await withSpan("ssr.seed", async (span) => {
+    span.setAttribute("pathname", pathname);
+    span.setAttribute("streaming", streaming);
+    await seedSSRModuleForPath(pathname, clientDir, cwd, isWatchMode);
+    if (debug)
+      console.log(`[Setup] ${pathname} - seedModule: ${(performance.now() - t0).toFixed(2)}ms`);
+  });
   resetSSRAccessTracking();
   const bundlePreload = createBundlePreload(bundleUrl);
-  const preloadResult = await preloadContentModule(pathname, clientDir, cwd, isWatchMode);
-  if (debug)
-    console.log(`[Setup] ${pathname} - preloadContent: ${(performance.now() - t0).toFixed(2)}ms`);
-  const computeResult = await computeSSRData(pathname, clientDir, cwd, isWatchMode, { streaming, maxAge }, searchParams);
-  if (debug)
-    console.log(`[Setup] ${pathname} - computeSSRData: ${(performance.now() - t0).toFixed(2)}ms`);
+  const preloadResult = await withSpan("ssr.preload", async (span) => {
+    span.setAttribute("pathname", pathname);
+    const result = await preloadContentModule(pathname, clientDir, cwd, isWatchMode);
+    span.setAttribute("has_module", !!result.modulePath);
+    if (debug)
+      console.log(`[Setup] ${pathname} - preloadContent: ${(performance.now() - t0).toFixed(2)}ms`);
+    return result;
+  });
+  const computeResult = await withSpan("ssr.compute.data", async (span) => {
+    span.setAttribute("pathname", pathname);
+    span.setAttribute("streaming", streaming);
+    const result = await computeSSRData(pathname, clientDir, cwd, isWatchMode, { streaming, maxAge }, searchParams);
+    span.setAttribute("has_error", !!result.error);
+    span.setAttribute("has_data", Object.keys(result.data).length > 0);
+    if (debug)
+      console.log(`[Setup] ${pathname} - computeSSRData: ${(performance.now() - t0).toFixed(2)}ms`);
+    return result;
+  });
   setGlobalSSRData(computeResult.data);
   const usingCachedCollections = !!options.cachedCollections;
-  const byCollectionForSSR = options.cachedCollections ? options.cachedCollections : await loadCollections(cwd, isWatchMode);
-  if (debug)
-    console.log(`[Setup] ${pathname} - loadCollections (cached: ${usingCachedCollections}): ${(performance.now() - t0).toFixed(2)}ms`);
+  const byCollectionForSSR = await withSpan("ssr.load.collections", async (span) => {
+    span.setAttribute("pathname", pathname);
+    span.setAttribute("cached", usingCachedCollections);
+    const collections = options.cachedCollections ? options.cachedCollections : await loadCollections(cwd, isWatchMode);
+    span.setAttribute("collection_count", Object.keys(collections).length);
+    if (debug)
+      console.log(`[Setup] ${pathname} - loadCollections (cached: ${usingCachedCollections}): ${(performance.now() - t0).toFixed(2)}ms`);
+    return collections;
+  });
   setGlobalCollections(byCollectionForSSR);
   const usingCachedCSS = !!options.cachedTailwindCSS;
-  const inlineStyleTag = options.cachedTailwindCSS ? options.cachedTailwindCSS : await inlineTailwindCSS(clientDir, !streaming, isWatchMode);
-  if (debug)
-    console.log(`[Setup] ${pathname} - inlineTailwindCSS (cached: ${usingCachedCSS}): ${(performance.now() - t0).toFixed(2)}ms`);
+  const inlineStyleTag = await withSpan("ssr.inline.css", async (span) => {
+    const css = options.cachedTailwindCSS ? options.cachedTailwindCSS : await inlineTailwindCSS(clientDir, !streaming, isWatchMode);
+    span.setAttributes({
+      "reroute.cached": usingCachedCSS,
+      "reroute.css.size": css.length
+    });
+    if (debug)
+      console.log(`[Setup] ${pathname} - inlineTailwindCSS (cached: ${usingCachedCSS}): ${(performance.now() - t0).toFixed(2)}ms`);
+    return css;
+  });
   let statusOverride = preloadResult.statusOverride;
   if (computeResult.statusContainer.value) {
     statusOverride = computeResult.statusContainer.value;
   }
-  const metadataResult = await extractPageMetadata(pathname, clientDir, cwd, isWatchMode, statusOverride, ogConfig);
-  if (debug)
-    console.log(`[Setup] ${pathname} - extractMetadata: ${(performance.now() - t0).toFixed(2)}ms`);
+  const metadataResult = await withSpan("ssr.extract.metadata", async (span) => {
+    const result = await extractPageMetadata(pathname, clientDir, cwd, isWatchMode, statusOverride, ogConfig);
+    span.setAttributes({
+      "reroute.pathname": pathname,
+      "reroute.metadata.exists": !!result.perPageHead
+    });
+    if (debug)
+      console.log(`[Setup] ${pathname} - extractMetadata: ${(performance.now() - t0).toFixed(2)}ms`);
+    return result;
+  });
   return {
     ssrData: computeResult.data,
     ssrError: computeResult.error,
@@ -2201,10 +2397,10 @@ function generateCollectionScripts(byCollectionForSSR) {
   } catch {}
   return "";
 }
-function generateHydrationScripts(ssrData, isWatchMode, ssrError, collectionScripts = "", preloadScript = "", bundleUrl = "", pathname = "") {
+function generateHydrationScripts(ssrData, isWatchMode, ssrError, collectionScripts = "", preloadScript = "", bundleUrl = "", pathname = "", browserTelemetryConfig) {
   let scripts = preloadScript;
   scripts += collectionScripts;
-  scripts += createDataScript(ssrData, isWatchMode ? ssrError : undefined, pathname);
+  scripts += createDataScript(ssrData, isWatchMode ? ssrError : undefined, pathname, browserTelemetryConfig);
   scripts += createFeedsScript();
   scripts += createLlmsScript();
   if (bundleUrl) {
@@ -2216,6 +2412,7 @@ function generateHydrationScripts(ssrData, isWatchMode, ssrError, collectionScri
   return scripts;
 }
 var init_setup = __esm(() => {
+  init_server2();
   init_collections();
   init_compute();
   init_metadata2();
@@ -2284,6 +2481,7 @@ async function renderSSRDocument(options) {
     clientDir,
     cwd,
     isWatchMode,
+    parentSpan: options.parentSpan,
     bundleUrl,
     maxAge,
     searchParams,
@@ -2293,14 +2491,29 @@ async function renderSSRDocument(options) {
   }, false);
   const duplicatedData = duplicateQueryParamData(setup2.ssrData);
   setGlobalSSRData(duplicatedData);
-  const componentWithPathname = cloneElement(rootComponent, {
-    pathname,
-    searchParams
+  const appHtml = await withSpan("ssr.render.react", async (span) => {
+    const componentWithPathname = cloneElement(rootComponent, {
+      pathname,
+      searchParams
+    });
+    span.setAttribute("reroute.pathname", pathname);
+    const html3 = renderToString(componentWithPathname);
+    span.setAttribute("reroute.html.final.size", html3.length);
+    return html3;
+  });
+  const baseTemplate = await withSpan("ssr.load.template", async (span) => {
+    const template2 = await loadIndexHtml(clientDir);
+    span.setAttribute("reroute.template.size", template2.length);
+    return template2;
   });
-  const appHtml = renderToString(componentWithPathname);
-  const baseTemplate = await loadIndexHtml(clientDir);
   const collectionScripts = generateCollectionScripts(setup2.byCollectionForSSR);
-  const hydrationScript = generateHydrationScripts(setup2.ssrData, isWatchMode, setup2.ssrError, collectionScripts, setup2.preloadHydrationScript, bundleUrl, pathname);
+  const config = await loadConfig(cwd);
+  const browserTelemetryConfig = config.telemetry?.browser;
+  const hydrationScript = await withSpan("ssr.generate.scripts", async (span) => {
+    const script = generateHydrationScripts(setup2.ssrData, isWatchMode, setup2.ssrError, collectionScripts, setup2.preloadHydrationScript, bundleUrl, pathname, browserTelemetryConfig);
+    span.setAttribute("reroute.scripts.size", script.length);
+    return script;
+  });
   let statusOverride = setup2.preloadStatusOverride;
   if (setup2.statusContainer.value) {
     statusOverride = setup2.statusContainer.value;
@@ -2315,12 +2528,19 @@ async function renderSSRDocument(options) {
     dedent(setup2.metadataResult.perPageHead)
   ].filter(Boolean).join(`
 `));
-  const html2 = applyIndexTemplate(baseTemplate, appHtml, {
-    head: [setup2.inlineStyleTag, combinedHead].filter(Boolean).join(`
+  const html2 = withSpanSync("ssr.apply.template", (span) => {
+    const result = applyIndexTemplate(baseTemplate, appHtml, {
+      head: [setup2.inlineStyleTag, combinedHead].filter(Boolean).join(`
 `),
-    hydrationScript,
-    lang: setup2.metadataResult.pageLang || lang,
-    appId
+      hydrationScript,
+      lang: setup2.metadataResult.pageLang || lang,
+      appId
+    });
+    span.setAttributes({
+      "reroute.html.final.size": result.length,
+      "reroute.html.original.size": appHtml.length
+    });
+    return result;
   });
   return {
     html: html2,
@@ -2328,6 +2548,8 @@ async function renderSSRDocument(options) {
   };
 }
 var init_render = __esm(() => {
+  init_server2();
+  init_config();
   init_lib();
   init_html();
 });
@@ -4255,6 +4477,7 @@ async function renderSSRDocumentStream(options) {
     clientDir,
     cwd,
     isWatchMode,
+    parentSpan: options.parentSpan,
     bundleUrl,
     maxAge,
     searchParams,
@@ -4276,14 +4499,19 @@ async function renderSSRDocumentStream(options) {
   const { readable, writable } = new TransformStream;
   const writer = writable.getWriter();
   const usingCache = !!options.cachedIndexHtml;
-  const tBeforeLoad = debug ? performance.now() : 0;
-  const baseTemplate = options.cachedIndexHtml ? options.cachedIndexHtml : await loadIndexHtml(clientDir);
-  if (debug)
-    console.log(`[renderStream] ${pathname} - loadIndexHtml (cached: ${usingCache}): ${(performance.now() - t0).toFixed(2)}ms (actual load: ${(performance.now() - tBeforeLoad).toFixed(2)}ms)`);
-  const tBeforeSplit = debug ? performance.now() : 0;
-  const { htmlHead, rootStart, rootEnd, htmlTail } = splitTemplate(baseTemplate, appId);
-  if (debug)
-    console.log(`[renderStream] ${pathname} - splitTemplate: ${(performance.now() - t0).toFixed(2)}ms (split took: ${(performance.now() - tBeforeSplit).toFixed(2)}ms)`);
+  const { htmlHead, rootStart, rootEnd, htmlTail } = await withSpan("ssr.load.template", async (span) => {
+    const template2 = options.cachedIndexHtml ? options.cachedIndexHtml : await loadIndexHtml(clientDir);
+    span.setAttribute("reroute.cached", usingCache);
+    span.setAttribute("reroute.template.size", template2.length);
+    if (debug)
+      console.log(`[renderStream] ${pathname} - loadIndexHtml (cached: ${usingCache}): ${(performance.now() - t0).toFixed(2)}ms`);
+    const parts = splitTemplate(template2, appId);
+    if (debug)
+      console.log(`[renderStream] ${pathname} - splitTemplate: ${(performance.now() - t0).toFixed(2)}ms`);
+    return {
+      ...parts
+    };
+  });
   const pageLang = setup2.metadataResult.pageLang || lang;
   let headWithLang = htmlHead.replace(/<html([^>]*)>/i, `<html$1 lang="${pageLang}">`);
   const extraHead = setup2.bundlePreload + setup2.preloadExtraHead + setup2.metadataResult.perPageHead;
@@ -4293,6 +4521,8 @@ async function renderSSRDocumentStream(options) {
   if (/<meta\s+name\s*=\s*['"]description['"][^>]*>/i.test(extraHead)) {
     headWithLang = headWithLang.replace(/<meta\s+name\s*=\s*['"]description['"][^>]*>/i, "");
   }
+  const config = await loadConfig(cwd);
+  const browserTelemetryConfig = config.telemetry?.browser;
   streamSSRContent(writer, encoder, {
     rootComponent,
     pathname,
@@ -4311,82 +4541,102 @@ async function renderSSRDocumentStream(options) {
     ssrData: setup2.ssrData,
     ssrError: setup2.ssrError,
     byCollectionForSSR: setup2.byCollectionForSSR,
-    preloadHydrationScript: setup2.preloadHydrationScript
+    preloadHydrationScript: setup2.preloadHydrationScript,
+    browserTelemetryConfig,
+    parentSpan: options.parentSpan
   });
   if (debug)
     console.log(`[renderStream] ${pathname} - returning stream: ${(performance.now() - t0).toFixed(2)}ms`);
   return { stream: readable, status: statusOverride || 200 };
 }
 async function streamSSRContent(writer, encoder, ctx) {
-  const t0 = ctx.debug ? performance.now() : 0;
-  const STREAM_TIMEOUT_MS = 60000;
-  let streamTimedOut = false;
-  let timeoutId = null;
-  const cleanup = () => {
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-      timeoutId = null;
-    }
-  };
-  try {
-    const combinedHead = deduplicateMetaTags([ctx.inlineStyleTag, ctx.head, ctx.extraHead].filter(Boolean).join(`
+  return withParentSpan(ctx.parentSpan, async () => {
+    const t0 = ctx.debug ? performance.now() : 0;
+    const STREAM_TIMEOUT_MS = 60000;
+    let streamTimedOut = false;
+    let timeoutId = null;
+    const cleanup = () => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+    };
+    try {
+      const combinedHead = deduplicateMetaTags([ctx.inlineStyleTag, ctx.head, ctx.extraHead].filter(Boolean).join(`
 `));
-    const headWithLangAndContent = ctx.headWithLang.replace(/<html([^>]*)>/i, `<html$1 lang="${ctx.pageLang}">`).replace(/<\/head>/i, `${combinedHead ? `${combinedHead}
+      const headWithLangAndContent = ctx.headWithLang.replace(/<html([^>]*)>/i, `<html$1 lang="${ctx.pageLang}">`).replace(/<\/head>/i, `${combinedHead ? `${combinedHead}
 ` : ""}</head>`);
-    const headContent = `${headWithLangAndContent}<body>`;
-    await writer.write(encoder.encode(headContent));
-    if (ctx.debug)
-      console.log(`[Stream] ${ctx.pathname} - first byte written: ${(performance.now() - t0).toFixed(2)}ms`);
-    await writer.write(encoder.encode(ctx.rootStart));
-    const componentWithPathname = cloneElement2(ctx.rootComponent, {
-      pathname: ctx.pathname,
-      searchParams: ctx.searchParams
-    });
-    let streamError = null;
-    const streamPromise = renderToReadableStream(componentWithPathname, {
-      onError(error) {
-        console.error("[reroute] SSR stream error:", error);
-        streamError = error instanceof Error ? error : new Error(String(error));
-      }
-    }).catch((err) => {
-      streamError = err;
-      throw err;
-    });
-    const reactStream = await streamPromise;
-    if (streamError)
-      throw streamError;
-    const streamTimeoutPromise = new Promise((resolve) => {
-      timeoutId = setTimeout(() => {
-        console.warn(`[reroute] Stream timeout after ${STREAM_TIMEOUT_MS}ms for ${ctx.pathname}, forcing close`);
-        streamTimedOut = true;
-        resolve({ done: true, value: undefined });
-      }, STREAM_TIMEOUT_MS);
-    });
-    const reader = reactStream.getReader();
-    while (true) {
-      const result = await Promise.race([reader.read(), streamTimeoutPromise]);
-      if (result.done || streamTimedOut) {
-        try {
-          reader.releaseLock();
-        } catch {}
-        break;
-      }
-      if (result.value) {
-        await writer.write(result.value);
-      }
+      const headContent = `${headWithLangAndContent}<body>`;
+      await writer.write(encoder.encode(headContent));
+      if (ctx.debug)
+        console.log(`[Stream] ${ctx.pathname} - first byte written: ${(performance.now() - t0).toFixed(2)}ms`);
+      await writer.write(encoder.encode(ctx.rootStart));
+      await withSpan("ssr.document.stream", async (span) => {
+        const componentWithPathname = cloneElement2(ctx.rootComponent, {
+          pathname: ctx.pathname,
+          searchParams: ctx.searchParams
+        });
+        span.setAttribute("reroute.pathname", ctx.pathname);
+        let streamError = null;
+        const streamPromise = renderToReadableStream(componentWithPathname, {
+          onError(error) {
+            console.error("[reroute] SSR stream error:", error);
+            streamError = error instanceof Error ? error : new Error(String(error));
+          }
+        }).catch((err) => {
+          streamError = err;
+          throw err;
+        });
+        const reactStream = await streamPromise;
+        if (streamError)
+          throw streamError;
+        const streamTimeoutPromise = new Promise((resolve) => {
+          timeoutId = setTimeout(() => {
+            console.warn(`[reroute] Stream timeout after ${STREAM_TIMEOUT_MS}ms for ${ctx.pathname}, forcing close`);
+            streamTimedOut = true;
+            resolve({ done: true, value: undefined });
+          }, STREAM_TIMEOUT_MS);
+        });
+        const reader = reactStream.getReader();
+        let chunkCount = 0;
+        while (true) {
+          const result = await Promise.race([
+            reader.read(),
+            streamTimeoutPromise
+          ]);
+          if (result.done || streamTimedOut) {
+            try {
+              reader.releaseLock();
+            } catch {}
+            break;
+          }
+          if (result.value) {
+            await writer.write(result.value);
+            chunkCount++;
+          }
+        }
+        cleanup();
+        span.setAttributes({
+          "reroute.stream.chunks": chunkCount,
+          "reroute.stream.timedOut": streamTimedOut
+        });
+      });
+      await writer.write(encoder.encode(ctx.rootEnd));
+      const allScripts = await withSpan("ssr.generate.scripts", async (span) => {
+        const scripts2 = buildStreamingScripts(ctx);
+        span.setAttribute("reroute.script_size", scripts2.length);
+        return scripts2;
+      });
+      await writer.write(encoder.encode(allScripts + ctx.htmlTail));
+      await writer.close();
+    } catch (error) {
+      cleanup();
+      console.error("[reroute] Stream error:", error);
+      try {
+        await writer.abort(error);
+      } catch {}
     }
-    cleanup();
-    await writer.write(encoder.encode(ctx.rootEnd));
-    const allScripts = buildStreamingScripts(ctx);
-    await writer.write(encoder.encode(allScripts + ctx.htmlTail));
-    await writer.close();
-  } catch (error) {
-    cleanup();
-    console.error("[reroute] Stream error:", error);
-    try {
-      await writer.abort(error);
-    } catch {}
-  }
+  });
 }
 function buildStreamingScripts(ctx) {
   const collectionScripts = generateCollectionScripts(ctx.byCollectionForSSR);
@@ -4397,7 +4647,7 @@ function buildStreamingScripts(ctx) {
       ssrDataSnapshot[key] = value;
     }
   }
-  const dataScript = createDataScript(ssrDataSnapshot, ctx.isWatchMode ? ctx.ssrError : undefined, ctx.pathname);
+  const dataScript = createDataScript(ssrDataSnapshot, ctx.isWatchMode ? ctx.ssrError : undefined, ctx.pathname, ctx.browserTelemetryConfig);
   const feedsScript = createFeedsScript();
   const llmsScript = createLlmsScript();
   let allScripts = dataScript + feedsScript + llmsScript + collectionScripts + ctx.preloadHydrationScript;
@@ -4408,6 +4658,8 @@ function buildStreamingScripts(ctx) {
   return allScripts;
 }
 var init_stream = __esm(() => {
+  init_server2();
+  init_config();
   init_lib();
   init_html();
   init_imports();
@@ -4955,12 +5207,19 @@ function registerArtifactsRoutes(app, cwd, fileCache, options) {
 
 // packages/elysia/src/routes/content.ts
 init_core();
+import { trace as trace3 } from "@opentelemetry/api";
 import { NotFoundError as NotFoundError3 } from "elysia";
-function getOtelUtilities() {
+var otelAvailable2;
+function isOtelAvailable2() {
+  if (otelAvailable2 !== undefined)
+    return otelAvailable2;
   try {
-    return __require("@elysiajs/opentelemetry");
+    __require("@opentelemetry/api");
+    otelAvailable2 = true;
+    return true;
   } catch {
-    return null;
+    otelAvailable2 = false;
+    return false;
   }
 }
 function registerContentRoutes(app, cwd, collectionCache, directive, maxAge, isWatchMode) {
@@ -4971,14 +5230,13 @@ function registerContentRoutes(app, cwd, collectionCache, directive, maxAge, isW
     const cacheKey = `content:${collectionPath}`;
     const cached = collectionCache.get(cacheKey);
     if (cached) {
-      const otel = getOtelUtilities();
-      const currentSpan = otel?.getCurrentSpan();
-      currentSpan?.setAttributes({
-        "http.request.method": "GET",
-        "http.response.status_code": 200,
-        "reroute.content.cache_hit": true,
-        "reroute.content.collection": collectionPath
-      });
+      if (isOtelAvailable2()) {
+        const currentSpan = trace3.getActiveSpan();
+        currentSpan?.setAttributes({
+          "reroute.cache.hit": true,
+          "reroute.collection": collectionPath
+        });
+      }
       const response = cached.clone();
       response.headers.set("Reroute-Cache", "HIT");
       return response;
@@ -4987,14 +5245,10 @@ function registerContentRoutes(app, cwd, collectionCache, directive, maxAge, isW
       const collectionFile = join(cwd, ".reroute", "collections", `${collectionPath}.js`);
       const file = Bun.file(collectionFile);
       if (!await file.exists()) {
-        const otel2 = getOtelUtilities();
-        const currentSpan2 = otel2?.getCurrentSpan();
-        currentSpan2?.setAttributes({
-          "http.request.method": "GET",
-          "http.response.status_code": 404,
-          "reroute.content.not_found": true,
-          "reroute.content.collection": collectionPath
-        });
+        if (isOtelAvailable2()) {
+          const currentSpan = trace3.getActiveSpan();
+          currentSpan?.setAttribute("reroute.collection", collectionPath);
+        }
         throw new NotFoundError3;
       }
       const url = `${Bun.pathToFileURL(collectionFile).href}${isWatchMode ? `?t=${Date.now()}` : ""}`;
@@ -5010,29 +5264,23 @@ function registerContentRoutes(app, cwd, collectionCache, directive, maxAge, isW
         }
       });
       collectionCache.set(cacheKey, response);
-      const otel = getOtelUtilities();
-      const currentSpan = otel?.getCurrentSpan();
-      currentSpan?.setAttributes({
-        "http.request.method": "GET",
-        "http.response.status_code": 200,
-        "reroute.content.served": true,
-        "reroute.content.collection": collectionPath,
-        "reroute.content.items_count": items.length,
-        "reroute.content.cache_hit": false
-      });
+      if (isOtelAvailable2()) {
+        const currentSpan = trace3.getActiveSpan();
+        currentSpan?.setAttributes({
+          "reroute.collection": collectionPath,
+          "reroute.collection.docs": items.length,
+          "reroute.cache.hit": false
+        });
+      }
       return response.clone();
     } catch (e) {
       if (e instanceof NotFoundError3)
         throw e;
       console.error(`[reroute] Failed to serve collection ${collectionPath}:`, e);
-      const otel = getOtelUtilities();
-      const currentSpan = otel?.getCurrentSpan();
-      currentSpan?.setAttributes({
-        "http.request.method": "GET",
-        "http.response.status_code": 500,
-        "reroute.content.error": true,
-        "reroute.content.collection": collectionPath
-      });
+      if (isOtelAvailable2()) {
+        const currentSpan = trace3.getActiveSpan();
+        currentSpan?.setAttribute("reroute.collection", collectionPath);
+      }
       throw new NotFoundError3;
     }
   });
@@ -6681,7 +6929,9 @@ function registerSitemapRoutes(app, options) {
 
 // packages/elysia/src/routes/ssr.ts
 init_core();
+init_server2();
 import { join as join4 } from "node:path";
+import { trace as trace4 } from "@opentelemetry/api";
 import { NotFoundError as NotFoundError11 } from "elysia";
 if (typeof process !== "undefined") {
   process.on("unhandledRejection", (reason, _promise) => {
@@ -6691,16 +6941,17 @@ if (typeof process !== "undefined") {
     console.error("[reroute] Uncaught Exception:", error);
   });
 }
-var cachedOtelUtilities;
-function getOtelUtilities2() {
-  if (cachedOtelUtilities !== undefined)
-    return cachedOtelUtilities;
+var otelAvailable3;
+function isOtelAvailable3() {
+  if (otelAvailable3 !== undefined)
+    return otelAvailable3;
   try {
-    cachedOtelUtilities = __require("@elysiajs/opentelemetry");
-    return cachedOtelUtilities;
+    __require("@opentelemetry/api");
+    otelAvailable3 = true;
+    return true;
   } catch {
-    cachedOtelUtilities = null;
-    return null;
+    otelAvailable3 = false;
+    return false;
   }
 }
 function registerSSRRoutes(app, options) {
@@ -6742,7 +6993,8 @@ function registerSSRRoutes(app, options) {
   }
   const handleSSR = async ({
     request,
-    set
+    set,
+    store
   }) => {
     const t0 = performance.now();
     const method = request.method || "GET";
@@ -6757,62 +7009,71 @@ function registerSSRRoutes(app, options) {
     const fullPath = pathname;
     const searchParams = url.searchParams;
     const acceptEncoding = request.headers.get("accept-encoding") || "";
-    if (!isWatchMode && SSR_HTML_TTL_MS > 0) {
-      try {
-        const ck = makeKey(pathname, acceptEncoding);
-        const cached = htmlCache.get(ck);
-        if (cached && cached.exp > Date.now()) {
-          const otel = getOtelUtilities2();
-          const currentSpan = otel?.getCurrentSpan();
-          currentSpan?.setAttributes({
-            "reroute.cache.hit": true,
-            "reroute.cache.key": ck,
-            "reroute.pathname": pathname,
-            "http.request.method": method,
-            "http.response.status_code": cached.status
-          });
-          set.status = cached.status;
-          Object.assign(set.headers, cached.headers);
-          set.headers["Reroute-Cache"] = "HIT";
-          return new Response(cached.body);
-        }
-      } catch {}
-    }
-    const tBeforeBundle = debug ? performance.now() : 0;
-    const bundleUrl = await getBundleUrl();
-    if (debug)
-      console.log(`[SSR] ${pathname} - bundleUrl: ${(performance.now() - t0).toFixed(2)}ms (actual call: ${(performance.now() - tBeforeBundle).toFixed(2)}ms)`);
-    const cachedCollections = await getCollections();
-    const cachedTailwindCSS = await getTailwindCSS();
-    const cachedIndexHtml = await getIndexHtml();
-    if (debug)
-      console.log(`[SSR] ${pathname} - cached setup: ${(performance.now() - t0).toFixed(2)}ms`);
-    try {
-      const linkValue = `<${bundleUrl}>; rel=modulepreload; as=script`;
+    const parentSpan = store.telemetrySpan;
+    return withParentSpan(parentSpan, async () => {
+      if (!isWatchMode && SSR_HTML_TTL_MS > 0) {
+        try {
+          const ck = makeKey(pathname, acceptEncoding);
+          const cached = htmlCache.get(ck);
+          if (cached && cached.exp > Date.now()) {
+            if (isOtelAvailable3()) {
+              const currentSpan = trace4.getActiveSpan();
+              currentSpan?.setAttributes({
+                "reroute.cache.hit": true,
+                "reroute.cache.key": ck,
+                "reroute.pathname": pathname
+              });
+            }
+            set.status = cached.status;
+            Object.assign(set.headers, cached.headers);
+            set.headers["Reroute-Cache"] = "HIT";
+            return new Response(cached.body);
+          }
+        } catch {}
+      }
+      const bundleUrl = await withSpan("ssr.get.bundle", async (span) => {
+        span.setAttribute("reroute.pathname", pathname);
+        const url2 = await getBundleUrl();
+        if (debug)
+          console.log(`[SSR] ${pathname} - bundleUrl: ${(performance.now() - t0).toFixed(2)}ms`);
+        return url2;
+      });
+      const { cachedCollections, cachedTailwindCSS, cachedIndexHtml } = await withSpan("ssr.load.cache", async (span) => {
+        const collections2 = await getCollections();
+        const tailwindCSS = await getTailwindCSS();
+        const indexHtml = await getIndexHtml();
+        span.setAttributes({
+          "reroute.pathname": pathname,
+          "reroute.collections.exists": !!collections2,
+          "reroute.collections.count": Object.keys(collections2).length
+        });
+        if (debug)
+          console.log(`[SSR] ${pathname} - cached setup: ${(performance.now() - t0).toFixed(2)}ms`);
+        return {
+          cachedCollections: collections2,
+          cachedTailwindCSS: tailwindCSS,
+          cachedIndexHtml: indexHtml
+        };
+      });
       try {
-        const hints = new Headers({ Link: linkValue });
-        request?.sendEarlyHints?.(hints);
+        const linkValue = `<${bundleUrl}>; rel=modulepreload; as=script`;
+        try {
+          const hints = new Headers({ Link: linkValue });
+          request?.sendEarlyHints?.(hints);
+        } catch {}
+        set.headers.link = set.headers.link ? `${set.headers.link}, ${linkValue}` : linkValue;
       } catch {}
-      set.headers.link = set.headers.link ? `${set.headers.link}, ${linkValue}` : linkValue;
-    } catch {}
-    const cacheControlHeader = isWatchMode ? "no-cache, no-store, must-revalidate" : `${directive}, max-age=${maxAge}`;
-    let response;
-    if (streamingEnabled) {
-      let stream2;
-      let status;
-      if (debug)
-        console.log(`[SSR] ${pathname} - starting stream: ${(performance.now() - t0).toFixed(2)}ms`);
-      try {
-        const otel = getOtelUtilities2();
-        const renderFn = async () => {
-          otel?.setAttributes({
-            "http.request.method": "GET",
-            "reroute.ssr.enabled": true,
-            "reroute.ssr.streaming": true,
-            "reroute.cache.hit": false,
-            "reroute.pathname": pathname
+      const cacheControlHeader = isWatchMode ? "no-cache, no-store, must-revalidate" : `${directive}, max-age=${maxAge}`;
+      let response;
+      if (streamingEnabled) {
+        if (debug)
+          console.log(`[SSR] ${pathname} - starting stream: ${(performance.now() - t0).toFixed(2)}ms`);
+        const { stream: stream2, status } = await withSpan("ssr.document.render", async (renderSpan) => {
+          renderSpan?.setAttributes({
+            "reroute.pathname": pathname,
+            "reroute.cache.hit": false
           });
-          const result2 = await renderSSRDocumentStream({
+          const result = await renderSSRDocumentStream({
             pathname: fullPath,
             rootComponent,
             clientDir,
@@ -6828,25 +7089,191 @@ function registerSSRRoutes(app, options) {
             appId,
             maxAge,
             searchParams,
-            ogConfig: options.ogConfig
+            ogConfig: options.ogConfig,
+            parentSpan: renderSpan
           });
-          otel?.setAttributes({
-            "http.response.status_code": result2.status
-          });
-          return result2;
-        };
-        const tBeforeRecord = debug ? performance.now() : 0;
-        const result = otel ? await otel.record("reroute.ssr.render_stream", renderFn) : await renderFn();
-        if (debug)
-          console.log(`[SSR] ${pathname} - otel.record completed: ${(performance.now() - t0).toFixed(2)}ms (record overhead: ${(performance.now() - tBeforeRecord - (performance.now() - t0)).toFixed(2)}ms)`);
-        const tBeforeExtract = debug ? performance.now() : 0;
-        stream2 = result.stream;
-        status = result.status;
+          renderSpan?.setAttribute("http.response.status_code", result.status);
+          if (debug)
+            console.log(`[SSR] ${pathname} - render completed: ${(performance.now() - t0).toFixed(2)}ms`);
+          return result;
+        });
         if (debug)
-          console.log(`[SSR] ${pathname} - stream extracted from result: ${(performance.now() - t0).toFixed(2)}ms (extract: ${(performance.now() - tBeforeExtract).toFixed(2)}ms)`);
-      } catch (ssrError) {
-        console.error("[reroute] SSR streaming failed, returning error page:", ssrError);
-        const errorHtml = `<!DOCTYPE html>
+          console.log(`[SSR] ${pathname} - before compression check: ${(performance.now() - t0).toFixed(2)}ms, compression=${compression2}, acceptEncoding=${!!acceptEncoding}`);
+        if (compression2 && acceptEncoding) {
+          const fullHtml = await withSpan("ssr.buffer.stream", async (span) => {
+            const chunks = [];
+            const reader = stream2.getReader();
+            try {
+              while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                  break;
+                chunks.push(new Uint8Array(value));
+              }
+            } finally {
+              reader.releaseLock();
+            }
+            const totalLength = chunks.reduce((sum, c) => sum + c.length, 0);
+            const buffer = new Uint8Array(totalLength);
+            let offset = 0;
+            for (const chunk of chunks) {
+              buffer.set(chunk, offset);
+              offset += chunk.length;
+            }
+            span.setAttributes({
+              "reroute.stream.chunks": chunks.length,
+              "reroute.stream.bytes": totalLength
+            });
+            return buffer;
+          });
+          const { body, extraHeaders } = await withSpan("ssr.compress", async (span) => {
+            const result = gzipIfAccepted(fullHtml, "text/html; charset=utf-8", acceptEncoding);
+            span.setAttributes({
+              "reroute.size.original": fullHtml.length,
+              "reroute.size.compressed": result.body.length,
+              "reroute.encoding": extraHeaders["Content-Encoding"] || "none"
+            });
+            return result;
+          });
+          if (!isWatchMode && SSR_HTML_TTL_MS > 0 && status === 200) {
+            try {
+              const ck = makeKey(pathname, acceptEncoding);
+              const cacheHeaders = {
+                "Content-Type": "text/html; charset=utf-8",
+                "Cache-Control": cacheControlHeader,
+                ...extraHeaders
+              };
+              if (set.headers.link) {
+                cacheHeaders.Link = set.headers.link;
+              }
+              htmlCache.set(ck, {
+                status,
+                headers: cacheHeaders,
+                body,
+                exp: Date.now() + SSR_HTML_TTL_MS
+              });
+            } catch {}
+          }
+          const resHeaders = {
+            "Content-Type": "text/html; charset=utf-8",
+            "Cache-Control": cacheControlHeader,
+            "Reroute-Cache": "MISS",
+            ...extraHeaders
+          };
+          if (set.headers.link) {
+            resHeaders.Link = set.headers.link;
+          }
+          set.status = status;
+          response = new Response(body, {
+            status,
+            headers: resHeaders
+          });
+        } else {
+          const shouldCache = !isWatchMode && SSR_HTML_TTL_MS > 0 && status === 200;
+          if (debug)
+            console.log(`[SSR] ${pathname} - no compression path, shouldCache=${shouldCache}`);
+          if (shouldCache) {
+            response = await withSpan("ssr.create.response", async (span) => {
+              if (debug)
+                console.log(`[SSR] ${pathname} - creating caching stream: ${(performance.now() - t0).toFixed(2)}ms`);
+              const chunks = [];
+              const cachingStream = stream2.pipeThrough(new TransformStream({
+                transform(chunk, controller) {
+                  chunks.push(new Uint8Array(chunk));
+                  controller.enqueue(chunk);
+                },
+                flush() {
+                  try {
+                    const totalLength = chunks.reduce((sum, c) => sum + c.length, 0);
+                    const fullHtml = new Uint8Array(totalLength);
+                    let offset = 0;
+                    for (const chunk of chunks) {
+                      fullHtml.set(chunk, offset);
+                      offset += chunk.length;
+                    }
+                    const ck = makeKey(pathname, acceptEncoding);
+                    const cacheHeaders = {
+                      "Content-Type": "text/html; charset=utf-8",
+                      "Cache-Control": cacheControlHeader
+                    };
+                    if (set.headers.link) {
+                      cacheHeaders.Link = set.headers.link;
+                    }
+                    htmlCache.set(ck, {
+                      status,
+                      headers: cacheHeaders,
+                      body: fullHtml,
+                      exp: Date.now() + SSR_HTML_TTL_MS
+                    });
+                  } catch (e) {
+                    console.error("[reroute] Failed to cache stream:", e);
+                  }
+                }
+              }));
+              set.status = status;
+              const tBeforeResponse = debug ? performance.now() : 0;
+              const res = new Response(cachingStream, {
+                status,
+                headers: {
+                  "Content-Type": "text/html; charset=utf-8",
+                  "Cache-Control": cacheControlHeader,
+                  "Reroute-Cache": "MISS"
+                }
+              });
+              if (debug)
+                console.log(`[SSR] ${pathname} - Response created (cached stream): ${(performance.now() - t0).toFixed(2)}ms (creation: ${(performance.now() - tBeforeResponse).toFixed(2)}ms)`);
+              span.setAttribute("reroute.cached", true);
+              return res;
+            });
+          } else {
+            if (debug)
+              console.log(`[SSR] ${pathname} - creating direct stream response: ${(performance.now() - t0).toFixed(2)}ms`);
+            set.status = status;
+            response = new Response(stream2, {
+              status,
+              headers: {
+                "Content-Type": "text/html; charset=utf-8",
+                "Cache-Control": cacheControlHeader,
+                "Reroute-Cache": "MISS"
+              }
+            });
+            if (debug)
+              console.log(`[SSR] ${pathname} - Response created (direct stream): ${(performance.now() - t0).toFixed(2)}ms`);
+          }
+        }
+      } else {
+        let html2;
+        let status;
+        try {
+          const result = await withSpan("ssr.render.sync", async (renderSpan) => {
+            renderSpan?.setAttributes({
+              "reroute.pathname": pathname,
+              "reroute.cache.hit": false
+            });
+            const renderResult = await renderSSRDocument({
+              pathname: fullPath,
+              rootComponent,
+              clientDir,
+              cwd,
+              isWatchMode,
+              bundleUrl,
+              head,
+              lang,
+              appId,
+              maxAge,
+              searchParams,
+              ogConfig: options.ogConfig,
+              parentSpan: renderSpan
+            });
+            renderSpan?.setAttribute("http.response.status_code", renderResult.status);
+            return renderResult;
+          });
+          html2 = result.html;
+          status = result.status;
+        } catch (ssrError) {
+          console.error("[reroute] SSR rendering failed, returning error page:", ssrError);
+          set.status = 500;
+          const errorHtml = `<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="UTF-8">
@@ -6865,53 +7292,20 @@ function registerSSRRoutes(app, options) {
   <script type="module" src="${bundleUrl}"></script>
 </body>
 </html>`;
-        return new Response(errorHtml, {
-          status: 500,
-          headers: { "Content-Type": "text/html; charset=utf-8" }
-        });
-      }
-      if (debug)
-        console.log(`[SSR] ${pathname} - before compression check: ${(performance.now() - t0).toFixed(2)}ms, compression=${compression2}, acceptEncoding=${!!acceptEncoding}`);
-      if (compression2 && acceptEncoding) {
-        const chunks = [];
-        const reader = stream2.getReader();
-        try {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-              break;
-            chunks.push(new Uint8Array(value));
-          }
-        } finally {
-          reader.releaseLock();
-        }
-        const totalLength = chunks.reduce((sum, c) => sum + c.length, 0);
-        const fullHtml = new Uint8Array(totalLength);
-        let offset = 0;
-        for (const chunk of chunks) {
-          fullHtml.set(chunk, offset);
-          offset += chunk.length;
-        }
-        const { body, extraHeaders } = gzipIfAccepted(fullHtml, "text/html; charset=utf-8", acceptEncoding);
-        if (!isWatchMode && SSR_HTML_TTL_MS > 0 && status === 200) {
-          try {
-            const ck = makeKey(pathname, acceptEncoding);
-            const cacheHeaders = {
-              "Content-Type": "text/html; charset=utf-8",
-              "Cache-Control": cacheControlHeader,
-              ...extraHeaders
-            };
-            if (set.headers.link) {
-              cacheHeaders.Link = set.headers.link;
-            }
-            htmlCache.set(ck, {
-              status,
-              headers: cacheHeaders,
-              body,
-              exp: Date.now() + SSR_HTML_TTL_MS
-            });
-          } catch {}
+          return new Response(errorHtml, {
+            status: 500,
+            headers: { "Content-Type": "text/html; charset=utf-8" }
+          });
         }
+        const { body, extraHeaders } = compression2 ? await withSpan("ssr.compress", async (span) => {
+          const result = gzipIfAccepted(html2, "text/html; charset=utf-8", acceptEncoding);
+          span.setAttributes({
+            "reroute.size.original": html2.length,
+            "reroute.size.compressed": typeof result.body === "string" ? result.body.length : result.body.length,
+            "reroute.encoding": result.extraHeaders["Content-Encoding"] || "none"
+          });
+          return result;
+        }) : { body: html2, extraHeaders: {} };
         const resHeaders = {
           "Content-Type": "text/html; charset=utf-8",
           "Cache-Control": cacheControlHeader,
@@ -6926,171 +7320,26 @@ function registerSSRRoutes(app, options) {
           status,
           headers: resHeaders
         });
-      } else {
-        const shouldCache = !isWatchMode && SSR_HTML_TTL_MS > 0 && status === 200;
-        if (debug)
-          console.log(`[SSR] ${pathname} - no compression path, shouldCache=${shouldCache}`);
-        if (shouldCache) {
-          if (debug)
-            console.log(`[SSR] ${pathname} - creating caching stream: ${(performance.now() - t0).toFixed(2)}ms`);
-          const chunks = [];
-          const cachingStream = stream2.pipeThrough(new TransformStream({
-            transform(chunk, controller) {
-              chunks.push(new Uint8Array(chunk));
-              controller.enqueue(chunk);
-            },
-            flush() {
-              try {
-                const totalLength = chunks.reduce((sum, c) => sum + c.length, 0);
-                const fullHtml = new Uint8Array(totalLength);
-                let offset = 0;
-                for (const chunk of chunks) {
-                  fullHtml.set(chunk, offset);
-                  offset += chunk.length;
-                }
-                const ck = makeKey(pathname, acceptEncoding);
-                const cacheHeaders = {
-                  "Content-Type": "text/html; charset=utf-8",
-                  "Cache-Control": cacheControlHeader
-                };
-                if (set.headers.link) {
-                  cacheHeaders.Link = set.headers.link;
-                }
-                htmlCache.set(ck, {
-                  status,
-                  headers: cacheHeaders,
-                  body: fullHtml,
-                  exp: Date.now() + SSR_HTML_TTL_MS
-                });
-              } catch (e) {
-                console.error("[reroute] Failed to cache stream:", e);
-              }
-            }
-          }));
-          set.status = status;
-          const tBeforeResponse = debug ? performance.now() : 0;
-          response = new Response(cachingStream, {
-            status,
-            headers: {
-              "Content-Type": "text/html; charset=utf-8",
-              "Cache-Control": cacheControlHeader,
-              "Reroute-Cache": "MISS"
-            }
-          });
-          if (debug)
-            console.log(`[SSR] ${pathname} - Response created (cached stream): ${(performance.now() - t0).toFixed(2)}ms (creation: ${(performance.now() - tBeforeResponse).toFixed(2)}ms)`);
-        } else {
-          if (debug)
-            console.log(`[SSR] ${pathname} - creating direct stream response: ${(performance.now() - t0).toFixed(2)}ms`);
-          set.status = status;
-          const tBeforeResponse = debug ? performance.now() : 0;
-          response = new Response(stream2, {
-            status,
-            headers: {
-              "Content-Type": "text/html; charset=utf-8",
-              "Cache-Control": cacheControlHeader,
-              "Reroute-Cache": "MISS"
-            }
-          });
-          if (debug)
-            console.log(`[SSR] ${pathname} - Response created (direct stream): ${(performance.now() - t0).toFixed(2)}ms (creation: ${(performance.now() - tBeforeResponse).toFixed(2)}ms)`);
+        if (!isWatchMode && SSR_HTML_TTL_MS > 0 && status >= 200 && status < 300) {
+          try {
+            const ck = makeKey(pathname, acceptEncoding);
+            htmlCache.set(ck, {
+              status,
+              headers: resHeaders,
+              body,
+              exp: Date.now() + SSR_HTML_TTL_MS
+            });
+          } catch {}
         }
       }
-    } else {
-      let html2;
-      let status;
-      try {
-        const otel = getOtelUtilities2();
-        const renderFn = async () => {
-          otel?.setAttributes({
-            "http.request.method": "GET",
-            "reroute.ssr.enabled": true,
-            "reroute.ssr.streaming": false,
-            "reroute.cache.hit": false,
-            "reroute.pathname": pathname
-          });
-          const result2 = await renderSSRDocument({
-            pathname: fullPath,
-            rootComponent,
-            clientDir,
-            cwd,
-            isWatchMode,
-            bundleUrl,
-            head,
-            lang,
-            appId,
-            maxAge,
-            searchParams,
-            ogConfig: options.ogConfig
-          });
-          otel?.setAttributes({
-            "http.response.status_code": result2.status
-          });
-          return result2;
-        };
-        const result = otel ? await otel.record("reroute.ssr.render_sync", renderFn) : await renderFn();
-        html2 = result.html;
-        status = result.status;
-      } catch (ssrError) {
-        console.error("[reroute] SSR rendering failed, returning error page:", ssrError);
-        const errorHtml = `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>Error</title>
-  <style>
-    body { font-family: system-ui, sans-serif; padding: 2rem; background: #111; color: #fff; }
-    h1 { color: #f87171; }
-    pre { background: #222; padding: 1rem; border-radius: 0.5rem; overflow: auto; }
-  </style>
-</head>
-<body>
-  <h1>Server Error</h1>
-  <p>An error occurred while rendering this page.</p>
-  ${isWatchMode ? `<pre>${ssrError instanceof Error ? ssrError.stack : String(ssrError)}</pre>` : ""}
-  <script type="module" src="${bundleUrl}"></script>
-</body>
-</html>`;
-        return new Response(errorHtml, {
-          status: 500,
-          headers: { "Content-Type": "text/html; charset=utf-8" }
-        });
-      }
-      const { body, extraHeaders } = compression2 ? gzipIfAccepted(html2, "text/html; charset=utf-8", acceptEncoding) : { body: html2, extraHeaders: {} };
-      const resHeaders = {
-        "Content-Type": "text/html; charset=utf-8",
-        "Cache-Control": cacheControlHeader,
-        "Reroute-Cache": "MISS",
-        ...extraHeaders
-      };
-      if (set.headers.link) {
-        resHeaders.Link = set.headers.link;
-      }
-      set.status = status;
-      response = new Response(body, {
-        status,
-        headers: resHeaders
-      });
-      if (!isWatchMode && SSR_HTML_TTL_MS > 0 && status >= 200 && status < 300) {
-        try {
-          const ck = makeKey(pathname, acceptEncoding);
-          htmlCache.set(ck, {
-            status,
-            headers: resHeaders,
-            body,
-            exp: Date.now() + SSR_HTML_TTL_MS
-          });
-        } catch {}
-      }
-    }
-    const tBeforeReturn = debug ? performance.now() : 0;
-    if (debug)
-      console.log(`[SSR] ${pathname} - about to return response: ${(performance.now() - t0).toFixed(2)}ms`);
-    const returnValue = response;
-    if (debug)
-      console.log(`[SSR] ${pathname} - response returned: ${(performance.now() - t0).toFixed(2)}ms (return overhead: ${(performance.now() - tBeforeReturn).toFixed(2)}ms)`);
-    return returnValue;
+      const tBeforeReturn = debug ? performance.now() : 0;
+      if (debug)
+        console.log(`[SSR] ${pathname} - about to return response: ${(performance.now() - t0).toFixed(2)}ms`);
+      const returnValue = response;
+      if (debug)
+        console.log(`[SSR] ${pathname} - response returned: ${(performance.now() - t0).toFixed(2)}ms (return overhead: ${(performance.now() - tBeforeReturn).toFixed(2)}ms)`);
+      return returnValue;
+    });
   };
   const allRoutes = [...staticRoutes, ...contentRoutes, ...dynamicRoutes];
   for (const path2 of allRoutes) {
@@ -7101,12 +7350,19 @@ function registerSSRRoutes(app, options) {
 
 // packages/elysia/src/routes/static.ts
 init_core();
+import { trace as trace5 } from "@opentelemetry/api";
 import { NotFoundError as NotFoundError12 } from "elysia";
-function getOtelUtilities3() {
+var otelAvailable4;
+function isOtelAvailable4() {
+  if (otelAvailable4 !== undefined)
+    return otelAvailable4;
   try {
-    return __require("@elysiajs/opentelemetry");
+    __require("@opentelemetry/api");
+    otelAvailable4 = true;
+    return true;
   } catch {
-    return null;
+    otelAvailable4 = false;
+    return false;
   }
 }
 function registerStaticRoutes(app, options) {
@@ -7123,21 +7379,18 @@ function registerStaticRoutes(app, options) {
     compression: compression2 = true
   } = options;
   function setOtelAttributes(statusCode, cachHit, requestPath, encoding, reason) {
-    const otel = getOtelUtilities3();
-    const currentSpan = otel?.getCurrentSpan();
+    if (!isOtelAvailable4())
+      return;
+    const currentSpan = trace5.getActiveSpan();
     const attrs = {
-      "http.request.method": "GET",
-      "http.response.status_code": statusCode,
       "reroute.static.path": requestPath
     };
     if (statusCode === 200) {
-      attrs["reroute.static.cache_hit"] = cachHit;
+      attrs["reroute.cache.hit"] = cachHit;
       if (encoding)
-        attrs["reroute.static.encoding"] = encoding;
-    } else if (statusCode === 404) {
-      attrs["reroute.static.not_found"] = true;
-      if (reason)
-        attrs["reroute.static.reason"] = reason;
+        attrs["reroute.encoding"] = encoding;
+    } else if (reason) {
+      attrs["reroute.error.reason"] = reason;
     }
     currentSpan?.setAttributes(attrs);
   }
@@ -7188,31 +7441,25 @@ function registerStaticRoutes(app, options) {
         }
       });
       fileCache.set(cacheKey, response);
-      const otel = getOtelUtilities3();
-      const currentSpan = otel?.getCurrentSpan();
-      currentSpan?.setAttributes({
-        "http.request.method": "GET",
-        "http.response.status_code": 200,
-        "reroute.static.served": true,
-        "reroute.static.path": requestPath,
-        "reroute.static.content_type": contentType,
-        "reroute.static.cache_hit": false,
-        "reroute.static.compressed": !!extraHeaders["Content-Encoding"]
-      });
+      if (isOtelAvailable4()) {
+        const currentSpan = trace5.getActiveSpan();
+        currentSpan?.setAttributes({
+          "reroute.static.path": requestPath,
+          "reroute.content.type": contentType,
+          "reroute.cache.hit": false,
+          "reroute.compressed": !!extraHeaders["Content-Encoding"]
+        });
+      }
       return response.clone();
     } catch (error) {
       if (error instanceof NotFoundError12) {
         throw error;
       }
       console.error(`[reroute] Error serving ${filePath}:`, error);
-      const otel = getOtelUtilities3();
-      const currentSpan = otel?.getCurrentSpan();
-      currentSpan?.setAttributes({
-        "http.request.method": "GET",
-        "http.response.status_code": 500,
-        "reroute.static.error": true,
-        "reroute.static.path": requestPath
-      });
+      if (isOtelAvailable4()) {
+        const currentSpan = trace5.getActiveSpan();
+        currentSpan?.setAttribute("reroute.static.path", requestPath);
+      }
       throw new NotFoundError12;
     }
   });
@@ -7567,4 +7814,4 @@ export {
   reroute
 };
 
-//# debugId=435341DAA645AB5564756E2164756E21
+//# debugId=2F8AA864C3640F9564756E2164756E21