@wular/pnext 0.0.4 → 0.0.7

package/src/compat/otel/tracer.ts

@@ -8,8 +8,8 @@
 //
 // Everything is inert unless @opentelemetry/api resolves from the app AND a work unit is active.
 
-import { getWorkUnit, queueAfterTask, type WorkUnit } from '../../request/context';
-import { getOtelApi, type OtelApi, type OtelContext, type OtelSpan } from './api';
+import { getWorkUnit, queueAfterTask, type WorkUnit } from '../../request/context'
+import { getOtelApi, type OtelApi, type OtelContext, type OtelSpan } from './api'
 
 // next.span_type taxonomy (exact strings Next emits; asserted verbatim).
 export const SPAN_TYPE = {
@@ -29,14 +29,14 @@ export const SPAN_TYPE = {
   renderDocument: 'Render.renderDocument',
   getServerSideProps: 'Render.getServerSideProps',
   getStaticProps: 'Render.getStaticProps',
-} as const;
+} as const
 
 // The runtime label the app's exporter reads at export time. Next's test exporter serializes
 // `process.env.NEXT_RUNTIME` per span; for a route declared `runtime: 'edge'` Next runs the render in
 // the edge sandbox, so its spans say 'edge' while node-server-side spans stay 'nodejs'. pnext runs
 // everything in one Bun process, so the tracer mirrors the per-span runtime split by setting
 // NEXT_RUNTIME around each span.end() - SimpleSpanProcessor exports synchronously inside end().
-type SpanRuntime = 'edge' | 'nodejs';
+type SpanRuntime = 'edge' | 'nodejs'
 
 // Span types Next emits from INSIDE the edge sandbox when the route is edge.
 const EDGE_SANDBOX_SPAN_TYPES: ReadonlySet<string> = new Set([
@@ -48,30 +48,30 @@ const EDGE_SANDBOX_SPAN_TYPES: ReadonlySet<string> = new Set([
   SPAN_TYPE.renderDocument,
   SPAN_TYPE.getServerSideProps,
   SPAN_TYPE.getStaticProps,
-]);
+])
 
 // Per-WorkUnit otel state (stashed on the compat scratch map).
-const OTEL_STATE = Symbol.for('pnext.compat.otel.state');
+const OTEL_STATE = Symbol.for('pnext.compat.otel.state')
 
 interface OtelState {
-  api: OtelApi;
+  api: OtelApi
   /** Context with the root span active — children re-enter this to nest. */
-  rootContext: OtelContext;
+  rootContext: OtelContext
   /** The root BaseServer.handleRequest span (closed by the finalizer). */
-  rootSpan: OtelSpan;
+  rootSpan: OtelSpan
   /** Guard so the root span is ended exactly once. */
-  rootEnded: boolean;
+  rootEnded: boolean
   /** Request method, kept for the pattern-rename span name. */
-  method: string;
+  method: string
   /** Whether this was an RSC request, kept for the pattern-rename span name. */
-  rsc: boolean;
+  rsc: boolean
   /** The raw request target (`pathname + search`) the root span opened with. */
-  target: string;
+  target: string
   /**
    * The extracted INCOMING context (traceparent applied, no pnext span active). Top-level spans parent
    * here, mirroring Next's spans that sit beside - not under - handleRequest.
    */
-  incomingContext: OtelContext;
+  incomingContext: OtelContext
   /**
    * Edge emulation mode for the matched route. 'page': the whole render tree
    * exports as runtime 'edge' with the params-query target (Next renders edge
@@ -79,70 +79,70 @@ interface OtelState {
    * and it parents on the incoming context (Next's node server keeps its own
    * nodejs spans; the sandbox emits a stand-alone runHandler).
    */
-  edgeMode?: 'page' | 'handler';
+  edgeMode?: 'page' | 'handler'
   /** NEXT_OTEL_VERBOSE=1 wrapper span (NextServer.getRequestHandler). */
-  verboseSpan?: OtelSpan;
+  verboseSpan?: OtelSpan
   /**
    * The context a NEW child span parents under. Starts as rootContext; each
    * withChildSpan pushes its own child context for the duration of `fn` so a
    * nested withChildSpan (e.g. `resolve segment modules` inside `build component
    * tree`) nests under its lexical parent, not the root. Restored on settle.
    */
-  currentContext: OtelContext;
+  currentContext: OtelContext
   /** The stamped display route pattern (`/pages/[param]/getServerSideProps`). */
-  route?: string;
+  route?: string
   /**
    * A pages-router data fetcher errored or returned notFound and the fallback span set replaced the
    * render span. Post-fallback render-internal leaves must not surface as root children - Next does not
    * emit them there.
    */
-  pagesFallback?: boolean;
+  pagesFallback?: boolean
   /** A materialized pages-API handler ran (suppresses the start-response leaf). */
-  pagesApi?: boolean;
+  pagesApi?: boolean
   renderSpan?: {
-    span: OtelSpan;
-    parentContext: OtelContext;
-    spanContext: OtelContext;
-    ended: boolean;
+    span: OtelSpan
+    parentContext: OtelContext
+    spanContext: OtelContext
+    ended: boolean
     /** markRenderSpanError already set an ERROR status; finish must keep it. */
-    errored?: boolean;
+    errored?: boolean
     /** `next.span_type` the span opened with (runtime label at end). */
-    spanType: string;
+    spanType: string
     /**
      * Pages-router notFound/error fallback: Next replaces the route's render
      * span with the fallback page's own spans (`/_error`, `/_not-found`). A
      * discarded span is NEVER ended, so SimpleSpanProcessor never exports it
      * (its children become orphans the suite's tree-builder filters out).
      */
-    discarded?: boolean;
-  };
+    discarded?: boolean
+  }
   componentTreeSpan?: {
-    span: OtelSpan;
-    parentContext: OtelContext;
-    spanContext: OtelContext;
-    ended: boolean;
-  };
+    span: OtelSpan
+    parentContext: OtelContext
+    spanContext: OtelContext
+    ended: boolean
+  }
 }
 
 /** The runtime label for a child span of the given next.span_type. */
 function childRuntime(state: OtelState, spanType: string): SpanRuntime {
-  return state.edgeMode === 'page' && EDGE_SANDBOX_SPAN_TYPES.has(spanType) ? 'edge' : 'nodejs';
+  return state.edgeMode === 'page' && EDGE_SANDBOX_SPAN_TYPES.has(spanType) ? 'edge' : 'nodejs'
 }
 
