Benchmark Harness

Overview

The @vercel/devlow-bench benchmark harness is a specialized CLI-driven performance measurement tool designed to evaluate developer workflows and runtime characteristics in Next.js applications packages/devlow-bench/package.json:2-3, packages/devlow-bench/src/cli.ts:28-30. It provides structured scenario definitions, robust iterative execution loops with warmup handling, and Playwright-backed browser session instrumentation to track latency, resource consumption, and network activity packages/devlow-bench/src/cli.ts:33-82, packages/devlow-bench/src/runner.ts:29-33, packages/devlow-bench/src/browser.ts:237-291. By combining rigorous statistical sampling, percentile aggregation, and nonparametric significance testing (such as Mann-Whitney U) with persistent CSV snapshots and automated Git metadata tracking, the harness enables reproducible performance regression analysis across code revisions packages/devlow-bench/src/cli.ts:84-91, packages/devlow-bench/src/snapshot.ts:9-20, packages/devlow-bench/src/statistics.ts:81-106, packages/devlow-bench/src/compare.ts:58-73.

Command-Line Interface and Subcommand Dispatch

Commander Configuration and Command Definitions

The devlow-bench command-line interface is initialized using the commander package, configuring the program name as devlow-bench, setting a description for developer-workflow benchmarks, and enabling showHelpAfterError() packages/devlow-bench/src/cli.ts:28-31. The interface registers two primary subcommands: run (designated as the default subcommand) and compare packages/devlow-bench/src/cli.ts:33-34, packages/devlow-bench/src/cli.ts:84-85. Top-level execution errors are caught at the async IIFE boundary, printing the stack trace to console.error and exiting with status code 1 packages/devlow-bench/src/cli.ts:27-97.

Sources: packages/devlow-bench/src/cli.ts:27-91

Option Parsing and Scenario Orchestration

The run subcommand accepts a comprehensive set of options governing filtering, sampling iterations, warmup runs, snapshot paths, and reporting sinks packages/devlow-bench/src/cli.ts:37-81. Repeatable options like -s, --scenario and -F, --filter accumulate values into string arrays using custom accumulator functions packages/devlow-bench/src/cli.ts:37-48. The -F option parses key=value pairs, exiting with an error if the equals sign is missing packages/devlow-bench/src/cli.ts:118-125.

Copy.option(
  '-s, --scenario <filter>',
  'Only run scenarios whose name matches the filter (repeatable).',
  (v: string, prev: string[] | undefined) => (prev ?? []).concat(v),
  []
)
.option(
  '-F, --filter <pair>',
  'Filter variants by property: -F key=value (repeatable; same key repeated = OR).',
  (v: string, prev: string[] | undefined) => (prev ?? []).concat(v),
  []
)
.option('-i, --interactive', 'Select scenarios and variants interactively.')
.option(
  '--n <number>',
  'Run each variant N times; reports mean/p50/p90 per metric. Default: 1.',
  (v: string) => Number(v)
)
.option(
  '--warmup <number>',
  'Discard the first N runs of each variant before sampling. Default: 0. Do NOT enable when measuring cold-start metrics.',
  (v: string) => Number(v)
)
.option(
  '--snapshot <path>',
  'Override the snapshot CSV path. Default: ./.devlow-bench/snapshots/<ts>.csv. Snapshots are always written.'
)
.option(
  '--compare',
  'Print a comparison table at end of run. Baseline = newest snapshot, unless --baseline overrides.'
)
.option(
  '--baseline <path>',
  'Explicit baseline (file or directory). Implies --compare.'
)
.option('-j, --json <path>', 'Write the results to the given path as JSON.')
.option('--no-console', 'Suppress console output.')
.option(
  '--datadog [host]',
  'Upload the results to Datadog (requires DATADOG_API_KEY).'
)
.option(
  '--snowflake [batchUri]',
  'Upload the results to Snowflake (requires SNOWFLAKE_TOPIC_NAME and SNOWFLAKE_SCHEMA_ID).'
)
.action(runRun)

Sources: packages/devlow-bench/src/cli.ts:37-82

Sources: packages/devlow-bench/src/cli.ts:56-59

Scenario Definition and Configuration Model

Scenario Declarations and Typing Abstractions

