overtake 2.0.1 → 2.0.3

package/build/cli.js

@@ -83,6 +83,7 @@ if (opts['compare-baseline']) {
     }
 }
 const files = new Set((await Promise.all(patterns.map((pattern) => Array.fromAsync(glob(pattern, { cwd: process.cwd() })).catch(() => [])))).flat());
+const allBaselineResults = {};
 for (const file of files) {
     const stats = await stat(file).catch(() => false);
     if (stats && stats.isFile()) {
@@ -95,16 +96,28 @@ for (const file of files) {
             instance = Benchmark.create(...args);
             return instance;
         };
-        await import(identifier);
+        try {
+            await import(identifier);
+        }
+        catch (e) {
+            console.error(`Error loading ${file}: ${e instanceof Error ? e.message : String(e)}`);
+            continue;
+        }
         if (instance) {
-            const reports = await instance.execute({
-                ...executeOptions,
-                [BENCHMARK_URL]: identifier,
-            });
+            let reports;
+            try {
+                reports = await instance.execute({
+                    ...executeOptions,
+                    [BENCHMARK_URL]: identifier,
+                });
+            }
+            catch (e) {
+                console.error(`Error executing ${file}: ${e instanceof Error ? e.message : String(e)}`);
+                continue;
+            }
             if (opts['save-baseline']) {
-                const baselineData = reportsToBaseline(reports);
-                await writeFile(opts['save-baseline'], JSON.stringify(baselineData, null, 2));
-                console.log(`Baseline saved to: ${opts['save-baseline']}`);
+                const bd = reportsToBaseline(reports);
+                Object.assign(allBaselineResults, bd.results);
             }
             if (baseline) {
                 printComparisonReports(reports, baseline);
@@ -133,3 +146,12 @@ for (const file of files) {
         }
     }
 }
+if (opts['save-baseline'] && Object.keys(allBaselineResults).length > 0) {
+    const baselineData = {
+        version: 1,
+        timestamp: new Date().toISOString(),
+        results: allBaselineResults,
+    };
+    await writeFile(opts['save-baseline'], JSON.stringify(baselineData, null, 2));
+    console.log(`Baseline saved to: ${opts['save-baseline']}`);
+}

package/build/executor.js

@@ -2,7 +2,7 @@ import { Worker } from 'node:worker_threads';
 import { once } from 'node:events';
 import { pathToFileURL } from 'node:url';
 import { createReport, computeStats, Report } from './reporter.js';
-import { cmp, assertNoClosure } from './utils.js';
+import { cmp, assertNoClosure, normalizeFunction } from './utils.js';
 import { Control, CONTROL_SLOTS, COMPLETE_VALUE, } from './types.js';
 const BENCHMARK_URL = Symbol.for('overtake.benchmarkUrl');
 export const createExecutor = (options) => {
@@ -10,6 +10,7 @@ export const createExecutor = (options) => {
     const benchmarkUrl = options[BENCHMARK_URL];
     const resolvedBenchmarkUrl = typeof benchmarkUrl === 'string' ? benchmarkUrl : pathToFileURL(process.cwd()).href;
     const pending = [];
+    const activeWorkers = new Set();
     let running = 0;
     const schedule = async (task) => {
         running++;
@@ -33,11 +34,11 @@ export const createExecutor = (options) => {
         });
     };
     const runTask = async ({ id, setup, teardown, pre, run, post, data }) => {
-        const setupCode = setup?.toString();
-        const teardownCode = teardown?.toString();
-        const preCode = pre?.toString();
-        const runCode = run.toString();
-        const postCode = post?.toString();
+        const setupCode = setup ? normalizeFunction(setup.toString()) : undefined;
+        const teardownCode = teardown ? normalizeFunction(teardown.toString()) : undefined;
+        const preCode = pre ? normalizeFunction(pre.toString()) : undefined;
+        const runCode = normalizeFunction(run.toString());
+        const postCode = post ? normalizeFunction(post.toString()) : undefined;
         if (setupCode)
             assertNoClosure(setupCode, 'setup');
         if (teardownCode)
@@ -69,6 +70,7 @@ export const createExecutor = (options) => {
         const worker = new Worker(workerFile, {
             workerData,
         });
+        activeWorkers.add(worker);
         const control = new Int32Array(controlSAB);
         let progressIntervalId;
         if (onProgress && id) {
@@ -96,6 +98,7 @@ export const createExecutor = (options) => {
                 clearInterval(progressIntervalId);
             workerError = err instanceof Error ? err.message : String(err);
         }
+        activeWorkers.delete(worker);
         const count = control[Control.INDEX];
         const heapUsedKB = control[Control.HEAP_USED];
         const durations = new BigUint64Array(durationsSAB).slice(0, count).sort(cmp);
@@ -112,15 +115,26 @@ export const createExecutor = (options) => {
             }
         }
         const stats = count > 0 ? computeStats(durations) : undefined;
-        const report = reportTypes
+        const entries = reportTypes
             .map((type) => [type, createReport(durations, type, stats)])
             .concat([
             ['count', count],
             ['heapUsedKB', heapUsedKB],
             ['dceWarning', dceWarning],
-            ['error', workerError],
         ]);
-        return Object.fromEntries(report);
+        if (workerError)
+            entries.push(['error', workerError]);
+        return Object.fromEntries(entries);
+    };
+    return {
+        pushAsync,
+        kill() {
+            for (const w of activeWorkers)
+                w.terminate();
+            activeWorkers.clear();
+            for (const p of pending)
+                p.reject(new Error('Executor killed'));
+            pending.length = 0;
+        },
     };
-    return { pushAsync, kill() { } };
 };

package/build/loader-hook.d.ts

@@ -0,0 +1,2 @@
+export declare function resolve(specifier: string, context: unknown, nextResolve: (...args: unknown[]) => unknown): Promise<unknown>;
+export declare function load(url: string, context: unknown, nextLoad: (...args: unknown[]) => unknown): Promise<unknown>;

package/build/loader-hook.js

@@ -0,0 +1,33 @@
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { transformSync } from '@swc/core';
+export async function resolve(specifier, context, nextResolve) {
+    try {
+        return await nextResolve(specifier, context);
+    }
+    catch (e) {
+        if (specifier.endsWith('.js'))
+            try {
+                return await nextResolve(specifier.slice(0, -3) + '.ts', context);
+            }
+            catch { }
+        throw e;
+    }
+}
+export async function load(url, context, nextLoad) {
+    if (!url.endsWith('.ts') && !url.endsWith('.mts')) {
+        return nextLoad(url, context);
+    }
+    const filePath = fileURLToPath(url);
+    const rawSource = await readFile(filePath, 'utf-8');
+    const { code } = transformSync(rawSource, {
+        filename: filePath,
+        jsc: {
+            parser: { syntax: 'typescript' },
+            target: 'esnext',
+        },
+        module: { type: 'es6' },
+        sourceMaps: false,
+    });
+    return { format: 'module', source: code, shortCircuit: true };
+}

package/build/register-hook.js

@@ -1,15 +1,2 @@
 import { register } from 'node:module';
-async function resolve(s, c, n) {
-    try {
-        return await n(s, c);
-    }
-    catch (e) {
-        if (s.endsWith('.js'))
-            try {
-                return await n(s.slice(0, -3) + '.ts', c);
-            }
-            catch { }
-        throw e;
-    }
-}
-register('data:text/javascript,' + encodeURIComponent(`export ${resolve.toString()}`));
+register(new URL('../build/loader-hook.js', import.meta.url).href);

package/build/runner.js

@@ -475,7 +475,6 @@ export const benchmark = async ({ setup, teardown, pre, run: runRaw, post, data,
             const durationNumber = Number(sampleDuration);
             if (!disableFiltering) {
                 const { median, iqr } = medianAndIqr(outlierWindow);
-                pushWindow(outlierWindow, durationNumber, OUTLIER_WINDOW);
                 const maxAllowed = median + OUTLIER_IQR_MULTIPLIER * iqr || Number.POSITIVE_INFINITY;
                 if (outlierWindow.length >= 8 && durationNumber > maxAllowed && durationNumber - median > OUTLIER_ABS_THRESHOLD) {
                     skipped++;
@@ -487,9 +486,7 @@ export const benchmark = async ({ setup, teardown, pre, run: runRaw, post, data,
                     continue;
                 }
             }
-            else {
-                pushWindow(outlierWindow, durationNumber, OUTLIER_WINDOW);
-            }
+            pushWindow(outlierWindow, durationNumber, OUTLIER_WINDOW);
             durations[i++] = sampleDuration;
             const deltaS = sampleDuration * WELFORD_SCALE - meanS;
             meanS += deltaS / BigInt(i);

package/build/utils.d.ts

@@ -4,4 +4,5 @@ export declare const cmp: (a: bigint | number, b: bigint | number) => number;
 export declare const max: (a: bigint, b: bigint) => bigint;
 export declare function div(a: bigint, b: bigint, decimals?: number): string;
 export declare function divs(a: bigint, b: bigint, scale: bigint): bigint;
+export declare function normalizeFunction(code: string): string;
 export declare function assertNoClosure(code: string, name: string): void;

package/build/utils.js

@@ -1,18 +1,5 @@
 import { parseSync } from '@swc/core';
-async function resolve(s, c, n) {
-    try {
-        return await n(s, c);
-    }
-    catch (e) {
-        if (s.endsWith('.js'))
-            try {
-                return await n(s.slice(0, -3) + '.ts', c);
-            }
-            catch { }
-        throw e;
-    }
-}
-export const resolveHookUrl = 'data:text/javascript,' + encodeURIComponent(`export ${resolve.toString()}`);
+export const resolveHookUrl = new URL('./loader-hook.js', import.meta.url).href;
 export const isqrt = (n) => {
     if (n < 0n)
         throw new RangeError('Square root of negative');
@@ -44,11 +31,14 @@ export const max = (a, b) => {
 export function div(a, b, decimals = 2) {
     if (b === 0n)
         throw new RangeError('Division by zero');
+    const neg = a < 0n !== b < 0n;
+    const absA = a < 0n ? -a : a;
+    const absB = b < 0n ? -b : b;
     const scale = 10n ** BigInt(decimals);
-    const scaled = (a * scale) / b;
+    const scaled = (absA * scale) / absB;
     const intPart = scaled / scale;
     const fracPart = scaled % scale;
-    return `${intPart}.${fracPart.toString().padStart(decimals, '0')}`;
+    return `${neg ? '-' : ''}${intPart}.${fracPart.toString().padStart(decimals, '0')}`;
 }
 export function divs(a, b, scale) {
     if (b === 0n)
@@ -57,22 +47,75 @@ export function divs(a, b, scale) {
 }
 const KNOWN_GLOBALS = new Set(Object.getOwnPropertyNames(globalThis));
 KNOWN_GLOBALS.add('arguments');
-function collectUnresolved(node, result) {
+let _unresolvedCtxt;
+function findIdentifierCtxt(node, name) {
+    if (!node || typeof node !== 'object')
+        return undefined;
+    if (Array.isArray(node)) {
+        for (const item of node) {
+            const r = findIdentifierCtxt(item, name);
+            if (r !== undefined)
+                return r;
+        }
+        return undefined;
+    }
+    const obj = node;
+    if (obj.type === 'Identifier' && obj.value === name && typeof obj.ctxt === 'number') {
+        return obj.ctxt;
+    }
+    for (const key of Object.keys(obj)) {
+        if (key === 'span')
+            continue;
+        const r = findIdentifierCtxt(obj[key], name);
+        if (r !== undefined)
+            return r;
+    }
+    return undefined;
+}
+function probeUnresolvedCtxt() {
+    if (_unresolvedCtxt !== undefined)
+        return _unresolvedCtxt;
+    try {
+        const ast = parseSync('var _ = () => __PROBE__', { syntax: 'ecmascript', target: 'esnext' });
+        _unresolvedCtxt = findIdentifierCtxt(ast, '__PROBE__') ?? 1;
+    }
+    catch {
+        _unresolvedCtxt = 1;
+    }
+    return _unresolvedCtxt;
+}
+function collectUnresolved(node, ctxt, result) {
     if (!node || typeof node !== 'object')
         return;
     if (Array.isArray(node)) {
         for (const item of node)
-            collectUnresolved(item, result);
+            collectUnresolved(item, ctxt, result);
         return;
     }
     const obj = node;
-    if (obj.type === 'Identifier' && obj.ctxt === 1 && typeof obj.value === 'string') {
+    if (obj.type === 'Identifier' && obj.ctxt === ctxt && typeof obj.value === 'string') {
         result.add(obj.value);
     }
     for (const key of Object.keys(obj)) {
         if (key === 'span')
             continue;
-        collectUnresolved(obj[key], result);
+        collectUnresolved(obj[key], ctxt, result);
+    }
+}
+export function normalizeFunction(code) {
+    try {
+        parseSync(`var __fn = ${code}`, { syntax: 'ecmascript', target: 'esnext' });
+        return code;
+    }
+    catch {
+        const normalized = code.startsWith('async ') ? `async function ${code.slice(6)}` : `function ${code}`;
+        try {
+            parseSync(`var __fn = ${normalized}`, { syntax: 'ecmascript', target: 'esnext' });
+            return normalized;
+        }
+        catch {
+            return code;
+        }
     }
 }
 export function assertNoClosure(code, name) {
@@ -83,8 +126,9 @@ export function assertNoClosure(code, name) {
     catch {
         return;
     }
+    const unresolvedCtxt = probeUnresolvedCtxt();
     const unresolved = new Set();
-    collectUnresolved(ast, unresolved);
+    collectUnresolved(ast, unresolvedCtxt, unresolved);
     for (const g of KNOWN_GLOBALS)
         unresolved.delete(g);
     if (unresolved.size === 0)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "overtake",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "NodeJS performance benchmark",
   "type": "module",
   "types": "build/index.d.ts",
@@ -12,7 +12,7 @@
     "overtake": "bin/overtake.js"
   },
   "engines": {
-    "node": ">=24"
+    "node": ">=22"
   },
   "repository": {
     "type": "git",

package/src/__tests__/fixtures/enum-bench.ts

@@ -0,0 +1,17 @@
+import 'overtake';
+
+const suite = benchmark('ops', () => null);
+
+const target = suite.target('enum', () => {
+  enum Direction {
+    Up,
+    Down,
+    Left,
+    Right,
+  }
+  return { Direction };
+});
+
+target.measure('access', ({ Direction }) => {
+  return Direction.Up + Direction.Right;
+});

package/src/__tests__/fixtures/param-property-bench.ts

@@ -0,0 +1,14 @@
+import 'overtake';
+
+const suite = benchmark('ops', () => null);
+
+const target = suite.target('param-property', () => {
+  class Container {
+    constructor(public value: number) {}
+  }
+  return { Container };
+});
+
+target.measure('create', ({ Container }) => {
+  return new Container(42);
+});

package/src/__tests__/loader-hook.ts

@@ -0,0 +1,33 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { fileURLToPath } from 'node:url';
+
+const exec = promisify(execFile);
+const overtakeBin = fileURLToPath(new URL('../../bin/overtake.js', import.meta.url));
+const nodeFlags = ['--experimental-vm-modules', '--no-warnings', '--expose-gc'];
+
+const runBench = async (fixture: string) => {
+  const { stdout } = await exec(process.execPath, [...nodeFlags, overtakeBin, '-f', 'json', '--max-cycles', '50', '--min-cycles', '10', '--warmup-cycles', '5', fixture], {
+    timeout: 30_000,
+  });
+
+  const result = JSON.parse(stdout);
+  const key = Object.keys(result)[0];
+  assert.ok(key, 'should have at least one benchmark result');
+  const feeds = result[key];
+  const feed = Object.keys(feeds)[0];
+  assert.ok(feeds[feed].ops, 'should have ops metric');
+  assert.ok(!feeds[feed].error, 'should not have an error');
+};
+
+describe('loader-hook', () => {
+  it('loads benchmark files using parameter properties', async () => {
+    await runBench(fileURLToPath(new URL('fixtures/param-property-bench.ts', import.meta.url)));
+  });
+
+  it('loads benchmark files using enums', async () => {
+    await runBench(fileURLToPath(new URL('fixtures/enum-bench.ts', import.meta.url)));
+  });
+});

package/src/cli.ts

@@ -105,6 +105,8 @@ if (opts['compare-baseline']) {
 
 const files = new Set((await Promise.all(patterns.map((pattern) => Array.fromAsync(glob(pattern, { cwd: process.cwd() })).catch(() => [] as string[])))).flat());
 
+const allBaselineResults: Record<string, Record<string, number>> = {};
+
 for (const file of files) {
   const stats = await stat(file).catch(() => false as const);
   if (stats && stats.isFile()) {
@@ -117,18 +119,28 @@ for (const file of files) {
       instance = Benchmark.create(...args);
       return instance;
     };
-    await import(identifier);
+    try {
+      await import(identifier);
+    } catch (e) {
+      console.error(`Error loading ${file}: ${e instanceof Error ? e.message : String(e)}`);
+      continue;
+    }
 
     if (instance) {
-      const reports = await instance.execute({
-        ...executeOptions,
-        [BENCHMARK_URL]: identifier,
-      } as typeof executeOptions);
+      let reports;
+      try {
+        reports = await instance.execute({
+          ...executeOptions,
+          [BENCHMARK_URL]: identifier,
+        } as typeof executeOptions);
+      } catch (e) {
+        console.error(`Error executing ${file}: ${e instanceof Error ? e.message : String(e)}`);
+        continue;
+      }
 
       if (opts['save-baseline']) {
-        const baselineData = reportsToBaseline(reports);
-        await writeFile(opts['save-baseline'], JSON.stringify(baselineData, null, 2));
-        console.log(`Baseline saved to: ${opts['save-baseline']}`);
+        const bd = reportsToBaseline(reports);
+        Object.assign(allBaselineResults, bd.results);
       }
 
       if (baseline) {
@@ -157,3 +169,13 @@ for (const file of files) {
     }
   }
 }
+
+if (opts['save-baseline'] && Object.keys(allBaselineResults).length > 0) {
+  const baselineData: BaselineData = {
+    version: 1,
+    timestamp: new Date().toISOString(),
+    results: allBaselineResults,
+  };
+  await writeFile(opts['save-baseline'], JSON.stringify(baselineData, null, 2));
+  console.log(`Baseline saved to: ${opts['save-baseline']}`);
+}

package/src/executor.ts

@@ -2,7 +2,7 @@ import { Worker } from 'node:worker_threads';
 import { once } from 'node:events';
 import { pathToFileURL } from 'node:url';
 import { createReport, computeStats, Report } from './reporter.js';
-import { cmp, assertNoClosure } from './utils.js';
+import { cmp, assertNoClosure, normalizeFunction } from './utils.js';
 import {
   type ExecutorRunOptions,
   type ReportOptions,
@@ -43,6 +43,7 @@ export const createExecutor = <TContext, TInput, R extends ReportTypeList>(optio
   const resolvedBenchmarkUrl = typeof benchmarkUrl === 'string' ? benchmarkUrl : pathToFileURL(process.cwd()).href;
 
   const pending: { task: ExecutorRunOptions<TContext, TInput>; resolve: (v: unknown) => void; reject: (e: unknown) => void }[] = [];
+  const activeWorkers = new Set<Worker>();
   let running = 0;
 
   const schedule = async (task: ExecutorRunOptions<TContext, TInput>) => {
@@ -68,11 +69,11 @@ export const createExecutor = <TContext, TInput, R extends ReportTypeList>(optio
   };
 
   const runTask = async ({ id, setup, teardown, pre, run, post, data }: ExecutorRunOptions<TContext, TInput>) => {
-    const setupCode = setup?.toString();
-    const teardownCode = teardown?.toString();
-    const preCode = pre?.toString();
-    const runCode = run.toString();
-    const postCode = post?.toString();
+    const setupCode = setup ? normalizeFunction(setup.toString()) : undefined;
+    const teardownCode = teardown ? normalizeFunction(teardown.toString()) : undefined;
+    const preCode = pre ? normalizeFunction(pre.toString()) : undefined;
+    const runCode = normalizeFunction(run.toString());
+    const postCode = post ? normalizeFunction(post.toString()) : undefined;
 
     if (setupCode) assertNoClosure(setupCode, 'setup');
     if (teardownCode) assertNoClosure(teardownCode, 'teardown');
@@ -106,6 +107,7 @@ export const createExecutor = <TContext, TInput, R extends ReportTypeList>(optio
     const worker = new Worker(workerFile, {
       workerData,
     });
+    activeWorkers.add(worker);
 
     const control = new Int32Array(controlSAB);
     let progressIntervalId: ReturnType<typeof setInterval> | undefined;
@@ -132,6 +134,7 @@ export const createExecutor = <TContext, TInput, R extends ReportTypeList>(optio
       if (progressIntervalId) clearInterval(progressIntervalId);
       workerError = err instanceof Error ? err.message : String(err);
     }
+    activeWorkers.delete(worker);
 
     const count = control[Control.INDEX];
     const heapUsedKB = control[Control.HEAP_USED];
@@ -150,16 +153,24 @@ export const createExecutor = <TContext, TInput, R extends ReportTypeList>(optio
     }
 
     const stats = count > 0 ? computeStats(durations) : undefined;
-    const report = reportTypes
+    const entries: [string, unknown][] = reportTypes
       .map<[string, unknown]>((type) => [type, createReport(durations, type, stats)] as [ReportType, Report])
       .concat([
         ['count', count],
         ['heapUsedKB', heapUsedKB],
         ['dceWarning', dceWarning],
-        ['error', workerError],
       ]);
-    return Object.fromEntries(report);
+    if (workerError) entries.push(['error', workerError]);
+    return Object.fromEntries(entries);
   };
 
-  return { pushAsync, kill() {} };
+  return {
+    pushAsync,
+    kill() {
+      for (const w of activeWorkers) w.terminate();
+      activeWorkers.clear();
+      for (const p of pending) p.reject(new Error('Executor killed'));
+      pending.length = 0;
+    },
+  };
 };

package/src/loader-hook.ts

@@ -0,0 +1,33 @@
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { transformSync } from '@swc/core';
+
+export async function resolve(specifier: string, context: unknown, nextResolve: (...args: unknown[]) => unknown) {
+  try {
+    return await nextResolve(specifier, context);
+  } catch (e) {
+    if (specifier.endsWith('.js'))
+      try {
+        return await nextResolve(specifier.slice(0, -3) + '.ts', context);
+      } catch {}
+    throw e;
+  }
+}
+
+export async function load(url: string, context: unknown, nextLoad: (...args: unknown[]) => unknown) {
+  if (!url.endsWith('.ts') && !url.endsWith('.mts')) {
+    return nextLoad(url, context);
+  }
+  const filePath = fileURLToPath(url);
+  const rawSource = await readFile(filePath, 'utf-8');
+  const { code } = transformSync(rawSource, {
+    filename: filePath,
+    jsc: {
+      parser: { syntax: 'typescript' },
+      target: 'esnext',
+    },
+    module: { type: 'es6' },
+    sourceMaps: false,
+  });
+  return { format: 'module', source: code, shortCircuit: true };
+}

package/src/register-hook.ts

@@ -1,15 +1,3 @@
 import { register } from 'node:module';
 
-async function resolve(s: string, c: unknown, n: (...args: unknown[]) => unknown) {
-  try {
-    return await n(s, c);
-  } catch (e) {
-    if (s.endsWith('.js'))
-      try {
-        return await n(s.slice(0, -3) + '.ts', c);
-      } catch {}
-    throw e;
-  }
-}
-
-register('data:text/javascript,' + encodeURIComponent(`export ${resolve.toString()}`));
+register(new URL('../build/loader-hook.js', import.meta.url).href);

package/src/runner.ts

@@ -592,7 +592,6 @@ export const benchmark = async <TContext, TInput>({
       const durationNumber = Number(sampleDuration);
       if (!disableFiltering) {
         const { median, iqr } = medianAndIqr(outlierWindow);
-        pushWindow(outlierWindow, durationNumber, OUTLIER_WINDOW);
         const maxAllowed = median + OUTLIER_IQR_MULTIPLIER * iqr || Number.POSITIVE_INFINITY;
         if (outlierWindow.length >= 8 && durationNumber > maxAllowed && durationNumber - median > OUTLIER_ABS_THRESHOLD) {
           skipped++;
@@ -604,9 +603,8 @@ export const benchmark = async <TContext, TInput>({
           skipped++;
           continue;
         }
-      } else {
-        pushWindow(outlierWindow, durationNumber, OUTLIER_WINDOW);
       }
+      pushWindow(outlierWindow, durationNumber, OUTLIER_WINDOW);
 
       durations[i++] = sampleDuration;
       const deltaS = sampleDuration * WELFORD_SCALE - meanS;

package/src/utils.ts

@@ -1,18 +1,6 @@
 import { parseSync } from '@swc/core';
 
-async function resolve(s: string, c: unknown, n: (...args: unknown[]) => unknown) {
-  try {
-    return await n(s, c);
-  } catch (e) {
-    if (s.endsWith('.js'))
-      try {
-        return await n(s.slice(0, -3) + '.ts', c);
-      } catch {}
-    throw e;
-  }
-}
-
-export const resolveHookUrl = 'data:text/javascript,' + encodeURIComponent(`export ${resolve.toString()}`);
+export const resolveHookUrl = new URL('./loader-hook.js', import.meta.url).href;
 
 export const isqrt = (n: bigint): bigint => {
   if (n < 0n) throw new RangeError('Square root of negative');
@@ -45,11 +33,14 @@ export const max = (a: bigint, b: bigint) => {
 
 export function div(a: bigint, b: bigint, decimals: number = 2): string {
   if (b === 0n) throw new RangeError('Division by zero');
+  const neg = a < 0n !== b < 0n;
+  const absA = a < 0n ? -a : a;
+  const absB = b < 0n ? -b : b;
   const scale = 10n ** BigInt(decimals);
-  const scaled = (a * scale) / b;
+  const scaled = (absA * scale) / absB;
   const intPart = scaled / scale;
   const fracPart = scaled % scale;
-  return `${intPart}.${fracPart.toString().padStart(decimals, '0')}`;
+  return `${neg ? '-' : ''}${intPart}.${fracPart.toString().padStart(decimals, '0')}`;
 }
 
 export function divs(a: bigint, b: bigint, scale: bigint): bigint {
@@ -60,19 +51,68 @@ export function divs(a: bigint, b: bigint, scale: bigint): bigint {
 const KNOWN_GLOBALS = new Set(Object.getOwnPropertyNames(globalThis));
 KNOWN_GLOBALS.add('arguments');
 
-function collectUnresolved(node: unknown, result: Set<string>) {
+let _unresolvedCtxt: number | undefined;
+
+function findIdentifierCtxt(node: unknown, name: string): number | undefined {
+  if (!node || typeof node !== 'object') return undefined;
+  if (Array.isArray(node)) {
+    for (const item of node) {
+      const r = findIdentifierCtxt(item, name);
+      if (r !== undefined) return r;
+    }
+    return undefined;
+  }
+  const obj = node as Record<string, unknown>;
+  if (obj.type === 'Identifier' && obj.value === name && typeof obj.ctxt === 'number') {
+    return obj.ctxt;
+  }
+  for (const key of Object.keys(obj)) {
+    if (key === 'span') continue;
+    const r = findIdentifierCtxt(obj[key], name);
+    if (r !== undefined) return r;
+  }
+  return undefined;
+}
+
+function probeUnresolvedCtxt(): number {
+  if (_unresolvedCtxt !== undefined) return _unresolvedCtxt;
+  try {
+    const ast = parseSync('var _ = () => __PROBE__', { syntax: 'ecmascript', target: 'esnext' });
+    _unresolvedCtxt = findIdentifierCtxt(ast, '__PROBE__') ?? 1;
+  } catch {
+    _unresolvedCtxt = 1;
+  }
+  return _unresolvedCtxt;
+}
+
+function collectUnresolved(node: unknown, ctxt: number, result: Set<string>) {
   if (!node || typeof node !== 'object') return;
   if (Array.isArray(node)) {
-    for (const item of node) collectUnresolved(item, result);
+    for (const item of node) collectUnresolved(item, ctxt, result);
     return;
   }
   const obj = node as Record<string, unknown>;
-  if (obj.type === 'Identifier' && obj.ctxt === 1 && typeof obj.value === 'string') {
+  if (obj.type === 'Identifier' && obj.ctxt === ctxt && typeof obj.value === 'string') {
     result.add(obj.value);
   }
   for (const key of Object.keys(obj)) {
     if (key === 'span') continue;
-    collectUnresolved(obj[key], result);
+    collectUnresolved(obj[key], ctxt, result);
+  }
+}
+
+export function normalizeFunction(code: string): string {
+  try {
+    parseSync(`var __fn = ${code}`, { syntax: 'ecmascript', target: 'esnext' });
+    return code;
+  } catch {
+    const normalized = code.startsWith('async ') ? `async function ${code.slice(6)}` : `function ${code}`;
+    try {
+      parseSync(`var __fn = ${normalized}`, { syntax: 'ecmascript', target: 'esnext' });
+      return normalized;
+    } catch {
+      return code;
+    }
   }
 }
 
@@ -83,8 +123,9 @@ export function assertNoClosure(code: string, name: string): void {
   } catch {
     return;
   }
+  const unresolvedCtxt = probeUnresolvedCtxt();
   const unresolved = new Set<string>();
-  collectUnresolved(ast, unresolved);
+  collectUnresolved(ast, unresolvedCtxt, unresolved);
   for (const g of KNOWN_GLOBALS) unresolved.delete(g);
   if (unresolved.size === 0) return;