@wular/pnext 0.0.1

package/src/compat/next/server.ts

@@ -0,0 +1,28 @@
+import { requireRequest, requestApiPromise } from '../../request/context';
+import { assertRequestApiAllowedInAfter } from '../lifecycle/after-scope';
+import { assertNoDynamicApiInsideCache } from '../cache/revalidate';
+import { assertDynamicErrorRequestApi } from './headers';
+
+export { after } from '../lifecycle/after';
+export { io } from '../ppr/io';
+export { NextRequest, NextResponse } from '../../api/server';
+export type { NextRequestGeo } from '../../api/server';
+export type { NextFetchEvent } from '../../types';
+export type { ProxyConfig } from '../../proxy';
+export { ImageResponse } from './og';
+// Pure UA/URLPattern helpers live in a client-safe module so the client
+// `next/server` variant (client-server.ts) can share them without pulling this
+// file's node:async_hooks imports into the browser bundle.
+export { URLPattern, userAgent, userAgentFromString } from './user-agent';
+export type { UserAgent } from './user-agent';
+
+/** Marks the surrounding scope as dynamic, like headers()/cookies(). */
+export function connection(): Promise<Record<never, never>> {
+  assertRequestApiAllowedInAfter('connection()');
+  assertDynamicErrorRequestApi('connection()');
+  assertNoDynamicApiInsideCache('connection()');
+  return requestApiPromise('connection()', () => {
+    requireRequest('connection()');
+    return {};
+  });
+}

package/src/compat/next/svgr.ts

@@ -0,0 +1,58 @@
+// SVGR-style `.svg`-as-component detection + inline SVG component generation (COMPAT).
+//
+// Projects commonly wire `@svgr/webpack` into next.config's `webpack()` to import `.svg` files as
+// React/Preact components instead of static asset URLs. pnext has no webpack graph to run that loader
+// against, but the overwhelming majority of configurations use its stock defaults, so detect the
+// reference and reproduce the import-as-component semantics directly against core's `staticAssetModule`
+// seam (see image/static-metadata.ts) instead of executing the loader.
+
+let svgAsComponent = false;
+
+/** Derived per config load (see config-loader's setNextConfig) — never a process one-shot. */
+export function setSvgAsComponentEnabled(enabled: boolean): void {
+  svgAsComponent = enabled;
+}
+
+export function isSvgAsComponentEnabled(): boolean {
+  return svgAsComponent;
+}
+
+/** True when next.config's `webpack()` references `@svgr/webpack` (the common custom-loader use). */
+export function webpackReferencesSvgr(config: { webpack?: unknown }): boolean {
+  return typeof config.webpack === 'function' && String(config.webpack).includes('@svgr/webpack');
+}
+
+const XML_PROLOGUE = /^\uFEFF?\s*(?:<\?xml[^>]*\?>\s*)?(?:<!DOCTYPE[^>]*>\s*)?/i;
+const SVG_TAG = /^<svg([^>]*)>([\s\S]*)<\/svg>\s*$/i;
+const ATTR = /([a-zA-Z_:][-a-zA-Z0-9_:.]*)\s*=\s*"([^"]*)"|([a-zA-Z_:][-a-zA-Z0-9_:.]*)\s*=\s*'([^']*)'/g;
+
+function parseRootAttrs(raw: string): Record<string, string> {
+  const attrs: Record<string, string> = {};
+  for (const match of raw.matchAll(ATTR)) {
+    const name = match[1] ?? match[3];
+    const value = match[2] ?? match[4] ?? '';
+    if (name) attrs[name] = value;
+  }
+  return attrs;
+}
+
+/**
+ * Generate the ESM module text an SVGR-mode `.svg` import evaluates to: a Preact component rendering the
+ * SVG inline. Root attributes spread first so a caller's `className`/`width`/`height`/etc. props override
+ * them — matching `@svgr/webpack`'s default output semantics. Identical for server and client bundles, so
+ * hydration sees the same markup the server rendered.
+ */
+export function svgComponentModule(bytes: Uint8Array): string {
+  const text = new TextDecoder().decode(bytes).replace(XML_PROLOGUE, '').trim();
+  const match = SVG_TAG.exec(text);
+  const rootAttrs = match ? parseRootAttrs(match[1] ?? '') : {};
+  const inner = match ? match[2] : text;
+  return `import { h } from 'preact';
+const __pnextSvgAttrs = ${JSON.stringify(rootAttrs)};
+const __pnextSvgInner = ${JSON.stringify(inner)};
+function SvgComponent(props) {
+  return h('svg', { ...__pnextSvgAttrs, ...props, dangerouslySetInnerHTML: { __html: __pnextSvgInner } });
+}
+export default SvgComponent;
+`;
+}

