@wular/pnext 0.0.4 → 0.0.6

package/src/compat/next/{image-usage.ts → usage.ts}

@@ -1,10 +1,10 @@
-import { existsSync, readdirSync, readFileSync, type Dirent } from 'node:fs';
-import path from 'node:path';
+import { existsSync, readdirSync, readFileSync, type Dirent } from 'node:fs'
+import path from 'node:path'
 
 /**
  * Build-time app facts that let compat drop code an app cannot reach. The fact here: whether any
  * first-party source can ask for a blurred image placeholder. `placeholder="blur"` on `next/image` (or
- * getImageProps) is the only route into image-props' inline blur-SVG builder, which otherwise ships on
+ * getImageProps) is the only route into image/props' inline blur-SVG builder, which otherwise ships on
  * every page that uses next/image.
  *
  * The gate is one-sided by construction: every unreadable case answers "yes". A wrong "no" would render
@@ -12,29 +12,29 @@ import path from 'node:path';
  */
 
 /** Skipped wholesale: not first-party source, or build output. */
-const skipDirs = new Set(['node_modules', 'dist', 'build', 'out', 'coverage', 'public', 'target']);
-const sourceFile = /\.(?:[cm]?[jt]sx?|mdx)$/;
+const skipDirs = new Set(['node_modules', 'dist', 'build', 'out', 'coverage', 'public', 'target'])
+const sourceFile = /\.(?:[cm]?[jt]sx?|mdx)$/
 
 /** Only these APIs reach the branch, so only files naming one can matter. */
-const imageApi = /next\/(?:legacy\/)?image|getImageProps|unstable_getImgProps/;
+const imageApi = /next\/(?:legacy\/)?image|getImageProps|unstable_getImgProps/
 
 /** A literal `placeholder="blur"`, in JSX-prop or object-property form. */
