@aztec/end-to-end 0.0.1-commit.96dac018d → 0.0.1-commit.9a89641

package/dest/shared/gas_portal_test_harness.js

@@ -1,9 +1,10 @@
 import { EthAddress } from '@aztec/aztec.js/addresses';
 import { L1FeeJuicePortalManager } from '@aztec/aztec.js/ethereum';
 import { Fr } from '@aztec/aztec.js/fields';
+import { FeeJuiceContract } from '@aztec/aztec.js/protocol';
 import { retryUntil } from '@aztec/foundation/retry';
-import { FeeJuiceContract } from '@aztec/noir-contracts.js/FeeJuice';
-import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { testSpan } from '../fixtures/timing.js';
+import { waitForL1ToL2MessageSeen } from './wait_for_l1_to_l2_message.js';
 export class FeeJuicePortalTestingHarnessFactory {
     config;
     constructor(config){
@@ -18,7 +19,7 @@ export class FeeJuicePortalTestingHarnessFactory {
         if (feeJuiceAddress.isZero() || feeJuicePortalAddress.isZero()) {
             throw new Error('Fee Juice portal not deployed on L1');
         }
-        const gasL2 = FeeJuiceContract.at(ProtocolContractAddress.FeeJuice, wallet);
+        const gasL2 = FeeJuiceContract.withWallet(wallet);
         return new GasBridgingTestHarness(aztecNode, aztecNodeAdmin, wallet, logger, gasL2, ethAccount, feeJuicePortalAddress, feeJuiceAddress, l1ContractAddresses.feeAssetHandlerAddress, l1Client);
     }
     static create(config) {
@@ -75,9 +76,9 @@ export class FeeJuicePortalTestingHarnessFactory {
         });
     }
     async getL2PublicBalanceOf(owner) {
-        return await this.feeJuice.methods.balance_of_public(owner).simulate({
+        return (await this.feeJuice.methods.balance_of_public(owner).simulate({
             from: owner
-        });
+        })).result;
     }
     async expectPublicBalanceOnL2(owner, expectedBalance) {
         const balance = await this.getL2PublicBalanceOf(owner);
@@ -87,20 +88,27 @@ export class FeeJuicePortalTestingHarnessFactory {
         const bridgeAmount = await this.l1TokenManager.getMintAmount();
         await this.mintTokensOnL1();
         const claim = await this.sendTokensToPortalPublic(bridgeAmount, owner);
-        const isSynced = async ()=>await this.aztecNode.isL1ToL2MessageSynced(Fr.fromHexString(claim.messageHash));
-        await retryUntil(isSynced, `message ${claim.messageHash} sync`, 24, 1);
+        await waitForL1ToL2MessageSeen(this.aztecNode, Fr.fromHexString(claim.messageHash), {
+            timeoutSeconds: 24
+        });
         // Progress by 2 L2 blocks so that the l1ToL2Message added above will be available to use on L2.
         await this.advanceL2Block();
         await this.advanceL2Block();
         return claim;
     }
     async bridgeFromL1ToL2(owner, claimer) {
-        // Prepare the tokens on the L1 side
-        const claim = await this.prepareTokensOnL1(owner);
-        // Consume L1 -> L2 message and claim tokens privately on L2
-        await this.consumeMessageOnAztecAndClaimPrivately(owner, claimer, claim);
+        await testSpan('setup:bridge', async ()=>{
+            // Prepare the tokens on the L1 side
+            const claim = await this.prepareTokensOnL1(owner);
+            // Consume L1 -> L2 message and claim tokens privately on L2
+            await this.consumeMessageOnAztecAndClaimPrivately(owner, claimer, claim);
+        });
     }
     async advanceL2Block() {
+        if (this.aztecNode.mineBlock) {
+            await this.aztecNode.mineBlock();
+            return;
+        }
         const initialBlockNumber = await this.aztecNode.getBlockNumber();
         let minTxsPerBlock = undefined;
         if (this.aztecNodeAdmin) {
@@ -109,11 +117,14 @@ export class FeeJuicePortalTestingHarnessFactory {
                 minTxsPerBlock: 0
             }); // Set to 0 to ensure we can advance the block
         }
-        await retryUntil(async ()=>await this.aztecNode.getBlockNumber() >= initialBlockNumber + 1);
-        if (this.aztecNodeAdmin && minTxsPerBlock !== undefined) {
-            await this.aztecNodeAdmin.setConfig({
-                minTxsPerBlock
-            });
+        try {
+            await retryUntil(async ()=>await this.aztecNode.getBlockNumber() >= initialBlockNumber + 1, 'gas portal block advance', 0, 0.25);
+        } finally{
+            if (this.aztecNodeAdmin && minTxsPerBlock !== undefined) {
+                await this.aztecNodeAdmin.setConfig({
+                    minTxsPerBlock
+                });
+            }
         }
     }
-} // docs:end:cross_chain_test_harness
+}

package/dest/shared/jest_setup.js