-let cachedAppRoot: string | undefined;
-let spanEndDepth = 0;
+let cachedAppRoot: string | undefined
+let spanEndDepth = 0
 
 /** Called once at init so the tracer can resolve @opentelemetry/api from the app. */
 export function setOtelAppRoot(root: string): void {
-  cachedAppRoot = root;
+  cachedAppRoot = root
 }
 
 function api(): OtelApi | null {
-  return cachedAppRoot ? getOtelApi(cachedAppRoot) : null;
+  return cachedAppRoot ? getOtelApi(cachedAppRoot) : null
 }
 
 function stateOf(unit: WorkUnit | undefined): OtelState | undefined {
-  return unit?.compat?.[OTEL_STATE] as OtelState | undefined;
+  return unit?.compat?.[OTEL_STATE] as OtelState | undefined
 }
 
 /**
@@ -152,34 +152,34 @@ function stateOf(unit: WorkUnit | undefined): OtelState | undefined {
  * unavailable, no work unit is active, or a root is already open.
  */
 export function startRootSpan(input: {
-  method: string;
-  target: string;
-  rsc: boolean;
-  headers: Headers;
+  method: string
+  target: string
+  rsc: boolean
+  headers: Headers
 }): void {
-  const a = api();
-  if (!a) return;
-  const unit = getWorkUnit();
-  if (!unit) return;
-  unit.compat ??= {};
-  if (unit.compat[OTEL_STATE]) return;
+  const a = api()
+  if (!a) return
+  const unit = getWorkUnit()
+  if (!unit) return
+  unit.compat ??= {}
+  if (unit.compat[OTEL_STATE]) return
 
   // Extract incoming context (traceparent + any custom propagators, e.g. the
   // test's x-custom sampler entry). The carrier is a plain header record.
-  const carrier: Record<string, string> = {};
+  const carrier: Record<string, string> = {}
   input.headers.forEach((value, key) => {
-    carrier[key] = value;
-  });
-  const incomingContext = a.propagation.extract(a.context.active(), carrier, headerGetter);
+    carrier[key] = value
+  })
+  const incomingContext = a.propagation.extract(a.context.active(), carrier, headerGetter)
 
-  const spanName = `${input.rsc ? 'RSC ' : ''}${input.method} ${input.target}`;
-  const tracer = a.trace.getTracer('next.js', '0.0.1');
+  const spanName = `${input.rsc ? 'RSC ' : ''}${input.method} ${input.target}`
+  const tracer = a.trace.getTracer('next.js', '0.0.1')
   // NEXT_OTEL_VERBOSE=1: Next additionally emits the NextServer.getRequestHandler
   // wrapper span between the incoming context and handleRequest. The verbose
   // suite asserts its span_type + that it parents directly on the incoming
   // traceparent while everything else nests below.
-  let verboseSpan: OtelSpan | undefined;
-  let rootParentCtx = incomingContext;
+  let verboseSpan: OtelSpan | undefined
+  let rootParentCtx = incomingContext
   // eslint-disable-next-line turbo/no-undeclared-env-vars
   if (process.env.NEXT_OTEL_VERBOSE === '1') {
     verboseSpan = tracer.startSpan(
@@ -192,8 +192,8 @@ export function startRootSpan(input: {
         },
       },
       incomingContext,
-    );
-    rootParentCtx = a.trace.setSpan(incomingContext, verboseSpan);
+    )
+    rootParentCtx = a.trace.setSpan(incomingContext, verboseSpan)
   }
   const rootSpan = tracer.startSpan(
     spanName,
@@ -208,8 +208,8 @@ export function startRootSpan(input: {
       },
     },
     rootParentCtx,
-  );
-  const rootContext = a.trace.setSpan(rootParentCtx, rootSpan);
+  )
+  const rootContext = a.trace.setSpan(rootParentCtx, rootSpan)
   const state: OtelState = {
     api: a,
     rootContext,
@@ -221,8 +221,8 @@ export function startRootSpan(input: {
     incomingContext,
     ...(verboseSpan ? { verboseSpan } : {}),
     currentContext: rootContext,
-  };
-  unit.compat[OTEL_STATE] = state;
+  }
+  unit.compat[OTEL_STATE] = state
 }
 
 /**
@@ -234,44 +234,44 @@ export function setRootSpanRoute(
   route: string,
   options: {
     /** The matched route declared `runtime: 'edge'`. */
-    edge?: boolean;
+    edge?: boolean
     /** 'handler' for a route handler, 'page' otherwise. */
-    kind?: 'page' | 'handler';
+    kind?: 'page' | 'handler'
     /** Resolved dynamic params (edge target emulation). */