-const literalBlur = /\bplaceholder\s*[=:]\s*\{?\s*['"`]blur['"`]/;
+const literalBlur = /\bplaceholder\s*[=:]\s*\{?\s*['"`]blur['"`]/
 
 /**
  * A `placeholder` whose value is not a string literal — `placeholder={value}`,
  * `placeholder: value`. Unreadable from source text, so it counts as usage.
  */
-const opaquePlaceholder = /\bplaceholder\s*[=:]\s*(?!\{?\s*['"`])/;
+const opaquePlaceholder = /\bplaceholder\s*[=:]\s*(?!\{?\s*['"`])/
 
 /**
  * Props reaching the image from somewhere this scan cannot see: a spread into
  * any element in an image-using file, or a re-export that lets another file
  * render `<Image>` without ever naming `next/image`.
  */
-const opaqueProps = /\{\s*\.\.\.|export\s[^;]*from\s*['"]next\/(?:legacy\/)?image/;
+const opaqueProps = /\{\s*\.\.\.|export\s[^;]*from\s*['"]next\/(?:legacy\/)?image/
 
-const cache = new Map<string, boolean>();
+const cache = new Map<string, boolean>()
 
 /**
  * Roots to scan: the app, plus the workspace's own packages when the app sits in one - a linked
@@ -42,61 +42,92 @@ const cache = new Map<string, boolean>();
  * there must be seen.
  */
 function scanRoots(root: string) {
-  const roots = [root];
+  const roots = [root]
   for (let dir = path.dirname(root); dir !== path.dirname(dir); dir = path.dirname(dir)) {
-    if (!existsSync(path.join(dir, 'pnpm-workspace.yaml')) && !existsSync(path.join(dir, 'lerna.json'))) {
-      continue;
+    if (
+      !existsSync(path.join(dir, 'pnpm-workspace.yaml')) &&
+      !existsSync(path.join(dir, 'lerna.json'))
+    ) {
+      continue
     }
-    const packages = path.join(dir, 'packages');
-    if (existsSync(packages)) roots.push(packages);
-    break;
+    const packages = path.join(dir, 'packages')
+    if (existsSync(packages)) roots.push(packages)
+    break
   }
-  return roots;
+  return roots
 }
 
 export function appUsesBlurPlaceholder(root: string) {
-  const cached = cache.get(root);
-  if (cached !== undefined) return cached;
-  const used = scanFirstPartySource(root, blurSource);
-  cache.set(root, used);
-  return used;
+  const cached = cache.get(root)
+  if (cached !== undefined) return cached
+  const used = scanFirstPartySource(root, blurSource)
+  cache.set(root, used)
+  return used
 }
 
 function blurSource(source: string): boolean {
   // The common case is one `test` and out: almost no file in an app names an
   // image API, and only those that do pay for the rest.
-  if (!imageApi.test(source)) return false;
-  return literalBlur.test(source) || opaquePlaceholder.test(source) || opaqueProps.test(source);
+  if (!imageApi.test(source)) return false
+  return literalBlur.test(source) || opaquePlaceholder.test(source) || opaqueProps.test(source)
 }
 
 /** Walk the app's first-party source (plus workspace packages) until `match`. */
 export function scanFirstPartySource(root: string, match: (source: string) => boolean): boolean {
-  return scanRoots(root).some(dir => scan(dir, match));
+  return scanRoots(root).some(dir => scan(dir, match))
 }
 
 function scan(dir: string, match: (source: string) => boolean): boolean {
-  let entries: Dirent[];
+  let entries: Dirent[]
   try {
-    entries = readdirSync(dir, { withFileTypes: true });
+    entries = readdirSync(dir, { withFileTypes: true })
   } catch {
-    return false;
+    return false
   }
   for (const entry of entries) {
-    if (entry.name.startsWith('.')) continue;
-    const file = path.join(dir, entry.name);
+    if (entry.name.startsWith('.')) continue
+    const file = path.join(dir, entry.name)
     if (entry.isDirectory()) {
-      if (skipDirs.has(entry.name)) continue;
-      if (scan(file, match)) return true;
-      continue;
+      if (skipDirs.has(entry.name)) continue
+      if (scan(file, match)) return true
+      continue
     }
-    if (!sourceFile.test(entry.name)) continue;
-    let source: string;
+    if (!sourceFile.test(entry.name)) continue
+    let source: string
     try {
-      source = readFileSync(file, 'utf8');
+      source = readFileSync(file, 'utf8')
     } catch {
-      continue;
+      continue
     }
-    if (match(source)) return true;
+    if (match(source)) return true
   }
-  return false;
+  return false
+}
+
+/**
+ * Build-time app fact: can any first-party source render `<Link legacyBehavior>`? The legacy child path
+ * (child validation, the deprecation notice, the server/lazy child diagnostics, cloneElement) is a
+ * meaningful slice of `next/link`, and next/link is initial on every page that links anywhere.
+ *
+ * One-sided like the blur gate: every unreadable case answers "yes". A wrong "no" renders the legacy
+ * child shape on the server and a plain anchor on the client - a hydration mismatch. The scan sees the
+ * app and its workspace packages, not registry dependencies.
+ */
+const legacyProp = /\blegacyBehavior\b/
+
+/** A Link re-exported from here can be rendered by a file this scan can't tie
+ * back to `next/link`, so treat the re-export itself as usage. */
+const reexportedLink = /export\s[^;]*from\s*['"]next\/link['"]/
+
+const legacyLinkCache = new Map<string, boolean>()
+
+export function appUsesLegacyLink(root: string) {
+  const cached = legacyLinkCache.get(root)
+  if (cached !== undefined) return cached
+  const used = scanFirstPartySource(
+    root,
+    source => legacyProp.test(source) || reexportedLink.test(source),
+  )
+  legacyLinkCache.set(root, used)
+  return used
 }

package/src/compat/next/user-agent.ts

@@ -7,23 +7,23 @@
 // (request/context, ppr, cache/revalidate) into the browser bundle.
 
 /** Native URLPattern when the runtime provides one (Bun/Node 23+/browsers). */
-export const URLPattern = (globalThis as { URLPattern?: unknown }).URLPattern;
+export const URLPattern = (globalThis as { URLPattern?: unknown }).URLPattern
 
 export interface UserAgent {
-  ua: string;
-  browser: { name?: string; version?: string };
-  os: { name?: string; version?: string };
-  device: { type?: string; vendor?: string; model?: string };
-  engine: { name?: string; version?: string };
-  cpu: { architecture?: string };
-  isBot: boolean;
+  ua: string
+  browser: { name?: string; version?: string }
+  os: { name?: string; version?: string }
+  device: { type?: string; vendor?: string; model?: string }
+  engine: { name?: string; version?: string }
+  cpu: { architecture?: string }
+  isBot: boolean
 }
 
 const botPattern =
-  /bot|crawler|spider|crawling|slurp|bingpreview|facebookexternalhit|mediapartners|headless/i;
+  /bot|crawler|spider|crawling|slurp|bingpreview|facebookexternalhit|mediapartners|headless/i
 
 export function userAgentFromString(input: string | undefined): UserAgent {
-  const ua = input ?? '';
+  const ua = input ?? ''
   return {
     ua,
     browser: parseBrowser(ua),
@@ -32,69 +32,73 @@ export function userAgentFromString(input: string | undefined): UserAgent {
     engine: parseEngine(ua),
     cpu: parseCpu(ua),
     isBot: botPattern.test(ua),
-  };
+  }
 }
 
 export function userAgent({ headers }: { headers: Headers }): UserAgent {
-  return userAgentFromString(headers.get('user-agent') ?? undefined);
+  return userAgentFromString(headers.get('user-agent') ?? undefined)
 }
 
 function parseBrowser(ua: string): UserAgent['browser'] {
-  const edge = ua.match(/Edg(?:e|A|iOS)?\/([\d.]+)/);
-  if (edge) return { name: 'Edge', version: edge[1] };
-  const samsung = ua.match(/SamsungBrowser\/([\d.]+)/);
-  if (samsung) return { name: 'Samsung Internet', version: samsung[1] };
-  const chrome = ua.match(/(?:Chrome|CriOS)\/([\d.]+)/);
-  if (chrome) return { name: 'Chrome', version: chrome[1] };
-  const firefox = ua.match(/(?:Firefox|FxiOS)\/([\d.]+)/);
-  if (firefox) return { name: 'Firefox', version: firefox[1] };
-  if (ua.includes('Safari')) return { name: 'Safari', version: ua.match(/Version\/([\d.]+)/)?.[1] };
-  return {};
+  const edge = ua.match(/Edg(?:e|A|iOS)?\/([\d.]+)/)
+  if (edge) return { name: 'Edge', version: edge[1] }
+  const samsung = ua.match(/SamsungBrowser\/([\d.]+)/)
+  if (samsung) return { name: 'Samsung Internet', version: samsung[1] }
+  const chrome = ua.match(/(?:Chrome|CriOS)\/([\d.]+)/)
+  if (chrome) return { name: 'Chrome', version: chrome[1] }
+  const firefox = ua.match(/(?:Firefox|FxiOS)\/([\d.]+)/)
+  if (firefox) return { name: 'Firefox', version: firefox[1] }
+  if (ua.includes('Safari')) return { name: 'Safari', version: ua.match(/Version\/([\d.]+)/)?.[1] }
+  return {}
 }
 
 function parseEngine(ua: string): UserAgent['engine'] {
-  const gecko = ua.match(/rv:([\d.]+)\).*Gecko/);
-  if (gecko) return { name: 'Gecko', version: gecko[1] };
-  const webkit = ua.match(/AppleWebKit\/([\d.]+)/);
+  const gecko = ua.match(/rv:([\d.]+)\).*Gecko/)
+  if (gecko) return { name: 'Gecko', version: gecko[1] }
+  const webkit = ua.match(/AppleWebKit\/([\d.]+)/)
   if (webkit) {
-    const chrome = ua.match(/(?:Chrome|CriOS|Edg(?:e|A|iOS)?|OPR)\/([\d.]+)/);
-    if (chrome) return { name: 'Blink', version: chrome[1] };
-    return { name: 'WebKit', version: webkit[1] };
+    const chrome = ua.match(/(?:Chrome|CriOS|Edg(?:e|A|iOS)?|OPR)\/([\d.]+)/)
+    if (chrome) return { name: 'Blink', version: chrome[1] }
+    return { name: 'WebKit', version: webkit[1] }
   }
-  return {};
+  return {}
 }
 
 function parseCpu(ua: string): UserAgent['cpu'] {
-  if (/arm64|aarch64/i.test(ua)) return { architecture: 'arm64' };
-  if (/\barm\b/i.test(ua)) return { architecture: 'arm' };
-  if (/x86_64|x64|Win64|WOW64/i.test(ua)) return { architecture: 'amd64' };
-  if (/i686|\bx86\b/i.test(ua)) return { architecture: 'ia32' };
-  return {};
+  if (/arm64|aarch64/i.test(ua)) return { architecture: 'arm64' }
+  if (/\barm\b/i.test(ua)) return { architecture: 'arm' }
+  if (/x86_64|x64|Win64|WOW64/i.test(ua)) return { architecture: 'amd64' }
+  if (/i686|\bx86\b/i.test(ua)) return { architecture: 'ia32' }
+  return {}
 }
 
 function parseOs(ua: string): UserAgent['os'] {
-  if (ua.includes('Windows')) return { name: 'Windows', version: ua.match(/Windows NT ([\d.]+)/)?.[1] };
-  if (ua.includes('Android')) return { name: 'Android', version: ua.match(/Android ([\d.]+)/)?.[1] };
+  if (ua.includes('Windows'))
+    return { name: 'Windows', version: ua.match(/Windows NT ([\d.]+)/)?.[1] }
+  if (ua.includes('Android')) return { name: 'Android', version: ua.match(/Android ([\d.]+)/)?.[1] }
   if (/iPhone|iPad|iPod/.test(ua)) {
-    return { name: 'iOS', version: ua.match(/OS (\d+(?:[_.]\d+)*)/)?.[1]?.replace(/_/g, '.') };
+    return { name: 'iOS', version: ua.match(/OS (\d+(?:[_.]\d+)*)/)?.[1]?.replace(/_/g, '.') }
   }
   if (ua.includes('Mac OS X')) {
-    return { name: 'Mac OS', version: ua.match(/Mac OS X (\d+(?:[_.]\d+)*)/)?.[1]?.replace(/_/g, '.') };
+    return {
+      name: 'Mac OS',
+      version: ua.match(/Mac OS X (\d+(?:[_.]\d+)*)/)?.[1]?.replace(/_/g, '.'),
+    }
   }
-  if (ua.includes('Linux')) return { name: 'Linux' };
-  return {};
+  if (ua.includes('Linux')) return { name: 'Linux' }
+  return {}
 }
 
 function parseDevice(ua: string): UserAgent['device'] {
-  if (ua.includes('iPhone')) return { type: 'mobile', vendor: 'Apple', model: 'iPhone' };
-  if (ua.includes('iPad')) return { type: 'tablet', vendor: 'Apple', model: 'iPad' };
+  if (ua.includes('iPhone')) return { type: 'mobile', vendor: 'Apple', model: 'iPhone' }
+  if (ua.includes('iPad')) return { type: 'tablet', vendor: 'Apple', model: 'iPad' }
   if (ua.includes('Android')) {
-    const type = ua.includes('Mobile') ? 'mobile' : 'tablet';
-    const samsung = ua.match(/\b(SM-[\w]+)\b/);
-    if (samsung) return { type, vendor: 'Samsung', model: samsung[1] };
-    const pixel = ua.match(/;\s*(Pixel[\w ]*?)\s*(?:Build|\))/);
-    if (pixel) return { type, vendor: 'Google', model: pixel[1] };
-    return { type };
+    const type = ua.includes('Mobile') ? 'mobile' : 'tablet'
+    const samsung = ua.match(/\b(SM-[\w]+)\b/)
+    if (samsung) return { type, vendor: 'Samsung', model: samsung[1] }
+    const pixel = ua.match(/;\s*(Pixel[\w ]*?)\s*(?:Build|\))/)
+    if (pixel) return { type, vendor: 'Google', model: pixel[1] }
+    return { type }
   }
-  return ua.includes('Mobile') ? { type: 'mobile' } : {};
+  return ua.includes('Mobile') ? { type: 'mobile' } : {}
 }

package/src/compat/next/web-vitals.ts

@@ -1,30 +1,28 @@
-'use client';
+'use client'
 
 // `next/web-vitals` compat surface. Next measures Core Web Vitals (plus its own Next.js-* custom
 // metrics) and invokes the reporter callback per registered hook instance. The Core Web Vitals are
 // backed by the `web-vitals` package - this is browser-bundled client code, so the import stays a plain
 // static import for the bundler to resolve. Next's own custom metrics are not emitted here.
-import { useEffect, useRef } from 'preact/hooks';
-import * as webVitals from 'web-vitals';
-import type { Metric } from 'web-vitals';
+import { useEffect, useRef } from 'preact/hooks'
+import * as webVitals from 'web-vitals'
+import type { Metric } from 'web-vitals'
 
 export interface NextWebVitalsMetric {
-  id: string;
-  name: string;
-  startTime: number;
-  value: number;
-  label: 'web-vital' | 'custom';
+  id: string
+  name: string
+  startTime: number
+  value: number
+  label: 'web-vital' | 'custom'
 }
 
-export function useReportWebVitals(
-  reportWebVitalsFn: (metric: NextWebVitalsMetric) => void,
-): void {
+export function useReportWebVitals(reportWebVitalsFn: (metric: NextWebVitalsMetric) => void): void {
   // Route metrics through a ref so the latest reporter identity receives them
   // without resubscribing to web-vitals on every render.
-  const reporterRef = useRef(reportWebVitalsFn);
+  const reporterRef = useRef(reportWebVitalsFn)
   useEffect(() => {
-    reporterRef.current = reportWebVitalsFn;
-  }, [reportWebVitalsFn]);
+    reporterRef.current = reportWebVitalsFn
+  }, [reportWebVitalsFn])
 
   useEffect(() => {
     const report = (metric: Metric): void => {
@@ -34,23 +32,23 @@ export function useReportWebVitals(
         startTime: metric.entries[0]?.startTime ?? 0,
         value: metric.value,
         label: 'web-vital',
-      });
-    };
+      })
+    }
 
-    webVitals.onTTFB(report);
-    webVitals.onFCP(report);
-    webVitals.onLCP(report);
+    webVitals.onTTFB(report)
+    webVitals.onFCP(report)
+    webVitals.onLCP(report)
     // CLS and INP accumulate over the page lifetime and, by default, only settle
     // when the page is hidden. A page that is never hidden (or one torn down by a
     // navigation before the visibilitychange flush lands) therefore never reports
     // them at all. Both metrics are documented as multi-report: `reportAllChanges`
     // emits each new value as it is determined instead of a single deferred one,
     // so opting in makes delivery deterministic without dropping any information.
-    webVitals.onCLS(report, { reportAllChanges: true });
-    webVitals.onINP(report, { reportAllChanges: true });
+    webVitals.onCLS(report, { reportAllChanges: true })
+    webVitals.onINP(report, { reportAllChanges: true })
     // `onFID` is deprecated (removed in newer majors); subscribe only if present.
     if (typeof webVitals.onFID === 'function') {
-      webVitals.onFID(report);
+      webVitals.onFID(report)
     }
-  }, []);
+  }, [])
 }

package/src/compat/otel/api.ts

@@ -10,31 +10,31 @@
 // share ONE api singleton - the same module instance the app's provider.register() mutated. A bare
 // import would resolve against pnext's location and never see the registered provider.
 
-import { createRequire } from 'node:module';
-import path from 'node:path';
+import { createRequire } from 'node:module'
+import path from 'node:path'
 
 // Structural subset of @opentelemetry/api we use. Kept local so pnext carries no
 // type dependency on the package (it may be absent).
 export interface OtelSpanContext {
-  traceId: string;
-  spanId: string;
-  traceFlags: number;
+  traceId: string
+  spanId: string
+  traceFlags: number
 }
 
 export interface OtelSpan {
-  setAttribute(key: string, value: unknown): OtelSpan;
-  setAttributes(attrs: Record<string, unknown>): OtelSpan;
-  setStatus(status: { code: number; message?: string }): OtelSpan;
-  recordException(error: unknown): void;
-  updateName(name: string): OtelSpan;
-  end(endTime?: number): void;
-  spanContext(): OtelSpanContext;
-  isRecording(): boolean;
+  setAttribute(key: string, value: unknown): OtelSpan
+  setAttributes(attrs: Record<string, unknown>): OtelSpan
+  setStatus(status: { code: number; message?: string }): OtelSpan
+  recordException(error: unknown): void
+  updateName(name: string): OtelSpan
+  end(endTime?: number): void
+  spanContext(): OtelSpanContext
+  isRecording(): boolean
 }
 
 export interface OtelContext {
   // opaque
-  readonly __brand?: 'otel-context';
+  readonly __brand?: 'otel-context'
 }
 
 export interface OtelTracer {
@@ -42,54 +42,54 @@ export interface OtelTracer {
     name: string,
     options?: { kind?: number; attributes?: Record<string, unknown>; startTime?: number },
     context?: OtelContext,
-  ): OtelSpan;
+  ): OtelSpan
 }
 
 export interface OtelApi {
   trace: {
-    getTracer(name: string, version?: string): OtelTracer;
-    getSpan(context: OtelContext): OtelSpan | undefined;
-    getSpanContext(context: OtelContext): OtelSpanContext | undefined;
-    setSpan(context: OtelContext, span: OtelSpan): OtelContext;
-    setSpanContext(context: OtelContext, sc: OtelSpanContext): OtelContext;
-  };
+    getTracer(name: string, version?: string): OtelTracer
+    getSpan(context: OtelContext): OtelSpan | undefined
+    getSpanContext(context: OtelContext): OtelSpanContext | undefined
+    setSpan(context: OtelContext, span: OtelSpan): OtelContext
+    setSpanContext(context: OtelContext, sc: OtelSpanContext): OtelContext
+  }
   context: {
-    active(): OtelContext;
-    with<T>(context: OtelContext, fn: () => T): T;
-  };
+    active(): OtelContext
+    with<T>(context: OtelContext, fn: () => T): T
+  }
   propagation: {
-    extract(context: OtelContext, carrier: unknown, getter?: unknown): OtelContext;
-    inject(context: OtelContext, carrier: unknown, setter?: unknown): void;
-    fields(): string[];
-  };
-  ROOT_CONTEXT: OtelContext;
-  SpanKind: { INTERNAL: number; SERVER: number; CLIENT: number; PRODUCER: number; CONSUMER: number };
-  SpanStatusCode: { UNSET: number; OK: number; ERROR: number };
-  TraceFlags: { NONE: number; SAMPLED: number };
+    extract(context: OtelContext, carrier: unknown, getter?: unknown): OtelContext
+    inject(context: OtelContext, carrier: unknown, setter?: unknown): void
+    fields(): string[]
+  }
+  ROOT_CONTEXT: OtelContext
+  SpanKind: { INTERNAL: number; SERVER: number; CLIENT: number; PRODUCER: number; CONSUMER: number }
+  SpanStatusCode: { UNSET: number; OK: number; ERROR: number }
+  TraceFlags: { NONE: number; SAMPLED: number }
 }
 
-let resolved: OtelApi | null | undefined;
+let resolved: OtelApi | null | undefined
 
 /**
  * Load `@opentelemetry/api` from the app root (once). Returns null when the
  * package is not installed — callers then no-op. Never throws.
  */
 export function getOtelApi(appRoot: string): OtelApi | null {
-  if (resolved !== undefined) return resolved;
-  resolved = null;
+  if (resolved !== undefined) return resolved
+  resolved = null
   try {
     // Resolve against a file inside the app root so Node walks the app's
     // node_modules (where instrumentation.ts's @opentelemetry/api lives).
-    const req = createRequire(path.join(appRoot, 'package.json'));
-    const api = req('@opentelemetry/api') as OtelApi;
-    if (api?.trace && api.context) resolved = api;
+    const req = createRequire(path.join(appRoot, 'package.json'))
+    const api = req('@opentelemetry/api') as OtelApi
+    if (api?.trace && api.context) resolved = api
   } catch {
-    resolved = null;
+    resolved = null
   }
-  return resolved;
+  return resolved
 }
 
 /** Test/bootstrap reset. */
 export function resetOtelApi(): void {
-  resolved = undefined;
+  resolved = undefined
 }

package/src/compat/otel/client-trace-metadata.ts

@@ -10,8 +10,8 @@
 // nothing, while dev emits for static too. The tags are produced once per document render, so soft navs
 // never mutate them.
 
-import { getNextConfig } from '../next/config-loader';
-import { activeOtelContext, carrierSetter } from './tracer';
+import { getNextConfig } from '../next/config-loader'
+import { activeOtelContext, carrierSetter } from './tracer'
 
 /**
  * Return the clientTraceMetadata `<meta>` tag HTML for the current render, or ''
@@ -22,44 +22,42 @@ import { activeOtelContext, carrierSetter } from './tracer';
  * defensively.
  */
 export function clientTraceMetadataTags(input: {
-  dynamic: boolean;
-  isNextStart: boolean;
-  rsc: boolean;
+  dynamic: boolean
+  isNextStart: boolean
+  rsc: boolean
 }): string {
-  const keys = configuredKeys();
-  if (keys.length === 0) return '';
-  if (input.rsc) return '';
+  const keys = configuredKeys()
+  if (keys.length === 0) return ''
+  if (input.rsc) return ''
   // Prod + static → no injection. Dev injects for static too (handled by the
   // caller passing dynamic=true in dev, since a dev render is never prebuilt).
-  if (input.isNextStart && !input.dynamic) return '';
+  if (input.isNextStart && !input.dynamic) return ''
 
-  const active = activeOtelContext();
-  if (!active) return '';
-  const { api, context } = active;
+  const active = activeOtelContext()
+  if (!active) return ''
+  const { api, context } = active
 
-  const carrier: Record<string, string> = {};
+  const carrier: Record<string, string> = {}
   try {
-    api.propagation.inject(context, carrier, carrierSetter);
+    api.propagation.inject(context, carrier, carrierSetter)
   } catch {
-    return '';
+    return ''
   }
 
-  const tags: string[] = [];
+  const tags: string[] = []
   for (const key of keys) {
-    const value = carrier[key];
-    if (value === undefined || value === null) continue;
-    tags.push(`<meta name="${escapeAttr(key)}" content="${escapeAttr(String(value))}"/>`);
+    const value = carrier[key]
+    if (value === undefined || value === null) continue
+    tags.push(`<meta name="${escapeAttr(key)}" content="${escapeAttr(String(value))}"/>`)
   }
-  return tags.join('');
+  return tags.join('')
 }
 
 function configuredKeys(): string[] {
-  const experimental = getNextConfig().experimental as
-    | { clientTraceMetadata?: unknown }
-    | undefined;
-  const list = experimental?.clientTraceMetadata;
-  if (!Array.isArray(list)) return [];
-  return list.filter((k): k is string => typeof k === 'string');
+  const experimental = getNextConfig().experimental as { clientTraceMetadata?: unknown } | undefined
+  const list = experimental?.clientTraceMetadata
+  if (!Array.isArray(list)) return []
+  return list.filter((k): k is string => typeof k === 'string')
 }
 
 function escapeAttr(value: string): string {
@@ -67,5 +65,5 @@ function escapeAttr(value: string): string {
     .replace(/&/g, '&amp;')
     .replace(/"/g, '&quot;')
     .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;');
+    .replace(/>/g, '&gt;')
 }