Benchmark scenarios are declared using the describe function, which accepts a scenario name, a configuration object typed via ConfigFor, and an asynchronous benchmark execution function taking typed properties P packages/devlow-bench/src/describe.ts:16-20, packages/devlow-bench/src/index.ts:1-9. The ConfigFor utility type maps each property key in P to an array of possible values for strings and numbers, or an array or single boolean value for booleans packages/devlow-bench/src/index.ts:1-9. When describe is invoked for the first time, it initializes the global scenario accumulator array and asynchronously imports reporting interfaces specified by the INTERFACE environment variable (defaulting to 'interactive,console') before triggering scenario execution via runScenarios packages/devlow-bench/src/describe.ts:21-45. The configuration object is normalized such that boolean property values are expanded into [value, !value] arrays packages/devlow-bench/src/describe.ts:46-54. Each defined scenario object stores its name, normalized config dictionary, an only boolean flag defaulted to false, and the typed execution function packages/devlow-bench/src/index.ts:11-16, packages/devlow-bench/src/describe.ts:55-63. The describe.only method delegates to describe and marks the newly pushed scenario with only: true packages/devlow-bench/src/describe.ts:65-72.

Sources: packages/devlow-bench/src/describe.ts:16-72, packages/devlow-bench/src/index.ts:1-34

Sources: packages/devlow-bench/src/describe.ts:25-43, packages/devlow-bench/src/index.ts:86-99

Execution Scoping and Measurement Reporting

Execution scoping is managed through the withCurrent utility, which binds a CurrentScenario instance during the invocation of an asynchronous function and restores the previous context in a finally block packages/devlow-bench/src/describe.ts:74-85. Within this scope, measurements are captured using measureTime or reportMeasurement packages/devlow-bench/src/describe.ts:89-182. The reportMeasurement function validates that a current scenario is active, that the name and unit are strings, and that the value is a finite number and not NaN packages/devlow-bench/src/describe.ts:105-142. Relative measurements can be anchored against the PREVIOUS symbol or an explicit measurement name, automatically subtracting the baseline value before dispatching through the interface sink packages/devlow-bench/src/describe.ts:143-182.

Sources: packages/devlow-bench/src/describe.ts:115-117

Benchmark Runner and Execution Lifecycle

Iterative Variant Invocation and Sampling Loops

The runScenarios runner function coordinates execution across registered scenarios and their configuration parameter combinations. It expands each scenario configuration object into a Cartesian product of variant properties, rejecting any properties named scenario or name packages/devlow-bench/src/runner.ts:29-67. After filtering through interface hooks, the runner iterates through each scenario variant to collect a specified number of warmup runs (warmup) and measured samples (n) packages/devlow-bench/src/runner.ts:68-111. Total attempts are strictly bounded by MAX_ATTEMPT_MULTIPLIER, which defaults to a multiplier of 2 applied to the sum of warmup runs and target samples packages/devlow-bench/src/runner.ts:24-28, packages/devlow-bench/src/runner.ts:102-111.

Copyconst MAX_ATTEMPT_MULTIPLIER = 2

Sources: packages/devlow-bench/src/runner.ts:27-27

Sources: packages/devlow-bench/src/runner.ts:121-168]

Metric Buffering and Statistical Aggregation

During a measured run, a wrapped interface intercepts metric measurements and populates a temporary perRun buffer. Warmup iterations execute with collecting set to false, which bypasses metric aggregation entirely packages/devlow-bench/src/runner.ts:78-115. Once a run completes successfully, recorded samples are committed into samplesByMetric and collectedRuns is incremented packages/devlow-bench/src/runner.ts:143-160.

Sources: packages/devlow-bench/src/runner.ts:18-22, packages/devlow-bench/src/runner.ts:27-27, packages/devlow-bench/src/runner.ts:71-79]

After finishing all attempts for a variant, summary statistics are calculated using the summary helper function and dispatched to fullIface.variantStatistics packages/devlow-bench/src/runner.ts:185-200. If any variant falls short of collecting the target number of samples n, the runner sets process.exitCode = 1 packages/devlow-bench/src/runner.ts:180-184.

Copyif (collectedRuns < n) {
  process.exitCode = 1
  variantsShortOfTarget++
}
 

Sources: packages/devlow-bench/src/runner.ts:180-184]

Browser Interaction and Navigation Instrumentation

Simulated Browser Sessions and Launch Options