package/src/compat/next/telemetry.ts

@@ -0,0 +1,77 @@
+// Telemetry debug emission (COMPAT).
+//
+// Next prints every telemetry event to stdout when NEXT_TELEMETRY_DEBUG is set: `[telemetry] ` plus a
+// pretty-printed `{ eventName, payload }`. Harnesses parse that output with a regex, so the two-space
+// indentation (closing brace at column 0) is part of the contract. pnext sends nothing anywhere - this
+// is wire-format parity only, emitted once per CLI session after next.config loads.
+
+import type { NextConfigObject } from './config-loader';
+
+const EVENT_CLI_SESSION_STARTED = 'NEXT_CLI_SESSION_STARTED';
+const EVENT_BUILD_FEATURE_USAGE = 'NEXT_BUILD_FEATURE_USAGE';
+
+let emitted = false;
+let featureUsageEmitted = false;
+
+function configuredStaleTimes(config: NextConfigObject): { static?: number; dynamic?: number } {
+  const experimental = config.experimental;
+  if (!experimental || typeof experimental !== 'object') return {};
+  const staleTimes = (experimental as { staleTimes?: unknown }).staleTimes;
+  if (!staleTimes || typeof staleTimes !== 'object') return {};
+  const value = staleTimes as { static?: unknown; dynamic?: unknown };
+  return {
+    ...(typeof value.static === 'number' ? { static: value.static } : {}),
+    ...(typeof value.dynamic === 'number' ? { dynamic: value.dynamic } : {}),
+  };
+}
+
+/** Print the session-started telemetry event when NEXT_TELEMETRY_DEBUG is on. */
+export function emitSessionStartedTelemetry(config: NextConfigObject): void {
+  if (emitted) return;
+  // eslint-disable-next-line turbo/no-undeclared-env-vars
+  if (!process.env.NEXT_TELEMETRY_DEBUG) return;
+  emitted = true;
+  const staleTimes = configuredStaleTimes(config);
+  const event = {
+    eventName: EVENT_CLI_SESSION_STARTED,
+    payload: {
+      nodeVersion: process.version,
+      cliCommand: process.argv[2] ?? 'unknown',
+      staticStaleTime: staleTimes.static ?? null,
+      dynamicStaleTime: staleTimes.dynamic ?? null,
+    },
+  };
+  console.log(`[telemetry] ${JSON.stringify(event, null, 2)}`);
+}
+
+/**
+ * Print `NEXT_BUILD_FEATURE_USAGE` events for the next.config features the suites assert on.
+ * Build-command only, matching Next (the event is produced by the build pipeline, not by start). Payload
+ * shape is exactly `{ featureName, invocationCount }` - the upstream assertions use `toContainEqual`, so
+ * any extra key fails the deep match.
+ */
+export function emitBuildFeatureUsageTelemetry(config: NextConfigObject): void {
+  if (featureUsageEmitted) return;
+  // eslint-disable-next-line turbo/no-undeclared-env-vars
+  if (!process.env.NEXT_TELEMETRY_DEBUG) return;
+  if ((process.argv[2] ?? '') !== 'build') return;
+  featureUsageEmitted = true;
+  const experimental = config.experimental;
+  const esmExternals =
+    experimental && typeof experimental === 'object'
+      ? (experimental as { esmExternals?: unknown }).esmExternals
+      : undefined;
+  // Next counts a feature as "used" only when it is set away from its default.
+  if (esmExternals !== undefined && esmExternals !== true) {
+    console.log(
+      `[telemetry] ${JSON.stringify(
+        {
+          eventName: EVENT_BUILD_FEATURE_USAGE,
+          payload: { featureName: 'esmExternals', invocationCount: 1 },
+        },
+        null,
+        2,
+      )}`,
+    );
+  }
+}

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

