overtake 2.0.0 → 2.0.2

package/build/utils.js

@@ -0,0 +1,157 @@
+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 isqrt = (n) => {
+    if (n < 0n)
+        throw new RangeError('Square root of negative');
+    if (n < 2n)
+        return n;
+    let x = n;
+    let y = (x + 1n) >> 1n;
+    while (y < x) {
+        x = y;
+        y = (x + n / x) >> 1n;
+    }
+    return x;
+};
+export const cmp = (a, b) => {
+    if (a > b) {
+        return 1;
+    }
+    if (a < b) {
+        return -1;
+    }
+    return 0;
+};
+export const max = (a, b) => {
+    if (a > b) {
+        return a;
+    }
+    return 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 = (absA * scale) / absB;
+    const intPart = scaled / scale;
+    const fracPart = scaled % scale;
+    return `${neg ? '-' : ''}${intPart}.${fracPart.toString().padStart(decimals, '0')}`;
+}
+export function divs(a, b, scale) {
+    if (b === 0n)
+        throw new RangeError('Division by zero');
+    return (a * scale) / b;
+}
+const KNOWN_GLOBALS = new Set(Object.getOwnPropertyNames(globalThis));
+KNOWN_GLOBALS.add('arguments');
+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, ctxt, result);
+        return;
+    }
+    const obj = node;
+    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], 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) {
+    let ast;
+    try {
+        ast = parseSync(`var __fn = ${code}`, { syntax: 'ecmascript', target: 'esnext' });
+    }
+    catch {
+        return;
+    }
+    const unresolvedCtxt = probeUnresolvedCtxt();
+    const unresolved = new Set();
+    collectUnresolved(ast, unresolvedCtxt, unresolved);
+    for (const g of KNOWN_GLOBALS)
+        unresolved.delete(g);
+    if (unresolved.size === 0)
+        return;
+    const vars = [...unresolved].join(', ');
+    throw new Error(`Benchmark "${name}" function references outer-scope variables: ${vars}\n\n` +
+        `Benchmark functions are serialized with .toString() and executed in an isolated\n` +
+        `worker thread. Closed-over variables from the original module scope are not\n` +
+        `available in the worker and will cause a ReferenceError at runtime.\n\n` +
+        `To fix this, move the referenced values into:\n` +
+        `  - "setup" function (returned value becomes the first argument of run/pre/post)\n` +
+        `  - "data" option (passed as the second argument of run/pre/post)`);
+}

package/build/worker.js

