vitest 0.0.21 → 0.0.25

package/dist/{node.js → node/node.js}

@@ -5,6 +5,7 @@ import vm from 'vm';
 import { createServer, mergeConfig } from 'vite';
 import c from 'picocolors';
 const { red, dim, yellow } = c;
+const __pendingModules__ = new Map();
 export async function run(argv) {
     process.exitCode = 0;
     const root = argv.root || process.cwd();
@@ -19,9 +20,9 @@ export async function run(argv) {
         resolve: {},
     }));
     await server.pluginContainer.buildStart({});
-    // @ts-expect-error
     process.__vite_node__ = {
         server,
+        moduleCache: __pendingModules__,
     };
     try {
         await execute(files, server, argv);
@@ -31,7 +32,8 @@ export async function run(argv) {
         throw e;
     }
     finally {
-        await server.close();
+        if (!process.__vite_node__.watch)
+            await server.close();
     }
 }
 function normalizeId(id) {
@@ -47,7 +49,9 @@ function toFilePath(id, server) {
         ? id.slice(4)
         : id.startsWith(dirname(server.config.root))
             ? id
-            : slash(resolve(server.config.root, id.slice(1)));
+            : id.startsWith('/')
+                ? slash(resolve(server.config.root, id.slice(1)))
+                : id;
     if (absolute.startsWith('//'))
         absolute = absolute.slice(1);
     if (!absolute.startsWith('/'))
@@ -55,15 +59,12 @@ function toFilePath(id, server) {
     return absolute;
 }
 async function execute(files, server, options) {
-    const __pendingModules__ = new Map();
     const result = [];
     for (const file of files)
         result.push(await cachedRequest(`/@fs/${slash(resolve(file))}`, []));
     return result;
-    async function directRequest(rawId, callstack) {
-        if (builtinModules.includes(rawId))
-            return import(rawId);
-        callstack = [...callstack, rawId];
+    async function directRequest(id, fsPath, callstack) {
+        callstack = [...callstack, id];
         const request = async (dep) => {
             if (callstack.includes(dep)) {
                 throw new Error(`${red('Circular dependency detected')}\nStack:\n${[...callstack, dep].reverse().map((i) => {
@@ -73,19 +74,15 @@ async function execute(files, server, options) {
             }
             return cachedRequest(dep, callstack);
         };
-        const id = normalizeId(rawId);
-        const absolute = toFilePath(id, server);
-        if (options.shouldExternalize(absolute))
-            return import(absolute);
         const result = await server.transformRequest(id, { ssr: true });
         if (!result)
             throw new Error(`failed to load ${id}`);
-        const url = pathToFileURL(absolute);
+        const url = pathToFileURL(fsPath);
         const exports = {};
         const context = {
             require: createRequire(url),
-            __filename: absolute,
-            __dirname: dirname(absolute),
+            __filename: fsPath,
+            __dirname: dirname(fsPath),
             __vite_ssr_import__: request,
             __vite_ssr_dynamic_import__: request,
             __vite_ssr_exports__: exports,
@@ -93,17 +90,23 @@ async function execute(files, server, options) {
             __vite_ssr_import_meta__: { url },
         };
         const fn = vm.runInThisContext(`async (${Object.keys(context).join(',')}) => { ${result.code} }`, {
-            filename: absolute,
+            filename: fsPath,
             lineOffset: 0,
         });
         await fn(...Object.values(context));
         return exports;
     }
-    async function cachedRequest(id, callstack) {
-        if (__pendingModules__.has(id))
-            return __pendingModules__.get(id);
-        __pendingModules__.set(id, directRequest(id, callstack));
-        return await __pendingModules__.get(id);
+    async function cachedRequest(rawId, callstack) {
+        if (builtinModules.includes(rawId))
+            return import(rawId);
+        const id = normalizeId(rawId);
+        const fsPath = toFilePath(id, server);
+        if (options.shouldExternalize(fsPath))
+            return import(fsPath);
+        if (__pendingModules__.has(fsPath))
+            return __pendingModules__.get(fsPath);
+        __pendingModules__.set(fsPath, directRequest(id, fsPath, callstack));
+        return await __pendingModules__.get(fsPath);
     }
     function exportAll(exports, sourceModule) {
         // eslint-disable-next-line no-restricted-syntax

package/dist/reporters/default.d.ts

@@ -1,24 +1,21 @@
 import Listr from 'listr';
-import { Reporter, RunnerContext, Task } from '../types';
+import { File, Reporter, RunnerContext, Task } from '../types';
 interface TaskPromise {
     promise: Promise<void>;
     resolve: () => void;
     reject: (e: unknown) => void;
 }
 export declare class DefaultReporter implements Reporter {
-    indent: number;
     start: number;
     end: number;
     listr: Listr | null;
     listrPromise: Promise<void> | null;
     taskMap: Map<Task, TaskPromise>;
-    onStart(): void;
-    onCollected(ctx: RunnerContext): void;
+    onCollected(files: File[]): void;
     onTaskEnd(task: Task): void;
-    onFinished({ files }: RunnerContext): Promise<void>;
-    private getIndent;
-    private log;
-    private error;
+    onFinished(ctx: RunnerContext): Promise<void>;
+    onWatcherStart(ctx: RunnerContext): Promise<void>;
+    onWatcherRerun(files: string[], trigger: string): Promise<void>;
     onSnapshotUpdate(): void;
 }
 export {};

package/dist/reporters/default.js

@@ -1,3 +1,4 @@
+/* eslint-disable no-console */
 import { performance } from 'perf_hooks';
 import { relative } from 'path';
 import c from 'picocolors';
@@ -5,20 +6,16 @@ import Listr from 'listr';
 const CROSS = '✖ ';
 export class DefaultReporter {
     constructor() {
-        this.indent = 0;
         this.start = 0;
         this.end = 0;
         this.listr = null;
         this.listrPromise = null;
         this.taskMap = new Map();
     }
-    onStart() {
-        this.indent = 0;
-    }
-    onCollected(ctx) {
+    onCollected(files) {
         this.start = performance.now();
         this.taskMap = new Map();
-        const tasks = ctx.files.reduce((acc, file) => acc.concat(file.suites.flatMap(i => i.tasks)), []);
+        const tasks = files.reduce((acc, file) => acc.concat(file.suites.flatMap(i => i.tasks)), []);
         tasks.forEach((t) => {
             const obj = {};
             obj.promise = new Promise((resolve, reject) => {
@@ -42,7 +39,7 @@ export class DefaultReporter {
         const listrOptions = {
             exitOnError: false,
         };
-        this.listr = new Listr(ctx.files.map((file) => {
+        this.listr = new Listr(files.map((file) => {
             return {
                 title: relative(process.cwd(), file.filepath),
                 task: () => {
@@ -67,66 +64,67 @@ export class DefaultReporter {
         else
             (_b = this.taskMap.get(task)) === null || _b === void 0 ? void 0 : _b.resolve();
     }
-    async onFinished({ files }) {
+    async onFinished(ctx) {
         await this.listrPromise;
-        this.log();
         this.end = performance.now();
-        const suites = files.reduce((acc, file) => acc.concat(file.suites), []);
-        const tasks = files.reduce((acc, file) => acc.concat(file.suites.flatMap(i => i.tasks)), []);
+        console.log();
+        const { tasks, suites, files } = ctx;
         const failedFiles = files.filter(i => i.error);
         const failedSuites = suites.filter(i => i.error);
-        const runable = tasks.filter(i => i.state === 'pass' || i.state === 'fail');
+        const runnable = tasks.filter(i => i.state === 'pass' || i.state === 'fail');
         const passed = tasks.filter(i => i.state === 'pass');
         const failed = tasks.filter(i => i.state === 'fail');
         const skipped = tasks.filter(i => i.state === 'skip');
         const todo = tasks.filter(i => i.state === 'todo');
-        this.indent = 0;
         if (failedFiles.length) {
-            this.error(c.bold(`\nFailed to parse ${failedFiles.length} files:`));
+            console.error(c.bold(`\nFailed to parse ${failedFiles.length} files:`));
             failedFiles.forEach((i) => {
-                this.error(`\n- ${i.filepath}`);
+                console.error(c.red(`\n- ${i.filepath}`));
                 console.error(i.error || 'Unknown error');
-                this.log();
+                console.log();
             });
         }
         if (failedSuites.length) {
-            this.error(c.bold(`\nFailed to run ${failedSuites.length} suites:`));
+            console.error(c.bold(c.red(`\nFailed to run ${failedSuites.length} suites:`)));
             failedSuites.forEach((i) => {
                 var _a;
-                this.error(`\n- ${(_a = i.file) === null || _a === void 0 ? void 0 : _a.filepath} > ${i.name}`);
+                console.error(c.red(`\n- ${(_a = i.file) === null || _a === void 0 ? void 0 : _a.filepath} > ${i.name}`));
                 console.error(i.error || 'Unknown error');
-                this.log();
+                console.log();
             });
         }
         if (failed.length) {
-            this.error(c.bold(`\nFailed Tests (${failed.length})`));
+            console.error(c.bold(c.red(`\nFailed Tests (${failed.length})`)));
             failed.forEach((task) => {
                 var _a;
-                this.error(`\n${CROSS + c.inverse(c.red(' FAIL '))} ${[task.suite.name, task.name].filter(Boolean).join(' > ')} ${c.gray(c.dim(`${(_a = task.file) === null || _a === void 0 ? void 0 : _a.filepath}`))}`);
+                console.error(`\n${CROSS + c.inverse(c.red(' FAIL '))} ${[task.suite.name, task.name].filter(Boolean).join(' > ')} ${c.gray(c.dim(`${(_a = task.file) === null || _a === void 0 ? void 0 : _a.filepath}`))}`);
                 console.error(task.error || 'Unknown error');
-                this.log();
+                console.log();
             });
         }
-        this.log(c.bold(c.green(`Passed   ${passed.length} / ${runable.length}`)));
+        console.log(c.bold(c.green(`Passed   ${passed.length} / ${runnable.length}`)));
         if (failed.length)
-            this.log(c.bold(c.red(`Failed   ${failed.length} / ${runable.length}`)));
+            console.log(c.bold(c.red(`Failed   ${failed.length} / ${runnable.length}`)));
         if (skipped.length)
-            this.log(c.yellow(`Skipped  ${skipped.length}`));
+            console.log(c.yellow(`Skipped  ${skipped.length}`));
         if (todo.length)
-            this.log(c.dim(`Todo     ${todo.length}`));
-        this.log(`Time     ${(this.end - this.start).toFixed(2)}ms`);
-    }
-    getIndent(offest = 0) {
-        return ' '.repeat((this.indent + offest) * 2);
+            console.log(c.dim(`Todo     ${todo.length}`));
+        console.log(`Time     ${(this.end - this.start).toFixed(2)}ms`);
     }
-    log(msg = '', indentOffset = 0) {
-        // eslint-disable-next-line no-console
-        console.log(`${this.getIndent(indentOffset)}${msg}`);
+    async onWatcherStart(ctx) {
+        await this.listrPromise;
+        const failed = ctx.tasks.filter(i => i.state === 'fail');
+        if (failed.length)
+            console.log(`\n${c.bold(c.inverse(c.red(' FAIL ')))}${c.red(` ${failed.length} tests failed. Watching for file changes...`)}`);
+        else
+            console.log(`\n${c.bold(c.inverse(c.green(' PASS ')))}${c.green(' Watching for file changes...')}`);
     }
-    error(msg = '', indentOffset = 0) {
-        // eslint-disable-next-line no-console
-        console.error(c.red(`${this.getIndent(indentOffset)}${msg}`));
+    async onWatcherRerun(files, trigger) {
+        await this.listrPromise;
+        console.clear();
+        console.log(c.blue('Re-running tests...') + c.dim(` [ ${relative(process.cwd(), trigger)} ]\n`));
     }
+    // TODO:
     onSnapshotUpdate() {
     }
 }

package/dist/run/index.d.ts

@@ -0,0 +1,8 @@
+import { File, ResolvedConfig, Task, RunnerContext, Suite } from '../types';
+export declare function runTask(task: Task, ctx: RunnerContext): Promise<void>;
+export declare function collectFiles(paths: string[]): Promise<Record<string, File>>;
+export declare function runSuite(suite: Suite, ctx: RunnerContext): Promise<void>;
+export declare function runFile(file: File, ctx: RunnerContext): Promise<void>;
+export declare function runFiles(filesMap: Record<string, File>, ctx: RunnerContext): Promise<void>;
+export declare function run(config: ResolvedConfig): Promise<void>;
+export declare function startWatcher(ctx: RunnerContext): Promise<void>;

package/dist/run/index.js

@@ -0,0 +1,240 @@
+import fg from 'fast-glob';
+import { setupChai } from '../integrations/chai/setup';
+import { clearContext, defaultSuite } from '../suite';
+import { context } from '../context';
+import { DefaultReporter } from '../reporters/default';
+import { defaultIncludes, defaultExcludes } from '../constants';
+import { getSnapshotManager } from '../integrations/chai/snapshot';
+async function callHook(suite, name, args) {
+    await Promise.all(suite.hooks[name].map(fn => fn(...args)));
+}
+export async function runTask(task, ctx) {
+    var _a, _b, _c;
+    const { reporter } = ctx;
+    (_a = getSnapshotManager()) === null || _a === void 0 ? void 0 : _a.setTask(task);
+    await ((_b = reporter.onTaskBegin) === null || _b === void 0 ? void 0 : _b.call(reporter, task, ctx));
+    if (task.mode === 'run') {
+        try {
+            await callHook(task.suite, 'beforeEach', [task, task.suite]);
+            await task.fn();
+            task.state = 'pass';
+        }
+        catch (e) {
+            task.state = 'fail';
+            task.error = e;
+            process.exitCode = 1;
+        }
+        try {
+            await callHook(task.suite, 'afterEach', [task, task.suite]);
+        }
+        catch (e) {
+            task.state = 'fail';
+            task.error = e;
+            process.exitCode = 1;
+        }
+    }
+    await ((_c = reporter.onTaskEnd) === null || _c === void 0 ? void 0 : _c.call(reporter, task, ctx));
+}
+export async function collectFiles(paths) {
+    const files = {};
+    for (const filepath of paths) {
+        const file = {
+            filepath,
+            suites: [],
+            collected: false,
+        };
+        clearContext();
+        try {
+            await import(filepath);
+            const collectors = [defaultSuite, ...context.suites];
+            for (const c of collectors) {
+                context.currentSuite = c;
+                file.suites.push(await c.collect(file));
+            }
+            file.collected = true;
+        }
+        catch (e) {
+            file.error = e;
+            file.collected = false;
+            process.exitCode = 1;
+        }
+        files[filepath] = file;
+    }
+    const allFiles = Object.values(files);
+    const allSuites = allFiles.reduce((suites, file) => suites.concat(file.suites), []);
+    interpretOnlyMode(allSuites);
+    allSuites.forEach((i) => {
+        if (i.mode === 'skip')
+            i.tasks.forEach(t => t.mode === 'run' && (t.mode = 'skip'));
+        else
+            interpretOnlyMode(i.tasks);
+        i.tasks.forEach(t => t.mode === 'skip' && (t.state = 'skip'));
+    });
+    return files;
+}
+/**
+ * If any items been marked as `only`, mark all other items as `skip`.
+ */
+function interpretOnlyMode(items) {
+    if (items.some(i => i.mode === 'only')) {
+        items.forEach((i) => {
+            if (i.mode === 'run')
+                i.mode = 'skip';
+            else if (i.mode === 'only')
+                i.mode = 'run';
+        });
+    }
+}
+export async function runSuite(suite, ctx) {
+    var _a, _b;
+    const { reporter } = ctx;
+    await ((_a = reporter.onSuiteBegin) === null || _a === void 0 ? void 0 : _a.call(reporter, suite, ctx));
+    if (suite.mode === 'skip') {
+        suite.status = 'skip';
+    }
+    else if (suite.mode === 'todo') {
+        suite.status = 'todo';
+    }
+    else {
+        try {
+            await callHook(suite, 'beforeAll', [suite]);
+            await Promise.all(suite.tasks.map(i => runTask(i, ctx)));
+            // for (const t of suite.tasks)
+            //   await runTask(t, ctx)
+            await callHook(suite, 'afterAll', [suite]);
+        }
+        catch (e) {
+            suite.error = e;
+            suite.status = 'fail';
+            process.exitCode = 1;
+        }
+    }
+    await ((_b = reporter.onSuiteEnd) === null || _b === void 0 ? void 0 : _b.call(reporter, suite, ctx));
+}
+export async function runFile(file, ctx) {
+    var _a, _b;
+    const { reporter } = ctx;
+    const runnableSuites = file.suites.filter(i => i.mode === 'run');
+    if (runnableSuites.length === 0)
+        return;
+    await ((_a = reporter.onFileBegin) === null || _a === void 0 ? void 0 : _a.call(reporter, file, ctx));
+    if (ctx.config.parallel) {
+        await Promise.all(file.suites.map(suite => runSuite(suite, ctx)));
+    }
+    else {
+        for (const suite of file.suites)
+            await runSuite(suite, ctx);
+    }
+    await ((_b = reporter.onFileEnd) === null || _b === void 0 ? void 0 : _b.call(reporter, file, ctx));
+}
+export async function runFiles(filesMap, ctx) {
+    var _a;
+    const { reporter } = ctx;
+    await ((_a = reporter.onCollected) === null || _a === void 0 ? void 0 : _a.call(reporter, Object.values(filesMap), ctx));
+    for (const file of Object.values(filesMap))
+        await runFile(file, ctx);
+}
+export async function run(config) {
+    var _a, _b, _c;
+    config.reporter = config.reporter || new DefaultReporter();
+    const { reporter } = config;
+    // if watch, tell `vite-node` not to end the process
+    if (config.watch)
+        process.__vite_node__.watch = true;
+    // setup chai
+    await setupChai(config);
+    // collect files
+    let testFilepaths = await fg(config.includes || defaultIncludes, {
+        absolute: true,
+        cwd: config.root,
+        ignore: config.excludes || defaultExcludes,
+    });
+    // if name filters are provided by the CLI
+    if ((_a = config.filters) === null || _a === void 0 ? void 0 : _a.length)
+        testFilepaths = testFilepaths.filter(i => config.filters.some(f => i.includes(f)));
+    if (!testFilepaths.length) {
+        console.error('No test files found');
+        process.exitCode = 1;
+        return;
+    }
+    // setup envs
+    if (config.global)
+        (await import('../integrations/global')).registerApiGlobally();
+    if (config.jsdom)
+        (await import('../integrations/jsdom')).setupJSDOM(globalThis);
+    await ((_b = reporter.onStart) === null || _b === void 0 ? void 0 : _b.call(reporter, config));
+    const filesMap = await collectFiles(testFilepaths);
+    const ctx = {
+        filesMap,
+        get files() {
+            return Object.values(this.filesMap);
+        },
+        get suites() {
+            return Object.values(this.filesMap)
+                .reduce((suites, file) => suites.concat(file.suites), []);
+        },
+        get tasks() {
+            return this.suites
+                .reduce((tasks, suite) => tasks.concat(suite.tasks), []);
+        },
+        config,
+        reporter: config.reporter,
+    };
+    await runFiles(filesMap, ctx);
+    const snapshot = getSnapshotManager();
+    snapshot === null || snapshot === void 0 ? void 0 : snapshot.saveSnap();
+    snapshot === null || snapshot === void 0 ? void 0 : snapshot.report();
+    await ((_c = reporter.onFinished) === null || _c === void 0 ? void 0 : _c.call(reporter, ctx));
+    if (config.watch)
+        startWatcher(ctx);
+}
+export async function startWatcher(ctx) {
+    var _a, _b;
+    await ((_b = (_a = ctx.reporter).onWatcherStart) === null || _b === void 0 ? void 0 : _b.call(_a, ctx));
+    let timer;
+    const changedTests = new Set();
+    const seen = new Set();
+    const { server, moduleCache } = process.__vite_node__;
+    server.watcher.on('change', async (id) => {
+        getDependencyTests(id, ctx, changedTests, seen);
+        seen.forEach(i => moduleCache.delete(i));
+        seen.clear();
+        if (changedTests.size === 0)
+            return;
+        clearTimeout(timer);
+        timer = setTimeout(async () => {
+            var _a, _b, _c, _d;
+            if (changedTests.size === 0)
+                return;
+            const snapshot = getSnapshotManager();
+            const paths = Array.from(changedTests);
+            changedTests.clear();
+            await ((_b = (_a = ctx.reporter).onWatcherRerun) === null || _b === void 0 ? void 0 : _b.call(_a, paths, id, ctx));
+            paths.forEach(i => moduleCache.delete(i));
+            const files = await collectFiles(paths);
+            Object.assign(ctx.filesMap, files);
+            await runFiles(files, ctx);
+            // TODO: clear snapshot state
+            snapshot === null || snapshot === void 0 ? void 0 : snapshot.saveSnap();
+            snapshot === null || snapshot === void 0 ? void 0 : snapshot.report();
+            await ((_d = (_c = ctx.reporter).onWatcherStart) === null || _d === void 0 ? void 0 : _d.call(_c, ctx));
+        }, 100);
+    });
+}
+function getDependencyTests(id, ctx, set = new Set(), seen = new Set()) {
+    if (seen.has(id) || set.has(id))
+        return set;
+    seen.add(id);
+    if (id in ctx.filesMap) {
+        set.add(id);
+        return set;
+    }
+    const mod = process.__vite_node__.server.moduleGraph.getModuleById(id);
+    if (mod) {
+        mod.importers.forEach((i) => {
+            if (i.id)
+                getDependencyTests(i.id, ctx, set, seen);
+        });
+    }
+    return set;
+}

package/dist/suite.js

@@ -32,12 +32,12 @@ function createSuiteCollector(name, factory = () => { }, mode) {
             name,
             mode,
             suite: {},
-            state: mode !== 'run' ? mode : undefined,
+            state: (mode !== 'run' && mode !== 'only') ? mode : undefined,
             fn,
         });
     }
     function test(name, fn) {
-        collectTask(name, fn, mode);
+        collectTask(name, fn, 'run');
     }
     test.skip = (name, fn) => collectTask(name, fn, 'skip');
     test.only = (name, fn) => collectTask(name, fn, 'only');

package/dist/types.d.ts

@@ -1,7 +1,15 @@
-import { ViteDevServer } from 'vite';
 export declare type Awaitable<T> = Promise<T> | T;
 export interface UserOptions {
+    /**
+     * Include globs for test files
+     *
+     * @default ['**\/*.test.ts']
+     */
     includes?: string[];
+    /**
+     * Exclude globs for test files
+     * @default ['**\/node_modules\/**']
+     */
     excludes?: string[];
     /**
      * Register apis globally
@@ -21,13 +29,29 @@ export interface UserOptions {
      * @default false
      */
     parallel?: boolean;
-}
-export interface Config extends UserOptions {
-    rootDir?: string;
-    updateSnapshot?: boolean;
-    nameFilters?: string[];
-    server: ViteDevServer;
+    /**
+     * Update snapshot files
+     *
+     * @default false
+     */
+    update?: boolean;
+    /**
+     * Watch mode
+     *
+     * @default false
+     */
     watch?: boolean;
+    /**
+     * Project root
+     */
+    root?: string;
+    /**
+     * Custom reporter for output
+     */
+    reporter?: Reporter;
+}
+export interface ResolvedConfig extends Required<UserOptions> {
+    filters?: string[];
 }
 export declare type RunMode = 'run' | 'skip' | 'only' | 'todo';
 export declare type TaskState = RunMode | 'pass' | 'fail';
@@ -78,8 +102,11 @@ export interface File {
     error?: unknown;
 }
 export interface RunnerContext {
+    filesMap: Record<string, File>;
     files: File[];
-    config: Config;
+    suites: Suite[];
+    tasks: Task[];
+    config: ResolvedConfig;
     reporter: Reporter;
 }
 export interface GlobalContext {
@@ -87,8 +114,8 @@ export interface GlobalContext {
     currentSuite: SuiteCollector | null;
 }
 export interface Reporter {
-    onStart?: (userOptions: Config) => Awaitable<void>;
-    onCollected?: (ctx: RunnerContext) => Awaitable<void>;
+    onStart?: (userOptions: ResolvedConfig) => Awaitable<void>;
+    onCollected?: (files: File[], ctx: RunnerContext) => Awaitable<void>;
     onFinished?: (ctx: RunnerContext) => Awaitable<void>;
     onSuiteBegin?: (suite: Suite, ctx: RunnerContext) => Awaitable<void>;
     onSuiteEnd?: (suite: Suite, ctx: RunnerContext) => Awaitable<void>;
@@ -96,5 +123,7 @@ export interface Reporter {
     onFileEnd?: (file: File, ctx: RunnerContext) => Awaitable<void>;
     onTaskBegin?: (task: Task, ctx: RunnerContext) => Awaitable<void>;
     onTaskEnd?: (task: Task, ctx: RunnerContext) => Awaitable<void>;
+    onWatcherStart?: (ctx: RunnerContext) => Awaitable<void>;
+    onWatcherRerun?: (files: string[], trigger: string, ctx: RunnerContext) => Awaitable<void>;
     onSnapshotUpdate?: () => Awaitable<void>;
 }