@rangojs/router 0.0.0-experimental.15 → 0.0.0-experimental.151

package/src/router/segment-wrappers.ts

@@ -0,0 +1,292 @@
+import type { EntryData, InterceptEntry } from "../server/context";
+import type {
+  HandlerContext,
+  ResolvedSegment,
+  ShouldRevalidateFn,
+} from "../types";
+import type { SegmentResolutionDeps } from "./types.js";
+import type { ResolveSegmentOptions } from "./segment-resolution.js";
+
+import {
+  resolveAllSegments as _resolveAllSegments,
+  resolveLoadersOnly as _resolveLoadersOnly,
+  resolveLoadersOnlyWithRevalidation as _resolveLoadersOnlyWithRevalidation,
+  buildEntryRevalidateMap as _buildEntryRevalidateMap,
+  resolveAllSegmentsWithRevalidation as _resolveAllSegmentsWithRevalidation,
+} from "./segment-resolution.js";
+
+import {
+  findInterceptForRoute as _findInterceptForRoute,
+  resolveInterceptEntry as _resolveInterceptEntry,
+  resolveInterceptLoadersOnly as _resolveInterceptLoadersOnly,
+} from "./intercept-resolution.js";
+
+import type { InterceptSelectorContext } from "../server/context";
+
+export interface SegmentWrappers<TEnv = any> {
+  resolveAllSegments: (
+    entries: EntryData[],
+    routeKey: string,
+    params: Record<string, string>,
+    context: HandlerContext<any, TEnv>,
+    loaderPromises: Map<string, Promise<any>>,
+    options?: ResolveSegmentOptions,
+  ) => Promise<ResolvedSegment[]>;
+  resolveLoadersOnly: (
+    entries: EntryData[],
+    context: HandlerContext<any, TEnv>,
+  ) => Promise<ResolvedSegment[]>;
+  resolveLoadersOnlyWithRevalidation: (
+    entries: EntryData[],
+    context: HandlerContext<any, TEnv>,
+    clientSegmentIds: Set<string>,
+    prevParams: Record<string, string>,
+    request: Request,
+    prevUrl: URL,
+    nextUrl: URL,
+    routeKey: string,
+    actionContext?: {
+      actionId?: string;
+      actionUrl?: URL;
+      actionResult?: any;
+      formData?: FormData;
+    },
+    stale?: boolean,
+  ) => Promise<{ segments: ResolvedSegment[]; matchedIds: string[] }>;
+  buildEntryRevalidateMap: (
+    entries: EntryData[],
+  ) => Map<
+    string,
+    { entry: EntryData; revalidate: ShouldRevalidateFn<any, any>[] }
+  >;
+  resolveAllSegmentsWithRevalidation: (
+    entries: EntryData[],
+    routeKey: string,
+    params: Record<string, string>,
+    context: HandlerContext<any, TEnv>,
+    clientSegmentSet: Set<string>,
+    prevParams: Record<string, string>,
+    request: Request,
+    prevUrl: URL,
+    nextUrl: URL,
+    actionContext:
+      | {
+          actionId?: string;
+          actionUrl?: URL;
+          actionResult?: any;
+          formData?: FormData;
+        }
+      | undefined,
+    interceptResult: { intercept: InterceptEntry; entry: EntryData } | null,
+    localRouteName: string,
+    pathname: string,
+  ) => Promise<{ segments: ResolvedSegment[]; matchedIds: string[] }>;
+  findInterceptForRoute: (
+    targetRouteKey: string,
+    fromEntry: EntryData | null,
+    selectorContext?: InterceptSelectorContext | null,
+    isAction?: boolean,
+  ) => { intercept: InterceptEntry; entry: EntryData } | null;
+  resolveInterceptEntry: (
+    interceptEntry: InterceptEntry,
+    parentEntry: EntryData,
+    params: Record<string, string>,
+    context: HandlerContext<any, TEnv>,
+    belongsToRoute?: boolean,
+    revalidationContext?: any,
+    options?: { skipMiddleware?: boolean },
+  ) => Promise<ResolvedSegment[]>;
+  resolveInterceptLoadersOnly: (
+    interceptEntry: InterceptEntry,
+    parentEntry: EntryData,
+    params: Record<string, string>,
+    context: HandlerContext<any, TEnv>,
+    belongsToRoute?: boolean,
+    revalidationContext?: any,
+  ) => Promise<{
+    loaderDataPromise: Promise<any[]> | any[];
+    loaderIds: string[];
+  } | null>;
+}
+
+/**
+ * Create thin wrapper functions that bind segmentDeps to extracted
+ * segment resolution and intercept resolution functions.
+ *
+ * These maintain the same signatures as the original inline functions
+ * so that RouterContext and call sites don't need to change.
+ */
+export function createSegmentWrappers<TEnv = any>(
+  segmentDeps: SegmentResolutionDeps<TEnv>,
+): SegmentWrappers<TEnv> {
+  function resolveAllSegments(
+    entries: EntryData[],
+    routeKey: string,
+    params: Record<string, string>,
+    context: HandlerContext<any, TEnv>,
+    loaderPromises: Map<string, Promise<any>>,
+    options?: ResolveSegmentOptions,
+  ): ReturnType<typeof _resolveAllSegments> {
+    return _resolveAllSegments(
+      entries,
+      routeKey,
+      params,
+      context,
+      loaderPromises,
+      segmentDeps,
+      options,
+    );
+  }
+
+  function resolveLoadersOnly(
+    entries: EntryData[],
+    context: HandlerContext<any, TEnv>,
+  ): ReturnType<typeof _resolveLoadersOnly> {
+    return _resolveLoadersOnly(entries, context, segmentDeps);
+  }
+
+  function resolveLoadersOnlyWithRevalidation(
+    entries: EntryData[],
+    context: HandlerContext<any, TEnv>,
+    clientSegmentIds: Set<string>,
+    prevParams: Record<string, string>,
+    request: Request,
+    prevUrl: URL,
+    nextUrl: URL,
+    routeKey: string,
+    actionContext?: {
+      actionId?: string;
+      actionUrl?: URL;
+      actionResult?: any;
+      formData?: FormData;
+    },
+    stale?: boolean,
+  ): ReturnType<typeof _resolveLoadersOnlyWithRevalidation> {
+    return _resolveLoadersOnlyWithRevalidation(
+      entries,
+      context,
+      clientSegmentIds,
+      prevParams,
+      request,
+      prevUrl,
+      nextUrl,
+      routeKey,
+      segmentDeps,
+      actionContext,
+      stale,
+    );
+  }
+
+  function buildEntryRevalidateMap(
+    entries: EntryData[],
+  ): ReturnType<typeof _buildEntryRevalidateMap> {
+    return _buildEntryRevalidateMap(entries);
+  }
+
+  function resolveAllSegmentsWithRevalidation(
+    entries: EntryData[],
+    routeKey: string,
+    params: Record<string, string>,
+    context: HandlerContext<any, TEnv>,
+    clientSegmentSet: Set<string>,
+    prevParams: Record<string, string>,
+    request: Request,
+    prevUrl: URL,
+    nextUrl: URL,
+    actionContext:
+      | {
+          actionId?: string;
+          actionUrl?: URL;
+          actionResult?: any;
+          formData?: FormData;
+        }
+      | undefined,
+    interceptResult: { intercept: InterceptEntry; entry: EntryData } | null,
+    localRouteName: string,
+    pathname: string,
+    stale?: boolean,
+  ): ReturnType<typeof _resolveAllSegmentsWithRevalidation> {
+    return _resolveAllSegmentsWithRevalidation(
+      entries,
+      routeKey,
+      params,
+      context,
+      clientSegmentSet,
+      prevParams,
+      request,
+      prevUrl,
+      nextUrl,
+      actionContext,
+      interceptResult,
+      localRouteName,
+      pathname,
+      segmentDeps,
+      stale,
+    );
+  }
+
+  function findInterceptForRoute(
+    targetRouteKey: string,
+    fromEntry: EntryData | null,
+    selectorContext: InterceptSelectorContext | null = null,
+    isAction: boolean = false,
+  ): ReturnType<typeof _findInterceptForRoute> {
+    return _findInterceptForRoute(
+      targetRouteKey,
+      fromEntry,
+      selectorContext,
+      isAction,
+    );
+  }
+
+  function resolveInterceptEntry(
+    interceptEntry: InterceptEntry,
+    parentEntry: EntryData,
+    params: Record<string, string>,
+    context: HandlerContext<any, TEnv>,
+    belongsToRoute: boolean = true,
+    revalidationContext?: any,
+    options?: { skipMiddleware?: boolean },
+  ): ReturnType<typeof _resolveInterceptEntry> {
+    return _resolveInterceptEntry(
+      interceptEntry,
+      parentEntry,
+      params,
+      context,
+      belongsToRoute,
+      segmentDeps,
+      revalidationContext,
+      options,
+    );
+  }
+
+  function resolveInterceptLoadersOnly(
+    interceptEntry: InterceptEntry,
+    parentEntry: EntryData,
+    params: Record<string, string>,
+    context: HandlerContext<any, TEnv>,
+    belongsToRoute: boolean = true,
+    revalidationContext: any,
+  ): ReturnType<typeof _resolveInterceptLoadersOnly> {
+    return _resolveInterceptLoadersOnly(
+      interceptEntry,
+      parentEntry,
+      params,
+      context,
+      belongsToRoute,
+      segmentDeps,
+      revalidationContext,
+    );
+  }
+
+  return {
+    resolveAllSegments: resolveAllSegments,
+    resolveLoadersOnly: resolveLoadersOnly,
+    resolveLoadersOnlyWithRevalidation: resolveLoadersOnlyWithRevalidation,
+    buildEntryRevalidateMap: buildEntryRevalidateMap,
+    resolveAllSegmentsWithRevalidation: resolveAllSegmentsWithRevalidation,
+    findInterceptForRoute: findInterceptForRoute,
+    resolveInterceptEntry: resolveInterceptEntry,
+    resolveInterceptLoadersOnly: resolveInterceptLoadersOnly,
+  };
+}