@@ -0,0 +1,111 @@
+import { workerData } from 'node:worker_threads';
+import { SourceTextModule, SyntheticModule } from 'node:vm';
+import { createRequire, register } from 'node:module';
+import { isAbsolute } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { benchmark } from './runner.js';
+import {} from './types.js';
+import { resolveHookUrl } from './utils.js';
+register(resolveHookUrl);
+const { benchmarkUrl, setupCode, teardownCode, preCode, runCode, postCode, data, warmupCycles, minCycles, absThreshold, relThreshold, gcObserver = true, durationsSAB, controlSAB, } = workerData;
+const serialize = (code) => (code ? code : 'undefined');
+const resolvedBenchmarkUrl = typeof benchmarkUrl === 'string' ? benchmarkUrl : pathToFileURL(process.cwd()).href;
+const benchmarkDirUrl = new URL('.', resolvedBenchmarkUrl).href;
+const requireFrom = createRequire(fileURLToPath(new URL('benchmark.js', benchmarkDirUrl)));
+const resolveSpecifier = (specifier) => {
+    if (specifier.startsWith('file:')) {
+        return specifier;
+    }
+    if (specifier.startsWith('./') || specifier.startsWith('../')) {
+        return new URL(specifier, benchmarkDirUrl).href;
+    }
+    if (isAbsolute(specifier)) {
+        return pathToFileURL(specifier).href;
+    }
+    try {
+        return requireFrom.resolve(specifier);
+    }
+    catch {
+        return specifier;
+    }
+};
+const source = `
+export const setup = ${serialize(setupCode)};
+export const teardown = ${serialize(teardownCode)};
+export const pre = ${serialize(preCode)};
+export const run = ${serialize(runCode)};
+export const post = ${serialize(postCode)};
+  `;
+const imports = new Map();
+const createSyntheticModule = (moduleExports, exportNames, identifier) => {
+    const mod = new SyntheticModule(exportNames, () => {
+        for (const name of exportNames) {
+            if (name === 'default') {
+                mod.setExport(name, moduleExports);
+                continue;
+            }
+            mod.setExport(name, moduleExports[name]);
+        }
+    }, { identifier });
+    return mod;
+};
+const isCjsModule = (target) => target.endsWith('.cjs') || target.endsWith('.cts');
+const toRequireTarget = (target) => (target.startsWith('file:') ? fileURLToPath(target) : target);
+const loadModule = async (target) => {
+    const cached = imports.get(target);
+    if (cached)
+        return cached;
+    if (isCjsModule(target)) {
+        const required = requireFrom(toRequireTarget(target));
+        const exportNames = required && (typeof required === 'object' || typeof required === 'function') ? Object.keys(required) : [];
+        if (!exportNames.includes('default')) {
+            exportNames.push('default');
+        }
+        const mod = createSyntheticModule(required, exportNames, target);
+        imports.set(target, mod);
+        return mod;
+    }
+    const importedModule = await import(target);
+    const exportNames = Object.keys(importedModule);
+    const mod = createSyntheticModule(importedModule, exportNames, target);
+    imports.set(target, mod);
+    return mod;
+};
+const loadDynamicModule = async (target) => {
+    const mod = await loadModule(target);
+    if (mod.status !== 'evaluated') {
+        await mod.evaluate();
+    }
+    return mod;
+};
+const mod = new SourceTextModule(source, {
+    identifier: resolvedBenchmarkUrl,
+    initializeImportMeta(meta) {
+        meta.url = resolvedBenchmarkUrl;
+    },
+    importModuleDynamically(specifier) {
+        const resolved = resolveSpecifier(specifier);
+        return loadDynamicModule(resolved);
+    },
+});
+await mod.link(async (specifier) => loadModule(resolveSpecifier(specifier)));
+await mod.evaluate();
+const { setup, teardown, pre, run, post } = mod.namespace;
+if (!run) {
+    throw new Error('Benchmark run function is required');
+}
+process.exitCode = await benchmark({
+    setup,
+    teardown,
+    pre,
+    run,
+    post,
+    data,
+    warmupCycles,
+    minCycles,
+    absThreshold,
+    relThreshold,
+    gcObserver,
+    durationsSAB,
+    controlSAB,
+});

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "overtake",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "NodeJS performance benchmark",
   "type": "module",
   "types": "build/index.d.ts",
   "exports": {
     "types": "./build/index.d.ts",
-    "import": "./src/index.ts"
+    "import": "./build/index.js"
   },
   "bin": {
     "overtake": "bin/overtake.js"
@@ -44,9 +44,9 @@
     "progress": "^2.0.3"
   },
   "scripts": {
-    "build": "rm -rf build && tsc --declaration --emitDeclarationOnly",
+    "build": "rm -rf build && tsc",
     "start": "./bin/overtake.js",
-    "test": "node --experimental-test-module-mocks --test src/__tests__/*.ts",
-    "test:cov": "node --experimental-test-module-mocks --experimental-test-coverage --test src/__tests__/*.ts"
+    "test": "node --experimental-test-module-mocks --import ./src/register-hook.ts --test src/__tests__/*.ts",
+    "test:cov": "node --experimental-test-module-mocks --experimental-test-coverage --import ./src/register-hook.ts --test src/__tests__/*.ts"
   }
 }

package/src/__tests__/assert-no-closure.ts

@@ -1,6 +1,6 @@
 import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
