@plugjs/plug 0.3.4 → 0.4.0

package/{extra/plug.mts → src/cli.mts}

@@ -2,52 +2,81 @@
 /* eslint-disable no-console */
 
 import _fs from 'node:fs'
-import _path from 'node:path'
 
-import _yargs from 'yargs-parser'
+import { main, yargsParser } from '@plugjs/tsrun'
 
-import { $blu, $gry, $rst, $tsk, $und, $wht, isDirectory, isFile, main } from './utils.js'
+import { BuildFailure } from './asserts'
+import { invokeTasks, isBuild } from './build'
+import { $blu, $gry, $p, $red, $t, $und, $wht } from './logging/colors'
+import { getCurrentWorkingDirectory, resolveDirectory, resolveFile, resolveAbsolutePath } from './paths'
 
-import type { BuildFailure } from '../src/asserts.js'
-import type { Build } from '../src/index.js'
+import type { AbsolutePath } from './paths'
 
-/** Version injected by esbuild */
-declare const __version: string
+/* Extra colors */
+const $bnd = (s: string): string => $blu($und(s))
+const $gnd = (s: string): string => $gry($und(s))
+const $wnd = (s: string): string => $wht($und(s))
+
+/** Version injected by esbuild, defaulted in case of dynamic transpilation */
+const version = typeof __version === 'string' ? __version : '0.0.0-dev'
+declare const __version: string | undefined
 
 /* ========================================================================== *
- * ========================================================================== *
- * BUILD INSPECTION                                                           *
- * ========================================================================== *
+ * HELP SCREEN                                                                *
  * ========================================================================== */
 
