@aztec/end-to-end 0.0.1-commit.4d79d1f2d → 0.0.1-commit.4d9804df

package/src/shared/jest_setup.ts

@@ -1,8 +1,19 @@
 import { createLogger } from '@aztec/aztec.js/log';
 
-import { beforeEach, expect } from '@jest/globals';
+import { afterAll, afterEach, beforeEach, expect } from '@jest/globals';
+import { readlinkSync } from 'fs';
 import { basename } from 'path';
 
+import { EluMonitor } from '../fixtures/elu_monitor.js';
+
+const eluMonitor = process.env.ELU_MONITOR_FILE
+  ? new EluMonitor(process.env.ELU_MONITOR_FILE, Number(process.env.ELU_MONITOR_INTERVAL_MS) || undefined)
+  : undefined;
+
+if (eluMonitor) {
+  process.on('exit', () => eluMonitor.stop());
+}
+
 beforeEach(() => {
   const { testPath, currentTestName } = expect.getState();
   if (!testPath || !currentTestName) {
@@ -10,4 +21,43 @@ beforeEach(() => {
   }
   const logger = createLogger(`e2e:${basename(testPath).replace('.test.ts', '')}`);
   logger.info(`Running test: ${currentTestName}`);
+  eluMonitor?.startTest(currentTestName);
+});
+
+afterEach(() => {
+  eluMonitor?.stopTest();
+});
+
+// Log leaked handles after all tests complete. This runs after test-level afterAll hooks,
+// so any handles still alive at this point were not properly cleaned up during teardown.
+// This diagnostic helps identify the source of exit hangs without masking them.
+afterAll(() => {
+  const handles = (process as any)._getActiveHandles();
+  if (handles.length > 0) {
+    const details = handles.map((h: any) => {
+      const type = h?.constructor?.name ?? typeof h;
+      const fd = h?.fd ?? h?._handle?.fd ?? '?';
+      const destroyed = h?.destroyed ?? '?';
+      const hasRef = typeof h?.hasRef === 'function' ? h.hasRef() : '?';
+      const localAddr = h?.localAddress ?? '';
+      const remoteAddr = h?.remoteAddress ?? '';
+      const localPort = h?.localPort ?? '';
+      const remotePort = h?.remotePort ?? '';
+      const proto = Object.getPrototypeOf(h)?.constructor?.name ?? '?';
+      const keys = Object.keys(h).slice(0, 10).join(',');
+      let fdTarget = '';
+      if (typeof fd === 'number') {
+        try {
+          fdTarget = ` -> ${readlinkSync(`/proc/self/fd/${fd}`)}`;
+        } catch {
+          // ignore
+        }
+      }
+      return `  ${type}(fd=${fd}, destroyed=${destroyed}, hasRef=${hasRef}${fdTarget}) proto=${proto} addr=${localAddr}:${localPort}->${remoteAddr}:${remotePort} keys=[${keys}]`;
+    });
+    process.stderr.write(
+      `\n[jest_setup] WARNING: ${handles.length} handle(s) still active after teardown:\n${details.join('\n')}\n` +
+        `These may prevent Jest from exiting. Investigate and fix the leak.\n\n`,
+    );
+  }
 });

package/src/shared/mock_state_view.ts

@@ -0,0 +1,188 @@
+import { EthAddress } from '@aztec/aztec.js/addresses';
+import { type Logger, createLogger } from '@aztec/aztec.js/log';
+import type { EthCheatCodes } from '@aztec/aztec/testing';
+import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
+
+import { getContract } from 'viem';
+
+/**
+ * Mock StateView contract for testing the Uniswap price oracle.
+ *
+ * Wraps a compiled Solidity contract that mimics the Uniswap V4 StateView's getSlot0 function.
+ * The mock allows setting return values dynamically for testing different price scenarios.
+ *
+ * Solidity source:
+ * ```solidity
+ * // SPDX-License-Identifier: Apache-2.0
+ * pragma solidity >=0.8.27;
+ *
+ * contract MockStateView {
+ *     uint160 public sqrtPriceX96;
+ *     int24 public tick;
+ *     uint24 public protocolFee;
+ *     uint24 public lpFee;
+ *
+ *     function setReturnValues(
+ *         uint160 _sqrtPriceX96,
+ *         int24 _tick,
+ *         uint24 _protocolFee,
+ *         uint24 _lpFee
+ *     ) external {
+ *         sqrtPriceX96 = _sqrtPriceX96;
+ *         tick = _tick;
+ *         protocolFee = _protocolFee;
+ *         lpFee = _lpFee;
+ *     }
+ *
+ *     function getSlot0(bytes32 poolId) external view returns (uint160, int24, uint24, uint24) {
+ *         return (sqrtPriceX96, tick, protocolFee, lpFee);
+ *     }
+ * }
+ * ```
+ */
+export class MockStateView {
+  private static readonly BYTECODE: `0x${string}` =
+    '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';
+  private static readonly ABI = [
+    {
+      type: 'function',
+      name: 'setReturnValues',
+      inputs: [
+        { name: '_sqrtPriceX96', type: 'uint160' },
+        { name: '_tick', type: 'int24' },
+        { name: '_protocolFee', type: 'uint24' },
+        { name: '_lpFee', type: 'uint24' },
+      ],
+      outputs: [],
+      stateMutability: 'nonpayable',
+    },
+    {
+      inputs: [
+        {
+          internalType: 'bytes32',
+          name: 'poolId',
+          type: 'bytes32',
+        },
+      ],
+      name: 'getSlot0',
+      outputs: [
+        {
+          internalType: 'uint160',
+          name: '',
+          type: 'uint160',
+        },
+        {
+          internalType: 'int24',
+          name: '',
+          type: 'int24',
+        },
+        {
+          internalType: 'uint24',
+          name: '',
+          type: 'uint24',
+        },
+        {
+          internalType: 'uint24',
+          name: '',
+          type: 'uint24',
+        },
+      ],
+      stateMutability: 'view',
+      type: 'function',
+    },
+  ] as const;
+
+  private constructor(
+    private readonly address: EthAddress,
+    private readonly walletClient: ExtendedViemWalletClient,
+    private readonly log: Logger = createLogger('mock-state-view'),
+  ) {}
+
+  /**
+   * Deploys the mock StateView contract at the specified address using etch.
+   * @param ethCheatCodes - Cheat codes for etching bytecode
+   * @param walletClient - Wallet client for sending transactions
+   * @param address - Address to deploy the mock at (typically the real StateView address)
+   */
+  static async deploy(
+    ethCheatCodes: EthCheatCodes,
+    walletClient: ExtendedViemWalletClient,
+    address: EthAddress,
+  ): Promise<MockStateView> {
+    await ethCheatCodes.etch(address, MockStateView.BYTECODE);
+    return new MockStateView(address, walletClient);
+  }
+
+  /**
+   * Sets the price using the ethPerFeeAssetE12 format (same as rollup contract).
+   * Computes the corresponding sqrtPriceX96 internally.
+   *
+   * Math (from fee_asset_price_oracle.ts):
+   *   ethPerFeeAssetE12 = 1e12 * 2^192 / sqrtPriceX96^2
+   *
+   * Inverted:
+   *   sqrtPriceX96^2 = 1e12 * 2^192 / ethPerFeeAssetE12
+   *   sqrtPriceX96 = sqrt(1e12 * 2^192 / ethPerFeeAssetE12)
+   *
+   * @param ethPerFeeAssetE12 - The price in ETH per fee asset, scaled by 1e12
+   */
+  async setEthPerFeeAsset(ethPerFeeAssetE12: bigint) {
+    const sqrtPriceX96 = this.ethPerFeeAssetE12ToSqrtPriceX96(ethPerFeeAssetE12);
+    return await this.setSqrtPriceX96(sqrtPriceX96);
+  }
+
+  /**
+   * Sets the sqrtPriceX96 value directly (Uniswap's price encoding).
+   * @param sqrtPriceX96 - The sqrtPriceX96 value
+   * @param tick - The tick value (default 10)
+   * @param protocolFee - The protocol fee (default 0)
+   * @param lpFee - The LP fee (default 500)
+   */
+  async setSqrtPriceX96(sqrtPriceX96: bigint, tick: number = 10, protocolFee: number = 0, lpFee: number = 500) {
+    const contract = getContract({
+      address: this.address.toString() as `0x${string}`,
+      abi: MockStateView.ABI,
+      client: this.walletClient,
+    });
+
+    const hash = await contract.write.setReturnValues([sqrtPriceX96, tick, protocolFee, lpFee]);
+    this.log.info(`Set sqrtPriceX96 to ${sqrtPriceX96}`);
+    return await this.walletClient.waitForTransactionReceipt({ hash });
+  }
+
+  /**
+   * Converts ethPerFeeAssetE12 to sqrtPriceX96 (inverse of sqrtPriceX96ToEthPerFeeAssetE12).
+   *
+   * Math:
+   *   sqrtPriceX96 = sqrt(1e12 * 2^192 / ethPerFeeAssetE12)
+   */
+  ethPerFeeAssetE12ToSqrtPriceX96(ethPerFeeAssetE12: bigint): bigint {
+    if (ethPerFeeAssetE12 === 0n) {
+      throw new Error('Cannot convert zero ethPerFeeAssetE12');
+    }
+    const Q192 = 2n ** 192n;
+    const sqrtPriceSquared = (10n ** 12n * Q192) / ethPerFeeAssetE12;
+    return this.bigintSqrt(sqrtPriceSquared);
+  }
+
+  /** Integer square root using Newton's method */
+  bigintSqrt(n: bigint): bigint {
+    if (n < 0n) {
+      throw new Error('Cannot compute sqrt of negative number');
+    }
+    if (n === 0n) {
+      return 0n;
+    }
+    let x = n;
+    let y = (x + 1n) / 2n;
+    while (y < x) {
+      x = y;
+      y = (x + n / x) / 2n;
+    }
+    return x;
+  }
+}
+
+export function diffInBps(a: bigint, b: bigint): bigint {
+  return ((a - b) * 10000n) / b;
+}

package/src/shared/submit-transactions.ts

@@ -1,9 +1,10 @@
 import { AztecAddress } from '@aztec/aztec.js/addresses';
-import { NO_WAIT } from '@aztec/aztec.js/contracts';
-import { Fr, GrumpkinScalar } from '@aztec/aztec.js/fields';
+import { NO_WAIT, getContractInstanceFromInstantiationParams } from '@aztec/aztec.js/contracts';
+import { Fr } from '@aztec/aztec.js/fields';
 import type { Logger } from '@aztec/aztec.js/log';
 import { TxHash, type TxReceipt, TxStatus } from '@aztec/aztec.js/tx';
 import { times } from '@aztec/foundation/collection';
+import { TestContract, TestContractArtifact } from '@aztec/noir-test-contracts.js/Test';
 
 import type { TestWallet } from '../test-wallet/test_wallet.js';
 
@@ -14,12 +15,19 @@ export const submitTxsTo = async (
   numTxs: number,
   logger: Logger,
 ): Promise<TxHash[]> => {
+  // Register (without deploying) a single TestContract instance to source cheap throwaway txs from.
+  // emit_nullifier is #[noinitcheck], so it runs on a register-only instance — this avoids a full
+  // account-contract deployment per tx, which is all these callers were paying for a mined/gossiped tx.
+  const testContractInstance = await getContractInstanceFromInstantiationParams(TestContractArtifact, {
+    salt: Fr.random(),
+  });
+  await wallet.registerContract(testContractInstance, TestContractArtifact);
+  const contract = TestContract.at(testContractInstance.address, wallet);
+
   const txHashes: TxHash[] = [];
   await Promise.all(
     times(numTxs, async () => {
-      const accountManager = await wallet.createSchnorrAccount(Fr.random(), Fr.random(), GrumpkinScalar.random());
-      const deployMethod = await accountManager.getDeployMethod();
-      const txHash = await deployMethod.send({ from: submitter, wait: NO_WAIT });
+      const { txHash } = await contract.methods.emit_nullifier(Fr.random()).send({ from: submitter, wait: NO_WAIT });
 
       logger.info(`Tx sent with hash ${txHash}`);
       const receipt: TxReceipt = await wallet.getTxReceipt(txHash);

package/src/shared/timing_env.d.mts

@@ -0,0 +1,39 @@
+/** A single recorded span occurrence on the shared `performance.now()` clock. */
+export type TimingSpan = {
+  /** Full name of the test running when the span started, or `null` during a beforeAll/afterAll hook. */
+  owner?: string | null;
+  /** Stable `category:label` tag. */
+  name?: string;
+  /** Clock value at span start. */
+  start: number;
+  /** Clock value at span end. */
+  end: number;
+};
+
+/** Aggregate of one tag's occurrences. */
+export type SpanAggregate = {
+  count: number;
+  totalMs: number;
+  busyMs: number;
+  maxMs: number;
+};
+
+/**
+ * Aggregates a list of `{ start, end }` spans of one tag into `{ count, totalMs, busyMs, maxMs }`.
+ * Does not mutate the input array.
+ */
+export function aggregateSpans(spans: TimingSpan[]): SpanAggregate;
+
+/**
+ * Groups `spans` by owner then tag, attaches a `spans` aggregate map to the matching record (or
+ * `suiteRecord` for `null`-owner spans), derives back-compat `setupFnMs` / `teardownFnMs`, drops spans
+ * whose owner matches no record, and returns the raw per-occurrence list (empty unless `emitSpanLines`).
+ */
+export function foldSpansInto(
+  spans: TimingSpan[],
+  options: {
+    recordsByName: Map<string, Record<string, unknown>>;
+    suiteRecord: Record<string, unknown>;
+    emitSpanLines?: boolean;
+  },
+): { owner: string | null; name: string; ms: number }[];

package/src/shared/timing_env.mjs

@@ -0,0 +1,363 @@
+import { appendFileSync, writeFileSync } from 'node:fs';
+import { basename } from 'node:path';
+
+import CustomEnvironment from '../../../foundation/src/jest/env.mjs';
+
+// Per-test e2e timing environment. Gated entirely on the TEST_TIMING_FILE env var: when unset, this
+// behaves exactly like the base CustomEnvironment (it only delegates). When set, it records, per test
+// worker process, the time spent in jest before/after hooks and the test body, and folds in the named
+// spans recorded via the `testSpan()` wrapper (fixtures/timing.ts) through a collector shared on
+// `this.global`.
+//
+// Output is one JSONL file per worker process (the env runs once per worker). Each line carries a
+// `type` discriminator and is one of:
+//   - `type: 'test'` (`name` set): beforeEach hooks, the it() body, afterEach hooks for one test; or
+//   - `type: 'suite'` (`name: null`): the suite-scoped beforeAll/afterAll hooks for the whole file.
+//
+// Each line also gains a `spans` map: per `category:label` tag the test/suite touched, the collector
+// records `{ count, totalMs, busyMs, maxMs }`. `busyMs` is the duration of the union of the spans'
+// `[start, end)` intervals on the shared `performance.now()` clock, so concurrent spans (Promise.all
+// fan-out) do not inflate it the way `totalMs` does. The legacy `setupFnMs`/`teardownFnMs` fields are
+// kept for back-compat, derived from the `setup:env`/`teardown:env` spans.
+//
+// When `TEST_TIMING_SPANS=1`, the collector additionally retains every raw span occurrence and emits
+// one `type:"span"` line per occurrence (owner, name, ms) for deep dives, at the cost of a larger file.
+export default class TimingEnvironment extends CustomEnvironment {
+  constructor(config, context) {
+    super(config, context);
+
+    this.timingFile = process.env.TEST_TIMING_FILE;
+    if (!this.timingFile) {
+      return;
+    }
+
+    this.suite = basename(context?.testPath ?? config?.testPath ?? 'unknown').replace(/\.test\.[cm]?[jt]s$/, '');
+    this.meta = {
+      commit: process.env.COMMIT_HASH ?? null,
+      branch: process.env.TARGET_BRANCH ?? process.env.REF_NAME ?? null,
+      runId: process.env.RUN_ID ?? null,
+    };
+
+    // Opt-in per-occurrence emission for deep dives (off by default keeps the JSONL one line per test).
+    this.emitSpanLines = process.env.TEST_TIMING_SPANS === '1';
+
+    // Shared collector. The instrumented helpers (running in the sandbox realm) read
+    // `globalThis.__e2eTimings`; this env (host realm) reads `this.global.__e2eTimings` — they are the
+    // same object. `current` is the full name of the test currently running (null during
+    // beforeAll/afterAll), used to attribute each span to a test or to the suite-scoped line. `spans`
+    // accumulates every recorded span until flush. The `start`/`end` timestamps come from the sandbox
+    // realm's `performance.now()`; Node's perf clock is process-wide (one monotonic origin across all
+    // realms), so merging the intervals here for `busyMs` is valid.
+    this.collector = { current: null, spans: [] };
+    this.global.__e2eTimings = this.collector;
+
+    // Records to flush as JSONL on teardown. One per test plus one suite-scoped record.
+    this.records = [];
+    this.recordsByName = new Map();
+    // The suite-scoped record (beforeAll/afterAll); bodyMs/totalMs are computed at flush time.
+    this.suiteRecord = { name: null, status: 'passed', beforeHooksMs: 0, afterHooksMs: 0 };
+    // Start times keyed by hook type (beforeAll/beforeEach/afterAll/afterEach).
+    this.hookStarts = {};
+    this.testStarts = new Map();
+    // Guards against double-flushing (we flush on both the teardown event and the teardown method).
+    this.flushed = false;
+    // Raw per-occurrence spans retained only when TEST_TIMING_SPANS=1, emitted as `type:"span"` lines.
+    this.rawSpans = [];
+  }
+
+  // Flush on the teardown method too: the jest lifecycle always calls this, whereas the 'teardown'
+  // event is not reliably delivered when a test run is interrupted. Whichever fires first wins.
+  async teardown() {
+    this.finalizeAndFlush();
+    await super.teardown();
+  }
+
+  async handleTestEvent(event, state) {
+    // Run the base env first so its unhandledRejection patching for after-hooks stays intact.
+    await super.handleTestEvent(event, state);
+
+    if (!this.timingFile) {
+      return;
+    }
+
+    const now = Date.now();
+    switch (event.name) {
+      case 'hook_start': {
+        this.hookStarts[event.hook.type] = now;
+        break;
+      }
+      case 'hook_success':
+      case 'hook_failure': {
+        const start = this.hookStarts[event.hook.type];
+        if (start === undefined) {
+          break;
+        }
+        delete this.hookStarts[event.hook.type];
+        const ms = now - start;
+        if (event.hook.type === 'beforeEach') {
+          this.addToCurrent('beforeHooksMs', ms);
+        } else if (event.hook.type === 'afterEach') {
+          this.addToCurrent('afterHooksMs', ms);
+        } else if (event.hook.type === 'beforeAll') {
+          this.suiteRecord.beforeHooksMs += ms;
+        } else if (event.hook.type === 'afterAll') {
+          this.suiteRecord.afterHooksMs += ms;
+        }
+        break;
+      }
+      case 'test_start': {
+        const name = this.fullTestName(event.test);
+        const record = {
+          type: 'test',
+          name,
+          status: 'passed',
+          setupFnMs: 0,
+          beforeHooksMs: 0,
+          bodyMs: 0,
+          teardownFnMs: 0,
+          afterHooksMs: 0,
+          totalMs: 0,
+          startedAt: new Date(now).toISOString(),
+        };
+        this.records.push(record);
+        this.recordsByName.set(name, record);
+        this.testStarts.set(name, now);
+        this.collector.current = name;
+        break;
+      }
+      case 'test_fn_start': {
+        this.testStarts.set(`fn:${this.fullTestName(event.test)}`, now);
+        break;
+      }
+      case 'test_fn_success':
+      case 'test_fn_failure': {
+        const name = this.fullTestName(event.test);
+        const start = this.testStarts.get(`fn:${name}`);
+        const record = this.recordsByName.get(name);
+        if (record && start !== undefined) {
+          record.bodyMs = now - start;
+        }
+        if (record && event.name === 'test_fn_failure') {
+          record.status = 'failed';
+        }
+        break;
+      }
+      case 'test_done': {
+        const name = this.fullTestName(event.test);
+        const record = this.recordsByName.get(name);
+        const start = this.testStarts.get(name);
+        if (record && start !== undefined) {
+          record.totalMs = now - start;
+        }
+        if (record && event.test?.errors?.length) {
+          record.status = 'failed';
+        }
+        this.collector.current = null;
+        break;
+      }
+      case 'teardown': {
+        this.finalizeAndFlush();
+        break;
+      }
+      default:
+        break;
+    }
+  }
+
+  /** The record for the test currently running, if any. */
+  currentRecord() {
+    return this.collector.current ? this.recordsByName.get(this.collector.current) : undefined;
+  }
+
+  /** Adds `ms` to a hook bucket on the current per-test record, or the suite record during beforeAll/afterAll. */
+  addToCurrent(field, ms) {
+    const record = this.currentRecord();
+    if (record) {
+      record[field] += ms;
+    }
+  }
+
+  /** Builds the full test name by walking up the describe blocks, matching jest's currentTestName. */
+  fullTestName(test) {
+    if (!test) {
+      return null;
+    }
+    const parts = [];
+    let node = test;
+    while (node && node.name && node.name !== 'ROOT_DESCRIBE_BLOCK') {
+      parts.unshift(node.name);
+      node = node.parent;
+    }
+    return parts.join(' ');
+  }
+
+  /** Folds the collected spans into the per-test / suite records via {@link foldSpansInto}, then drains the collector. */
+  foldSpans() {
+    const rawSpans = foldSpansInto(this.collector.spans, {
+      recordsByName: this.recordsByName,
+      suiteRecord: this.suiteRecord,
+      emitSpanLines: this.emitSpanLines,
+    });
+    this.rawSpans.push(...rawSpans);
+    this.collector.spans = [];
+  }
+
+  /** Folds spans into records, finalizes the suite-scoped record, and writes all JSONL. */
+  finalizeAndFlush() {
+    if (this.flushed || !this.timingFile) {
+      return;
+    }
+    this.flushed = true;
+    this.foldSpans();
+
+    const lines = [];
+    for (const record of this.records) {
+      lines.push(this.toLine({ ...record }));
+    }
+    lines.push(
+      this.toLine({
+        type: 'suite',
+        name: null,
+        status: 'passed',
+        setupFnMs: this.suiteRecord.setupFnMs ?? 0,
+        beforeHooksMs: this.suiteRecord.beforeHooksMs,
+        teardownFnMs: this.suiteRecord.teardownFnMs ?? 0,
+        afterHooksMs: this.suiteRecord.afterHooksMs,
+        totalMs: this.suiteRecord.beforeHooksMs + this.suiteRecord.afterHooksMs,
+        spans: this.suiteRecord.spans,
+      }),
+    );
+    for (const raw of this.rawSpans) {
+      lines.push(this.toLine({ type: 'span', name: raw.owner, span: raw.name, ms: raw.ms }));
+    }
+
+    const payload = lines.join('\n') + '\n';
+    try {
+      // One file per worker process, but a worker may run several suites: append so we keep them all.
+      appendFileSync(this.timingFile, payload);
+    } catch {
+      try {
+        writeFileSync(this.timingFile, payload);
+      } catch {
+        // Timing is best-effort; never fail a test because we couldn't write the file.
+      }
+    }
+  }
+
+  /** Flattens metadata onto a record and serializes to a single JSON line, rounding all Ms fields. */
+  toLine(record) {
+    const obj = { suite: this.suite, ...record, ...this.meta };
+    for (const key of Object.keys(obj)) {
+      if (key.endsWith('Ms') && typeof obj[key] === 'number') {
+        obj[key] = Math.round(obj[key]);
+      }
+    }
+    // Round the nested span aggregates' Ms fields too (totalMs/busyMs/maxMs per tag).
+    if (obj.spans && typeof obj.spans === 'object') {
+      for (const agg of Object.values(obj.spans)) {
+        for (const key of Object.keys(agg)) {
+          if (key.endsWith('Ms') && typeof agg[key] === 'number') {
+            agg[key] = Math.round(agg[key]);
+          }
+        }
+      }
+    }
+    return JSON.stringify(obj);
+  }
+}
+
+/**
+ * Aggregates a list of `{ start, end }` spans of one tag into `{ count, totalMs, busyMs, maxMs }`.
+ * `totalMs` is the naive sum of per-occurrence durations (correct for serial repeats); `busyMs` is
+ * the duration of the union of the `[start, end)` intervals (concurrency-correct — N concurrent
+ * spans collapse to their wall-clock span instead of summing to ~N×); `maxMs` is the longest single
+ * occurrence. All durations are on the shared process-wide `performance.now()` clock. Does not mutate
+ * the input array.
+ */
+export function aggregateSpans(spans) {
+  let totalMs = 0;
+  let maxMs = 0;
+  for (const span of spans) {
+    const ms = span.end - span.start;
+    totalMs += ms;
+    if (ms > maxMs) {
+      maxMs = ms;
+    }
+  }
+  // busyMs: sort by start and merge overlapping intervals, summing the merged lengths.
+  const sorted = [...spans].sort((a, b) => a.start - b.start);
+  let busyMs = 0;
+  let mergeStart = null;
+  let mergeEnd = null;
+  for (const span of sorted) {
+    if (mergeStart === null) {
+      mergeStart = span.start;
+      mergeEnd = span.end;
+    } else if (span.start <= mergeEnd) {
+      if (span.end > mergeEnd) {
+        mergeEnd = span.end;
+      }
+    } else {
+      busyMs += mergeEnd - mergeStart;
+      mergeStart = span.start;
+      mergeEnd = span.end;
+    }
+  }
+  if (mergeStart !== null) {
+    busyMs += mergeEnd - mergeStart;
+  }
+  return { count: spans.length, totalMs, busyMs, maxMs };
+}
+
+/**
+ * Groups `spans` by owner, then by tag, and attaches a `spans` map of aggregates to the matching
+ * per-test record (looked up in `recordsByName`) or, for `null`-owner spans, to `suiteRecord`. Also
+ * derives the back-compat `setupFnMs` / `teardownFnMs` fields from the `setup:env:<mode>` /
+ * `teardown:env` aggregates (additive over any pre-existing value). Spans whose owner matches no
+ * record (e.g. the pinned `other:mempool-feeder` owner) are dropped. Returns the raw per-occurrence
+ * list (`{ owner, name, ms }`), which is empty unless `emitSpanLines` is set.
+ */
+export function foldSpansInto(spans, { recordsByName, suiteRecord, emitSpanLines = false }) {
+  const rawSpans = [];
+  // Group by owner (null owner → suite record), then by tag.
+  const byOwner = new Map();
+  for (const span of spans) {
+    const owner = span.owner ?? null;
+    let byName = byOwner.get(owner);
+    if (!byName) {
+      byName = new Map();
+      byOwner.set(owner, byName);
+    }
+    let list = byName.get(span.name);
+    if (!list) {
+      list = [];
+      byName.set(span.name, list);
+    }
+    list.push(span);
+    if (emitSpanLines) {
+      rawSpans.push({ owner, name: span.name, ms: span.end - span.start });
+    }
+  }
+
+  for (const [owner, byName] of byOwner) {
+    const record = owner === null ? suiteRecord : recordsByName.get(owner);
+    if (!record) {
+      continue;
+    }
+    const aggregates = {};
+    for (const [name, list] of byName) {
+      aggregates[name] = aggregateSpans(list);
+    }
+    record.spans = aggregates;
+    // Back-compat: the legacy fn-span buckets are derived from the top-level env setup/teardown tags.
+    // The top-level setup is tagged `setup:env:<proverMode>` (the mode is a closed set, distinct from
+    // the `:anvil`/`:l1-deploy`/... sub-phase tags), so sum those three exact tags.
+    const setupFnMs =
+      (aggregates['setup:env:none']?.totalMs ?? 0) +
+      (aggregates['setup:env:fake']?.totalMs ?? 0) +
+      (aggregates['setup:env:real']?.totalMs ?? 0);
+    record.setupFnMs = setupFnMs + (record.setupFnMs ?? 0);
+    record.teardownFnMs = (aggregates['teardown:env']?.totalMs ?? 0) + (record.teardownFnMs ?? 0);
+  }
+  return rawSpans;
+}