ava 7.0.0 → 8.0.1

package/lib/plugin-support/shared-worker-loader.js

@@ -2,7 +2,7 @@ import {EventEmitter, on} from 'node:events';
 import process from 'node:process';
 import {workerData, parentPort, threadId} from 'node:worker_threads';
 
-import pkg from '../pkg.cjs';
+import pkg from '../pkg.js';
 
 // Used to forward messages received over the `parentPort` and any direct ports
 // to test workers. Every subscription adds a listener, so do not enforce any
@@ -199,7 +199,7 @@ try {
 
 					// Run possibly asynchronous release functions serially, in reverse
 					// order. Any error will crash the worker.
-					for await (const fn of [...teardownFns].reverse()) {
+					for await (const fn of [...teardownFns].toReversed()) {
 						await fn();
 					}
 

package/lib/plugin-support/shared-workers.js

@@ -84,7 +84,7 @@ export async function observeWorkerProcess(fork, runStatus) {
 		}
 	};
 
-	fork.promise.finally(() => { // eslint-disable-line promise/prefer-await-to-then
+	fork.promise.finally(() => {
 		removeAllInstances();
 	});
 
@@ -99,7 +99,7 @@ export async function observeWorkerProcess(fork, runStatus) {
 			}
 		};
 
-		launched.statePromises.error.then(error => { // eslint-disable-line promise/prefer-await-to-then
+		launched.statePromises.error.then(error => {
 			launched.worker.off('message', handleWorkerMessage);
 			removeAllInstances();
 			runStatus.emitStateChange({type: 'shared-worker-error', err: serializeError(error)});
@@ -118,7 +118,7 @@ export async function observeWorkerProcess(fork, runStatus) {
 				port,
 			}, [port]);
 
-			fork.promise.finally(() => { // eslint-disable-line promise/prefer-await-to-then
+			fork.promise.finally(() => {
 				launched.worker.postMessage({
 					type: 'deregister-test-worker',
 					id: fork.threadId,

package/lib/provider-manager.js

@@ -1,14 +1,15 @@
 import * as globs from './globs.js';
-import pkg from './pkg.cjs';
+import pkg from './pkg.js';
 
+// Provides an integer representation of the protocol level. This is internal to a particular AVA installation, and
+// allows other parts of AVA to assert minimum protocol levels for certain features without having to hardcode
+// identifier strings. Integer values can be reused across protocols when older identifiers are removed.
 export const levels = {
-	// As the protocol changes, comparing levels by integer allows AVA to be
-	// compatible with different versions.
-	ava6: 1,
+	ava8: 1,
 };
 
 const levelsByProtocol = Object.assign(Object.create(null), {
-	'ava-6': levels.ava6,
+	'ava-8': levels.ava8,
 });
 
 async function load(providerModule, projectDir, selectProtocol = () => true) {

package/lib/reporters/default.js

@@ -148,7 +148,7 @@ export default class Reporter {
 			this.prefixTitle = (testFile, title) => prefixTitle(this.extensions, plan.filePathPrefix, testFile, title);
 		}
 
-		this.removePreviousListener = plan.status.on('stateChange', evt => {
+		this.removePreviousListener = plan.status.on('stateChange', ({data: evt}) => {
 			this.consumeStateChange(evt);
 		});
 

package/lib/reporters/improper-usage-messages.js

@@ -1,5 +1,5 @@
 import {chalk} from '../chalk.js';
-import pkg from '../pkg.cjs';
+import pkg from '../pkg.js';
 
 export default function buildMessage(improperUsage) {
 	if (!improperUsage) {

package/lib/reporters/tap.js

@@ -24,7 +24,13 @@ function dumpError({
 		};
 	}
 
-	originalError.name = name; // Restore the original name.
+	if (originalError && Object.getOwnPropertyDescriptor(originalError, 'name')?.writable !== false) {
+		try {
+			originalError.name = name; // Restore the original name.
+		} catch {
+			// Ignore
+		}
+	}
 
 	if (type === 'ava') {
 		if (assertion) {
@@ -46,8 +52,6 @@ function dumpError({
 
 export default class TapReporter {
 	constructor(options) {
-		this.i = 0;
-
 		this.extensions = options.extensions;
 		this.stdStream = options.stdStream;
 		this.reportStream = options.reportStream;
@@ -65,7 +69,7 @@ export default class TapReporter {
 			this.prefixTitle = (testFile, title) => prefixTitle(this.extensions, plan.filePathPrefix, testFile, title);
 		}
 
-		plan.status.on('stateChange', evt => this.consumeStateChange(evt));
+		plan.status.on('stateChange', ({data: evt}) => this.consumeStateChange(evt));
 
 		this.reportStream.write(supertap.start() + os.EOL);
 	}
@@ -259,4 +263,6 @@ export default class TapReporter {
 			}
 		}
 	}
+
+	i = 0;
 }

package/lib/runner.js

@@ -10,7 +10,7 @@ import parseTestArgs from './parse-test-args.js';
 import serializeError from './serialize-error.js';
 import {load as loadSnapshots, determineSnapshotDir} from './snapshot-manager.js';
 import Runnable from './test.js';
-import {waitForReady} from './worker/state.cjs';
+import {waitForReady} from './worker/state.js';
 
 const makeFileURL = file => file.startsWith('file://') ? file : pathToFileURL(file).toString();
 
@@ -254,7 +254,7 @@ export default class Runner extends Emittery {
 		let waitForSerial = Promise.resolve();
 		await runnables.reduce((previous, runnable) => { // eslint-disable-line unicorn/no-array-reduce
 			if (runnable.metadata.serial || this.serial) {
-				waitForSerial = previous.then(() => // eslint-disable-line promise/prefer-await-to-then
+				waitForSerial = previous.then(() =>
 					// Serial runnables run as long as there was no previous failure, unless
 					// the runnable should always be run.
 					(allPassed || runnable.metadata.always) && runAndStoreResult(runnable));
@@ -263,7 +263,7 @@ export default class Runner extends Emittery {
 
 			return Promise.all([
 				previous,
-				waitForSerial.then(() => // eslint-disable-line promise/prefer-await-to-then
+				waitForSerial.then(() =>
 					// Concurrent runnables are kicked off after the previous serial
 					// runnables have completed, as long as there was no previous failure
 					// (or if the runnable should always be run). One concurrent runnable's
@@ -476,7 +476,7 @@ export default class Runner extends Emittery {
 
 		// Note that the hooks and tests always begin running asynchronously.
 		const beforePromise = this.runHooks(this.tasks.before, contextRef);
-		const serialPromise = beforePromise.then(beforeHooksOk => { // eslint-disable-line promise/prefer-await-to-then
+		const serialPromise = beforePromise.then(beforeHooksOk => {
 			// Don't run tests if a `before` hook failed.
 			if (!beforeHooksOk) {
 				return false;
@@ -498,7 +498,7 @@ export default class Runner extends Emittery {
 				return this.runTest(task, contextRef.copy());
 			}, true);
 		});
-		const concurrentPromise = Promise.all([beforePromise, serialPromise]).then(async ([beforeHooksOk, serialOk]) => { // eslint-disable-line promise/prefer-await-to-then
+		const concurrentPromise = Promise.all([beforePromise, serialPromise]).then(async ([beforeHooksOk, serialOk]) => {
 			// Don't run tests if a `before` hook failed, or if `failFast` is enabled
 			// and a previous serial test failed.
 			if (!beforeHooksOk || (!serialOk && this.failFast)) {

package/lib/scheduler.js

@@ -45,7 +45,7 @@ const scheduler = {
 			return selectedFiles;
 		}
 
-		return [...selectedFiles].sort((f, s) => {
+		return selectedFiles.toSorted((f, s) => {
 			if (failedTestFiles.includes(f) && failedTestFiles.includes(s)) {
 				return 0;
 			}

package/lib/snapshot-manager.js

@@ -6,14 +6,16 @@ import path from 'node:path';
 import {fileURLToPath} from 'node:url';
 import zlib from 'node:zlib';
 
-import cbor from 'cbor';
+import {decode as decodeCbor, encode as encodeCbor, TypeEncoderMap} from 'cbor2';
+import {writeArray, writeUint8Array} from 'cbor2/encoder';
+import {sortLengthFirstDeterministic} from 'cbor2/sorts';
 import concordance from 'concordance';
 import indentString from 'indent-string';
 import memoize from 'memoize';
+import slash from 'slash';
 import writeFileAtomic from 'write-file-atomic';
 
 import {snapshotManager as concordanceOptions} from './concordance-options.js';
-import slash from './slash.cjs';
 
 // Increment if encoding layout or Concordance serialization versions change. Previous AVA versions will not be able to
 // decode buffers generated by a newer version, so changing this value will require a major version bump of AVA itself.
@@ -92,7 +94,7 @@ function formatEntry(snapshot, index) {
 	} = snapshot;
 
 	const description = data
-		? concordance.formatDescriptor(concordance.deserialize(data), concordanceOptions)
+		? concordance.formatDescriptor(concordance.deserialize(Buffer.from(data.buffer, data.byteOffset, data.byteLength)), concordanceOptions)
 		: '<No Data>';
 
 	const blockquote = label.split(/\n/).map(line => '> ' + line).join('\n');
@@ -160,7 +162,7 @@ class BufferBuilder {
 }
 
 function sortBlocks(blocksByTitle, blockIndices) {
-	return [...blocksByTitle].sort(([aTitle], [bTitle]) => {
+	return [...blocksByTitle].toSorted(([aTitle], [bTitle]) => {
 		const a = blockIndices.get(aTitle);
 		const b = blockIndices.get(bTitle);
 
@@ -180,10 +182,36 @@ function sortBlocks(blocksByTitle, blockIndices) {
 	});
 }
 
-async function encodeSnapshots(snapshotData) {
-	const encoded = await cbor.encodeAsync(snapshotData, {
-		omitUndefinedProperties: true,
-		canonical: true,
+function normalizeBeforeEncoding(value) {
+	if (Array.isArray(value)) {
+		return value.map(v => normalizeBeforeEncoding(v));
+	}
+
+	// FIXME: The decode code path unexpectedly returns Buffers not Uint8Arrays.
+	if (Buffer.isBuffer(value)) {
+		return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+	}
+
+	if (value !== null && typeof value === 'object' && !(value instanceof Uint8Array)) {
+		return Object.fromEntries(Object.entries(value)
+			.filter(([, v]) => v !== undefined)
+			.map(([k, v]) => [k, normalizeBeforeEncoding(v)]));
+	}
+
+	return value;
+}
+
+// FIXME: This seems to be a bug in cbor2, ignoreGlobalTags shouldn't break (Uint8)Array encoding.
+const types = new TypeEncoderMap();
+types.registerEncoder(Array, writeArray);
+types.registerEncoder(Uint8Array, writeUint8Array);
+
+function encodeSnapshots(snapshotData) {
+	const encoded = encodeCbor(normalizeBeforeEncoding(snapshotData), {
+		ignoreGlobalTags: true,
+		rejectUndefined: true,
+		sortKeys: sortLengthFirstDeterministic,
+		types,
 	});
 	const compressed = zlib.gzipSync(encoded);
 	compressed[9] = 0x03; // Override the GZip header containing the OS to always be Linux
@@ -233,7 +261,9 @@ function decodeSnapshots(buffer, snapPath) {
 	}
 
 	const decompressed = zlib.gunzipSync(compressed);
-	return cbor.decode(decompressed);
+	return decodeCbor(decompressed, {
+		ignoreGlobalTags: true,
+	});
 }
 
 class Manager {
@@ -282,7 +312,7 @@ class Manager {
 			return {pass: true};
 		}
 
-		const actual = concordance.deserialize(data, concordanceOptions);
+		const actual = concordance.deserialize(Buffer.from(data.buffer, data.byteOffset, data.byteLength), concordanceOptions);
 		const expected = concordance.describe(options.expected, concordanceOptions);
 		const pass = concordance.compareDescriptors(actual, expected);
 
@@ -311,7 +341,8 @@ class Manager {
 	deferRecord(options) {
 		const {expected, belongsTo, label, index} = options;
 		const descriptor = concordance.describe(expected, concordanceOptions);
-		const data = concordance.serialize(descriptor);
+		const buffer = concordance.serialize(descriptor);
+		const data = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
 
 		return () => { // Must be called in order!
 			this.hasChanges = true;
@@ -369,7 +400,7 @@ class Manager {
 			blocks: sortBlocks(this.newBlocksByTitle, this.blockIndices).map(([title, block]) => ({title, ...block})),
 		};
 
-		const buffer = await encodeSnapshots(snapshots);
+		const buffer = encodeSnapshots(snapshots);
 		const reportBuffer = generateReport(relFile, snapFile, snapshots);
 
 		await fs.promises.mkdir(dir, {recursive: true});

package/lib/test.js

@@ -6,7 +6,7 @@ import {
 	AssertionError, Assertions, checkAssertionMessage, getAssertionStack,
 } from './assert.js';
 import concordanceOptions from './concordance-options.js';
-import nowAndTimers from './now-and-timers.cjs';
+import * as nowAndTimers from './now-and-timers.js';
 import parseTestArgs from './parse-test-args.js';
 
 function isExternalAssertError(error) {
@@ -43,8 +43,8 @@ class ExecutionContext extends Assertions {
 				test.countPassedAssertion();
 				return true;
 			},
-			pending(promise) {
-				test.addPendingAssertion(promise);
+			pending(promise, assertionStack) {
+				test.addPendingAssertion(promise, assertionStack);
 			},
 			fail(error) {
 				return test.addFailedAssertion(error);
@@ -293,6 +293,7 @@ export default class Test {
 		this.finishDueToTimeout = null;
 		this.finishing = false;
 		this.pendingAssertionCount = 0;
+		this.pendingAssertionMetadata = new Set();
 		this.pendingAttemptCount = 0;
 		this.planCount = null;
 		this.startedAt = 0;
@@ -321,7 +322,7 @@ export default class Test {
 		this.logs.push(text);
 	}
 
-	async addPendingAssertion(promise) {
+	async addPendingAssertion(promise, assertionStack) {
 		if (this.finishing) {
 			this.saveFirstError(new Error('Assertion started, but test has already finished'));
 		}
@@ -332,6 +333,8 @@ export default class Test {
 
 		this.assertCount++;
 		this.pendingAssertionCount++;
+		const metadata = {assertionStack};
+		this.pendingAssertionMetadata.add(metadata);
 		this.refreshTimeout();
 
 		try {
@@ -340,6 +343,7 @@ export default class Test {
 			// Ignore errors.
 		} finally {
 			this.pendingAssertionCount--;
+			this.pendingAssertionMetadata.delete(metadata);
 			this.refreshTimeout();
 		}
 	}
@@ -474,7 +478,7 @@ export default class Test {
 	}
 
 	async runTeardowns() {
-		const teardowns = [...this.teardowns].reverse();
+		const teardowns = this.teardowns.toReversed();
 
 		for (const teardown of teardowns) {
 			try {
@@ -505,7 +509,10 @@ export default class Test {
 		}
 
 		if (this.pendingAssertionCount > 0) {
-			this.saveFirstError(new Error('Test finished, but an assertion is still pending'));
+			const [first] = this.pendingAssertionMetadata;
+			this.saveFirstError(new AssertionError('Test finished, but an assertion was not awaited', {
+				assertionStack: first?.assertionStack ?? '',
+			}));
 			return;
 		}
 
@@ -590,7 +597,7 @@ export default class Test {
 				};
 
 				promise
-					.catch(error => { // eslint-disable-line promise/prefer-await-to-then
+					.catch(error => {
 						if (this.testFailure !== null && error === this.testFailure) {
 							return;
 						}
@@ -607,7 +614,7 @@ export default class Test {
 							}));
 						}
 					})
-					.then(() => resolve(this.finish())); // eslint-disable-line promise/prefer-await-to-then
+					.then(() => resolve(this.finish()));
 			});
 		}
 

package/lib/watcher.js

@@ -12,7 +12,6 @@ import {
 	applyTestFileFilter, classify, buildIgnoreMatcher, findTests,
 	normalizePattern,
 } from './globs.js';
-import {levels as providerLevels} from './provider-manager.js';
 
 const debug = createDebug('ava:watcher');
 
@@ -158,7 +157,6 @@ const promptForMatchPattern = async (reporter, lineReader, currentPattern) => {
 };
 
 export async function start({api, filter, globs, projectDir, providers, reporter, stdin, signal}) {
-	providers = providers.filter(({level}) => level >= providerLevels.ava6);
 	for await (const {files, testFileSelector, ...runtimeOptions} of plan({
 		api,
 		filter,
@@ -210,7 +208,7 @@ async function * plan({
 	};
 
 	// Begin a file trace in the background.
-	fileTracer.update(findTests(cwdAndGlobs).then(testFiles => testFiles.map(path => ({ // eslint-disable-line promise/prefer-await-to-then
+	fileTracer.update(findTests(cwdAndGlobs).then(testFiles => testFiles.map(path => ({
 		path: nodePath.relative(projectDir, path),
 		isTest: true,
 		exists: true,
@@ -231,8 +229,8 @@ async function * plan({
 	};
 
 	// Observe all test runs.
-	api.on('run', ({status}) => {
-		status.on('stateChange', evt => {
+	api.on('run', ({data: {status}}) => {
+		status.on('stateChange', ({data: evt}) => {
 			switch (evt.type) {
 				case 'accessed-snapshots': {
 					fileTracer.addDependency(nodePath.relative(projectDir, evt.testFile), nodePath.relative(projectDir, evt.filename));
@@ -258,8 +256,11 @@ async function * plan({
 				case 'uncaught-exception':
 				case 'unhandled-rejection':
 				case 'worker-failed': {
-					const path = nodePath.relative(projectDir, evt.testFile);
-					failureCounts.set(path, 1 + (failureCounts.get(path) ?? 0));
+					if (evt.testFile) {
+						const path = nodePath.relative(projectDir, evt.testFile);
+						failureCounts.set(path, 1 + (failureCounts.get(path) ?? 0));
+					}
+
 					break;
 				}
 
@@ -425,7 +426,7 @@ async function * plan({
 		// If the file tracer is still analyzing dependencies, wait for that to
 		// complete.
 		if (fileTracer.busy !== null) {
-			fileTracer.busy.then(() => debounce.refresh()); // eslint-disable-line promise/prefer-await-to-then
+			fileTracer.busy.then(() => debounce.refresh());
 			takeCoverageForSelfTests?.();
 			return;
 		}
@@ -707,15 +708,10 @@ class FileTracer {
 	#base;
 	#cache = Object.create(null);
 	#pendingTrace = null;
-	#updateRunning;
-	#signalUpdateRunning;
 	#tree = new Tree();
 
 	constructor({base}) {
 		this.#base = base;
-		this.#updateRunning = new Promise(resolve => {
-			this.#signalUpdateRunning = resolve;
-		});
 	}
 
 	get busy() {
@@ -761,12 +757,9 @@ class FileTracer {
 	}
 
 	update(changes) {
-		const current = this.#update(changes).finally(() => { // eslint-disable-line promise/prefer-await-to-then
+		const current = this.#update(changes).finally(() => {
 			if (this.#pendingTrace === current) {
 				this.#pendingTrace = null;
-				this.#updateRunning = new Promise(resolve => {
-					this.#signalUpdateRunning = resolve;
-				});
 			}
 		});
 
@@ -775,7 +768,6 @@ class FileTracer {
 
 	async #update(changes) {
 		await this.#pendingTrace; // Guard against race conditions.
-		this.#signalUpdateRunning();
 
 		let reuseCache = true;
 		const knownTestFiles = new Set();

package/lib/worker/base.js

@@ -1,5 +1,4 @@
 import {mkdir} from 'node:fs/promises';
-import {createRequire} from 'node:module';
 import path from 'node:path';
 import process from 'node:process';
 import {pathToFileURL} from 'node:url';
@@ -9,17 +8,17 @@ import setUpCurrentlyUnhandled from 'currently-unhandled';
 import writeFileAtomic from 'write-file-atomic';
 
 import {set as setChalk} from '../chalk.js';
-import nowAndTimers from '../now-and-timers.cjs';
+import {setImmediate} from '../now-and-timers.js';
 import providerManager from '../provider-manager.js';
 import Runner from '../runner.js';
 import serializeError from '../serialize-error.js';
 
-import channel from './channel.cjs';
+import * as channel from './channel.js';
 import {runCompletionHandlers} from './completion-handlers.js';
 import lineNumberSelection from './line-numbers.js';
-import {set as setOptions} from './options.cjs';
-import {flags, refs, sharedWorkerTeardowns} from './state.cjs';
-import {isRunningInThread, isRunningInChildProcess} from './utils.cjs';
+import {set as setOptions} from './options.js';
+import {flags, refs, sharedWorkerTeardowns} from './state.js';
+import {isRunningInThread, isRunningInChildProcess} from './utils.js';
 
 const currentlyUnhandled = setUpCurrentlyUnhandled();
 let runner;
@@ -88,14 +87,14 @@ const run = async options => {
 
 	refs.runnerChain = runner.chain;
 
-	channel.peerFailed.then(() => { // eslint-disable-line promise/prefer-await-to-then
+	channel.peerFailed.then(() => {
 		runner.interrupt();
 	});
 
-	runner.on('accessed-snapshots', filename => channel.send({type: 'accessed-snapshots', filename}));
-	runner.on('stateChange', state => channel.send(state));
+	runner.on('accessed-snapshots', ({data: filename}) => channel.send({type: 'accessed-snapshots', filename}));
+	runner.on('stateChange', ({data: state}) => channel.send(state));
 
-	runner.on('error', error => {
+	runner.on('error', ({data: error}) => {
 		channel.send({type: 'internal-error', err: serializeError(error)});
 		forceExit();
 	});
@@ -129,7 +128,7 @@ const run = async options => {
 		await channel.workerFreed;
 		channel.unref();
 
-		nowAndTimers.setImmediate(() => {
+		setImmediate(() => {
 			const unhandled = currentlyUnhandled();
 			if (unhandled.length === 0) {
 				return avaIsDone();
@@ -151,10 +150,6 @@ const run = async options => {
 	// Store value to prevent required modules from modifying it.
 	const testPath = options.file;
 
-	const extensionsToLoadAsModules = Object.entries(options.moduleTypes)
-		.filter(([, type]) => type === 'module')
-		.map(([extension]) => extension);
-
 	// Install before processing options.require, so if helpers are added to the
 	// require configuration the *compiled* helper will be loaded.
 	const {projectDir, providerStates = []} = options;
@@ -162,26 +157,18 @@ const run = async options => {
 	await Promise.all(providerStates.map(async ({type, state, protocol}) => {
 		if (type === 'typescript') {
 			const provider = await providerManager.typescript(projectDir, {protocol});
-			providers.push(provider.worker({extensionsToLoadAsModules, state}));
+			providers.push(provider.worker({state}));
 		}
 	}));
 
-	const require = createRequire(import.meta.url);
 	const load = async ref => {
 		for (const provider of providers) {
 			if (provider.canLoad(ref)) {
-				return provider.load(ref, {requireFn: require});
-			}
-		}
-
-		for (const extension of extensionsToLoadAsModules) {
-			if (ref.endsWith(`.${extension}`)) {
-				return import(pathToFileURL(ref));
+				return provider.load(ref);
 			}
 		}
 
-		// We still support require() since it's more easily monkey-patched.
-		return require(ref);
+		return import(pathToFileURL(ref));
 	};
 
 	const loadRequiredModule = async ref => {
@@ -189,21 +176,14 @@ const run = async options => {
 		// dependency.
 		for (const provider of providers) {
 			if (provider.canLoad(ref)) {
-				return provider.load(ref, {requireFn: require});
+				return provider.load(ref, {});
 			}
 		}
 
 		// Try to load the module as a file, relative to the project directory.
-		// Match load() behavior.
 		const fullPath = path.resolve(projectDir, ref);
 		try {
-			for (const extension of extensionsToLoadAsModules) {
-				if (fullPath.endsWith(`.${extension}`)) {
-					return await import(pathToFileURL(fullPath)); // eslint-disable-line no-await-in-loop
-				}
-			}
-
-			return require(fullPath);
+			return await import(pathToFileURL(fullPath));
 		} catch (error) {
 			// If the module could not be found, assume it's not a file but a dependency.
 			if (error.code === 'ERR_MODULE_NOT_FOUND' || error.code === 'MODULE_NOT_FOUND') {
@@ -226,12 +206,8 @@ const run = async options => {
 
 	try {
 		for await (const [ref, ...args] of (options.require ?? [])) {
-			const loadedModule = await loadRequiredModule(ref);
-
-			if (typeof loadedModule === 'function') { // CJS module
-				await loadedModule(...args);
-			} else if (typeof loadedModule.default === 'function') { // ES module, or exports.default from CJS
-				const {default: fn} = loadedModule;
+			const {default: fn} = await loadRequiredModule(ref);
+			if (typeof fn === 'function') {
 				await fn(...args);
 			}
 		}