package/src/router/state-cookie-name.ts

@@ -0,0 +1,33 @@
+import { DEFAULT_STATE_COOKIE_PREFIX } from "../browser/cookie-name.js";
+
+/**
+ * Resolve the rango state cookie name once, server-side, at router init. The
+ * resolved string is shipped in payload metadata and the client reads it
+ * verbatim, so composition happens in exactly one place.
+ *
+ * Shape: `{sanitizedPrefix}_{sanitizedRouterId}`. The prefix charset excludes
+ * `_` so the FIRST `_` is always the prefix/routerId boundary; that keeps the
+ * name injective even though a routerId may legitimately contain `_` (the
+ * counter fallback is `router_{n}`). Without that exclusion, prefix
+ * `rango-state` + id `router_0` and prefix `rango-state_router` + id `0` would
+ * both resolve to `rango-state_router_0` and silently share a cache key.
+ */
+
+// Prefix excludes `_` so it can never collide with the separator.
+function sanitizePrefix(prefix: string): string {
+  return prefix.replace(/[^A-Za-z0-9-]/g, "");
+}
+
+// routerId keeps `_` (so `router_0` survives); other illegal chars are dropped.
+function sanitizeRouterId(routerId: string): string {
+  return routerId.replace(/[^A-Za-z0-9_-]/g, "");
+}
+
+export function resolveStateCookieName(
+  prefix: string | undefined,
+  routerId: string,
+): string {
+  const sanitized = sanitizePrefix(prefix ?? DEFAULT_STATE_COOKIE_PREFIX);
+  const finalPrefix = sanitized || DEFAULT_STATE_COOKIE_PREFIX;
+  return `${finalPrefix}_${sanitizeRouterId(routerId)}`;
+}