@@ -0,0 +1,100 @@
+// Pure (client-safe) `next/server` helpers: userAgent parsing + URLPattern.
+//
+// These carry no request scope and import no node:* builtins, so both the
+// server entry (server.ts) and the client-safe entry (client-server.ts)
+// re-export them. Kept in their own module so the client `next/server` variant
+// can pull them in without dragging server.ts's node:async_hooks imports
+// (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 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;
+}
+
+const botPattern =
+  /bot|crawler|spider|crawling|slurp|bingpreview|facebookexternalhit|mediapartners|headless/i;
+
+export function userAgentFromString(input: string | undefined): UserAgent {
+  const ua = input ?? '';
+  return {
+    ua,
+    browser: parseBrowser(ua),
+    os: parseOs(ua),
+    device: parseDevice(ua),
+    engine: parseEngine(ua),
+    cpu: parseCpu(ua),
+    isBot: botPattern.test(ua),
+  };
+}
+
+export function userAgent({ headers }: { headers: Headers }): UserAgent {
+  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 {};
+}
+
+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.]+)/);
+  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] };
+  }
+  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 {};
+}
+
+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 (/iPhone|iPad|iPod/.test(ua)) {
+    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, '.') };
+  }
+  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('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 };
+  }
+  return ua.includes('Mobile') ? { type: 'mobile' } : {};
+}

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

@@ -0,0 +1,56 @@
+'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';
+
+export interface NextWebVitalsMetric {
+  id: string;
+  name: string;
+  startTime: number;
+  value: number;
+  label: 'web-vital' | 'custom';
+}
+
+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);
+  useEffect(() => {
+    reporterRef.current = reportWebVitalsFn;
+  }, [reportWebVitalsFn]);
+
+  useEffect(() => {
+    const report = (metric: Metric): void => {
+      reporterRef.current({
+        id: metric.id,
+        name: metric.name,
+        startTime: metric.entries[0]?.startTime ?? 0,
+        value: metric.value,
+        label: 'web-vital',
+      });
+    };
+
+    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 });
+    // `onFID` is deprecated (removed in newer majors); subscribe only if present.
+    if (typeof webVitals.onFID === 'function') {
+      webVitals.onFID(report);
+    }
+  }, []);
+}

package/src/compat/otel/api.ts

@@ -0,0 +1,95 @@
+// @opentelemetry/api loader + thin typed surface (COMPAT).
+//
+// pnext emits Next's span taxonomy through the GLOBAL OpenTelemetry API the app's instrumentation.ts
+// registers. Only `@opentelemetry/api` (the stable facade) is ever touched; the app supplies the SDK.
+// The api package is an OPTIONAL runtime dependency: absent, every helper is an inert no-op so a
+// pure-core app is byte-identical.
+//
+// Resolution: `@opentelemetry/api` is not vendored into pnext (it would pin a version and duplicate the
+// singleton the app registered). It is resolved from the app's own node_modules, so pnext and the app
+// 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';
+
+// 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;
+}
+
+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;
+}
+
+export interface OtelContext {
+  // opaque
+  readonly __brand?: 'otel-context';
+}
+
+export interface OtelTracer {
+  startSpan(
+    name: string,
+    options?: { kind?: number; attributes?: Record<string, unknown>; startTime?: number },
+    context?: OtelContext,
+  ): 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;
+  };
+  context: {
+    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 };
+}
+
+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;
+  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;
+  } catch {
+    resolved = null;
+  }
+  return resolved;
+}
+
+/** Test/bootstrap reset. */
+export function resetOtelApi(): void {
+  resolved = undefined;
+}

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