-    params?: Record<string, string | string[]>;
+    params?: Record<string, string | string[]>
   } = {},
 ): void {
-  const state = stateOf(getWorkUnit());
-  if (!state) return;
-  state.route = route;
-  const { rootSpan } = state;
-  const name = `${state.rsc ? 'RSC ' : ''}${state.method} ${route}`;
-  rootSpan.setAttribute('next.route', route);
-  rootSpan.setAttribute('http.route', route);
-  rootSpan.setAttribute('next.span_name', name);
-  rootSpan.updateName(name);
-  if (!options.edge) return;
-  state.edgeMode = options.kind === 'handler' ? 'handler' : 'page';
-  if (state.edgeMode !== 'page') return;
+  const state = stateOf(getWorkUnit())
+  if (!state) return
+  state.route = route
+  const { rootSpan } = state
+  const name = `${state.rsc ? 'RSC ' : ''}${state.method} ${route}`
+  rootSpan.setAttribute('next.route', route)
+  rootSpan.setAttribute('http.route', route)
+  rootSpan.setAttribute('next.span_name', name)
+  rootSpan.updateName(name)
+  if (!options.edge) return
+  state.edgeMode = options.kind === 'handler' ? 'handler' : 'page'
+  if (state.edgeMode !== 'page') return
   // A production start invokes an edge page through the sandbox with the resolved dynamic params
   // appended as query params, so the sandbox-side handleRequest span reports them in its route. Mirror
   // that. Always rebuilt from the ORIGINAL request target - the route is stamped twice (early
   // pre-rewrite and late post-rewrite interceptors) and the params must not accumulate.
-  const [pathname = '', search = ''] = splitTarget(state.target);
-  const query = new URLSearchParams(search);
+  const [pathname = '', search = ''] = splitTarget(state.target)
+  const query = new URLSearchParams(search)
   for (const [key, value] of Object.entries(options.params ?? {})) {
-    if (Array.isArray(value)) query.set(key, value.join('/'));
-    else query.set(key, value);
+    if (Array.isArray(value)) query.set(key, value.join('/'))
+    else query.set(key, value)
   }
-  const queryText = query.toString();
+  const queryText = query.toString()
   if (queryText) {
-    rootSpan.setAttribute('http.target', `${pathname}?${queryText}`);
+    rootSpan.setAttribute('http.target', `${pathname}?${queryText}`)
   }
 }
 
 function splitTarget(target: string): [string, string] {
-  const index = target.indexOf('?');
-  return index === -1 ? [target, ''] : [target.slice(0, index), target.slice(index + 1)];
+  const index = target.indexOf('?')
+  return index === -1 ? [target, ''] : [target.slice(0, index), target.slice(index + 1)]
 }
 
 /**
@@ -280,21 +280,21 @@ function splitTarget(target: string): [string, string] {
  * marked on the render span instead. Idempotent.
  */
 export function endRootSpan(status: number): void {
-  const state = stateOf(getWorkUnit());
-  if (!state || state.rootEnded) return;
-  state.rootEnded = true;
-  const { api: a, rootSpan } = state;
-  rootSpan.setAttribute('http.status_code', status);
+  const state = stateOf(getWorkUnit())
+  if (!state || state.rootEnded) return
+  state.rootEnded = true
+  const { api: a, rootSpan } = state
+  rootSpan.setAttribute('http.status_code', status)
   if (status >= 500) {
-    rootSpan.setAttribute('error.type', String(status));
-    rootSpan.setStatus({ code: a.SpanStatusCode.ERROR });
+    rootSpan.setAttribute('error.type', String(status))
+    rootSpan.setStatus({ code: a.SpanStatusCode.ERROR })
   } else {
-    rootSpan.setStatus({ code: a.SpanStatusCode.UNSET });
+    rootSpan.setStatus({ code: a.SpanStatusCode.UNSET })
   }
-  endSpan(rootSpan, state.edgeMode === 'page' ? 'edge' : 'nodejs');
+  endSpan(rootSpan, state.edgeMode === 'page' ? 'edge' : 'nodejs')
   if (state.verboseSpan) {
-    state.verboseSpan.setStatus({ code: a.SpanStatusCode.UNSET });
-    endSpan(state.verboseSpan, 'nodejs');
+    state.verboseSpan.setStatus({ code: a.SpanStatusCode.UNSET })
+    endSpan(state.verboseSpan, 'nodejs')
   }
 }
 