The benchmarking suite utilizes Playwright Chromium to manage browser instances through the newBrowserSession factory function packages/devlow-bench/src/browser.ts:358-375. This function accepts configuration options controlling headless execution, developer tools visibility, and the base URL packages/devlow-bench/src/browser.ts:358-362. Chromium launches with a default timeout of 60,000 milliseconds, automatically attaching the --auto-open-devtools-for-tabs argument when headless mode is disabled packages/devlow-bench/src/browser.ts:363-367.

Browser contexts are instantiated with a default viewport size of 1280x720 pixels and a base URL defaulting to http://localhost:3000 packages/devlow-bench/src/browser.ts:368-371. Furthermore, context-level timeouts for general operations and navigation events are explicitly configured to 120,000 milliseconds packages/devlow-bench/src/browser.ts:372-373.

Sources: packages/devlow-bench/src/browser.ts:358-373]

Hard and Soft Navigations

The BrowserSessionImpl class coordinates page-level navigation primitives, managing instance reuse across test actions packages/devlow-bench/src/browser.ts:237-356. A hard navigation via hardNavigation(metricName, url) initializes a new page if none exists, wrapping the operation with request metrics tracking packages/devlow-bench/src/browser.ts:255-260. It targets a commit load state, validating that the HTTP response is both present and successful before recording progressive metrics for HTML parsing, DOM content loading, and full page load packages/devlow-bench/src/browser.ts:261-288.

Copyasync hardNavigation(metricName: string, url: string) {
  this.page = this.page ?? (await this.context.newPage())
 
  const page = this.page
  await withRequestMetrics(metricName, page, async () => {
    await measureTime(`${metricName}/start`)
    const idle = networkIdle(page, 3000)
    const response = await page.goto(url, {
      waitUntil: 'commit',
    })
    if (!response) {
      throw new Error(`Navigation to ${url} produced no response`)
    }
    if (!response.ok()) {
      throw new Error(
        `Navigation to ${url} returned HTTP ${response.status()}`
      )
    }
    await measureTime(`${metricName}/html`, {
      relativeTo: `${metricName}/start`,
    })
    await page.waitForLoadState('domcontentloaded')
    await measureTime(`${metricName}/dom`, {
      relativeTo: `${metricName}/start`,
    })
    await page.waitForLoadState('load')
    await measureTime(`${metricName}/load`, {
      relativeTo: `${metricName}/start`,
    })
    const offset = await idle
    await measureTime(`${metricName}`, {
      offset,
      relativeTo: `${metricName}/start`,
    })
  })
  return page
}

Sources: packages/devlow-bench/src/browser.ts:255-291]

Sources: packages/devlow-bench/src/browser.ts:293-299, packages/devlow-bench/src/browser.ts:321-325]

Network Idle Tracking and Request Metrics

Network stability is quantified by monitoring active HTTP requests and response lifecycles on the target page packages/devlow-bench/src/browser.ts:217-235. The networkIdle function tracks inflight requests using event listeners for request, requestfailed, and requestfinished events packages/devlow-bench/src/browser.ts:231-233. When all tracked requests settle and the active request count drops to zero, a debounce timer of 3000 milliseconds is initiated before concluding the idle measurement window packages/devlow-bench/src/browser.ts:223-228.

Copy      if (currentCount === 1) {
        requests.delete(request.url())
      } else {
        requests.set(request.url(), currentCount - 1)
      }
 
      if (requests.size === 0) {
        timeout = setTimeout(() => {
          cleanup()
          resolve(Date.now() - lastRequest)
        }, delayMs)
      }
    }
 
    page.on('request', requestHandler)
    page.on('requestfailed', requestFinishedHandler)
    page.on('requestfinished', requestFinishedHandler)
  })
}

Sources: packages/devlow-bench/src/browser.ts:217-235]

Statistical Sampling and Significance Analysis

Aggregation and Quantile Estimation

