@plugjs/plug 0.0.14 → 0.0.16

package/src/pipe.ts

@@ -1,195 +1,244 @@
-import { assert } from './assert.js'
-import { Files } from './files.js'
-import { Run } from './run.js'
+import {
+  AbsolutePath,
+  commonPath,
+  getAbsoluteParent,
+  getCurrentWorkingDirectory,
+  resolveAbsolutePath,
+} from './paths'
+
+import { sep } from 'path'
+import { assert } from './assert'
+import { requireContext } from './async'
+import { Files } from './files'
+import { ForkingPlug } from './fork'
+import { getLogger, Logger } from './log'
+
+/* ========================================================================== *
+ * PLUGS                                                                      *
+ * ========================================================================== */
+
+/** A convenience type indicating what can be returned by a {@link Plug}. */
+export type PlugResult = Files | undefined | void
 
 /**
- * The {@link Plug} interface describes an extension mechanism for our build.
+ * The {@link Plug} interface describes _build plugin_.
+ *
+ * A {@link Plug} receives a {@link Files} instance in its input (for example
+ * a list of _source `.ts` files_) and optionally produces a possibly different
+ * list (for example the _compiled `.js` files_).
  */
-export interface Plug<T extends Files | undefined> {
-  pipe(files: Files, run: Run): T | Promise<T>
+export interface Plug<T extends PlugResult> {
+  pipe(files: Files, context: Context): T | Promise<T>
 }
 
-/**
- * A type identifying a {@link Plug} as a `function`
- */
-export type PlugFunction<T extends Files | undefined> = Plug<T>['pipe']
+/** A type identifying a {@link Plug} as a `function` */
+export type PlugFunction<T extends PlugResult> = Plug<T>['pipe']
+
+/* ========================================================================== *
+ * PLUG CONTEXT                                                               *
+ * ========================================================================== */
 
 /**
- * A {@link Pipe} represents a sequence of operations performed by
- * a series of {@link Plug | Plugs}.
+ * The {@link Context} class defines the context in which a {@link Plug}
+ * is invoked.
  */
-export interface Pipe {
-  /* Left empty, for definitions of installed plugs as extensions */
+export class Context {
+  /** The directory of the file where the task was defined (convenience). */
+  public readonly buildDir: AbsolutePath
+  /** The {@link Logger} associated with this instance. */
+  public readonly log: Logger
+
+  constructor(
+      /** The absolute file name where the task was defined. */
+      public readonly buildFile: AbsolutePath,
+      /** The _name_ of the task associated with this {@link Context}. */
+      public readonly taskName: string,
+  ) {
+    this.buildDir = getAbsoluteParent(buildFile)
+    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('@')) {
+      // We can have paths like "@/../foo/bar" or "@../foo/bar"... both are ok
+      const components = path.substring(1).split(sep).filter((s) => !!s)
+      return resolveAbsolutePath(this.buildDir, ...components, ...paths)
+    }
+
+    // No path? Resolve to the CWD!
+    if (! path) return getCurrentWorkingDirectory()
+
+    // For all the rest, normal resolution!
+    return resolveAbsolutePath(getCurrentWorkingDirectory(), path, ...paths)
+  }
 }
 
+/* ========================================================================== *
+ * PIPES                                                                      *
+ * ========================================================================== */
+
 /**
- * The {@link Pipe} abstract class exposes the prototype upon which all
- * extension plugs will be installed on.
+ * A class that will be extended by {@link Pipe} where {@link install} will
+ * add prototype properties from installed {@link Plug}s
  */
-export abstract class Pipe implements Pipe {
-  abstract plug(plug: Plug<Files> | PlugFunction<Files>): Pipe & Promise<Files>
-  abstract plug(plug: Plug<undefined> | PlugFunction<undefined>): Promise<undefined>
+abstract class PipeProto {
+  abstract plug(plug: Plug<PlugResult>): Pipe | Promise<undefined>
 }
 
-
-/** Implementation of our {@link Pipe}. */
-export class PipeImpl<T extends Files | undefined> extends Pipe implements Promise<T> {
-  readonly #promise: Promise<T>
-  readonly #run: Run
-
-  constructor(start: T | Promise<T>, run: Run) {
+/**
+ * The {@link Pipe} class defines processing pipeline where multiple
+ * {@link Plug}s can transform lists of {@link Files}.
+ */
+export class Pipe extends PipeProto {
+  constructor(
+      private readonly _context: Context,
+      private readonly _run: () => Promise<Files>,
+  ) {
     super()
-    this.#promise = Promise.resolve(start)
-    this.#run = run
   }
 
-  plug<T extends Files | undefined>(arg: Plug<T> | PlugFunction<T>): Pipe & Promise<T> {
+  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 promise = this.#promise.then((files) => {
-      assert(files, 'Pipe can not be further extended')
-      return plug.pipe(files, this.#run)
+
+    const parent = this
+    const context = this._context
+    return new Pipe(context, async (): Promise<Files> => {
+      const previous = await parent.run()
+      const current = await plug.pipe(previous, context)
+      assert(current, 'Unable to extend pipe')
+      return current
     })
-    return new PipeImpl(promise, this.#run)
   }
 
-  then<T1 = T, T2 = never>(
-      onfulfilled?: ((value: T) => T1 | PromiseLike<T1>) | null | undefined,
-      onrejected?: ((reason: any) => T2 | PromiseLike<T2>) | null | undefined,
-  ): Promise<T1 | T2> {
-    return this.#promise.then(onfulfilled, onrejected)
+  run(): Promise<Files> {
+    return this._run()
   }
 
-  catch<T0 = never>(
-      onrejected?: ((reason: any) => T0 | PromiseLike<T0>) | null | undefined,
-  ): Promise<T0 | T> {
-    return this.#promise.catch(onrejected)
-  }
+  /**
+   * 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([
+   *   // other tasks return `Pipe & Promise<Files>` so we can
+   *   // direcrly await their result without invoking `run()`
+   *   await this.anotherTask1(),
+   *   await this.anotherTask2(),
+   * ])
+   * ```
+   */
+  static merge(pipes: (Pipe | Files | Promise<Files>)[]): Pipe {
+    const context = requireContext()
+    return new Pipe(context, async (): Promise<Files> => {
+      if (pipes.length === 0) return Files.builder(getCurrentWorkingDirectory()).build()
 
-  finally(
-      onfinally?: (() => void) | null | undefined,
-  ): Promise<T> {
-    return this.#promise.finally(onfinally)
-  }
+      const [ first, ...other ] = await Promise.all(pipes.map((pipe) => {
+        return 'run' in pipe ? pipe.run() : pipe
+      }))
 
-  [Symbol.toStringTag] = 'Pipe'
+      const firstDir = first.directory
+      const otherDirs = other.map((f) => f.directory)
+
+      const directory = commonPath(firstDir, ...otherDirs)
+
+      return Files.builder(directory).merge(first, ...other).build()
+    })
+  }
 }
 
 /* ========================================================================== *
- * PLUG INSTALLATION (INTERNAL)                                               *
+ * PLUG INSTALLATION (NEW)                                                    *
  * ========================================================================== */
 
 /** The names which can be installed as direct plugs. */
-export type PlugName = string & Exclude<keyof Pipe, 'plug' | keyof Promise<Files>>
-
-/** A convenience type identifying a {@link Plug} constructor. */
-export type PlugConstructor = new (...args: any) => Plug<Files | undefined>
-
-/** Convert the resulting type of a {@link Plug} for use in a {@link Pipe} */
-type PlugReturnForPipe<T> =
-  T extends Plug<infer R> ?
-    R extends Files ?
-      Promise<Files> & Pipe :
-    R extends undefined ?
-      Promise<undefined> :
-    never :
-  never
+export type PlugName = string & Exclude<keyof Pipe, 'plug' | 'run'>
 
-/**
- * Map constructors into an array of all known overloads.
- *
- * This is a _royal_ pain in the ass, as we need to distinguish between
- * all possible number of overloads of a constructor... Limit to 5 of them!
- *
- * Also, the empty constructor (when specified in the overloads) will simply
- * match the first case (most overloads) and generate functions somewhat like
- *
- * (...args: unknown[]) => never
- * (...args: unknown[]) => never
- * (...args: unknown[]) => never
- * () => PlugReturnForPipe<R3>
- * (arg: Options) => PlugReturnForPipe<R4>
- *
- * Somehow inferring the result to `Function` or the right type and ANDing all
- * those together here doesn't work, so we create this array and we'll AND
- * all its members in the PipeExtension<...> type.
- */
-type PlugConstructorOverloads<T extends PlugConstructor> =
-  T extends {
-    new (...args: infer A0): infer R0
-    new (...args: infer A1): infer R1
-    new (...args: infer A2): infer R2
-    new (...args: infer A3): infer R3
-    new (...args: infer A4): infer R4
-  } ? [
-    R0 extends Plug<Files | undefined> ? ((...args: A0) => PlugReturnForPipe<R0>) : Function,
-    R1 extends Plug<Files | undefined> ? ((...args: A1) => PlugReturnForPipe<R1>) : Function,
-    R2 extends Plug<Files | undefined> ? ((...args: A2) => PlugReturnForPipe<R2>) : Function,
-    R3 extends Plug<Files | undefined> ? ((...args: A3) => PlugReturnForPipe<R3>) : Function,
-    R4 extends Plug<Files | undefined> ? ((...args: A4) => PlugReturnForPipe<R4>) : Function,
-  ] :
-  T extends {
-    new (...args: infer A0): infer R0
-    new (...args: infer A1): infer R1
-    new (...args: infer A2): infer R2
-    new (...args: infer A3): infer R3
-  } ? [
-    R0 extends Plug<Files | undefined> ? (...args: A0) => PlugReturnForPipe<R0> : Function,
-    R1 extends Plug<Files | undefined> ? (...args: A1) => PlugReturnForPipe<R1> : Function,
-    R2 extends Plug<Files | undefined> ? (...args: A2) => PlugReturnForPipe<R2> : Function,
-    R3 extends Plug<Files | undefined> ? (...args: A3) => PlugReturnForPipe<R3> : Function,
-  ] :
-  T extends {
-    new (...args: infer A0): infer R0
-    new (...args: infer A1): infer R1
-    new (...args: infer A2): infer R2
-  } ? [
-    R0 extends Plug<Files | undefined> ? (...args: A0) => PlugReturnForPipe<R0> : Function,
-    R1 extends Plug<Files | undefined> ? (...args: A1) => PlugReturnForPipe<R1> : Function,
-    R2 extends Plug<Files | undefined> ? (...args: A2) => PlugReturnForPipe<R2> : Function,
-  ] :
-  T extends {
-    new (...args: infer A0): infer R0
-    new (...args: infer A1): infer R1
-  } ? [
-    R0 extends Plug<Files | undefined> ? (...args: A0) => PlugReturnForPipe<R0> : Function,
-    R1 extends Plug<Files | undefined> ? (...args: A1) => PlugReturnForPipe<R1> : Function,
-  ] :
-  T extends {
-    new (...args: infer A0): infer R0
-  } ? [
-    R0 extends Plug<Files | undefined> ? (...args: A0) => PlugReturnForPipe<R0> : Function,
-  ] :
-  never
+/** The parameters of the plug extension with the given name */
+export type PipeParameters<Name extends PlugName> = PipeOverloads<Name>['args']
+
+/** Extract arguments and return types from function overloads. */
+type PipeOverloads<Name extends PlugName> =
+  Pipe[Name] extends {
+    (...args: infer A0): infer R0
+    (...args: infer A1): infer R1
+    (...args: infer A2): infer R2
+    (...args: infer A3): infer R3
+    (...args: infer A4): infer R4
+  } ?
+    | (R0 extends (Pipe | Promise<undefined>) ? { args: A0, ret: R0 } : never)
+    | (R1 extends (Pipe | Promise<undefined>) ? { args: A1, ret: R1 } : never)
+    | (R2 extends (Pipe | Promise<undefined>) ? { args: A2, ret: R2 } : never)
+    | (R3 extends (Pipe | Promise<undefined>) ? { args: A3, ret: R3 } : never)
+    | (R4 extends (Pipe | Promise<undefined>) ? { args: A4, ret: R4 } : never)
+  :
+  Pipe[Name] extends {
+    (...args: infer A0): infer R0
+    (...args: infer A1): infer R1
+    (...args: infer A2): infer R2
+    (...args: infer A3): infer R3
+  } ?
+    | (R0 extends (Pipe | Promise<undefined>) ? { args: A0, ret: R0 } : never)
+    | (R1 extends (Pipe | Promise<undefined>) ? { args: A1, ret: R1 } : never)
+    | (R2 extends (Pipe | Promise<undefined>) ? { args: A2, ret: R2 } : never)
+    | (R3 extends (Pipe | Promise<undefined>) ? { args: A3, ret: R3 } : never)
+  :
+  Pipe[Name] extends {
+    (...args: infer A0): infer R0
+    (...args: infer A1): infer R1
+    (...args: infer A2): infer R2
+  } ?
+    | (R0 extends (Pipe | Promise<undefined>) ? { args: A0, ret: R0 } : never)
+    | (R1 extends (Pipe | Promise<undefined>) ? { args: A1, ret: R1 } : never)
+    | (R2 extends (Pipe | Promise<undefined>) ? { args: A2, ret: R2 } : never)
+  :
+  Pipe[Name] extends {
+    (...args: infer A0): infer R0
+    (...args: infer A1): infer R1
+  } ?
+    | (R0 extends (Pipe | Promise<undefined>) ? { args: A0, ret: R0 } : never)
+    | (R1 extends (Pipe | Promise<undefined>) ? { args: A1, ret: R1 } : never)
+  :
+  Pipe[Name] extends {
+    (...args: infer A0): infer R0
+  } ?
+    | (R0 extends (Pipe | Promise<undefined>) ? { args: A0, ret: R0 } : never)
+  : never
+
+/** The parameters of the plug extension with the given name */
+type PipeResult<Name extends PlugName> = PipeOverloads<Name>['ret']
 
 /**
- * A convenience type to easily annotate installed {@link Plug Plugs}.
- *
- * See also {@link install}.
- *
- * ```
- * export class Write implements Plug {
- *   // ... the plug implementation lives here
- * }
- *
- * install('write', Write)
- *
- * declare module '../pipe' {
- *   export interface Pipe {
- *     write: PipeExtension<typeof Write>
- *   }
- * }
- * ```
+ * A type defining the correct constructor for a {@link Plug}, inferring
+ * argument types and instance type from the definitions in {@link Pipe}.
  */
-export type PipeExtension<T extends PlugConstructor, A = PlugConstructorOverloads<T>> =
-  A extends readonly [ infer First, ...infer Rest ] ?
-    First & PipeExtension<T, Rest> :
-  A extends readonly [ infer Only ] ?
-    Only :
-  Function
+type PlugConstructor<Name extends PlugName> =
+  PipeResult<Name> extends Pipe ?
+    new (...args: PipeParameters<Name>) => Plug<Files> :
+  PipeResult<Name> extends Promise<undefined> ?
+    new (...args: PipeParameters<Name>) => Plug<void | undefined> :
+  PipeResult<Name> extends (Pipe | Promise<undefined>) ?
+    new (...args: PipeParameters<Name>) => Plug<Files | void | undefined> :
+  never
 
 /**
- * Install a {@link Plug} into our {@link Pipe} prototype, and return a static
- * creator function for the {@link Plug} itself.
+ * Install a {@link Plug} into our {@link Pipe} prototype.
  *
  * This allows our shorthand syntax for well-defined plugs such as:
  *
@@ -202,30 +251,66 @@ export type PipeExtension<T extends PlugConstructor, A = PlugConstructorOverload
  * Use this alongside interface merging like:
  *
  * ```
- * export class Write implements Plug {
- *   // ... the plug implementation lives here
- * }
- *
- * install('write', Write)
- *
- * declare module '../pipe' {
+ * declare module '@plugjs/plug/pipe' {
  *   export interface Pipe {
- *     write: PipeExtension<typeof Write>
+ *     write(): Pipe
  *   }
  * }
+ *
+ * install('write', class Write implements Plug {
+ *   constructorg(...args: PipeParams<'write'>) {
+ *     // here `args` is automatically inferred by whatever was declared above
+ *   }
+ *
+ *   // ... the plug implementation lives here
+ * })
  * ```
  */
-export function install<C extends PlugConstructor>(name: PlugName, ctor: C): void {
-  /* This is quite hairy when it comes to types, so, just give up! :-P */
-
-  function create(this: Pipe, ...args: any): Pipe & Promise<Files | undefined> {
+export function install<
+  Name extends PlugName,
+  Ctor extends PlugConstructor<Name>,
+>(name: Name, ctor: Ctor): void {
+  /* The function plugging the newly constructed plug in a pipe */
+  function plug(this: PipeProto, ...args: PipeParameters<Name>): Pipe | Promise<undefined> {
     // eslint-disable-next-line new-cap
-    return this.plug(new ctor(...args) as any)
+    return this.plug(new ctor(...args))
   }
 
   /* Setup name so that stack traces look better */
-  Object.defineProperty(create, 'name', { value: name })
+  Object.defineProperty(plug, 'name', { value: name })
 
   /* Inject the create function in the Pipe's prototype */
-  Object.defineProperty(Pipe.prototype, name, { value: create })
+  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

@@ -1,10 +1,9 @@
-import { assert } from '../assert.js'
-import { Files } from '../files.js'
-import { $p } from '../log.js'
-import { assertAbsolutePath, getAbsoluteParent, resolveAbsolutePath } from '../paths.js'
-import { install, Plug } from '../pipe.js'
-import { Run } from '../run.js'
-import { chmod, copyFile, fsConstants, mkdir } from '../utils/asyncfs.js'
+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 { chmod, copyFile, fsConstants, mkdir } from '../utils/asyncfs'
 
 /** Options for copying files */
 export interface CopyOptions {
@@ -18,15 +17,37 @@ export interface CopyOptions {
   rename?: (relative: string) => string
 }
 
+declare module '../pipe' {
+  export interface Pipe {
+    /**
+     * Copy the curent {@link Files} to a different directory
+     *
+     * @param directory The target directory where files will be copied to
+     */
+    copy(directory: string): Pipe
+    /**
+     * Copy the curent {@link Files} to a different directory
+     *
+     * @param directory The target directory where files will be copied to
+     * @param options Extra {@link CopyOptions | options} for the copy operation
+     */
+    copy(directory: string, options: CopyOptions): Pipe
+  }
+}
+
+/* ========================================================================== *
+ * INSTALLATION / IMPLEMENTATION                                              *
+ * ========================================================================== */
+
 /** Copy the curent {@link Files} to a different directory */
-export class Copy implements Plug<Files> {
-  constructor(directory: string, options?: CopyOptions)
+install('copy', class Copy implements Plug<Files> {
+  constructor(...args: PipeParameters<'copy'>)
   constructor(
       private readonly _directory: string,
       private readonly _options: CopyOptions = {},
   ) {}
 
-  async pipe(files: Files, run: Run): Promise<Files> {
+  async pipe(files: Files, context: Context): Promise<Files> {
     /* Destructure our options with some defaults and compute write flags */
     const { mode, dirMode, overwrite, rename = (s): string => s } = this._options
     const flags = overwrite ? fsConstants.COPYFILE_EXCL : 0
@@ -34,7 +55,8 @@ export class Copy implements Plug<Files> {
     const fmode = parseMode(mode)
 
     /* Our files builder for all written files */
-    const builder = run.files(this._directory)
+    const directory = context.resolve(this._directory)
+    const builder = Files.builder(directory)
 
     /* Iterate through all the mappings of the source files */
     for (const [ relative, absolute ] of files.pathMappings()) {
@@ -44,7 +66,7 @@ export class Copy implements Plug<Files> {
 
       /* We never copy a file onto itself, but not fail either */
       if (target === absolute) {
-        run.log.warn('Cowardly refusing to copy same file', $p(absolute))
+        context.log.warn('Cowardly refusing to copy same file', $p(absolute))
         continue
       }
 
@@ -56,44 +78,31 @@ export class Copy implements Plug<Files> {
       if (firstParent && (dmode !== undefined)) {
         assertAbsolutePath(firstParent)
         for (let dir = directory; ; dir = getAbsoluteParent(dir)) {
-          run.log.trace(`Setting mode ${stringifyMode(dmode)} for directory`, $p(dir))
+          context.log.trace(`Setting mode ${stringifyMode(dmode)} for directory`, $p(dir))
           await chmod(dir, dmode)
           if (dir === firstParent) break
         }
       }
 
       /* Actually _copy_ the file */
-      run.log.trace(`Copying "${$p(absolute)}" to "${$p(target)}"`)
+      context.log.trace(`Copying "${$p(absolute)}" to "${$p(target)}"`)
       await copyFile(absolute, target, flags)
 
       /* Set the mode, if we need to */
       if (fmode !== undefined) {
-        run.log.trace(`Setting mode ${stringifyMode(fmode)} for file`, $p(target))
+        context.log.trace(`Setting mode ${stringifyMode(fmode)} for file`, $p(target))
         await chmod(target, fmode)
       }
 
       /* Record this file */
-      builder.unchecked(relative)
+      builder.add(target)
     }
 
     const result = builder.build()
-    run.log.info('Copied', result.length, 'files to', $p(builder.directory))
+    context.log.info('Copied', result.length, 'files to', $p(builder.directory))
     return result
   }
-}
-
-/* ========================================================================== *
- * INSTALLATION                                                               *
- * ========================================================================== */
-
-install('copy', Copy)
-
-declare module '../pipe.js' {
-  export interface Pipe {
-    /** Copy the curent {@link Files} to a different directory */
-    copy: PipeExtension<typeof Copy>
-  }
-}
+})
 
 /* ========================================================================== *
  * INTERNALS                                                                  *

package/src/plugs/coverage/analysis.ts

@@ -1,9 +1,9 @@
 import { fileURLToPath, pathToFileURL } from 'node:url'
 import { RawSourceMap, SourceMapConsumer } from 'source-map'
-import { assert } from '../../assert.js'
-import { $gry, $p, Logger } from '../../log.js'
-import { AbsolutePath } from '../../paths.js'
-import { readFile } from '../../utils/asyncfs.js'
+import { assert } from '../../assert'
+import { $gry, $p, Logger } from '../../log'
+import { AbsolutePath } from '../../paths'
+import { readFile } from '../../utils/asyncfs'
 
 /* ========================================================================== *
  * V8 COVERAGE TYPES                                                          *

package/src/plugs/coverage/report.ts

@@ -1,5 +1,4 @@
 
-import { parse } from '@babel/parser'
 import {
   Comment, isDeclaration,
   isExportDeclaration,
@@ -13,11 +12,13 @@ import {
   Node,
   VISITOR_KEYS
 } from '@babel/types'
+
+import { parse } from '@babel/parser'
 import { pathToFileURL } from 'node:url'
-import { $p, Logger } from '../../log.js'
-import { AbsolutePath } from '../../paths.js'
-import { readFile } from '../../utils/asyncfs.js'
-import { CoverageAnalyser } from './analysis.js'
+import { $p, Logger } from '../../log'
+import { AbsolutePath } from '../../paths'
+import { readFile } from '../../utils/asyncfs'
+import { CoverageAnalyser } from './analysis'
 
 /* ========================================================================== *
  * EXPORTED CONSTANTS AND TYPES                                               *