@@ -1,5 +1,6 @@
 import { createLogger } from '@aztec/aztec.js/log';
-import { afterEach, 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;
@@ -18,3 +19,33 @@ beforeEach(()=>{
 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._getActiveHandles();
+    if (handles.length > 0) {
+        const details = handles.map((h)=>{
+            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/dest/shared/submit-transactions.d.ts

@@ -3,4 +3,4 @@ import type { Logger } from '@aztec/aztec.js/log';
 import { TxHash } from '@aztec/aztec.js/tx';
 import type { TestWallet } from '../test-wallet/test_wallet.js';
 export declare const submitTxsTo: (wallet: TestWallet, submitter: AztecAddress, numTxs: number, logger: Logger) => Promise<TxHash[]>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3VibWl0LXRyYW5zYWN0aW9ucy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3NoYXJlZC9zdWJtaXQtdHJhbnNhY3Rpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUd6RCxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNsRCxPQUFPLEVBQUUsTUFBTSxFQUE0QixNQUFNLG9CQUFvQixDQUFDO0FBR3RFLE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBR2hFLGVBQU8sTUFBTSxXQUFXLG9HQXdCdkIsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3VibWl0LXRyYW5zYWN0aW9ucy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3NoYXJlZC9zdWJtaXQtdHJhbnNhY3Rpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUd6RCxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNsRCxPQUFPLEVBQUUsTUFBTSxFQUE0QixNQUFNLG9CQUFvQixDQUFDO0FBSXRFLE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBR2hFLGVBQU8sTUFBTSxXQUFXLG9HQTRCdkIsQ0FBQyJ9

package/dest/shared/submit-transactions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"submit-transactions.d.ts","sourceRoot":"","sources":["../../src/shared/submit-transactions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAGzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,MAAM,EAA4B,MAAM,oBAAoB,CAAC;AAGtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAGhE,eAAO,MAAM,WAAW,oGAwBvB,CAAC"}
+{"version":3,"file":"submit-transactions.d.ts","sourceRoot":"","sources":["../../src/shared/submit-transactions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAGzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,MAAM,EAA4B,MAAM,oBAAoB,CAAC;AAItE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAGhE,eAAO,MAAM,WAAW,oGA4BvB,CAAC"}

package/dest/shared/submit-transactions.js

@@ -1,14 +1,21 @@
-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 { TxStatus } from '@aztec/aztec.js/tx';
 import { times } from '@aztec/foundation/collection';
+import { TestContract, TestContractArtifact } from '@aztec/noir-test-contracts.js/Test';
 // submits a set of transactions to the provided Wallet
 export const submitTxsTo = async (wallet, submitter, numTxs, logger)=>{
+    // 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 = [];
     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({
+        const { txHash } = await contract.methods.emit_nullifier(Fr.random()).send({
             from: submitter,
             wait: NO_WAIT
         });

package/dest/shared/timing_env.d.js

@@ -0,0 +1,5 @@
+/** A single recorded span occurrence on the shared `performance.now()` clock. */ /**
+ * 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 { };

package/dest/shared/timing_env.js

@@ -0,0 +1,365 @@
+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;
+}

package/dest/shared/uniswap_l1_l2.d.ts

@@ -1,3 +1,3 @@
 import { type EndToEndContext } from '../fixtures/utils.js';
 export declare const uniswapL1L2TestSuite: (setup: () => Promise<EndToEndContext>, cleanup: () => Promise<void>, expectedForkBlockNumber?: number) => void;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW5pc3dhcF9sMV9sMi5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3NoYXJlZC91bmlzd2FwX2wxX2wyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQXVCQSxPQUFPLEVBQUUsS0FBSyxlQUFlLEVBQW1DLE1BQU0sc0JBQXNCLENBQUM7QUFhN0YsZUFBTyxNQUFNLG9CQUFvQixpSEFnK0JoQyxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW5pc3dhcF9sMV9sMi5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3NoYXJlZC91bmlzd2FwX2wxX2wyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQXVCQSxPQUFPLEVBQUUsS0FBSyxlQUFlLEVBQStCLE1BQU0sc0JBQXNCLENBQUM7QUFhekYsZUFBTyxNQUFNLG9CQUFvQixpSEE0Z0NoQyxDQUFDIn0=

package/dest/shared/uniswap_l1_l2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"uniswap_l1_l2.d.ts","sourceRoot":"","sources":["../../src/shared/uniswap_l1_l2.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAE,KAAK,eAAe,EAAmC,MAAM,sBAAsB,CAAC;AAa7F,eAAO,MAAM,oBAAoB,iHAg+BhC,CAAC"}
+{"version":3,"file":"uniswap_l1_l2.d.ts","sourceRoot":"","sources":["../../src/shared/uniswap_l1_l2.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAE,KAAK,eAAe,EAA+B,MAAM,sBAAsB,CAAC;AAazF,eAAO,MAAM,oBAAoB,iHA4gChC,CAAC"}