@plugjs/plug 0.0.15 → 0.0.17

package/src/helpers.ts

@@ -2,37 +2,15 @@ import { assert } from './assert'
 import { requireContext } from './async'
 import { Files } from './files'
 import { $p, log } from './log'
-import { AbsolutePath, commonPath, getCurrentWorkingDirectory, resolveDirectory, resolveFile } from './paths'
-import { Context, Pipe, Plug, PlugFunction, PlugResult } from './pipe'
+import { AbsolutePath, getCurrentWorkingDirectory, resolveDirectory, resolveFile } from './paths'
+import { Pipe } from './pipe'
 import { rm } from './utils/asyncfs'
 import { ParseOptions, parseOptions } from './utils/options'
 import { walk, WalkOptions } from './utils/walk'
 
-class PipeImpl extends Pipe implements Pipe {
-  constructor(private readonly _start: (context: Context) => Promise<Files>) {
-    super()
-  }
-
-  plug(plug: Plug<Files>): Pipe
-  plug(plug: PlugFunction<Files>): Pipe
-  plug(plug: Plug<void | undefined>): Promise<undefined>
-  plug(plug: PlugFunction<void | undefined>): Promise<undefined>
-  plug(arg: Plug<PlugResult> | PlugFunction<PlugResult>): Pipe | Promise<undefined> {
-    const plug = typeof arg === 'function' ? { pipe: arg } : arg
-
-    const parent = this
-    return new PipeImpl(async (context: Context): Promise<Files> => {
-      const files = await parent._start(context)
-      const files2 = await plug.pipe(files, context)
-      assert(files2, 'Unable to extend pipe (part tres)')
-      return files2
-    })
-  }
-
-  async run(): Promise<Files> {
-    return this._start(requireContext())
-  }
-}
+/* ========================================================================== *
+ * EXTERNAL HELPERS                                                           *
+ * ========================================================================== */
 
 /** The {@link FindOptions} interface defines the options for finding files. */
 export interface FindOptions extends WalkOptions {
@@ -40,16 +18,20 @@ export interface FindOptions extends WalkOptions {
   directory?: string
 }
 
-
+/** Find files in the current directory using the specified _glob_. */
 export function find(glob: string): Pipe
+/** Find files in the current directory using the specified _globs_. */
 export function find(glob: string, ...globs: string[]): Pipe
+/** Find files using the specified _glob_ and {@link FindOptions | options}. */
 export function find(glob: string, options: FindOptions): Pipe
+/** Find files using the specified _globs_ and {@link FindOptions | options}. */
 export function find(glob: string, ...extra: [...globs: string[], options: FindOptions]): Pipe
-
+/* Overload */
 export function find(...args: ParseOptions<FindOptions>): Pipe {
   const { params: globs, options } = parseOptions(args, {})
 
-  return new PipeImpl(async (context: Context): Promise<Files> => {
+  const context = requireContext()
+  return new Pipe(context, Promise.resolve().then(async () => {
     const directory = options.directory ?
       context.resolve(options.directory) :
       getCurrentWorkingDirectory()
@@ -60,30 +42,7 @@ export function find(...args: ParseOptions<FindOptions>): Pipe {
     }
 
     return builder.build()
-  })
-}
-
-export function merge(...pipes: Pipe[]): Pipe {
-  return new PipeImpl(async (): Promise<Files> => {
-    if (pipes.length === 0) return Files.builder(getCurrentWorkingDirectory()).build()
-
-    const results: Files[] = []
-
-    for (const pipe of pipes) {
-      const result = await pipe.run()
-      assert(result, 'Pipe did not return a Files result')
-      results.push(result)
-    }
-
-    const [ first, ...others ] = results
-
-    const firstDir = first.directory
-    const otherDirs = others.map((f) => f.directory)
-
-    const directory = commonPath(firstDir, ...otherDirs)
-
-    return Files.builder(directory).merge(first, ...others).build()
-  })
+  }))
 }
 
 /**
@@ -108,13 +67,33 @@ export async function rmrf(directory: string): Promise<void> {
   await rm(dir, { recursive: true })
 }
 
-/** Return an absolute path of the file if it exist on disk */
+/**
+ * Resolve a (set of) path(s) into an {@link AbsolutePath}.
+ *
+ * If the path (or first component thereof) starts with `@...`, then the
+ * resolved path will be relative to the directory containing the build file
+ * where the current task was defined, otherwise it will be relative to the
+ * current working directory.
+ */
+export function resolve(...paths: [ string, ...string[] ]): AbsolutePath {
+  return requireContext().resolve(...paths)
+}
+
+/**
+ * Return an absolute path of the file if it exist on disk.
+ *
+ * See the comments on {@link resolve} to understand how paths are resolved.
+ */
 export function isFile(...paths: [ string, ...string[] ]): AbsolutePath | undefined {
   const path = requireContext().resolve(...paths)
   return resolveFile(path)
 }
 
-/** Return an absolute path of the file if it exist on disk */
+/**
+ * Return an absolute path of the directory if it exist on disk.
+ *
+ * See the comments on {@link resolve} to understand how paths are resolved.
+ */
 export function isDirectory(...paths: [ string, ...string[] ]): AbsolutePath | undefined {
   const path = requireContext().resolve(...paths)
   return resolveDirectory(path)

package/src/index.ts

@@ -2,14 +2,15 @@
 
 export type { AbsolutePath } from './paths'
 export type { Files, FilesBuilder } from './files'
-export type { Pipe } from './pipe'
+
+export { BuildFailure } from './failure'
+export { Pipe } from './pipe'
 
 // Our minimal exports
 export * from './assert'
 export * from './build'
+export * from './fork'
 export * from './helpers'
 export * from './log'
-
-// PlugJS types
 export * from './plugs'
 export * from './types'

package/src/log/logger.ts

@@ -1,4 +1,4 @@
-import { isBuildError, isBuildFailure } from '../assert'
+import { BuildFailure, isBuildFailure } from '../failure'
 import { emitColor, emitPlain, LogEmitter } from './emit'
 import { DEBUG, ERROR, INFO, LogLevel, NOTICE, TRACE, WARN } from './levels'
 import { logOptions } from './options'
@@ -34,6 +34,8 @@ export interface Log {
   warn(...args: [ any, ...any ]): this
   /** Log an `ERROR` message */
   error(...args: [ any, ...any ]): this
+  /** Log an `ERROR` message and fail the build */
+  fail(...args: [ any, ...any ]): never
 }
 
 /** A {@link Logger} extends the basic {@link Log} adding some state. */
@@ -83,9 +85,18 @@ class LoggerImpl implements Logger {
   private _emit(level: LogLevel, args: [ any, ...any ]): this {
     if (this._level > level) return this
 
-    // Filter out build failures (they are not to be logged)
-    const params = args.filter((arg) => ! isBuildFailure(arg))
-    if (params.length === 0) return this // no logging only build failures
+    // Filter out build failures that were already logged
+    const params = args.filter((arg) => {
+      if (isBuildFailure(arg)) {
+        if (arg.logged) return false // already logged? skip!
+        return arg.logged = true // set logged to true and log!
+      } else {
+        return true
+      }
+    })
+
+    // If there's nothing left to log, then we're done
+    if (params.length === 0) return this
 
     // Prepare our options for logging
     const options = { level, taskName: this._task, indent: this._indent }
@@ -98,18 +109,8 @@ class LoggerImpl implements Logger {
       this._stack.splice(0)
     }
 
-    // Print all `BuildError`s _before_ any other entry
-    const remaining = params.filter((arg) => {
-      if (isBuildError(arg)) {
-        this._emitter({ ...options, level: ERROR }, [ arg.message ])
-        return false
-      } else {
-        return true
-      }
-    })
-
-    // If we have any leftovers, dump them out, too!
-    if (remaining) this._emitter(options, remaining)
+    // Emit our log lines and return
+    this._emitter(options, params)
     return this
   }
 
@@ -145,6 +146,11 @@ class LoggerImpl implements Logger {
     return this._emit(ERROR, args)
   }
 
+  fail(...args: [ any, ...any ]): never {
+    this._emit(ERROR, args)
+    throw new BuildFailure({ logged: true })
+  }
+
   enter(): this
   enter(level: LogLevel, message: string): this
   enter(...args: [] | [ level: LogLevel, message: string ]): this {

package/src/log/report.ts

@@ -1,4 +1,4 @@
-import { fail, failure } from '../assert'
+import { BuildFailure } from '../failure'
 import { AbsolutePath } from '../paths'
 import { readFile } from '../utils/asyncfs'
 import { $blu, $cyn, $gry, $red, $und, $wht, $ylw } from './colors'
@@ -191,7 +191,11 @@ export class ReportImpl implements Report {
             [ ...record.message.map((msg) => msg.split('\n')).flat(1) ] :
             record.message.split('\n')
       messages = messages.filter((message) => !! message)
-      if (! messages.length) fail('No message for report record')
+      if (! messages.length) {
+        const options = { taskName: this._task, level: ERROR }
+        this._emitter(options, [ 'No message for report record' ])
+        throw new BuildFailure({ logged: true })
+      }
 
       const level = record.level
       const file = record.file
@@ -263,7 +267,7 @@ export class ReportImpl implements Report {
   done(showSources?: boolean | undefined): void {
     if (showSources == null) showSources = logOptions.showSources
     if (! this.empty) this._emit(showSources)
-    if (this.errors) throw failure()
+    if (this.errors) throw new BuildFailure({ logged: true })
   }
 
   private _emit(showSources: boolean): this {

package/src/log.ts

@@ -58,6 +58,10 @@ export const log: LogFunction = ((): LogFunction => {
       logger().error(...args)
       return wrapper
     },
+
+    fail(...args: [ any, ...any ]): never {
+      throw logger().fail(...args) // fail() returns never but ?!?!?!?!?
+    },
   }
 
   /* Create a function that will default logging to "NOTICE" */

package/src/pipe.ts

@@ -1,9 +1,17 @@
-import type { Files } from './files'
-import { getLogger, Logger } from './log'
-import { AbsolutePath, getAbsoluteParent, getCurrentWorkingDirectory, resolveAbsolutePath } from './paths'
+import {
+  AbsolutePath,
+  commonPath,
+  getAbsoluteParent,
+  getCurrentWorkingDirectory,
+  resolveAbsolutePath,
+} from './paths'
 
-import { ForkingPlug } from './fork'
 import { sep } from 'path'
+import { assert, assertPromises } from './assert'
+import { requireContext } from './async'
+import { Files } from './files'
+import { getLogger, Logger } from './log'
+import { Result } from './types'
 
 /* ========================================================================== *
  * PLUGS                                                                      *
@@ -50,6 +58,14 @@ export class Context {
     this.log = getLogger(taskName)
   }
 
+  /**
+   * Resolve a (set of) path(s) in this {@link Context}.
+   *
+   * If the path (or first component thereof) starts with `@...`, then the
+   * resolved path will be relative to the directory containing the build file
+   * where the current task was defined, otherwise it will be relative to the
+   * current working directory.
+   */
   resolve(path: string, ...paths: string[]): AbsolutePath {
     // Paths starting with "@" are relative to the build file directory
     if (path && path.startsWith('@')) {
@@ -70,6 +86,25 @@ export class Context {
  * PIPES                                                                      *
  * ========================================================================== */
 
+/**
+ * In pipe chains, we want to keep track of the _leaf_ `Files` promises (that
+ * is, when a derived pipe is created calling `plug` we want to track only the
+ * new, derived, promise).
+ *
+ * We key these _leaf_ promises by _context_ (with a WeakMap), and those will
+ * be awaited at the end of the task.
+ */
+const contextPromises = new WeakMap<Context, Set<Promise<Result>>>()
+
+export function getContextPromises(context: Context): Set<Promise<Result>> {
+  let promises = contextPromises.get(context)
+  if (! promises) {
+    promises = new Set<Promise<Files>>()
+    contextPromises.set(context, promises)
+  }
+  return promises
+}
+
 /**
  * A class that will be extended by {@link Pipe} where {@link install} will
  * add prototype properties from installed {@link Plug}s
@@ -79,16 +114,116 @@ abstract class PipeProto {
 }
 
 /**
- * The {@link Pipe} abstract defines processing pipeline where multiple
+ * The {@link Pipe} class defines processing pipeline where multiple
  * {@link Plug}s can transform lists of {@link Files}.
  */
-export abstract class Pipe extends PipeProto {
-  abstract plug(plug: Plug<Files>): Pipe
-  abstract plug(plug: PlugFunction<Files>): Pipe
-  abstract plug(plug: Plug<void | undefined>): Promise<undefined>
-  abstract plug(plug: PlugFunction<void | undefined>): Promise<undefined>
+export class Pipe extends PipeProto implements Promise<Files> {
+  readonly [Symbol.toStringTag] = 'Pipe'
+
+  constructor(
+      private readonly _context: Context,
+      private readonly _promise: Promise<Result>,
+  ) {
+    super()
+
+    // New "Pipe", remember the promise!
+    getContextPromises(_context).add(_promise)
+  }
+
+  /* ------------------------------------------------------------------------ *
+   * Promise implementation                                                   *
+   * ------------------------------------------------------------------------ *
+   * From a _types_ point of view, the `Pipe` implements a `Promise<Files>`   *
+   * (because only when plugging the correct `Plug` the correct value are     *
+   * returned).                                                               *
+   *                                                                          *
+   * Whether to return (as a type) another `Pipe` or a `Promise<undefined>`   *
+   * is determined by the type of the `plug` parameter below.                 *
+   *                                                                          *
+   * That said, in practice, a `Pipe` implements `Promise<Files | undefined>` *
+   * because the result of the plug is _eventually_ computed asynchronously   *
+   * while `plug` returns immediately.
+   *                                                                          *
+   * So, all those "as whatever" below are kind-of-legit...                   *
+   * ------------------------------------------------------------------------ */
+
+  then<R1 = Files, R2 = never>(
+      onfulfilled?: ((value: Files) => R1 | PromiseLike<R1>) | null | undefined,
+      onrejected?: ((reason: any) => R2 | PromiseLike<R2>) | null | undefined,
+  ): Promise<R1 | R2> {
+    // We are delegating the handling of this promise to the caller
+    getContextPromises(this._context).delete(this._promise)
+    return this._promise.then(onfulfilled as (value: Result) => R1 | PromiseLike<R1>, onrejected)
+  }
+
+  catch<R = never>(
+      onrejected?: ((reason: any) => R | PromiseLike<R>) | null | undefined,
+  ): Promise<Files | R> {
+    // We are delegating the handling of this promise to the caller
+    getContextPromises(this._context).delete(this._promise)
+    return this._promise.catch(onrejected) as Promise<Files | R>
+  }
+
+  finally(onfinally?: (() => void) | null | undefined): Promise<Files> {
+    // We are delegating the handling of this promise to the caller
+    getContextPromises(this._context).delete(this._promise)
+    return this._promise.finally(onfinally) as Promise<Files>
+  }
+
+  /* ------------------------------------------------------------------------ *
+   * Pipe implementation                                                      *
+   * ------------------------------------------------------------------------ */
+
+  plug(plug: Plug<Files>): Pipe
+  plug(plug: PlugFunction<Files>): Pipe
+  plug(plug: Plug<void | undefined>): Promise<undefined>
+  plug(plug: PlugFunction<void | undefined>): Promise<undefined>
+  plug(arg: Plug<PlugResult> | PlugFunction<PlugResult>): Pipe | Promise<undefined> {
+    const plug = typeof arg === 'function' ? { pipe: arg } : arg
+
+    // We are creating a new "leaf" Pipe, we can forget our promise
+    getContextPromises(this._context).delete(this._promise)
+
+    // Create and return the new Pipe
+    return new Pipe(this._context, this._promise.then(async (result) => {
+      assert(result, 'Unable to extend pipe')
+      const result2 = await plug.pipe(result, this._context)
+      return result2 || undefined
+    }))
+  }
+
+  /**
+   * Merge the results of several {@link Pipe}s into a single one.
+   *
+   * Merging is performed _in parallel_. When serial execution is to be desired,
+   * we can merge the awaited _result_ of the {@link Pipe}.
+   *
+   * For example:
+   *
+   * ```
+   * const pipe: Pipe = merge([
+   *   await this.anotherTask1(),
+   *   await this.anotherTask2(),
+   * ])
+   * ```
+   */
+  static merge(pipes: (Pipe | Files | Promise<Files>)[]): Pipe {
+    const context = requireContext()
+    return new Pipe(context, Promise.resolve().then(async () => {
+      // No pipes? Just send off an empty pipe...
+      if (pipes.length === 0) return Files.builder(getCurrentWorkingDirectory()).build()
+
+      // Await for all pipes / files / files promises
+      const results = await assertPromises<Files>(pipes, 'Error in pipe while merging')
 
-  abstract run(): Promise<Files>
+      // Find the common directory between all the Files instances
+      const [ firstDir, ...otherDirs ] = results.map((f) => f.directory)
+      const directory = commonPath(firstDir, ...otherDirs)
+
+      // Build our new files instance merging all the results
+      return Files.builder(directory).merge(...results).build()
+    }))
+  }
 }
 
 /* ========================================================================== *
@@ -96,7 +231,7 @@ export abstract class Pipe extends PipeProto {
  * ========================================================================== */
 
 /** The names which can be installed as direct plugs. */
-export type PlugName = string & Exclude<keyof Pipe, 'plug' | 'run'>
+export type PlugName = string & Exclude<keyof Pipe, 'plug' | keyof Promise<any>>
 
 /** The parameters of the plug extension with the given name */
 export type PipeParameters<Name extends PlugName> = PipeOverloads<Name>['args']
@@ -210,35 +345,3 @@ export function install<
   /* Inject the create function in the Pipe's prototype */
   Object.defineProperty(PipeProto.prototype, name, { value: plug })
 }
-
-/**
- * Install a _forking_ {@link Plug} in the {@link Pipe}, in other words
- * execute the plug in a separate process.
- *
- * As a contract, if the _last non-null_ parameter of the constructor is an
- * object and contains the key `coverageDir`, the process will be forked with
- * the approptiately resolved `NODE_V8_COVERAGE` environment variable.
- *
- * Also, forking plugs require some special attention:
- *
- * * plug functions are not supported, only classes implementing the
- *   {@link Plug} interface can be used with this.
- *
- * * the class itself _MUST_ be exported as the _default_ export for the
- *   `scriptFile` specified below. This is to simplify interoperability between
- *   CommonJS and ESM modules as we use dynamic `import(...)` statements.
- */
-export function installForking<Name extends PlugName>(
-    plugName: Name,
-    scriptFile: AbsolutePath,
-): void {
-  /** Extend out our ForkingPlug below */
-  const ctor = class extends ForkingPlug {
-    constructor(...args: any[]) {
-      super(scriptFile, args)
-    }
-  } as unknown as PlugConstructor<Name>
-
-  /** Install the plug in  */
-  install(plugName, ctor)
-}

package/src/plugs/copy.ts

@@ -2,7 +2,7 @@ import { assert } from '../assert'
 import { Files } from '../files'
 import { $p } from '../log'
 import { assertAbsolutePath, getAbsoluteParent, resolveAbsolutePath } from '../paths'
-import { install, PipeParameters, Plug, Context } from '../pipe'
+import { Context, install, PipeParameters, Plug } from '../pipe'
 import { chmod, copyFile, fsConstants, mkdir } from '../utils/asyncfs'
 
 /** Options for copying files */
@@ -95,7 +95,7 @@ install('copy', class Copy implements Plug<Files> {
       }
 
       /* Record this file */
-      builder.add(relative)
+      builder.add(target)
     }
 
     const result = builder.build()

package/src/plugs/coverage/report.ts

@@ -10,7 +10,7 @@ import {
   isTSTypeReference,
   isTypeScript,
   Node,
-  VISITOR_KEYS
+  VISITOR_KEYS,
 } from '@babel/types'
 
 import { parse } from '@babel/parser'

package/src/plugs/coverage.ts

@@ -1,10 +1,9 @@
 import { html, initFunction } from '@plugjs/cov8-html'
 import { sep } from 'node:path'
-import { fail } from '../assert'
 import { Files } from '../files'
 import { $gry, $ms, $p, $red, $ylw, ERROR, NOTICE, WARN } from '../log'
 import { AbsolutePath, resolveAbsolutePath } from '../paths'
-import { install, PipeParameters, Plug, Context } from '../pipe'
+import { Context, install, PipeParameters, Plug } from '../pipe'
 import { walk } from '../utils/walk'
 import { createAnalyser, SourceMapBias } from './coverage/analysis'
 import { coverageReport, CoverageResult } from './coverage/report'
@@ -79,7 +78,7 @@ install('coverage', class Coverage implements Plug<Files | undefined> {
     }
 
     if (coverageFiles.length === 0) {
-      fail(`No coverage files found in ${$p(coverageDir)}`)
+      throw context.log.fail(`No coverage files found in ${$p(coverageDir)}`)
     }
 
     const sourceFiles = [ ...files.absolutePaths() ]

package/src/plugs/debug.ts

@@ -1,11 +1,11 @@
 import { Files } from '../files'
-import { $gry, $p, $und } from '../log'
-import { install, Plug, Context } from '../pipe'
+import { $gry, $p, $und, $ylw } from '../log'
+import { Context, install, PipeParameters, Plug } from '../pipe'
 
 declare module '../pipe' {
   export interface Pipe {
     /** Log some info about the current {@link Files} being passed around. */
-    debug(): Pipe
+    debug(title?: string): Pipe
   }
 }
 
@@ -15,8 +15,15 @@ declare module '../pipe' {
 
 /** Writes some info about the current {@link Files} being passed around. */
 install('debug', class Debug implements Plug<Files> {
+  private readonly _title: string
+
+  constructor(...args: PipeParameters<'debug'>) {
+    const [ title = 'Debugging' ] = args
+    this._title = title
+  }
+
   async pipe(files: Files, context: Context): Promise<Files> {
-    context.log.notice('Debugging', files.length, 'files')
+    context.log.notice(this._title, `${$gry('(')}${$ylw(files.length)} ${$gry('files)')}`)
     context.log.notice('-        base dir:', $p(context.resolve('@')))
     context.log.notice('-  build file dir:', $p(context.resolve('.')))
     context.log.notice('-       files dir:', $p(files.directory))

package/src/plugs/esbuild.ts

@@ -4,7 +4,7 @@ import { assert } from '../assert'
 import { Files, FilesBuilder } from '../files'
 import { $p, ERROR, Logger, ReportLevel, ReportRecord, WARN } from '../log'
 import { AbsolutePath, getAbsoluteParent, resolveAbsolutePath } from '../paths'
-import { install, PipeParameters, Plug, Context } from '../pipe'
+import { Context, install, PipeParameters, Plug } from '../pipe'
 import { readFile } from '../utils/asyncfs'
 
 export type ESBuildOptions = Omit<BuildOptions, 'absWorkingDir' | 'entryPoints' | 'watch'>

package/src/plugs/eslint/runner.ts

@@ -1,9 +1,10 @@
 import { ESLint as RealESLint } from 'eslint'
-import { assert, failure } from '../../assert'
+import { assert } from '../../assert'
+import { BuildFailure } from '../../failure'
 import { Files } from '../../files'
 import { $p, ERROR, NOTICE, WARN } from '../../log'
 import { getCurrentWorkingDirectory, resolveAbsolutePath, resolveDirectory, resolveFile } from '../../paths'
-import { PipeParameters, Plug, Context } from '../../pipe'
+import { Context, PipeParameters, Plug } from '../../pipe'
 import { readFile } from '../../utils/asyncfs'
 import { ESLintOptions } from '../eslint'
 
@@ -59,7 +60,7 @@ export default class ESLint implements Plug<void> {
 
     /* In case of failures from promises, fail! */
     const { results, failures } = summary
-    if (failures) throw failure() // already logged above
+    if (failures) throw new BuildFailure({ logged: true })
 
     /* Create our report */
     const report = context.log.report('ESLint Report')

package/src/plugs/eslint.ts

@@ -1,5 +1,5 @@
+import { installForking } from '../fork'
 import { requireResolve } from '../paths'
-import { installForking } from '../pipe'
 
 export interface ESLintOptions {
   /** ESLint's own _current working directory_, where config files are. */

package/src/plugs/exec.ts

@@ -3,12 +3,12 @@ import reaadline from 'node:readline'
 
 import { spawn, SpawnOptions } from 'node:child_process'
 import { assert } from '../assert'
+import { requireContext } from '../async'
 import { Files } from '../files'
 import { $p, logOptions } from '../log'
 import { AbsolutePath, getCurrentWorkingDirectory, resolveDirectory } from '../paths'
 import { Context, install, PipeParameters, Plug } from '../pipe'
 import { parseOptions } from '../utils/options'
-import { requireContext } from '../async'
 
 /** Options for executing scripts */
 export interface ExecOptions {

package/src/plugs/mocha/runner.ts

@@ -1,9 +1,9 @@
 import RealMocha from 'mocha' // Mocha types pollute the global scope!
 
-import { failure } from '../../assert'
+import { BuildFailure } from '../../failure'
 import { Files } from '../../files'
 import { $wht, NOTICE } from '../../log'
-import { PipeParameters, Plug, Context } from '../../pipe'
+import { Context, PipeParameters, Plug } from '../../pipe'
 import { MochaOptions } from '../mocha'
 import { logSymbol, PlugReporter } from './reporter'
 
@@ -40,7 +40,7 @@ export default class Mocha implements Plug<void> {
     return new Promise((resolve, reject) => {
       try {
         mocha.run((failures) => {
-          if (failures) reject(failure())
+          if (failures) reject(new BuildFailure({ logged: true }))
           resolve(undefined)
         })
       } catch (error) {

package/src/plugs/mocha.ts

@@ -1,5 +1,5 @@
+import { installForking } from '../fork'
 import { requireResolve } from '../paths'
-import { installForking } from '../pipe'
 
 /** Options to construct our {@link Mocha} plug. */
 export interface MochaOptions {

package/src/plugs/rmf.ts

@@ -1,6 +1,6 @@
 import { Files } from '../files'
 import { $gry, $p } from '../log'
-import { install, PipeParameters, Plug, Context } from '../pipe'
+import { Context, install, PipeParameters, Plug } from '../pipe'
 import { rm } from '../utils/asyncfs'
 
 declare module '../pipe' {