-/** Symbol indicating that an object is a Build */
-const buildMarker = Symbol.for('plugjs:isBuild')
+/** Show help screen */
+function help(): void {
+  console.log(`${$bnd('Usage:')}
 
-/** Symbol indicating that an object is a Build Failure */
-const buildFailure = Symbol.for('plugjs:buildFailure')
+  ${$wht('plugjs')} ${$gry('[')}--options${$gry('] [... ')}prop=val${$gry(' ...] [... ')}task${$gry(' ...]')}
 
-/** Check if the specified build is actually a {@link Build} */
-function isBuild(build: any): build is Build<Record<string, any>> & {
-  [buildMarker]: (tasks: string[], props?: Record<string, string | undefined>) => Promise<void>
-} {
-  return build && typeof build[buildMarker] === 'function'
-}
+  ${$bnd('Options:')}
 
-/** Check if the specified argument is a {@link BuildFailure} */
-function isBuildFailure(arg: any): arg is BuildFailure {
-  return arg && arg[buildFailure] === buildFailure
-}
+      ${$wht(`-f --file ${$gnd('file')}`)}  Specify the build file to use (default ${$wnd('./build.ts')})
+      ${$wht(`-w --watch ${$gnd('dir')}`)}  Watch for changes on the specified directory and run
+      ${$wht('-v --verbose')}    Increase logging verbosity
+      ${$wht('-q --quiet')}      Decrease logging verbosity
+      ${$wht('-c --colors')}     Force colorful output (use ${$wnd('--no-colors')} to force plain text)
+      ${$wht('-l --list')}       Only list the tasks defined by the build, nothing more!
+      ${$wht('-h --help')}       Help! You're reading it now!
+      ${$wht('   --version')}    Version! This one: ${version}!
+
+  ${$bnd('Properties:')}
+
+      Any argument in the format ${$wnd('key=value')} will be interpeted as a property to
+      be injected in the build process (e.g. ${$wnd('mode=production')}).
+
+  ${$bnd('Tasks:')}
 
+      Any other argument will be treated as a task name. If no task names are
+      specified, the ${$t('default')} task will be executed.
 
+  ${$bnd('Watch Mode:')}
+
+      The ${$wnd('--watch')} option can be specified multiple times, and each single
+      directory specified will be watched for changes. Note that Plug's own
+      watch mode is incredibly basic, for more complex scenarios use something
+      more advanced like nodemon ${$gry('(')}${$gnd('https://www.npmjs.com/package/nodemon')}${$gry(')')}.
+
+  ${$bnd('TypeScript module format:')}
+
+      Normally our TypeScript loader will transpile ${$wnd('.ts')} files to the type
+      specified in ${$wnd('package.json')}, either ${$wnd('commonjs')} (the default) or ${$wnd('module')}.
+
+      To force a specific module format use one of the following flags:
+
+      ${$wht('--force-esm')}    Force transpilation of ${$wnd('.ts')} files to EcmaScript modules
+      ${$wht('--force-cjs')}    Force transpilation of ${$wnd('.ts')} files to CommonJS modules
+    `)
+}
 /* ========================================================================== *
- * ========================================================================== *
  * PARSE COMMAND LINE ARGUMENTS                                               *
- * ========================================================================== *
  * ========================================================================== */
 
 /* Parsed and normalised command line options */
 interface CommandLineOptions {
-  buildFile: string,
+  buildFile: AbsolutePath,
   watchDirs: string[],
   tasks: string[],
   props: Record<string, string>
@@ -57,7 +86,7 @@ interface CommandLineOptions {
 /** Parse `perocess.argv` and return our normalised command line options */
 export function parseCommandLine(args: string[]): CommandLineOptions {
   /* Yargs-parse our arguments */
-  const parsed = _yargs(args, {
+  const parsed = yargsParser(args, {
     configuration: {
       'camel-case-expansion': false,
       'strip-aliased': true,
@@ -91,7 +120,6 @@ export function parseCommandLine(args: string[]): CommandLineOptions {
   let colors: boolean | undefined = undefined
   let file: string | undefined = undefined
   let listOnly = false
-  let help = false
 
   /* Switcharoo on arguments */
   for (const [ key, value ] of Object.entries(parsed)) {
@@ -123,69 +151,19 @@ export function parseCommandLine(args: string[]): CommandLineOptions {
         listOnly = !! value
         break
       case 'help':
-        help = !! value
+        help()
+        process.exit(0)
         break
       case 'version':
-        console.log(`v${__version}`)
+        console.log(`PlugJS ${$gry('ver.')} ${$wnd(version)}`)
         process.exit(0)
         break
       default:
-        console.log(`Unsupported option "${key}" (try "--help")`)
+        console.log(`Unsupported option ${$wnd(key)} (try ${$wnd('--help')})`)
         process.exit(1)
     }
   }
 
-  /* ======================================================================== *
-   * HELP OR NOT                                                              *
-   * ======================================================================== */
-
-  /* If help, end here! */
-  if (help) {
-    console.log(`${$blu}${$und}Usage:${$rst}
-
-    ${$wht}plugjs${$rst} ${$gry}[${$rst}--options${$gry}] [...${$rst}prop=val${$gry}] [...${$rst}tasks${$gry}]${$rst}
-
-    ${$blu}${$und}Options:${$rst}
-
-        ${$wht}-f --file ${$gry}${$und}file${$rst}  Specify the build file to use (default "./build.[ts/js/...]")
-        ${$wht}-w --watch ${$gry}${$und}dir${$rst}  Watch for changes on the specified directory and run build
-        ${$wht}-v --verbose${$rst}    Increase logging verbosity
-        ${$wht}-q --quiet${$rst}      Decrease logging verbosity
-        ${$wht}-c --colors${$rst}     Force colorful output (use "--no-colors" to force plain text)
-        ${$wht}-l --list${$rst}       Only list the tasks defined by the build, nothing more!
-        ${$wht}-h --help${$rst}       Help! You're reading it now!
-        ${$wht}   --version${$rst}    Version! This one: ${__version}!
-
-    ${$blu}${$und}Properties:${$rst}
-
-        Any argument in the format "key=value" will be interpeted as a property to
-        be injected in the build process (e.g. "mode=production").
-
-    ${$blu}${$und}Tasks:${$rst}
-
-        Any other argument will be treated as a task name. If no task names are
-        specified, the "default" task will be executed.
-
-    ${$blu}${$und}Watch Mode:${$rst}
-
-        The "-w" option can be specified multiple times, and each single directory
-        specified will be watched for changes. Please note that Plug's own watch
-        mode is incredibly basic, for more complex scenarios use something more
-        advanced like nodemon (https://www.npmjs.com/package/nodemon).
-
-    ${$blu}${$und}TypeScript module format:${$rst}
-
-        Normally our TypeScript loader will transpile ".ts" files to the "type"
-        specified in "package.json", either "commonjs" (the default) or "module".
-
-        To force a specific module format we can use one of the following flags:
-
-        ${$wht}--force-esm  ${$rst}   Force transpilation of ".ts" files to EcmaScript modules
-        ${$wht}--force-cjs  ${$rst}   Force transpilation of ".ts" files to CommonJS modules
-    `)
-    process.exit(0)
-  }
-
   /* ======================================================================== *
    * LOG OPTIONS AS ENVIRONMENT VARIABLES                                     *
    * ======================================================================== */
@@ -208,13 +186,14 @@ export function parseCommandLine(args: string[]): CommandLineOptions {
    * ======================================================================== */
 
   /* Find our build file */
+  const cwd = getCurrentWorkingDirectory()
   const exts = [ 'ts', 'mts', 'mjs', 'js', 'mjs', 'cjs' ]
 
-  let buildFile: string | undefined = undefined
+  let buildFile: AbsolutePath | undefined = undefined
 
   if (file) {
-    const absolute = _path.resolve(file)
-    if (! isFile(absolute)) {
+    const absolute = resolveFile(cwd, file)
+    if (! absolute) {
       console.log(`Specified build file "${file}" was not found`)
       process.exit(1)
     } else {
@@ -222,8 +201,8 @@ export function parseCommandLine(args: string[]): CommandLineOptions {
     }
   } else {
     for (const ext of exts) {
-      const absolute = _path.resolve(`build.${ext}`)
-      if (! isFile(absolute)) continue
+      const absolute = resolveFile(cwd, `build.${ext}`)
+      if (! absolute) continue
       buildFile = absolute
       break
     }
@@ -231,7 +210,7 @@ export function parseCommandLine(args: string[]): CommandLineOptions {
 
   /* Final check */
   if (! buildFile) {
-    console.log(`Unable to find build file "./build.[${exts.join('|')}]`)
+    console.log(`${$red('Unable to find build file')} ${$wht(`./build.[${exts.join('|')}]`)}`)
     process.exit(1)
   }
 
@@ -240,9 +219,10 @@ export function parseCommandLine(args: string[]): CommandLineOptions {
    * ======================================================================== */
 
   watchDirs.forEach((watchDir) => {
-    const absolute = _path.resolve(watchDir)
-    if (! isDirectory(absolute)) {
-      console.log(`Specified watch directory "${watchDir}" was not found`)
+    const absolute = resolveDirectory(cwd, watchDir)
+    if (! absolute) {
+      const path = resolveAbsolutePath(cwd, watchDir)
+      console.log(`Specified watch directory "${$p(path)}" was not found`)
       process.exit(1)
     } else {
       watchDir = absolute
@@ -257,21 +237,10 @@ export function parseCommandLine(args: string[]): CommandLineOptions {
 }
 
 /* ========================================================================== *
- * ========================================================================== *
  * MAIN ENTRY POINT                                                           *
- * ========================================================================== *
  * ========================================================================== */
 
-/* ========================================================================== *
- * ========================================================================== *
- * PROCESS SETUP                                                              *
- * ========================================================================== *
- * ========================================================================== */
-
-/* eslint-disable no-console */
-
-/* We have everyhing we need to start our asynchronous main! */
-main(async (args: string[]): Promise<void> => {
+main(import.meta.url, async (args: string[]): Promise<void> => {
   // Parse and destructure command line
   const {
     buildFile,
@@ -293,13 +262,13 @@ main(async (args: string[]): Promise<void> => {
 
   // We _need_ a build
   if (! isBuild(maybeBuild)) {
-    console.log('Build file did not export a proper build')
+    console.log($red('Build file did not export a proper build'))
     console.log()
     console.log('- If using CommonJS export your build as "module.exports"')
-    console.log('  e.g.: module.exports = build({ ... })')
+    console.log(`  e.g.: ${$wht('module.exports = build({ ... })')}`)
     console.log()
     console.log('- If using ESM modules export your build as "default"')
-    console.log('  e.g.: export default build({ ... })')
+    console.log(`  e.g.: ${$wht('export default build({ ... })')}`)
     console.log()
     process.exit(1)
   }
@@ -315,20 +284,18 @@ main(async (args: string[]): Promise<void> => {
       (typeof value === 'string' ? propNames : taskNames).push(key)
     }
 
-    const buildFileName = _path.relative(process.cwd(), buildFile)
-
-    console.log(`\n${$gry}Outline of ${$wht}${buildFileName}${$rst}`)
+    console.log(`\n${$gry('Outline of')} ${$p(buildFile)}`)
 
     console.log('\nKnown tasks:\n')
     for (const taskName of taskNames.sort()) {
-      console.log(` ${$gry}\u25a0${$tsk} ${taskName}${$rst}`)
+      console.log(` ${$gry('\u25a0')} ${$t(taskName)}`)
     }
 
     console.log('\nKnown properties:\n')
     for (const propName of propNames.sort()) {
       const value = build[propName] ?
-        ` ${$gry}(default "${$rst}${$und}${build[propName]}${$gry})` : ''
-      console.log(` ${$gry}\u25a1${$blu} ${propName}${value}${$rst}`)
+        ` ${$gry('(default')} ${$und(build[propName])}${$gry(')')}` : ''
+      console.log(` ${$gry('\u25a1')} ${$blu(propName)}${value}`)
     }
 
     console.log()
@@ -337,40 +304,47 @@ main(async (args: string[]): Promise<void> => {
 
   // Watch directories
   if (watchDirs.length) {
-    let timeout: NodeJS.Timeout | undefined = undefined
-
-    const runme = (): void => {
-      build[buildMarker](tasks, props)
-          .then(() => {
-            console.log(`\n${$gry}Watching for files change...${$rst}\n`)
-          }, (error) => {
-            if (isBuildFailure(error)) {
-              console.log(`\n${$gry}Watching for files change...${$rst}\n`)
-            } else {
-              console.log(error)
-              watchers.forEach((watcher) => watcher.close())
-            }
-          })
-          .finally(() => {
-            timeout = undefined
-          })
-    }
-
-    const watchers = watchDirs.map((watchDir) => {
-      return _fs.watch(watchDir, { recursive: true }, () => {
-        if (! timeout) timeout = setTimeout(runme, 250)
+    return new Promise((_, reject) => {
+      // filesystems change trigger a new run after 250 ms a change is detected,
+      // in order to give time to editors to save a bunch of files open and
+      // modified at the same time...
+      let timeout: NodeJS.Timeout | undefined = undefined
+
+      // our runner executed by the timeout
+      const runme = (): void => {
+        invokeTasks(build, tasks, props)
+            .then(() => {
+              console.log(`\n${$gry('Watching for files change...')}\n`)
+            }, (error) => {
+              if (error instanceof BuildFailure) {
+                console.log(`\n${$gry('Watching for files change...')}\n`)
+              } else {
+                watchers.forEach((watcher) => watcher.close())
+                reject(error)
+              }
+            })
+            .finally(() => {
+              timeout = undefined
+            })
+      }
+
+      // watch all directories and trigger a run after 250 milliseconds
+      const watchers = watchDirs.map((watchDir) => {
+        return _fs.watch(watchDir, { recursive: true }, () => {
+          if (! timeout) timeout = setTimeout(runme, 250)
+        })
       })
-    })
 
-    runme()
-    return
+      // start a build immediately on first run
+      runme()
+    })
   }
 
   // Normal build (no list, no watchers)
   try {
-    await build[buildMarker](tasks, props)
+    await invokeTasks(build, tasks, props)
   } catch (error) {
-    if (! isBuildFailure(error)) console.log(error)
-    process.exit(1)
+    if (!(error instanceof BuildFailure)) console.log(error)
+    process.exitCode = 1
   }
 })

package/src/fork.ts

@@ -3,13 +3,24 @@ import { fork } from 'node:child_process'
 import { assert, BuildFailure } from './asserts'
 import { runAsync } from './async'
 import { Files } from './files'
-import { $gry, $p, logOptions } from './logging'
+import { $gry, $p, $red, logOptions } from './logging'
 import { requireFilename, resolveFile } from './paths'
 import { Context, install } from './pipe'
 
 import type { AbsolutePath } from './paths'
 import type { Plug, PlugName, PlugResult } from './pipe'
 
+/**
+ * Options accepted by {@link ForkingPlug}'s instrumenting how the process
+ * will be spawned (environment variables to be passed to the child process).
+ */
+export interface ForkOptions {
+  /** The directory where coverage data will be saved */
+  coverageDir?: string,
+  /** Force the specified module type when dynamically transpiling TypeScript */
+  forceModule?: 'commonjs' | 'module'
+}
+
 /** Fork data, from parent to child process */
 export interface ForkData {
   /** Script name for the Plug to execute */
@@ -75,6 +86,10 @@ export abstract class ForkingPlug implements Plug<PlugResult> {
           const dir = env.NODE_V8_COVERAGE = context.resolve(this._arguments[i].coverageDir)
           context.log.debug('Forked process will produce coverage in', $p(dir))
         }
+        if (typeof this._arguments[i].forceModule === 'string') {
+          const force = env.__TS_LOADER_FORCE_TYPE = this._arguments[i].forceModule
+          context.log.debug('Forked process will force module type as', $p(force))
+        }
       }
     }
 
@@ -97,24 +112,24 @@ export abstract class ForkingPlug implements Plug<PlugResult> {
       let response: ForkResult | undefined = undefined
 
       child.on('error', (error) => {
-        context.log.error('Child process error', error)
+        context.log.error('Forked plug process error', error)
         return done || reject(BuildFailure.fail())
       })
 
       child.on('message', (message: ForkResult) => {
-        context.log.debug('Message from child process with PID', child.pid, message)
+        context.log.debug('Message from forked plug process with PID', child.pid, message)
         response = message
       })
 
       child.on('exit', (code, signal) => {
         if (signal) {
-          context.log.error(`Child process exited with signal ${signal}`, $gry(`(pid=${child.pid})`))
+          context.log.error(`Forked plug process exited with signal ${signal}`, $gry(`(pid=${child.pid})`))
           return done || reject(BuildFailure.fail())
         } else if (code !== 0) {
-          context.log.error(`Child process exited with code ${code}`, $gry(`(pid=${child.pid})`))
+          context.log.error(`Forked plug process exited with code ${code}`, $gry(`(pid=${child.pid})`))
           return done || reject(BuildFailure.fail())
         } else if (! response) {
-          context.log.error('Child process exited with no result', $gry(`(pid=${child.pid})`))
+          context.log.error('Forked plug process exited with no result', $gry(`(pid=${child.pid})`))
           return done || reject(BuildFailure.fail())
         } else if (response.failed) {
           // definitely logged on the child side
@@ -131,16 +146,16 @@ export abstract class ForkingPlug implements Plug<PlugResult> {
       try {
         const result = child.send(request, (error) => {
           if (error) {
-            context.log.error('Error sending message to child process (callback failure)', error)
+            context.log.error('Error sending message to forked plug process (callback failure)', error)
             reject(BuildFailure.fail())
           }
         })
         if (! result) {
-          context.log.error('Error sending message to child process (send returned false)')
+          context.log.error('Error sending message to forked plug process (send returned false)')
           reject(BuildFailure.fail())
         }
       } catch (error) {
-        context.log.error('Error sending message to child process (exception caught)', error)
+        context.log.error('Error sending message to forked plug process (exception caught)', error)
         reject(BuildFailure.fail())
       }
     }).finally(() => done = true)
@@ -158,12 +173,22 @@ export abstract class ForkingPlug implements Plug<PlugResult> {
  * for the message and respond once the plug returns _something_!
  */
 if ((process.argv[1] === requireFilename(__fileurl)) && (process.send)) {
+  /* Unhandled exceptions and graceful termination */
+  process.on('uncaughtException', (error, origin) => {
+    // eslint-disable-next-line no-console
+    console.error(
+        $red('\n= UNCAUGHT EXCEPTION ========================================='),
+        `\nError (${origin}):`, error,
+        `\nNode.js ${process.version} (pid=${process.pid})\n`)
+    process.nextTick(() => process.exit(3))
+  })
+
   /* If we haven't processed our message in 5 seconds, fail _badly_ */
   const timeout = setTimeout(() => {
     // eslint-disable-next-line no-console
     console.error('Fork not initialized in 5 seconds')
     process.exit(2)
-  }, 5000)
+  }, 5000).unref()
 
   /* Await our message to initialize and run the plug */
   process.on('message', (message: ForkData) => {
@@ -227,10 +252,22 @@ if ((process.argv[1] === requireFilename(__fileurl)) && (process.send)) {
     /* The promise generated by `process.send()` simply triggers process exit */
     promise.then(() => {
       context.log.debug('Forked plug exiting')
-      process.exit(0)
+      process.disconnect()
+      process.exitCode = 0
     }, (error) => {
-      context.log.error('Error sending message back to parent process', error)
-      process.exit(1)
+      // eslint-disable-next-line no-console
+      console.log('\n\nError sending message back to parent process', error)
+      process.exitCode = 1
+    }).finally(() => {
+      /* Flush and end our log output */
+      logOptions.output.end()
+
+      /* Set a timeout _forcefully_ killing the process in 5 seconds */
+      setTimeout(() => {
+        // eslint-disable-next-line no-console
+        console.log('\n\nProcess %d for %s did not exit in 5 seconds', process.pid, exportName)
+        process.exit(2)
+      }, 5000).unref()
     })
   })
 }

package/src/helpers.ts

@@ -7,14 +7,23 @@ import { requireContext } from './async'
 import { Files } from './files'
 import { rm } from './fs'
 import { $p, log } from './logging'
-import { commonPath, getCurrentWorkingDirectory, resolveDirectory, resolveFile } from './paths'
+import {
+  commonPath,
+  getAbsoluteParent,
+  getCurrentWorkingDirectory,
+  resolveDirectory,
+  resolveFile,
+} from './paths'
 import { PipeImpl } from './pipe'
+import { RunBuild } from './plugs/build'
 import { execChild } from './utils/exec'
 import { parseOptions } from './utils/options'
 import { walk } from './utils/walk'
 
+import type { ForkOptions } from './fork'
 import type { Pipe } from './index'
 import type { AbsolutePath } from './paths'
+import type { Context } from './pipe'
 import type { ExecChildOptions } from './utils/exec'
 import type { ParseOptions } from './utils/options'
 import type { WalkOptions } from './utils/walk'
@@ -29,6 +38,11 @@ export interface FindOptions extends WalkOptions {
   directory?: string
 }
 
+/** Return the current execution {@link Context} */
+export function context(): Context {
+  return requireContext()
+}
+
 /** 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_. */
@@ -56,6 +70,44 @@ export function find(...args: ParseOptions<FindOptions>): Pipe {
   }))
 }
 
+export type InvokeBuildOptions = ForkOptions & Record<string, string>
+export type InvokeBuildTasks = string | [ string, ...string[] ]
+
+export function invokeBuild(buildFile: string): Promise<void>
+export function invokeBuild(buildFile: string, task: string): Promise<void>
+export function invokeBuild(buildFile: string, task: string, options: InvokeBuildOptions): Promise<void>
+export function invokeBuild(buildFile: string, tasks: [ string, ...string[] ]): Promise<void>
+export function invokeBuild(buildFile: string, tasks: [ string, ...string[] ], options: InvokeBuildOptions): Promise<void>
+export function invokeBuild(buildFile: string, options: InvokeBuildOptions): Promise<void>
+export async function invokeBuild(
+    buildFile: string,
+    tasksOrOptions?: string | [ string, ...string[] ] | InvokeBuildOptions,
+    maybeOptions?: InvokeBuildOptions,
+): Promise<void> {
+  const [ tasks, options = {} ] =
+      typeof tasksOrOptions === 'string' ?
+          [ [ tasksOrOptions ], maybeOptions ] :
+      Array.isArray(tasksOrOptions) ?
+          [ tasksOrOptions, maybeOptions ] :
+      typeof tasksOrOptions === 'object' ?
+          [ [ 'default' ], tasksOrOptions ] :
+      [ [ 'default' ], {} ]
+
+  if (tasks.length === 0) tasks.push('default')
+
+  const { coverageDir, forceModule, ...props } = options
+  const forkOptions = { coverageDir, forceModule }
+
+  const context = requireContext()
+  const file = context.resolve(buildFile)
+  const dir = getAbsoluteParent(file)
+  const files = Files.builder(dir).add(file).build()
+
+  return new RunBuild(tasks, props, forkOptions)
+      .pipe(files, context)
+      .then(() => void 0)
+}
+
 /**
  * Recursively remove the specified directory _**(use with care)**_.
  */

package/src/index.ts

@@ -28,6 +28,7 @@ export interface Pipe extends Promise<Files> {
 
 // Submodule exports (our package.json exports)
 export * as asserts from './asserts'
+export * as async from './async'
 export * as files from './files'
 export * as fork from './fork'
 export * as fs from './fs'
@@ -37,7 +38,7 @@ export * as pipe from './pipe'
 export * as utils from './utils'
 
 // Individual utilities
-export { log, $ms, $p, $t, $blu, $cyn, $grn, $gry, $mgt, $red, $und, $wht, $ylw } from './logging'
+export { banner, log, $ms, $p, $t, $blu, $cyn, $grn, $gry, $mgt, $red, $und, $wht, $ylw } from './logging'
 export { assert, fail, BuildFailure } from './asserts'
 
 // Our minimal exports

package/src/logging/emit.ts

@@ -42,8 +42,8 @@ export type LogEmitter = (options: LogEmitterOptions, args: any[]) => void
 
 /** Emit in full colors! */
 export const emitColor: LogEmitter = (options: LogEmitterOptions, args: any[]): void => {
-  const { taskName, level, prefix, indent } = options
-  const logPrefix = prefix ? prefix : indent ? ''.padStart(indent * _indentSize) : ''
+  const { taskName, level, prefix = '', indent = 0 } = options
+  const logPrefix = ''.padStart(indent * _indentSize) + prefix
 
   /* Prefixes, to prepend at the beginning of each line */
   const prefixes: string[] = []
@@ -85,8 +85,8 @@ export const emitColor: LogEmitter = (options: LogEmitterOptions, args: any[]):
 
 /** Emit in plain text! (no colors) */
 export const emitPlain: LogEmitter = (options: LogEmitterOptions, args: any[]): void => {
-  const { taskName, level, prefix, indent } = options
-  const logPrefix = prefix ? prefix : indent ? ''.padStart(indent * _indentSize) : ''
+  const { taskName, level, prefix = '', indent = 0 } = options
+  const logPrefix = ''.padStart(indent * _indentSize) + prefix
 
   const prefixes: string[] = []