package/src/router/substitute-pattern-params.ts

@@ -0,0 +1,75 @@
+import { encodePathSegment, encodePathRemainder } from "./url-params.js";
+import { parsePattern } from "./parse-pattern.js";
+
+/**
+ * Substitute `:param` placeholders in a route pattern with values from
+ * `params`, producing a URL. Built by walking the SAME parsed segments the
+ * matcher uses (`parsePattern`) and emitting one piece per segment — so a
+ * substituted value is never re-scanned as if it were another placeholder (a
+ * catch-all value like `sha:abc/x` used to make the "required" pass read `:abc`
+ * and throw). Constraint syntax (`:name(en|gb)`) is stripped; trailing-slash
+ * patterns like `/blog/` are preserved unless an optional segment was omitted.
+ *
+ * Semantics per segment:
+ * - static             -> emitted verbatim.
+ * - `:name`            -> required; `undefined` throws, `""` yields an empty segment.
+ * - `:name?`           -> optional; `undefined`/`""` omitted.
+ * - `:name*` / `:name+`-> catch-all; the value is multi-segment, so each segment
+ *                         is encoded and the `/` separators are preserved. `+`
+ *                         (one-or-more) throws when absent; `*` (and bare `*`)
+ *                         omit when absent.
+ *
+ * Shared by `ctx.reverse()` (server), `createReverse()` (typed runtime
+ * helper), and `useReverse()` (client hook). The behavior must stay
+ * identical across all three call sites.
+ */
+export function substitutePatternParams(
+  pattern: string,
+  params: Record<string, string | undefined>,
+  routeName: string,
+): string {
+  const hasTrailingSlash = pattern.length > 1 && pattern.endsWith("/");
+  const normalized = hasTrailingSlash ? pattern.slice(0, -1) : pattern;
+  const segments = parsePattern(normalized);
+
+  const parts: string[] = [];
+  for (const seg of segments) {
+    if (seg.type === "static") {
+      parts.push("/" + seg.value);
+    } else if (seg.type === "wildcard") {
+      const value = params[seg.value];
+      if (value === undefined || value === "") {
+        // `:name+` requires at least one segment; bare `*` / `:name*` collapse.
+        if (seg.oneOrMore) {
+          throw new Error(
+            `Missing param "${seg.value}" for route "${routeName}"`,
+          );
+        }
+      } else {
+        parts.push("/" + encodePathRemainder(value));
+      }
+    } else {
+      // Plain param. Constraint (`seg.constraint`) is intentionally not re-emitted.
+      const value = params[seg.value];
+      const suffix = seg.suffix ?? "";
+      if (seg.optional) {
+        // The matcher omits absent optionals (`undefined`); callers/getParams()
+        // may pass `""` explicitly — treat both as absent.
+        if (value !== undefined && value !== "") {
+          parts.push("/" + encodePathSegment(value) + suffix);
+        }
+      } else {
+        if (value === undefined) {
+          throw new Error(
+            `Missing param "${seg.value}" for route "${routeName}"`,
+          );
+        }
+        parts.push("/" + encodePathSegment(value) + suffix);
+      }
+    }
+  }
+
+  let result = parts.join("") || "/";
+  if (hasTrailingSlash && !result.endsWith("/")) result += "/";
+  return result;
+}