Repeated-sampling performance metrics are processed into centralized summaries using descriptive statistics [[packages/devlow-bench/src/statistics.ts:1-18]. The mean function computes the arithmetic average of numeric sample arrays, returning NaN on empty inputs [[packages/devlow-bench/src/statistics.ts:20-25]. Quantile values—specifically the 50th percentile (p50) and 90th percentile (p90)—are derived using linear interpolation corresponding to the NumPy and R "type 7" default strategy [[packages/devlow-bench/src/statistics.ts:27-37]. The summary function wraps these helpers to construct a Summary interface containing the mean, median, and 90th percentile [[packages/devlow-bench/src/statistics.ts:14-18, 39-45].

Copyexport function mean(xs: number[]): number {
  if (xs.length === 0) return NaN
  let s = 0
  for (const x of xs) s += x
  return s / xs.length
}
 
// Linear-interpolation quantile (numpy/R "type 7" default).
export function quantile(xs: number[], q: number): number {
  if (xs.length === 0) return NaN
  if (xs.length === 1) return xs[0]
  const sorted = [...xs].sort((a, b) => a - b)
  const pos = q * (sorted.length - 1)
  const lo = Math.floor(pos)
  const hi = Math.ceil(pos)
  if (lo === hi) return sorted[lo]
  return sorted[lo] + (pos - lo) * (sorted[hi] - sorted[lo])
}
 
export function summary(samples: number[]): Summary {
  return {
    mean: mean(samples),
    p50: quantile(samples, 0.5),
    p90: quantile(samples, 0.9),
  }
}

Sources: packages/devlow-bench/src/statistics.ts:20-45]

Significance Testing and Distributions

Comparative significance between sample groups is evaluated via Welch's t-test and the Mann-Whitney U test, relying on jstat for Student's t and standard normal cumulative distribution functions [[packages/devlow-bench/src/statistics.ts:3-12, 53-106]. The welchsTTest function handles unequal variances and computes Welch-Satterthwaite degrees of freedom before calculating a two-sided p-value [[packages/devlow-bench/src/statistics.ts:53-79]. The mannWhitneyU function applies an asymptotic normal approximation with continuity correction based on average ranks that correct for ties by assigning the mean rank [[packages/devlow-bench/src/statistics.ts:86-124].

Sources: [packages/devlow-bench/src/statistics.ts:47-51, 75-77, 81-84, 103-104]

Sources: packages/devlow-bench/src/statistics.ts:56-64]

Snapshot Storage and Git Metadata

Snapshot Persistence and CSV Formatting

Performance metrics from benchmark runs are persisted as comma-separated values using a long-format data structure [[packages/devlow-bench/src/snapshot.ts:6-20]. Each record stores a single sample measurement per scenario, variant, and metric, avoiding sparse columns when mixing units such as milliseconds, megabytes, or request counts [[packages/devlow-bench/src/snapshot.ts:6-20]. The schema comprises ten fixed columns defined in COLUMNS [[packages/devlow-bench/src/snapshot.ts:22-33].

Sources: [packages/devlow-bench/src/snapshot.ts:9-33]

Snapshots are stored in directory .devlow-bench/snapshots by default [[packages/devlow-bench/src/snapshot.ts:4]. File paths are generated via defaultSnapshotPath, which creates ISO-based filenames with colons and periods replaced by hyphens for filesystem safety and lexicographic sorting [[packages/devlow-bench/src/snapshot.ts:35-42]. The writeSnapshot function ensures parent directories exist recursively before serializing headers and escaped CSV rows to disk [[packages/devlow-bench/src/snapshot.ts:44-54]. The inverse operation, readSnapshot, parses CSV text into structured SnapshotRow entries, dynamically mapping header positions to object keys [[packages/devlow-bench/src/snapshot.ts:56-88].

Copyexport async function writeSnapshot(
  path: string,
  rows: SnapshotRow[]
): Promise<void> {
  await mkdir(dirname(path), { recursive: true })
  const lines: string[] = [COLUMNS.join(',')]
  for (const row of rows) {
    lines.push(COLUMNS.map((c) => csvCell(row[c])).join(','))
  }
  await writeFile(path, lines.join('\n') + '\n')
}

Sources: packages/devlow-bench/src/snapshot.ts:44-54]

Git Revision Tracking and Historical Artifact Indexing

Before writing records to disk, the snapshot reporting interface retrieves version control metadata via readGitInfo [[packages/devlow-bench/src/interfaces/snapshot.ts:14-20]. It checks environment variables GITHUB_SHA and GITHUB_REF_NAME first, falling back to executing git rev-parse HEAD and git rev-parse --abbrev-ref HEAD via execFile [[packages/devlow-bench/src/interfaces/snapshot.ts:14-20]. If git execution fails or repositories are absent, tryGit catches errors and returns empty strings [[packages/devlow-bench/src/interfaces/snapshot.ts:22-29]. Once gathered, the commit hash and branch name are injected into every pending snapshot row prior to file serialization [[packages/devlow-bench/src/interfaces/snapshot.ts:61-66].

Copyasync function readGitInfo(): Promise<{ sha: string; branch: string }> {
  const sha = process.env.GITHUB_SHA || (await tryGit(['rev-parse', 'HEAD']))
  const branch =
    process.env.GITHUB_REF_NAME ||
    (await tryGit(['rev-parse', '--abbrev-ref', 'HEAD']))
  return { sha, branch }
}

Sources: packages/devlow-bench/src/interfaces/snapshot.ts:14-20]

Historical artifacts are indexed and queried through directory scanners [[packages/devlow-bench/src/snapshot.ts:92-144]. The findMostRecentSnapshot function reads snapshot directories, filters for .csv files, and tracks modification times (mtimeMs) to locate the newest artifact while optionally excluding a specific path [[packages/devlow-bench/src/snapshot.ts:92-115]. The companion function resolveCompareTarget processes --compare command inputs, supporting boolean flags to pick the newest snapshot automatically, directory paths to search within, or direct file paths [[packages/devlow-bench/src/snapshot.ts:119-144].

Copyexport async function findMostRecentSnapshot(
  dir: string = DEFAULT_SNAPSHOT_DIR,
  excludePath?: string
): Promise<string | null> {
  let entries: string[]
  try {
    entries = await readdir(dir)
  } catch (e: any) {
    if (e.code === 'ENOENT') return null
    throw e
  }
  const candidates = entries.filter((f) => f.endsWith('.csv'))
  const excludeResolved = excludePath ? resolve(excludePath) : null
  let best: { path: string; mtime: number } | null = null
  for (const f of candidates) {
    const full = resolve(join(dir, f))
    if (excludeResolved && full === excludeResolved) continue
    const s = await stat(full)
    if (!best || s.mtimeMs > best.mtime) {
      best = { path: full, mtime: s.mtimeMs }
    }
  }
  return best?.path ?? null
}

Sources: packages/devlow-bench/src/snapshot.ts:92-115]

Sources: packages/devlow-bench/src/snapshot.ts:96-102]

Regression Comparison and Result Reporting

Diffing Snapshots and Sample Grouping

The comparison engine ingests benchmark snapshot rows and organizes them into a memory structure for differential analysis [[packages/devlow-bench/src/compare.ts:25-46]. The groupRows function iterates over raw SnapshotRow entries, filtering out non-finite measurements such as failed CSV parses [[packages/devlow-bench/src/compare.ts:27-30]. Each retained sample is indexed using a composite key generated by makeKey, which concatenates the scenario, variant, and metric strings separated by null bytes (\x00) to prevent collisions [[packages/devlow-bench/src/compare.ts:31-33, 48-54]. The resulting data structure maps each unique key to a SampleGroup containing the scenario identifier, variant properties, metric name, unit, and an array of numeric sample values [[packages/devlow-bench/src/compare.ts:17-23, 34-44].

Copyexport function groupRows(rows: SnapshotRow[]): Map<string, SampleGroup> {
  const out = new Map<string, SampleGroup>()
  for (const r of rows) {
    if (!Number.isFinite(r.value)) continue
    const key = makeKey(r.scenario, r.variant, r.metric)
    let group = out.get(key)
    if (!group) {
      group = {
        scenario: r.scenario,
        variant: r.variant,
        metric: r.metric,
        unit: r.unit,
        samples: [],
      }
      out.set(key, group)
    }
    group.samples.push(r.value)
  }
  return out
}

Sources: packages/devlow-bench/src/compare.ts:27-46]

To compare a current run against a historical snapshot, the printComparison function aligns baseline and current SampleGroup maps [[packages/devlow-bench/src/compare.ts:58-99]. It categorizes unmatched series into distinct lists: metrics present only in the current run, metrics present only in the baseline, and series skipped due to incompatible measurement units [[packages/devlow-bench/src/compare.ts:75-98]. For metrics present in both datasets, sample counts are summarized using the modeN utility, which identifies the most frequent sample size across all pairs and breaks ties in favor of the larger collection size [[packages/devlow-bench/src/compare.ts:103-104, 147-163].

Copy// Picks the most common n in the list. Ties are broken in favor of the
// larger n (treat "the typical fully-collected sample count" as the default).
// Returns null for an empty list.
function modeN(ns: number[]): number | null {
  if (ns.length === 0) return null
  const counts = new Map<number, number>()
  for (const n of ns) counts.set(n, (counts.get(n) ?? 0) + 1)
  let bestN = ns[0]
  let bestCount = 0
  for (const [n, c] of counts) {
    if (c > bestCount || (c === bestCount && n > bestN)) {
      bestN = n
      bestCount = c
    }
  }
  return bestN
}

Sources: packages/devlow-bench/src/compare.ts:147-163]

Sources: packages/devlow-bench/src/compare.ts:147-163]

Statistical Comparison Tables and Delta Formatting

For each matched series, the comparison pipeline computes distribution percentiles (p50, p90, p99) via quantile calculations and evaluates statistical significance using the Mann–Whitney U test [[packages/devlow-bench/src/compare.ts:171-175, 196-206]. A row verdict of 'improved' or 'regressed' is assigned only if the Mann–Whitney $p$-value falls below the significance threshold of 0.05, the absolute difference in p50 values is non-zero, and the shift direction indicates performance gain or loss [[packages/devlow-bench/src/compare.ts:8-10, 178-181].

Sources: [packages/devlow-bench/src/compare.ts:114-122, 183-191]

Table cells containing unit measurements utilize splitFormattedUnit to parse numeric quantities from unit strings [[packages/devlow-bench/src/compare.ts:228-236]. When all three percentiles share an identical unit suffix, the formatter prints the suffix exclusively on the final value to eliminate redundancy [[packages/devlow-bench/src/compare.ts:213-226].

Copyfunction formatGroupCell(
  group: SampleGroup,
  s: { p50: number; p90: number; p99: number },
  showN: boolean
): string {
  const parts = [s.p50, s.p90, s.p99].map((v) =>
    splitFormattedUnit(v, group.unit)
  )
  const nSuffix = showN ? ` (${group.samples.length})` : ''
  // If all three values render with the same unit suffix (e.g. all "requests"),
  // only print the suffix on the last value to avoid "7 req / 7 req / 7 req".
  if (
    parts[0].suffix === parts[1].suffix &&
    parts[1].suffix === parts[2].suffix
  ) {
    return `${parts[0].num} / ${parts[1].num} / ${parts[2].num}${parts[2].suffix}${nSuffix}`
  }
  return `${parts[0].num}${parts[0].suffix} / ${parts[1].num}${parts[1].suffix} / ${parts[2].num}${parts[2].suffix}${nSuffix}`
}

Sources: packages/devlow-bench/src/compare.ts:208-226]

Interface Reporting Sinks

The benchmark harness abstracts result reporting through the Interface contract, allowing execution loops to delegate output generation [[packages/devlow-bench/src/interfaces/compare.ts:11-37]. The comparison interface implementation reads baseline rows from disk via readSnapshot, groups them, and populates a current sample map as variant statistics stream in from benchmark scenarios [[packages/devlow-bench/src/interfaces/compare.ts:11-31]. Upon completion of all test runs, the finish hook invokes printComparison, rendering the formatted differential table and unmatched series lists to the console using color-coded verdicts from picocolors [[packages/devlow-bench/src/compare.ts:1-6, 33-35, 251-272].

Copyexport default async function createInterface(options: {
  baselinePath: string
}): Promise<Interface> {
  const baselinePath = options.baselinePath
  const baselineRows = await readSnapshot(baselinePath)
  const baseline = groupRows(baselineRows)
  const current = new Map<string, SampleGroup>()
 
  return {
    variantStatistics: async (scenario, props, stats) => {
      const variant = formatVariantProps(props)
      for (const [metric, s] of Object.entries(stats)) {
        const key = makeKey(scenario, variant, metric)
        current.set(key, {
          scenario,
          variant,
          metric,
          unit: s.unit,
          samples: s.samples.slice(),
        })
      }
    },
    finish: async () => {
      printComparison(baseline, current, { baselineLabel: baselinePath })
    },
  }

Sources: packages/devlow-bench/src/interfaces/compare.ts:11-36]

Related

• Trace Profiling