@@ -306,31 +306,31 @@ export function endRootSpan(status: number): void {
  * already-ended 200 span to 500.
  */
 export function endRootSpanIfUnclosed(fallbackStatus: number): void {
-  const state = stateOf(getWorkUnit());
-  if (!state || state.rootEnded) return;
-  endRootSpan(fallbackStatus);
+  const state = stateOf(getWorkUnit())
+  if (!state || state.rootEnded) return
+  endRootSpan(fallbackStatus)
 }
 
 /** The active root span's spanContext. */
 export function rootSpanContext(): { traceId: string; spanId: string } | undefined {
-  const state = stateOf(getWorkUnit());
-  if (!state) return undefined;
-  const sc = state.rootSpan.spanContext();
-  return { traceId: sc.traceId, spanId: sc.spanId };
+  const state = stateOf(getWorkUnit())
+  if (!state) return undefined
+  const sc = state.rootSpan.spanContext()
+  return { traceId: sc.traceId, spanId: sc.spanId }
 }
 
 /** The stashed root OTel context (root span active). */
 export function rootOtelContext(): { api: OtelApi; context: OtelContext } | undefined {
-  const state = stateOf(getWorkUnit());
-  if (!state) return undefined;
-  return { api: state.api, context: state.rootContext };
+  const state = stateOf(getWorkUnit())
+  if (!state) return undefined
+  return { api: state.api, context: state.rootContext }
 }
 
 /** The active render context, for client trace propagation. */
 export function activeOtelContext(): { api: OtelApi; context: OtelContext } | undefined {
-  const state = stateOf(getWorkUnit());
-  if (!state) return undefined;
-  return { api: state.api, context: state.api.context.active() };
+  const state = stateOf(getWorkUnit())
+  if (!state) return undefined
+  return { api: state.api, context: state.api.context.active() }
 }
 
 /**
@@ -346,13 +346,13 @@ export function withChildSpan<T>(
   fn: () => T,
   options: { kind?: number; onError?: (span: OtelSpan, error: unknown) => void } = {},
 ): T {
-  const state = stateOf(getWorkUnit());
-  if (!state) return fn();
-  const { api: a } = state;
+  const state = stateOf(getWorkUnit())
+  if (!state) return fn()
+  const { api: a } = state
   // Parent under the lexically-enclosing span (currentContext), not always the
   // root, so nested withChildSpan calls form the right tree.
-  const parentContext = state.currentContext;
-  const tracer = a.trace.getTracer('next.js', '0.0.1');
+  const parentContext = state.currentContext
+  const tracer = a.trace.getTracer('next.js', '0.0.1')
   const span = tracer.startSpan(
     name,
     {
@@ -364,42 +364,42 @@ export function withChildSpan<T>(
       },
     },
     parentContext,
-  );
-  const childContext = a.trace.setSpan(parentContext, span);
-  state.currentContext = childContext;
+  )
+  const childContext = a.trace.setSpan(parentContext, span)
+  state.currentContext = childContext
   const settle = (error?: unknown) => {
     // Restore the enclosing context so siblings parent correctly.
-    state.currentContext = parentContext;
+    state.currentContext = parentContext
     if (error !== undefined) {
-      if (options.onError) options.onError(span, error);
+      if (options.onError) options.onError(span, error)
       else {
-        span.recordException(error);
-        span.setStatus({ code: a.SpanStatusCode.ERROR, message: errorMessage(error) });
+        span.recordException(error)
+        span.setStatus({ code: a.SpanStatusCode.ERROR, message: errorMessage(error) })
       }
     } else {
-      span.setStatus({ code: a.SpanStatusCode.UNSET });
+      span.setStatus({ code: a.SpanStatusCode.UNSET })
     }
-    endSpan(span, childRuntime(state, spanType));
-  };
+    endSpan(span, childRuntime(state, spanType))
+  }
   try {
-    const result = a.context.with(childContext, fn);
+    const result = a.context.with(childContext, fn)
     if (isThenable(result)) {
       return (result as PromiseLike<unknown>).then(
         value => {
-          settle();
-          return value;
+          settle()
+          return value
         },
         error => {
-          settle(error);
-          throw error;
+          settle(error)
+          throw error
         },
-      ) as T;
+      ) as T
     }
-    settle();
-    return result;
+    settle()
+    return result
   } catch (error) {
-    settle(error);
-    throw error;
+    settle(error)
+    throw error
   }
 }
 
@@ -409,11 +409,11 @@ export function withRenderBodySpan<T>(
   fn: () => T,
   spanType: string = SPAN_TYPE.getBodyResult,
 ): T {
-  const state = stateOf(getWorkUnit());
-  if (!state) return fn();
-  const { api: a } = state;
-  const parentContext = state.currentContext;
-  const tracer = a.trace.getTracer('next.js', '0.0.1');
+  const state = stateOf(getWorkUnit())
+  if (!state) return fn()
+  const { api: a } = state
+  const parentContext = state.currentContext
+  const tracer = a.trace.getTracer('next.js', '0.0.1')
   const span = tracer.startSpan(
     name,
     {
@@ -425,63 +425,63 @@ export function withRenderBodySpan<T>(
       },
     },
     parentContext,
-  );
-  const spanContext = a.trace.setSpan(parentContext, span);
-  const previousRenderSpan = state.renderSpan;
-  state.renderSpan = { span, parentContext, spanContext, ended: false, spanType };
-  state.currentContext = spanContext;
+  )
+  const spanContext = a.trace.setSpan(parentContext, span)
+  const previousRenderSpan = state.renderSpan
+  state.renderSpan = { span, parentContext, spanContext, ended: false, spanType }
+  state.currentContext = spanContext
 
   const finish = (error?: unknown) => {
-    const current = state.renderSpan;
-    if (current?.span !== span || current.ended) return;
-    current.ended = true;
-    endComponentTreeSpan(state);
+    const current = state.renderSpan
+    if (current?.span !== span || current.ended) return
+    current.ended = true
+    endComponentTreeSpan(state)
     if (current.discarded) {
       // Pages fallback replaced this span — leave it un-ended (never exported).
-      state.renderSpan = previousRenderSpan;
-      if (state.currentContext === spanContext) state.currentContext = parentContext;
-      return;
+      state.renderSpan = previousRenderSpan
+      if (state.currentContext === spanContext) state.currentContext = parentContext
+      return
     }
-    if (error !== undefined) markSpanError(a, span, error);
+    if (error !== undefined) markSpanError(a, span, error)
     // A streaming (Suspense-boundary) error already stamped ERROR through
     // markRenderSpanError — never downgrade it back to UNSET here.
     else if (!current.errored && span.isRecording()) {
-      span.setStatus({ code: a.SpanStatusCode.UNSET });
+      span.setStatus({ code: a.SpanStatusCode.UNSET })
     }
-    endSpan(span, childRuntime(state, spanType));
-    state.renderSpan = previousRenderSpan;
-    if (state.currentContext === spanContext) state.currentContext = parentContext;
-  };
+    endSpan(span, childRuntime(state, spanType))
+    state.renderSpan = previousRenderSpan
+    if (state.currentContext === spanContext) state.currentContext = parentContext
+  }
 
-  const queued = queueAfterTask(() => finish());
+  const queued = queueAfterTask(() => finish())
   try {
-    const result = a.context.with(spanContext, fn);
+    const result = a.context.with(spanContext, fn)
     if (isThenable(result)) {
       return (result as PromiseLike<unknown>).then(
         value => {
-          if (!queued) finish();
-          return value;
+          if (!queued) finish()
+          return value
         },
         error => {
-          finish(error);
-          throw error;
+          finish(error)
+          throw error
         },
-      ) as T;
+      ) as T
     }
-    if (!queued) finish();
-    return result;
+    if (!queued) finish()
+    return result
   } catch (error) {
-    finish(error);
-    throw error;
+    finish(error)
+    throw error
   }
 }
 
 export function markRenderSpanError(error: unknown): void {
-  const state = stateOf(getWorkUnit());
-  const render = state?.renderSpan;
-  if (!state || !render || render.ended) return;
-  render.errored = true;
-  markSpanError(state.api, render.span, error);
+  const state = stateOf(getWorkUnit())
+  const render = state?.renderSpan
+  if (!state || !render || render.ended) return
+  render.errored = true
+  markSpanError(state.api, render.span, error)
 }
 
 /**
@@ -496,7 +496,7 @@ export function withRouteHandlerSpan<T>(route: string, fn: () => T): T {
     SPAN_TYPE.runHandler,
     { 'next.route': route },
     fn,
-  );
+  )
 }
 
 function runHandlerSpan<T>(
@@ -505,12 +505,12 @@ function runHandlerSpan<T>(
   attributes: Record<string, unknown>,
   fn: () => T,
 ): T {
-  const state = stateOf(getWorkUnit());
-  if (!state) return fn();
-  const { api: a } = state;
-  const edge = state.edgeMode === 'handler';
-  const parentContext = edge ? state.incomingContext : state.currentContext;
-  const tracer = a.trace.getTracer('next.js', '0.0.1');
+  const state = stateOf(getWorkUnit())
+  if (!state) return fn()
+  const { api: a } = state
+  const edge = state.edgeMode === 'handler'
+  const parentContext = edge ? state.incomingContext : state.currentContext
+  const tracer = a.trace.getTracer('next.js', '0.0.1')
   const span = tracer.startSpan(
     name,
     {
@@ -522,39 +522,39 @@ function runHandlerSpan<T>(
       },
     },
     parentContext,
-  );
-  const spanContext = a.trace.setSpan(parentContext, span);
-  const previousContext = state.currentContext;
-  state.currentContext = spanContext;
+  )
+  const spanContext = a.trace.setSpan(parentContext, span)
+  const previousContext = state.currentContext
+  state.currentContext = spanContext
   const settle = (error?: unknown) => {
-    state.currentContext = previousContext;
+    state.currentContext = previousContext
     if (error !== undefined) {
-      span.recordException(error);
-      span.setStatus({ code: a.SpanStatusCode.ERROR, message: errorMessage(error) });
+      span.recordException(error)
+      span.setStatus({ code: a.SpanStatusCode.ERROR, message: errorMessage(error) })
     } else {
-      span.setStatus({ code: a.SpanStatusCode.UNSET });
+      span.setStatus({ code: a.SpanStatusCode.UNSET })
     }
-    endSpan(span, edge ? 'edge' : 'nodejs');
-  };
+    endSpan(span, edge ? 'edge' : 'nodejs')
+  }
   try {
-    const result = a.context.with(spanContext, fn);
+    const result = a.context.with(spanContext, fn)
     if (isThenable(result)) {
       return (result as PromiseLike<unknown>).then(
         value => {
-          settle();
-          return value;
+          settle()
+          return value
         },
         error => {
-          settle(error);
-          throw error;
+          settle(error)
+          throw error
         },
-      ) as T;
+      ) as T
     }
-    settle();
-    return result;
+    settle()
+    return result
   } catch (error) {
-    settle(error);
-    throw error;
+    settle(error)
+    throw error
   }
 }
 
@@ -566,10 +566,10 @@ function runHandlerSpan<T>(
  * start-response leaf is suppressed for the rest of the request.
  */
 export function withPagesApiHandlerSpan<T>(route: string, fn: () => T): T {
-  const state = stateOf(getWorkUnit());
-  if (state) state.pagesApi = true;
-  const name = `executing api route (pages) ${route}`;
-  return runHandlerSpan(name, SPAN_TYPE.nodeRunHandler, {}, fn);
+  const state = stateOf(getWorkUnit())
+  if (state) state.pagesApi = true
+  const name = `executing api route (pages) ${route}`
+  return runHandlerSpan(name, SPAN_TYPE.nodeRunHandler, {}, fn)
 }
 
 /**
@@ -586,13 +586,13 @@ export function withPagesDataSpan<T>(
   kind: 'getServerSideProps' | 'getStaticProps',
   fn: () => T,
 ): T {
-  const state = stateOf(getWorkUnit());
-  const route = state?.route;
-  if (!state || !route) return fn();
-  const { api: a } = state;
+  const state = stateOf(getWorkUnit())
+  const route = state?.route
+  if (!state || !route) return fn()
+  const { api: a } = state
   const spanType =
-    kind === 'getServerSideProps' ? SPAN_TYPE.getServerSideProps : SPAN_TYPE.getStaticProps;
-  const name = `${kind} ${route}`;
+    kind === 'getServerSideProps' ? SPAN_TYPE.getServerSideProps : SPAN_TYPE.getStaticProps
+  const name = `${kind} ${route}`
   const span = a.trace.getTracer('next.js', '0.0.1').startSpan(
     name,
     {
@@ -604,38 +604,38 @@ export function withPagesDataSpan<T>(
       },
     },
     state.rootContext,
-  );
+  )
   const settle = (error: unknown, result: unknown) => {
     if (error !== undefined) {
-      markSpanError(a, span, error);
-      emitPagesErrorFallbackSpans(state, route);
+      markSpanError(a, span, error)
+      emitPagesErrorFallbackSpans(state, route)
     } else {
-      span.setStatus({ code: a.SpanStatusCode.UNSET });
+      span.setStatus({ code: a.SpanStatusCode.UNSET })
       if ((result as { notFound?: boolean } | null | undefined)?.notFound) {
-        emitPagesNotFoundFallbackSpans(state, route);
+        emitPagesNotFoundFallbackSpans(state, route)
       }
     }
-    endSpan(span, childRuntime(state, spanType));
-  };
+    endSpan(span, childRuntime(state, spanType))
+  }
   try {
-    const result = fn();
+    const result = fn()
     if (isThenable(result)) {
       return (result as PromiseLike<unknown>).then(
         value => {
-          settle(undefined, value);
-          return value;
+          settle(undefined, value)
+          return value
         },
         (error: unknown) => {
-          settle(error ?? new Error('getServerSideProps error'), undefined);
-          throw error;
+          settle(error ?? new Error('getServerSideProps error'), undefined)
+          throw error
         },
-      ) as T;
+      ) as T
     }
-    settle(undefined, result);
-    return result;
+    settle(undefined, result)
+    return result
   } catch (error) {
-    settle(error ?? new Error('getServerSideProps error'), undefined);
-    throw error;
+    settle(error ?? new Error('getServerSideProps error'), undefined)
+    throw error
   }
 }
 
@@ -646,7 +646,7 @@ function emitRootLeafSpan(
   spanType: string,
   attributes: Record<string, unknown>,
 ): void {
-  const { api: a } = state;
+  const { api: a } = state
   const span = a.trace.getTracer('next.js', '0.0.1').startSpan(
     name,
     {
@@ -658,41 +658,41 @@ function emitRootLeafSpan(
       },
     },
     state.rootContext,
-  );
-  span.setStatus({ code: a.SpanStatusCode.UNSET });
-  endSpan(span, 'nodejs');
+  )
+  span.setStatus({ code: a.SpanStatusCode.UNSET })
+  endSpan(span, 'nodejs')
 }
 
 /** Discard the route's open render span (see withPagesDataSpan). */
 function discardRenderSpan(state: OtelState): void {
-  state.pagesFallback = true;
-  if (state.renderSpan && !state.renderSpan.ended) state.renderSpan.discarded = true;
+  state.pagesFallback = true
+  if (state.renderSpan && !state.renderSpan.ended) state.renderSpan.discarded = true
 }
 
 // gSSP threw: Next renders `/_error` (its own renderDocument span), resolves
 // `/_error`, probes `/500` twice (prod), and the route resolve already fired.
 function emitPagesErrorFallbackSpans(state: OtelState, _route: string): void {
-  discardRenderSpan(state);
+  discardRenderSpan(state)
   emitRootLeafSpan(state, 'render route (pages) /_error', SPAN_TYPE.renderDocument, {
     'next.route': '/_error',
-  });
+  })
   emitRootLeafSpan(state, 'resolve page components', SPAN_TYPE.findPageComponents, {
     'next.route': '/_error',
-  });
+  })
   for (let i = 0; i < 2; i += 1) {
     emitRootLeafSpan(state, 'resolve page components', SPAN_TYPE.findPageComponents, {
       'next.route': '/500',
-    });
+    })
   }
 }
 
 // gSSP returned { notFound: true }: Next serves the prerendered `/_not-found`
 // (prod: a findPageComponents probe only, no render span).
 function emitPagesNotFoundFallbackSpans(state: OtelState, _route: string): void {
-  discardRenderSpan(state);
+  discardRenderSpan(state)
   emitRootLeafSpan(state, 'resolve page components', SPAN_TYPE.findPageComponents, {
     'next.route': '/_not-found',
-  });
+  })
 }
 
 /**
@@ -702,9 +702,9 @@ function emitPagesNotFoundFallbackSpans(state: OtelState, _route: string): void
  * pipes from the node server even for edge routes.
  */
 export function emitStartResponseSpan(): void {
-  const state = stateOf(getWorkUnit());
-  if (state?.pagesFallback || state?.pagesApi) return;
-  emitNodeLeafSpan('start response', SPAN_TYPE.startResponse, {});
+  const state = stateOf(getWorkUnit())
+  if (state?.pagesFallback || state?.pagesApi) return
+  emitNodeLeafSpan('start response', SPAN_TYPE.startResponse, {})
 }
 
 /**
@@ -714,11 +714,11 @@ export function emitStartResponseSpan(): void {
  * emitted for page renders, matching Next.
  */
 export function emitClientComponentLoadingSpan(count: number): void {
-  const state = stateOf(getWorkUnit());
-  if (!state?.renderSpan || state.renderSpan.ended) return;
+  const state = stateOf(getWorkUnit())
+  if (!state?.renderSpan || state.renderSpan.ended) return
   emitNodeLeafSpan(SPAN_TYPE.clientComponentLoading, SPAN_TYPE.clientComponentLoading, {
     'next.clientComponentLoadCount': count,
-  });
+  })
 }
 
 function emitNodeLeafSpan(
@@ -726,11 +726,11 @@ function emitNodeLeafSpan(
   spanType: string,
   attributes: Record<string, unknown>,
 ): void {
-  const state = stateOf(getWorkUnit());
-  if (!state) return;
-  const { api: a } = state;
-  const render = state.renderSpan;
-  const parentContext = render && !render.ended ? render.spanContext : state.rootContext;
+  const state = stateOf(getWorkUnit())
+  if (!state) return
+  const { api: a } = state
+  const render = state.renderSpan
+  const parentContext = render && !render.ended ? render.spanContext : state.rootContext
   const span = a.trace.getTracer('next.js', '0.0.1').startSpan(
     name,
     {
@@ -742,9 +742,9 @@ function emitNodeLeafSpan(
       },
     },
     parentContext,
-  );
-  span.setStatus({ code: a.SpanStatusCode.UNSET });
-  endSpan(span, 'nodejs');
+  )
+  span.setStatus({ code: a.SpanStatusCode.UNSET })
+  endSpan(span, 'nodejs')
 }
 
 /**
@@ -757,23 +757,23 @@ function emitNodeLeafSpan(
  * unavailable. Does not require an open work-unit root span.
  */
 export function withMiddlewareSpan<T>(request: Request, fn: () => T): T {
-  const a = api();
-  if (!a) return fn();
-  const method = request.method.toUpperCase();
-  let target = '';
+  const a = api()
+  if (!a) return fn()
+  const method = request.method.toUpperCase()
+  let target = ''
   try {
-    const url = new URL(request.url);
-    target = url.pathname + url.search;
+    const url = new URL(request.url)
+    target = url.pathname + url.search
   } catch {
-    target = request.url;
+    target = request.url
   }
-  const carrier: Record<string, string> = {};
+  const carrier: Record<string, string> = {}
   request.headers.forEach((value, key) => {
-    carrier[key] = value;
-  });
-  const parentCtx = a.propagation.extract(a.context.active(), carrier, headerGetter);
-  const name = `middleware ${method}`;
-  const tracer = a.trace.getTracer('next.js', '0.0.1');
+    carrier[key] = value
+  })
+  const parentCtx = a.propagation.extract(a.context.active(), carrier, headerGetter)
+  const name = `middleware ${method}`
+  const tracer = a.trace.getTracer('next.js', '0.0.1')
   const span = tracer.startSpan(
     name,
     {
@@ -785,39 +785,39 @@ export function withMiddlewareSpan<T>(request: Request, fn: () => T): T {
       },
     },
     parentCtx,
-  );
-  const spanCtx = a.trace.setSpan(parentCtx, span);
+  )
+  const spanCtx = a.trace.setSpan(parentCtx, span)
   const settle = (error?: unknown) => {
     if (error !== undefined) {
-      span.recordException(error);
-      span.setStatus({ code: a.SpanStatusCode.ERROR, message: errorMessage(error) });
+      span.recordException(error)
+      span.setStatus({ code: a.SpanStatusCode.ERROR, message: errorMessage(error) })
     } else {
-      span.setStatus({ code: a.SpanStatusCode.UNSET });
+      span.setStatus({ code: a.SpanStatusCode.UNSET })
     }
     // Middleware always runs in the edge runtime in Next; pnext's proxy runner
     // already wraps the handler in withRouteRuntime('edge') — the explicit tag
     // makes the exported runtime deterministic regardless of settle timing.
-    endSpan(span, 'edge');
-  };
+    endSpan(span, 'edge')
+  }
   try {
-    const result = a.context.with(spanCtx, fn);
+    const result = a.context.with(spanCtx, fn)
     if (isThenable(result)) {
       return (result as PromiseLike<unknown>).then(
         value => {
-          settle();
-          return value;
+          settle()
+          return value
         },
         error => {
-          settle(error);
-          throw error;
+          settle(error)
+          throw error
         },
-      ) as T;
+      ) as T
     }