package/src/router/telemetry-otel.ts

@@ -0,0 +1,259 @@
+/**
+ * OpenTelemetry adapters for the router.
+ *
+ * Two adapters, two surfaces — matching the split in instrument.ts:
+ *
+ *   - createOTelTracing(tracer): the OTel adapter for the `tracing` SLOT — the
+ *     canonical phase-span layer. It bridges observePhase's callback boundary
+ *     onto OTel's callback-bound `startActiveSpan`, so the router's phase spans
+ *     (rango.request/middleware/loader/render/ssr) nest by async context and the
+ *     loader's own OTel spans (db/fetch) land under rango.loader. This is the
+ *     OTel equivalent of createCloudflareTracing — pass it to
+ *     `createRouter({ tracing })`.
+ *
+ *   - createOTelSink(tracer): the OTel adapter for the `telemetry` SLOT — a
+ *     TelemetrySink for the EVENT-shaped facts (handler errors, cache decisions,
+ *     revalidation decisions, timeouts, origin rejections). It emits one instant
+ *     OTel span per fact. It deliberately does NOT emit request/loader phase
+ *     spans: those are owned by the tracing slot (createOTelTracing) so the two
+ *     layers don't produce duplicate rango.request / rango.loader spans.
+ *
+ * The core router stays OTel-agnostic — these adapters accept a standard OTel
+ * Tracer (structurally typed, no import needed) and bridge the gap.
+ *
+ * Usage:
+ *   import { trace } from "@opentelemetry/api";
+ *   import { createRouter, createOTelTracing, createOTelSink } from "@rangojs/router";
+ *
+ *   const tracer = trace.getTracer("my-app");
+ *   const router = createRouter({
+ *     tracing: createOTelTracing(tracer),   // phase spans (callback-bound)
+ *     telemetry: createOTelSink(tracer),     // discrete-fact instant spans
+ *   });
+ *
+ * Faithful nesting requires an OTel async context manager
+ * (AsyncLocalStorageContextManager) configured in your OTel setup — standard for
+ * any startActiveSpan-based instrumentation.
+ */
+
+import type { TelemetrySink, TelemetryEvent } from "./telemetry.js";
+import { runThenSettle } from "./tracing.js";
+import type {
+  RouterTracingConfig,
+  SpanRunner,
+  TracingToggleOptions,
+} from "./tracing.js";
+
+// ---------------------------------------------------------------------------
+// Minimal OTel-compatible types (structurally typed, no import needed)
+// ---------------------------------------------------------------------------
+
+/**
+ * Minimal Span interface compatible with @opentelemetry/api Span.
+ * Only the methods used by the adapters are declared.
+ */
+export interface OTelSpan {
+  setAttribute(key: string, value: string | number | boolean): OTelSpan | void;
+  setStatus(status: { code: number; message?: string }): OTelSpan | void;
+  recordException(exception: Error): void;
+  end(): void;
+}
+
+/**
+ * Minimal Tracer interface for the EVENT sink (createOTelSink): only `startSpan`
+ * is used (one instant span per discrete fact). Kept narrow so a custom,
+ * event-only tracer that does not implement `startActiveSpan` still satisfies it.
+ * The real `@opentelemetry/api` Tracer has both methods, so it satisfies this and
+ * `OTelActiveSpanTracer` below.
+ */
+export interface OTelTracer {
+  startSpan(
+    name: string,
+    options?: {
+      attributes?: Record<string, string | number | boolean>;
+    },
+  ): OTelSpan;
+}
+
+/**
+ * Minimal Tracer interface for the PHASE-SPAN adapter (createOTelTracing): only
+ * `startActiveSpan` is used (callback-bound, so the span is active for the work
+ * and child spans nest). Declared separately from `OTelTracer` so each factory
+ * requires exactly the method it calls.
+ */
+export interface OTelActiveSpanTracer {
+  startActiveSpan<T>(name: string, fn: (span: OTelSpan) => T): T;
+}
+
+// OTel SpanStatusCode constants (mirrors @opentelemetry/api values)
+const STATUS_ERROR = 2;
+
+// ---------------------------------------------------------------------------
+// Tracing adapter: phase spans via startActiveSpan (the `tracing` slot)
+// ---------------------------------------------------------------------------
+
+/**
+ * Options for createOTelTracing. Alias of the shared {@link TracingToggleOptions}
+ * (`enabled` master switch + per-phase `spans` toggles); the name is public API.
+ */
+export type OTelTracingOptions = TracingToggleOptions;
+
+/**
+ * Create the tracing config that maps the router's phases onto OTel spans via
+ * `tracer.startActiveSpan`, which runs the work inside the span's active context
+ * (so child spans nest) and returns the work's value unchanged. The span ends
+ * when that value — or, for async work, the returned promise — settles, matching
+ * observePhase's contract. When the work throws or rejects, the exception is
+ * recorded and the span status is set to ERROR before it ends, so a failed phase
+ * stays visible in the trace (the old createOTelSink error path is preserved here
+ * now that phase spans live in this adapter). Pass the result to
+ * `createRouter({ tracing })`.
+ *
+ * @see createCloudflareTracing (`@rangojs/router/cloudflare`) for the same slot
+ *   using Cloudflare Workers native custom spans.
+ */
+export function createOTelTracing(
+  tracer: OTelActiveSpanTracer,
+  options: OTelTracingOptions = {},
+): RouterTracingConfig {
+  const runner: SpanRunner = <T>(name: string, fn: (span: OTelSpan) => T): T =>
+    tracer.startActiveSpan(
+      name,
+      (span): T =>
+        runThenSettle(
+          () => fn(span),
+          (error) => {
+            // On failure record the exception + ERROR status before ending, so a
+            // failed phase stays visible in the trace.
+            if (error !== undefined) {
+              if (error instanceof Error) {
+                span.recordException(error);
+                span.setStatus({ code: STATUS_ERROR, message: error.message });
+              } else {
+                span.setStatus({ code: STATUS_ERROR });
+              }
+            }
+            span.end();
+          },
+        ),
+    );
+
+  return {
+    runner,
+    enabled: options.enabled ?? true,
+    spans: options.spans,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Telemetry sink: discrete-fact instant spans (the `telemetry` slot)
+// ---------------------------------------------------------------------------
+
+/**
+ * Create a TelemetrySink that maps the router's discrete-fact events to instant
+ * OTel spans. One span per fact; no duration spans.
+ *
+ * Fact mapping:
+ *   - handler.error              -> "rango.handler.error" (error)
+ *   - cache.decision             -> "rango.cache.decision"
+ *   - revalidation.decision      -> "rango.revalidation.decision"
+ *   - request.timeout            -> "rango.request.timeout" (error)
+ *   - request.origin-rejected    -> "rango.request.origin-rejected" (error)
+ *
+ * Request and loader PHASE spans are intentionally NOT emitted here — they are
+ * owned by the tracing slot (createOTelTracing) so the two layers cannot produce
+ * duplicate rango.request / rango.loader spans. request.start/end and
+ * loader.start/end events are no-ops for this sink.
+ *
+ * Attributes use the `rango.*` namespace for router-specific data and
+ * `http.method` / `http.route` for HTTP semantics.
+ */
+export function createOTelSink(tracer: OTelTracer): TelemetrySink {
+  const instant = (
+    name: string,
+    attributes: Record<string, string | number | boolean>,
+  ): OTelSpan => tracer.startSpan(name, { attributes });
+
+  return {
+    emit(event: TelemetryEvent): void {
+      switch (event.type) {
+        case "handler.error": {
+          const attrs: Record<string, string | number | boolean> = {
+            "rango.handled_by_boundary": event.handledByBoundary,
+          };
+          if (event.segmentId) attrs["rango.segment_id"] = event.segmentId;
+          if (event.segmentType)
+            attrs["rango.segment_type"] = event.segmentType;
+          if (event.pathname) attrs["http.route"] = event.pathname;
+          if (event.routeKey) attrs["rango.route_key"] = event.routeKey;
+          if (event.params)
+            attrs["rango.params"] = JSON.stringify(event.params);
+
+          const span = instant("rango.handler.error", attrs);
+          span.recordException(event.error);
+          span.setStatus({ code: STATUS_ERROR, message: event.error.message });
+          span.end();
+          break;
+        }
+
+        case "cache.decision": {
+          const attrs: Record<string, string | number | boolean> = {
+            "http.route": event.pathname,
+            "rango.route_key": event.routeKey,
+            "rango.cache.hit": event.hit,
+            "rango.cache.should_revalidate": event.shouldRevalidate,
+          };
+          if (event.source) attrs["rango.cache.source"] = event.source;
+          instant("rango.cache.decision", attrs).end();
+          break;
+        }
+
+        case "revalidation.decision": {
+          instant("rango.revalidation.decision", {
+            "rango.segment_id": event.segmentId,
+            "http.route": event.pathname,
+            "rango.route_key": event.routeKey,
+            "rango.revalidate": event.shouldRevalidate,
+          }).end();
+          break;
+        }
+
+        case "request.timeout": {
+          const attrs: Record<string, string | number | boolean> = {
+            "rango.phase": event.phase,
+            "http.route": event.pathname,
+            "rango.duration_ms": event.durationMs,
+            "rango.timeout.custom_handler": event.customHandler,
+          };
+          if (event.routeKey) attrs["rango.route_key"] = event.routeKey;
+          if (event.actionId) attrs["rango.action_id"] = event.actionId;
+          const span = instant("rango.request.timeout", attrs);
+          span.setStatus({
+            code: STATUS_ERROR,
+            message: `timeout: ${event.phase}`,
+          });
+          span.end();
+          break;
+        }
+
+        case "request.origin-rejected": {
+          const attrs: Record<string, string | number | boolean> = {
+            "http.method": event.method,
+            "http.route": event.pathname,
+            "rango.phase": event.phase,
+          };
+          if (event.origin) attrs["rango.origin"] = event.origin;
+          if (event.host) attrs["http.host"] = event.host;
+          const span = instant("rango.request.origin-rejected", attrs);
+          span.setStatus({ code: STATUS_ERROR, message: "origin rejected" });
+          span.end();
+          break;
+        }
+
+        // request.start/end/error and loader.start/end/error are phase events;
+        // their spans are owned by the tracing slot (createOTelTracing), so this
+        // sink ignores them to avoid duplicate rango.request / rango.loader spans.
+      }
+    },
+  };
+}