@@ -0,0 +1,71 @@
+// experimental.clientTraceMetadata (COMPAT).
+//
+// For each key listed in `experimental.clientTraceMetadata`, inject a `<meta name="<key>"
+// content="<value>">` into the HTML head, where the value comes from running the app's GLOBAL
+// propagator inject() against the active render's span context. The app's propagator decides which keys
+// carry a value; keys with no injected value are skipped, and keys the propagator sets but that are not
+// in the config list are dropped.
+//
+// Gating (matches Next): only DYNAMIC renders, and only in production - a prod STATIC page emits
+// 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';
+
+/**
+ * Return the clientTraceMetadata `<meta>` tag HTML for the current render, or ''
+ * when the feature is off / not applicable. `dynamic` is true when the render is
+ * request-dependent (Next only injects on dynamic renders in prod). Values are
+ * escaped by the caller's head-composition path if needed; keys/values here come
+ * from config + the propagator and are attribute-safe in practice, but we escape
+ * defensively.
+ */
+export function clientTraceMetadataTags(input: {
+  dynamic: boolean;
+  isNextStart: boolean;
+  rsc: boolean;
+}): string {
+  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 '';
+
+  const active = activeOtelContext();
+  if (!active) return '';
+  const { api, context } = active;
+
+  const carrier: Record<string, string> = {};
+  try {
+    api.propagation.inject(context, carrier, carrierSetter);
+  } catch {
+    return '';
+  }
+
+  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))}"/>`);
+  }
+  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');
+}
+
+function escapeAttr(value: string): string {
+  return value
+    .replace(/&/g, '&amp;')
+    .replace(/"/g, '&quot;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;');
+}

package/src/compat/otel/fetch-span.ts

@@ -0,0 +1,77 @@
+// AppRender.fetch span (COMPAT).
+//
+// Wraps globalThis.fetch to emit a `fetch <METHOD> <url>` CLIENT span nested under the request's render,
+// for every outgoing fetch made during a render. Installed AFTER the cache fetch-patch (register order:
+// cache before otel) so the span brackets the cache layer too. Disabled by NEXT_OTEL_FETCH_DISABLED=1.
+// Only emits when a root span is open, so build-time and out-of-request fetches pass through untouched.
+
+import { SPAN_TYPE, withChildSpan, rootOtelContext, otelExportInProgress } from './tracer';
+import { getOtelApi } from './api';
+
+let installed = false;
+
+export function installFetchSpan(appRoot: string): void {
+  if (installed) return;
+  // eslint-disable-next-line turbo/no-undeclared-env-vars
+  if (process.env.NEXT_OTEL_FETCH_DISABLED === '1') return;
+  if (!getOtelApi(appRoot)) return;
+  installed = true;
+
+  const original = globalThis.fetch.bind(globalThis);
+  const patched = async function fetch(
+    input: Parameters<typeof globalThis.fetch>[0],
+    init?: Parameters<typeof globalThis.fetch>[1],
+  ): Promise<Response> {
+    // Only trace inside an active request render (root span open).
+    if (otelExportInProgress()) return original(input, init);
+    if (!rootOtelContext()) return original(input, init);
+    const info = describeFetch(input, init);
+    if (!info) return original(input, init);
+    const name = `fetch ${info.method} ${info.url}`;
+    return withChildSpan(
+      name,
+      SPAN_TYPE.fetch,
+      {
+        'http.method': info.method,
+        'http.url': info.url,
+        'net.peer.name': info.host,
+      },
+      () => original(input, init),
+      { kind: fetchSpanKind() },
+    );
+  };
+  globalThis.fetch = patched as typeof globalThis.fetch;
+}
+
+function fetchSpanKind(): number | undefined {
+  // SpanKind.CLIENT (2) — resolved lazily so we don't hold the api reference.
+  return 2;
+}
+
+function describeFetch(
+  input: Parameters<typeof globalThis.fetch>[0],
+  init?: Parameters<typeof globalThis.fetch>[1],
+): { method: string; url: string; host: string } | undefined {
+  try {
+    let url: string;
+    let method = 'GET';
+    if (typeof input === 'string' || input instanceof URL) {
+      url = String(input);
+      method = (init?.method ?? 'GET').toUpperCase();
+    } else if (input instanceof Request) {
+      url = input.url;
+      method = (init?.method ?? input.method).toUpperCase();
+    } else {
+      return undefined;
+    }
+    if (!/^https?:/i.test(url)) return undefined;
+    const parsed = new URL(url);
+    return { method, url: parsed.href, host: parsed.hostname };
+  } catch {
+    return undefined;
+  }
+}
+
+export function resetFetchSpanForTest(): void {
+  installed = false;
+}