-import { assertNoClosure } from '../utils.ts';
+import { assertNoClosure } from '../utils.js';
 
 describe('assertNoClosure', () => {
   describe('allows functions without closures', () => {

package/src/__tests__/benchmark-execute.ts

@@ -6,13 +6,13 @@ describe('Benchmark.execute', () => {
     const pushAsync = mock.fn(() => Promise.reject(new Error('Benchmark "run" function references outer-scope variables: port')));
     const kill = mock.fn();
 
-    mock.module('../executor.ts', {
+    mock.module('../executor.js', {
       namedExports: {
         createExecutor: () => ({ pushAsync, kill }),
       },
     });
 
-    const { Benchmark } = await import('../index.ts');
+    const { Benchmark } = await import('../index.js');
 
     const bench = Benchmark.create('feed');
     bench.target('target').measure('run', () => 1);

package/src/cli.ts

@@ -14,9 +14,9 @@ import {
   type BaselineData,
   DEFAULT_REPORT_TYPES,
   DEFAULT_WORKERS,
-} from './index.ts';
-import { REPORT_TYPES } from './types.ts';
-import { resolveHookUrl } from './utils.ts';
+} from './index.js';
+import { REPORT_TYPES } from './types.js';
+import { resolveHookUrl } from './utils.js';
 
 register(resolveHookUrl);
 
@@ -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

@@ -1,8 +1,8 @@
 import { Worker } from 'node:worker_threads';
 import { once } from 'node:events';
 import { pathToFileURL } from 'node:url';
-import { createReport, computeStats, Report } from './reporter.ts';
-import { cmp, assertNoClosure } from './utils.ts';
+import { createReport, computeStats, Report } from './reporter.js';
+import { cmp, assertNoClosure, normalizeFunction } from './utils.js';
 import {
   type ExecutorRunOptions,
   type ReportOptions,
@@ -14,7 +14,7 @@ import {
   CONTROL_SLOTS,
   COMPLETE_VALUE,
   type ProgressCallback,
-} from './types.ts';
+} from './types.js';
 
 export type ExecutorReport<R extends ReportTypeList> = Record<R[number], Report> & {
   count: number;
@@ -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');
@@ -83,7 +84,7 @@ export const createExecutor = <TContext, TInput, R extends ReportTypeList>(optio
     const controlSAB = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * CONTROL_SLOTS);
     const durationsSAB = new SharedArrayBuffer(BigUint64Array.BYTES_PER_ELEMENT * maxCycles);
 
-    const workerFile = new URL('./worker.ts', import.meta.url);
+    const workerFile = new URL('./worker.js', import.meta.url);
     const workerData: WorkerOptions = {
       benchmarkUrl: resolvedBenchmarkUrl,
       setupCode,
@@ -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];
@@ -161,5 +164,13 @@ export const createExecutor = <TContext, TInput, R extends ReportTypeList>(optio
     return Object.fromEntries(report);
   };
 
-  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/index.ts

@@ -1,7 +1,7 @@
 import { cpus } from 'node:os';
 import Progress from 'progress';
-import { createExecutor, type ExecutorOptions, type ExecutorReport } from './executor.ts';
-import { type MaybePromise, type StepFn, type SetupFn, type TeardownFn, type FeedFn, type ReportType, type ReportTypeList, DEFAULT_CYCLES, type ProgressInfo } from './types.ts';
+import { createExecutor, type ExecutorOptions, type ExecutorReport } from './executor.js';
+import { type MaybePromise, type StepFn, type SetupFn, type TeardownFn, type FeedFn, type ReportType, type ReportTypeList, DEFAULT_CYCLES, type ProgressInfo } from './types.js';
 
 declare global {
   const benchmark: typeof Benchmark.create;

package/src/register-hook.ts

@@ -0,0 +1,15 @@
+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()}`));

package/src/reporter.ts

@@ -1,5 +1,5 @@
-import { div, max, divs, isqrt } from './utils.ts';
-import { type ReportType, DURATION_SCALE } from './types.ts';
+import { div, max, divs, isqrt } from './utils.js';
+import { type ReportType, DURATION_SCALE } from './types.js';
 
 const units = [
   { unit: 'ns', factor: 1 },

package/src/runner.ts

@@ -1,6 +1,6 @@
 import { performance, PerformanceObserver } from 'node:perf_hooks';
-import { type Options, Control, DURATION_SCALE, COMPLETE_VALUE, type StepFn } from './types.ts';
-import { GCWatcher } from './gc-watcher.ts';
+import { type Options, Control, DURATION_SCALE, COMPLETE_VALUE, type StepFn } from './types.js';
+import { GCWatcher } from './gc-watcher.js';
 
 const hr = process.hrtime.bigint.bind(process.hrtime);
 
@@ -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

@@ -45,11 +45,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 +63,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 +135,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;
 

package/src/worker.ts

@@ -3,9 +3,9 @@ import { SourceTextModule, SyntheticModule } from 'node:vm';
 import { createRequire, register } from 'node:module';
 import { isAbsolute } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import { benchmark } from './runner.ts';
-import { type WorkerOptions } from './types.ts';
-import { resolveHookUrl } from './utils.ts';
+import { benchmark } from './runner.js';
+import { type WorkerOptions } from './types.js';
+import { resolveHookUrl } from './utils.js';
 
 register(resolveHookUrl);
 

package/tsconfig.json

@@ -8,7 +8,6 @@
     "resolveJsonModule": true,
     "allowJs": true,
     "moduleResolution": "NodeNext",
-    "allowImportingTsExtensions": true,
     "verbatimModuleSyntax": true,
     "lib": ["ESNext"],
     "rootDir": "src",