-    settle();
-    return result;
+    settle()
+    return result
   } catch (error) {
-    settle(error);
-    throw error;
+    settle(error)
+    throw error
   }
 }
 
@@ -829,10 +829,10 @@ export function emitLeafSpan(
   kind?: number,
 ): void {
   if (spanType === SPAN_TYPE.getLayoutOrPageModule) {
-    emitSegmentSpan(name, spanType, attributes, kind);
-    return;
+    emitSegmentSpan(name, spanType, attributes, kind)
+    return
   }
-  withChildSpan(name, spanType, attributes, () => undefined, kind !== undefined ? { kind } : {});
+  withChildSpan(name, spanType, attributes, () => undefined, kind !== undefined ? { kind } : {})
 }
 
 function emitSegmentSpan(
@@ -841,28 +841,28 @@ function emitSegmentSpan(
   attributes: Record<string, unknown>,
   kind?: number,
 ): void {
-  const state = stateOf(getWorkUnit());
-  if (state?.pagesFallback) return;
+  const state = stateOf(getWorkUnit())
+  if (state?.pagesFallback) return
   if (!state?.renderSpan || state.renderSpan.ended) {
-    withChildSpan(name, spanType, attributes, () => undefined, kind !== undefined ? { kind } : {});
-    return;
+    withChildSpan(name, spanType, attributes, () => undefined, kind !== undefined ? { kind } : {})
+    return
   }
-  const tree = ensureComponentTreeSpan(state);
-  const previous = state.currentContext;
-  state.currentContext = tree.spanContext;
+  const tree = ensureComponentTreeSpan(state)
+  const previous = state.currentContext
+  state.currentContext = tree.spanContext
   try {
-    withChildSpan(name, spanType, attributes, () => undefined, kind !== undefined ? { kind } : {});
+    withChildSpan(name, spanType, attributes, () => undefined, kind !== undefined ? { kind } : {})
   } finally {
-    state.currentContext = previous;
+    state.currentContext = previous
   }
 }
 
 function ensureComponentTreeSpan(state: OtelState) {
-  const current = state.componentTreeSpan;
-  if (current && !current.ended) return current;
-  const { api: a } = state;
-  const parentContext = state.renderSpan?.spanContext ?? state.currentContext;
-  const name = 'build component tree';
+  const current = state.componentTreeSpan
+  if (current && !current.ended) return current
+  const { api: a } = state
+  const parentContext = state.renderSpan?.spanContext ?? state.currentContext
+  const name = 'build component tree'
   const span = a.trace.getTracer('next.js', '0.0.1').startSpan(
     name,
     {
@@ -873,72 +873,72 @@ function ensureComponentTreeSpan(state: OtelState) {
       },
     },
     parentContext,
-  );
-  const spanContext = a.trace.setSpan(parentContext, span);
-  const next = { span, parentContext, spanContext, ended: false };
-  state.componentTreeSpan = next;
-  return next;
+  )
+  const spanContext = a.trace.setSpan(parentContext, span)
+  const next = { span, parentContext, spanContext, ended: false }
+  state.componentTreeSpan = next
+  return next
 }
 
 function endComponentTreeSpan(state: OtelState): void {
-  const tree = state.componentTreeSpan;
-  if (!tree || tree.ended) return;
-  tree.ended = true;
-  tree.span.setStatus({ code: state.api.SpanStatusCode.UNSET });
-  endSpan(tree.span, childRuntime(state, SPAN_TYPE.createComponentTree));
-  if (state.currentContext === tree.spanContext) state.currentContext = tree.parentContext;
+  const tree = state.componentTreeSpan
+  if (!tree || tree.ended) return
+  tree.ended = true
+  tree.span.setStatus({ code: state.api.SpanStatusCode.UNSET })
+  endSpan(tree.span, childRuntime(state, SPAN_TYPE.createComponentTree))
+  if (state.currentContext === tree.spanContext) state.currentContext = tree.parentContext
 }
 
 const headerGetter = {
   keys(carrier: Record<string, string>): string[] {
-    return Object.keys(carrier);
+    return Object.keys(carrier)
   },
   get(carrier: Record<string, string>, key: string): string | undefined {
-    return carrier[key.toLowerCase()] ?? carrier[key];
+    return carrier[key.toLowerCase()] ?? carrier[key]
   },
-};
+}
 
 /** Setter for propagation.inject into a plain record carrier. */
 export const carrierSetter = {
   set(carrier: Record<string, string>, key: string, value: string): void {
-    carrier[key] = value;
+    carrier[key] = value
   },
-};
+}
 
 function errorMessage(error: unknown): string {
-  if (error instanceof Error) return error.message;
-  return String(error);
+  if (error instanceof Error) return error.message
+  return String(error)
 }
 
 function markSpanError(api: OtelApi, span: OtelSpan, error: unknown): void {
-  span.setAttribute('error.type', error instanceof Error ? error.name : typeof error);
-  span.recordException(error);
-  span.setStatus({ code: api.SpanStatusCode.ERROR, message: errorMessage(error) });
+  span.setAttribute('error.type', error instanceof Error ? error.name : typeof error)
+  span.recordException(error)
+  span.setStatus({ code: api.SpanStatusCode.ERROR, message: errorMessage(error) })
 }
 
 export function otelExportInProgress(): boolean {
-  return spanEndDepth > 0;
+  return spanEndDepth > 0
 }
 
 function endSpan(span: OtelSpan, runtime?: SpanRuntime): void {
-  spanEndDepth++;
+  spanEndDepth++
   // eslint-disable-next-line turbo/no-undeclared-env-vars
-  const previousRuntime = process.env.NEXT_RUNTIME;
+  const previousRuntime = process.env.NEXT_RUNTIME
   // eslint-disable-next-line turbo/no-undeclared-env-vars
-  if (runtime) process.env.NEXT_RUNTIME = runtime;
+  if (runtime) process.env.NEXT_RUNTIME = runtime
   try {
-    span.end();
+    span.end()
   } finally {
     if (runtime) {
       // eslint-disable-next-line turbo/no-undeclared-env-vars
-      if (previousRuntime === undefined) delete process.env.NEXT_RUNTIME;
+      if (previousRuntime === undefined) delete process.env.NEXT_RUNTIME
       // eslint-disable-next-line turbo/no-undeclared-env-vars
-      else process.env.NEXT_RUNTIME = previousRuntime;
+      else process.env.NEXT_RUNTIME = previousRuntime
     }
-    spanEndDepth--;
+    spanEndDepth--
   }
 }
 
 function isThenable(value: unknown): value is PromiseLike<unknown> {
-  return typeof (value as { then?: unknown } | null | undefined)?.then === 'function';
+  return typeof (value as { then?: unknown } | null | undefined)?.then === 'function'
 }