@roots/bud-compiler 6.21.0 → 6.23.0

package/README.md

@@ -69,9 +69,6 @@ However, the amount of effort needed to maintain and develop new features and pr
 <a href="https://worksitesafety.ca/careers/">
 <img src="https://cdn.roots.io/app/uploads/worksite-safety.svg" alt="Worksite Safety" width="200" height="150"/>
 </a>
-<a href="https://www.copiadigital.com/">
-<img src="https://cdn.roots.io/app/uploads/copia-digital.svg" alt="Copia Digital" width="200" height="150"/>
-</a>
-<a href="https://www.freave.com/">
-<img src="https://cdn.roots.io/app/uploads/freave.svg" alt="Freave" width="200" height="150"/>
+<a href="https://www.itineris.co.uk/">
+<img src="https://cdn.roots.io/app/uploads/itineris.svg" alt="Itineris" width="200" height="150"/>
 </a>

package/lib/service/formatError.d.ts

@@ -0,0 +1,3 @@
+import type { StatsCompilation, StatsError } from '@roots/bud-framework/config';
+import type { ErrorWithSourceFile } from '@roots/bud-support/open';
+export declare const makeErrorFormatter: (stats: StatsCompilation) => (error: StatsError) => ErrorWithSourceFile | StatsError;

package/lib/service/formatError.js

@@ -0,0 +1,54 @@
+import isNull from '@roots/bud-support/isNull';
+import isString from '@roots/bud-support/isString';
+import logger from '@roots/bud-support/logger';
+export const makeErrorFormatter = (stats) => (error) => {
+    try {
+        let file;
+        let module;
+        const ident = error.moduleId ?? error.moduleName;
+        /**
+         * In a perfect world webpack plugins would use the
+         * {@link StatsError.nameForCondition} property to identify the module.
+         */
+        if (ident && stats?.children) {
+            module = stats.children
+                .flatMap(child => child?.modules)
+                .find(module => [module?.id, module?.name].includes(ident));
+        }
+        /**
+         * If the module is not found, we try to parse the error message
+         */
+        if (!ident && error.message?.includes(`[stylelint]`)) {
+            // try to get the origin of the stylelint error,
+            // which is contained in the second line of the error message
+            const unparsedOrigin = error.message?.split(`\n`)?.[1];
+            // if the origin is not a string or too long, we return the error as-is
+            if (!isString(unparsedOrigin) || unparsedOrigin.length > 100)
+                return error;
+            // extract absolute path and context relative name of module
+            const styleError = unparsedOrigin.match(/file:\/\/(.*)\x07(.*)\x1B]8;;/);
+            if (isNull(styleError))
+                return error;
+            // get parts of matched error
+            const [, file, name] = styleError;
+            // return enriched error
+            return { ...error, file, name, nameForCondition: file };
+        }
+        /**
+         * If the module is still not found, we return the error as-is
+         */
+        if (!module)
+            return error;
+        /**
+         * We'll prefer the `nameForCondition` property if it exists,
+         * otherwise we'll use the `name` property.
+         */
+        file = module.nameForCondition ?? module.name;
+        const name = module.name ?? error.name ?? `error`;
+        return { ...error, file, name };
+    }
+    catch (formatError) {
+        logger.warn(`Problem parsing errors. This probably won't break anything but please report it: https://github.com/roots/bud/issues/new`, formatError);
+        return error;
+    }
+};

package/lib/service/index.d.ts

@@ -1,7 +1,6 @@
 import type { Bud } from '@roots/bud-framework';
 import type { Compiler as BudCompiler } from '@roots/bud-framework';
-import type { MultiCompiler, MultiStats, Stats, StatsError, Webpack } from '@roots/bud-framework/config';
-import type { ErrorWithSourceFile } from '@roots/bud-support/open';
+import type { MultiCompiler, MultiStats, Webpack } from '@roots/bud-framework/config';
 import { Service } from '@roots/bud-framework/service';
 /**
  * {@link BudCompiler} implementation
@@ -23,14 +22,10 @@ declare class Compiler extends Service implements BudCompiler {
      * {@link BudCompiler.stats}
      */
     stats: BudCompiler[`stats`];
-    /**
-     * {@link BudCompiler.onError}
-     */
-    onError(error: Error | undefined): void;
     /**
      * {@link BudCompiler.onStats}
      */
-    onStats(stats: Stats & MultiStats): void;
+    onStats(stats: MultiStats): void;
     /**
      * {@link BudCompiler.compile}
      */
@@ -39,6 +34,5 @@ declare class Compiler extends Service implements BudCompiler {
      * {@link Service.register}
      */
     register?(bud: Bud): Promise<any>;
-    sourceErrors?(errors: Array<StatsError> | undefined): Array<ErrorWithSourceFile | StatsError>;
 }
 export { Compiler as default };

package/lib/service/index.js

@@ -1,16 +1,14 @@
 import { __decorate } from "tslib";
-import { jsx as _jsx } from "@roots/bud-support/jsx-runtime";
 import { cpus } from 'node:os';
 import process from 'node:process';
 import { pathToFileURL } from 'node:url';
-import { Display as DisplayError } from '@roots/bud-dashboard/components/error';
 import { Service } from '@roots/bud-framework/service';
 import { bind } from '@roots/bud-support/decorators/bind';
-import { BudError, CompilerError } from '@roots/bud-support/errors';
-import isNull from '@roots/bud-support/isNull';
+import { BudError } from '@roots/bud-support/errors';
 import isNumber from '@roots/bud-support/isNumber';
-import isString from '@roots/bud-support/isString';
 import stripAnsi from '@roots/bud-support/strip-ansi';
+import { makeErrorFormatter } from './formatError.js';
+import { makeNoticeTitle } from './makeNoticeTitle.js';
 /**
  * {@link BudCompiler} implementation
  */
@@ -23,83 +21,70 @@ class Compiler extends Service {
      * {@link BudCompiler.implementation}
      */
     implementation;
-    /**
-     * {@link BudCompiler.onError}
-     */
-    onError(error) {
-        process.exitCode = 1;
-        if (!error)
-            return;
-        this.app.server?.appliedMiddleware?.hot?.publish({ error });
-        const normalized = CompilerError.normalize(error, {
-            thrownBy: import.meta.url,
-        });
-        normalized.details = undefined;
-        this.app.notifier?.notify({
-            group: this.app.label,
-            message: normalized.message,
-            subtitle: normalized.name,
-        });
-        this.app.context.render(_jsx(DisplayError, { error: error }));
-    }
     /**
      * {@link BudCompiler.onStats}
      */
     onStats(stats) {
-        const makeNoticeTitle = (child) => this.app.label !== child.name
-            ? `${this.app.label} (${child.name})`
-            : child.name;
-        this.stats = stats.toJson(statsOptions);
-        this.app.context.render(this.app.dashboard.render(stats));
+        this.stats = stats.toJson({
+            all: false,
+            children: {
+                all: false,
+                assets: true,
+                cached: true,
+                cachedAssets: true,
+                cachedModules: true,
+                entrypoints: true,
+                errorDetails: false,
+                errors: true,
+                errorsCount: true,
+                hash: true,
+                modules: true,
+                name: true,
+                outputPath: true,
+                timings: true,
+                warnings: true,
+                warningsCount: true,
+            },
+        });
+        this.app.dashboard.render(stats);
         if (stats.hasErrors()) {
             process.exitCode = 1;
+            const format = makeErrorFormatter(this.stats);
             this.stats.children = this.stats.children?.map(child => ({
                 ...child,
-                errors: child.errors && this.sourceErrors
-                    ? this.sourceErrors(child.errors)
-                    : child.errors ?? [],
+                errors: (child.errors
+                    ? child.errors?.map(format).filter(Boolean)
+                    : child.errors) ?? [],
             }));
             this.stats.children
                 ?.filter(child => isNumber(child.errorsCount) && child.errorsCount > 0)
                 .forEach(child => {
-                try {
-                    const error = child.errors?.shift();
-                    if (!error)
-                        return;
-                    this.app.notifier.notify({
-                        group: `${this.app.label}-${child.name}`,
-                        message: stripAnsi(error.message),
-                        open: error.file ? pathToFileURL(error.file) : ``,
-                        subtitle: error.file ? `Error in ${error.name}` : error.name,
-                        title: makeNoticeTitle(child),
-                    });
-                    error.file && this.app.notifier.openEditor(error.file);
-                }
-                catch (error) {
-                    this.logger.error(error);
-                }
-            });
-        }
-        this.stats.children
-            ?.filter(child => child.errorsCount === 0)
-            .forEach(child => {
-            try {
+                const error = child.errors?.shift();
+                if (!error)
+                    return;
                 this.app.notifier.notify({
                     group: `${this.app.label}-${child.name}`,
-                    message: child.modules
-                        ? `${child.modules.length} modules compiled`
-                        : `Modules compiled successfully`,
-                    open: this.app.server?.publicUrl.href,
-                    subtitle: `Build successful`,
-                    title: makeNoticeTitle(child),
+                    message: stripAnsi(error.message),
+                    open: error.file ? pathToFileURL(error.file) : ``,
+                    subtitle: error.file ? `Error in ${error.name}` : error.name,
+                    title: makeNoticeTitle(this.app, child),
                 });
-                this.app.server?.publicUrl.href &&
-                    this.app.context.browser &&
-                    this.app.notifier.openBrowser(this.app.server?.publicUrl.href);
-            }
-            catch (error) {
-                this.logger.error(error);
-            }
+                error.file && this.app.notifier.openEditor(error.file);
+            });
+        }
+        this.stats.children?.forEach(child => {
+            this.app.notifier.notify({
+                group: `${this.app.label}-${child.name}`,
+                message: child.modules
+                    ? `${child.modules.length} modules compiled`
+                    : `Modules compiled successfully`,
+                open: this.app.server?.publicUrl.href,
+                subtitle: `Build successful`,
+                title: makeNoticeTitle(this.app, child),
+            });
+            this.app.server?.publicUrl.href &&
+                this.app.context.browser &&
+                this.app.notifier.openBrowser(this.app.server?.publicUrl.href);
         });
     }
     /**
@@ -108,25 +93,16 @@ class Compiler extends Service {
     async compile(bud) {
         const config = !bud.hasChildren
             ? [await bud.build.make()]
-            : await Promise.all(Object.values(bud.children).map(async (child) => await child.build.make().catch(error => {
-                throw error;
-            })));
+            : await Promise.all(Object.values(bud.children).map(async (child) => await child.build.make()));
         this.config = config?.filter(Boolean);
         if (this.config.length > 1) {
             this.config.parallelism = Math.max(cpus().length - 1, 1);
             this.logger.info(`parallel compilations: ${this.config.parallelism}`);
         }
-        await bud.hooks.fire(`compiler.before`, bud).catch(error => {
-            throw error;
-        });
-        this.logger.timeEnd(`initialize`);
+        await bud.hooks.fire(`compiler.before`, bud);
         this.instance = this.implementation(this.config);
-        this.instance.hooks.done.tap(bud.label, (stats) => {
-            this.onStats(stats);
-            bud.hooks
-                .fire(`compiler.done`, bud, this.stats)
-                .catch(this.app.catch);
-        });
+        this.instance.hooks.done.tap(bud.label, this.onStats);
+        this.instance.hooks.done.tap(`${bud.label}-compiler.done`, stats => bud.hooks.fire(`compiler.done`, bud, stats));
         return this.instance;
     }
     /**
@@ -139,72 +115,7 @@ class Compiler extends Service {
             throw BudError.normalize(error);
         });
     }
-    sourceErrors(errors) {
-        if (!errors || !errors.length)
-            return [];
-        try {
-            return errors
-                ?.map((error) => {
-                let file;
-                let module;
-                const ident = error.moduleId ?? error.moduleName;
-                /**
-                 * In a perfect world webpack plugins would use the
-                 * `nameForCondition` property to identify the module.
-                 */
-                if (ident && this.stats?.children) {
-                    module = this.stats.children
-                        .flatMap(child => child?.modules)
-                        .find(module => [module?.id, module?.name].includes(ident));
-                }
-                /**
-                 * If the module is not found, we try to parse the error message
-                 */
-                if (!ident && error.message?.includes(`[stylelint]`)) {
-                    // try to get the origin of the stylelint error,
-                    // which is contained in the second line of the error message
-                    const unparsedOrigin = error.message?.split(`\n`)?.[1];
-                    // if the origin is not a string or too long, we return the error as-is
-                    if (!isString(unparsedOrigin) || unparsedOrigin.length > 100)
-                        return error;
-                    // extract absolute path and context relative name of module
-                    const styleError = unparsedOrigin.match(/file:\/\/(.*)\x07(.*)\x1B]8;;/);
-                    if (isNull(styleError))
-                        return error;
-                    // get parts of matched error
-                    const [, file, name] = styleError;
-                    // return enriched error
-                    return { ...error, file, name, nameForCondition: file };
-                }
-                /**
-                 * If the module is still not found, we return the error as-is
-                 */
-                if (!module)
-                    return error;
-                /**
-                 * We'll prefer the `nameForCondition` property if it exists,
-                 * otherwise we'll use the `name` property.
-                 */
-                if (module.nameForCondition) {
-                    file = module.nameForCondition;
-                }
-                else if (module.name) {
-                    file = this.app.path(`@src`, module.name);
-                }
-                const name = module.name ?? error.name ?? `error`;
-                return { ...error, file, name };
-            })
-                .filter(Boolean);
-        }
-        catch (error) {
-            this.logger.warn(`Problem parsing errors. This probably won't break anything but please report it: https://github.com/roots/bud/issues/new`, error);
-            return errors;
-        }
-    }
 }
-__decorate([
-    bind
-], Compiler.prototype, "onError", null);
 __decorate([
     bind
 ], Compiler.prototype, "onStats", null);
@@ -214,28 +125,4 @@ __decorate([
 __decorate([
     bind
 ], Compiler.prototype, "register", null);
-__decorate([
-    bind
-], Compiler.prototype, "sourceErrors", null);
-const statsOptions = {
-    all: false,
-    children: {
-        all: false,
-        assets: true,
-        cached: true,
-        cachedAssets: true,
-        cachedModules: true,
-        entrypoints: true,
-        errorDetails: false,
-        errors: true,
-        errorsCount: true,
-        hash: true,
-        modules: true,
-        name: true,
-        outputPath: true,
-        timings: true,
-        warnings: true,
-        warningsCount: true,
-    },
-};
 export { Compiler as default };

package/lib/service/makeNoticeTitle.d.ts

@@ -0,0 +1,3 @@
+import type { Bud } from '@roots/bud-framework';
+import type { StatsCompilation } from '@roots/bud-framework/config';
+export declare const makeNoticeTitle: (bud: Bud, child: StatsCompilation) => string;

package/lib/service/makeNoticeTitle.js

@@ -0,0 +1 @@
+export const makeNoticeTitle = (bud, child) => bud.label !== child.name ? `${bud.label} (${child.name})` : child.name;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@roots/bud-compiler",
-  "version": "6.21.0",
+  "version": "6.23.0",
   "description": "Compilation handler",
   "engines": {
     "node": ">=16"
@@ -65,16 +65,14 @@
   "types": "./lib/index.d.ts",
   "module": "./lib/index.js",
   "devDependencies": {
-    "@roots/bud-api": "6.21.0",
+    "@roots/bud-api": "6.23.0",
     "@skypack/package-check": "0.2.2",
-    "@types/node": "20.10.5",
-    "@types/react": "18.2.45"
+    "@types/node": "20.12.8"
   },
   "dependencies": {
-    "@roots/bud-dashboard": "6.21.0",
-    "@roots/bud-framework": "6.21.0",
-    "@roots/bud-support": "6.21.0",
-    "react": "18.2.0",
+    "@roots/bud-dashboard": "6.23.0",
+    "@roots/bud-framework": "6.23.0",
+    "@roots/bud-support": "6.23.0",
     "tslib": "2.6.2"
   },
   "volta": {

package/src/service/formatError.ts

@@ -0,0 +1,78 @@
+import type {
+  StatsCompilation,
+  StatsError,
+  StatsModule,
+} from '@roots/bud-framework/config'
+import type {
+  ErrorWithSourceFile,
+  SourceFile,
+} from '@roots/bud-support/open'
+
+import isNull from '@roots/bud-support/isNull'
+import isString from '@roots/bud-support/isString'
+import logger from '@roots/bud-support/logger'
+
+export const makeErrorFormatter =
+  (stats: StatsCompilation) =>
+  (error: StatsError): ErrorWithSourceFile | StatsError => {
+    try {
+      let file: SourceFile[`file`] | undefined
+      let module: StatsModule | undefined
+
+      const ident = error.moduleId ?? error.moduleName
+
+      /**
+       * In a perfect world webpack plugins would use the
+       * {@link StatsError.nameForCondition} property to identify the module.
+       */
+      if (ident && stats?.children) {
+        module = stats.children
+          .flatMap(child => child?.modules)
+          .find(module => [module?.id, module?.name].includes(ident))
+      }
+
+      /**
+       * If the module is not found, we try to parse the error message
+       */
+      if (!ident && error.message?.includes(`[stylelint]`)) {
+        // try to get the origin of the stylelint error,
+        // which is contained in the second line of the error message
+        const unparsedOrigin = error.message?.split(`\n`)?.[1]
+
+        // if the origin is not a string or too long, we return the error as-is
+        if (!isString(unparsedOrigin) || unparsedOrigin.length > 100)
+          return error
+
+        // extract absolute path and context relative name of module
+        const styleError = unparsedOrigin.match(
+          /file:\/\/(.*)\x07(.*)\x1B]8;;/,
+        )
+        if (isNull(styleError)) return error
+
+        // get parts of matched error
+        const [, file, name] = styleError
+        // return enriched error
+        return {...error, file, name, nameForCondition: file}
+      }
+
+      /**
+       * If the module is still not found, we return the error as-is
+       */
+      if (!module) return error
+
+      /**
+       * We'll prefer the `nameForCondition` property if it exists,
+       * otherwise we'll use the `name` property.
+       */
+      file = module.nameForCondition ?? module.name
+
+      const name = module.name ?? error.name ?? `error`
+      return {...error, file, name}
+    } catch (formatError) {
+      logger.warn(
+        `Problem parsing errors. This probably won't break anything but please report it: https://github.com/roots/bud/issues/new`,
+        formatError,
+      )
+      return error
+    }
+  }

package/src/service/index.ts

@@ -0,0 +1,167 @@
+import type {Bud} from '@roots/bud-framework'
+import type {Compiler as BudCompiler} from '@roots/bud-framework'
+import type {
+  MultiCompiler,
+  MultiStats,
+  Webpack,
+} from '@roots/bud-framework/config'
+
+import {cpus} from 'node:os'
+import process from 'node:process'
+import {pathToFileURL} from 'node:url'
+
+import {Service} from '@roots/bud-framework/service'
+import {bind} from '@roots/bud-support/decorators/bind'
+import {BudError} from '@roots/bud-support/errors'
+import isNumber from '@roots/bud-support/isNumber'
+import stripAnsi from '@roots/bud-support/strip-ansi'
+
+import {makeErrorFormatter} from './formatError.js'
+import {makeNoticeTitle} from './makeNoticeTitle.js'
+
+/**
+ * {@link BudCompiler} implementation
+ */
+class Compiler extends Service implements BudCompiler {
+  /**
+   * {@link BudCompiler.config}
+   */
+  public config: BudCompiler[`config`] = []
+
+  /**
+   * {@link BudCompiler.implementation}
+   */
+  public implementation: BudCompiler[`implementation`] & typeof Webpack
+
+  /**
+   * {@link BudCompiler.instance}
+   */
+  public declare instance: BudCompiler[`instance`]
+
+  /**
+   * {@link BudCompiler.stats}
+   */
+  public declare stats: BudCompiler[`stats`]
+
+  /**
+   * {@link BudCompiler.onStats}
+   */
+  @bind
+  public onStats(stats: MultiStats) {
+    this.stats = stats.toJson({
+      all: false,
+      children: {
+        all: false,
+        assets: true,
+        cached: true,
+        cachedAssets: true,
+        cachedModules: true,
+        entrypoints: true,
+        errorDetails: false,
+        errors: true,
+        errorsCount: true,
+        hash: true,
+        modules: true,
+        name: true,
+        outputPath: true,
+        timings: true,
+        warnings: true,
+        warningsCount: true,
+      },
+    })
+    this.app.dashboard.render(stats)
+
+    if (stats.hasErrors()) {
+      process.exitCode = 1
+
+      const format = makeErrorFormatter(this.stats)
+      this.stats.children = this.stats.children?.map(child => ({
+        ...child,
+        errors:
+          (child.errors
+            ? child.errors?.map(format).filter(Boolean)
+            : child.errors) ?? [],
+      }))
+
+      this.stats.children
+        ?.filter(
+          child => isNumber(child.errorsCount) && child.errorsCount > 0,
+        )
+        .forEach(child => {
+          const error = child.errors?.shift()
+          if (!error) return
+
+          this.app.notifier.notify({
+            group: `${this.app.label}-${child.name}`,
+            message: stripAnsi(error.message),
+            open: error.file ? pathToFileURL(error.file) : ``,
+            subtitle: error.file ? `Error in ${error.name}` : error.name,
+            title: makeNoticeTitle(this.app, child),
+          })
+
+          error.file && this.app.notifier.openEditor(error.file)
+        })
+    }
+
+    this.stats.children?.forEach(child => {
+      this.app.notifier.notify({
+        group: `${this.app.label}-${child.name}`,
+        message: child.modules
+          ? `${child.modules.length} modules compiled`
+          : `Modules compiled successfully`,
+        open: this.app.server?.publicUrl.href,
+        subtitle: `Build successful`,
+        title: makeNoticeTitle(this.app, child),
+      })
+
+      this.app.server?.publicUrl.href &&
+        this.app.context.browser &&
+        this.app.notifier.openBrowser(this.app.server?.publicUrl.href)
+    })
+  }
+
+  /**
+   * {@link BudCompiler.compile}
+   */
+  @bind
+  public async compile(bud: Bud): Promise<MultiCompiler> {
+    const config = !bud.hasChildren
+      ? [await bud.build.make()]
+      : await Promise.all(
+          Object.values(bud.children).map(
+            async (child: Bud) => await child.build.make(),
+          ),
+        )
+
+    this.config = config?.filter(Boolean)
+
+    if (this.config.length > 1) {
+      this.config.parallelism = Math.max(cpus().length - 1, 1)
+      this.logger.info(`parallel compilations: ${this.config.parallelism}`)
+    }
+
+    await bud.hooks.fire(`compiler.before`, bud)
+
+    this.instance = this.implementation(this.config)
+    this.instance.hooks.done.tap(bud.label, this.onStats)
+    this.instance.hooks.done.tap(`${bud.label}-compiler.done`, stats =>
+      bud.hooks.fire(`compiler.done`, bud, stats),
+    )
+
+    return this.instance
+  }
+
+  /**
+   * {@link Service.register}
+   */
+  @bind
+  public override async register?(bud: Bud): Promise<any> {
+    this.implementation = await bud.module
+      .import(`@roots/bud-support/webpack`, import.meta.url)
+      .catch(error => {
+        throw BudError.normalize(error)
+      })
+  }
+}
+
+export {Compiler as default}

package/src/service/makeNoticeTitle.ts

@@ -0,0 +1,5 @@
+import type {Bud} from '@roots/bud-framework'
+import type {StatsCompilation} from '@roots/bud-framework/config'
+
+export const makeNoticeTitle = (bud: Bud, child: StatsCompilation) =>
+  bud.label !== child.name ? `${bud.label} (${child.name})` : child.name

package/src/service/index.tsx

@@ -1,300 +0,0 @@
-import type {Bud} from '@roots/bud-framework'
-import type {Compiler as BudCompiler} from '@roots/bud-framework'
-import type {
-  MultiCompiler,
-  MultiStats,
-  Stats,
-  StatsCompilation,
-  StatsError,
-  Webpack,
-} from '@roots/bud-framework/config'
-import type {
-  ErrorWithSourceFile,
-  SourceFile,
-} from '@roots/bud-support/open'
-
-import {cpus} from 'node:os'
-import process from 'node:process'
-import {pathToFileURL} from 'node:url'
-
-import {Display as DisplayError} from '@roots/bud-dashboard/components/error'
-import {Service} from '@roots/bud-framework/service'
-import {bind} from '@roots/bud-support/decorators/bind'
-import {BudError, CompilerError} from '@roots/bud-support/errors'
-import isNull from '@roots/bud-support/isNull'
-import isNumber from '@roots/bud-support/isNumber'
-import isString from '@roots/bud-support/isString'
-import stripAnsi from '@roots/bud-support/strip-ansi'
-
-/**
- * {@link BudCompiler} implementation
- */
-class Compiler extends Service implements BudCompiler {
-  /**
-   * {@link BudCompiler.config}
-   */
-  public config: BudCompiler[`config`] = []
-
-  /**
-   * {@link BudCompiler.implementation}
-   */
-  public implementation: BudCompiler[`implementation`] & typeof Webpack
-
-  /**
-   * {@link BudCompiler.instance}
-   */
-  public declare instance: BudCompiler[`instance`]
-
-  /**
-   * {@link BudCompiler.stats}
-   */
-  public declare stats: BudCompiler[`stats`]
-
-  /**
-   * {@link BudCompiler.onError}
-   */
-  @bind
-  public onError(error: Error | undefined) {
-    process.exitCode = 1
-    if (!error) return
-
-    this.app.server?.appliedMiddleware?.hot?.publish({error})
-
-    const normalized = CompilerError.normalize(error, {
-      thrownBy: import.meta.url,
-    })
-
-    normalized.details = undefined
-
-    this.app.notifier?.notify({
-      group: this.app.label,
-      message: normalized.message,
-      subtitle: normalized.name,
-    })
-
-    this.app.context.render(<DisplayError error={error} />)
-  }
-
-  /**
-   * {@link BudCompiler.onStats}
-   */
-  @bind
-  public onStats(stats: Stats & MultiStats) {
-    const makeNoticeTitle = (child: StatsCompilation) =>
-      this.app.label !== child.name
-        ? `${this.app.label} (${child.name})`
-        : child.name
-
-    this.stats = stats.toJson(statsOptions)
-    this.app.context.render(this.app.dashboard.render(stats))
-
-    if (stats.hasErrors()) {
-      process.exitCode = 1
-
-      this.stats.children = this.stats.children?.map(child => ({
-        ...child,
-        errors:
-          child.errors && this.sourceErrors
-            ? this.sourceErrors(child.errors)
-            : child.errors ?? [],
-      }))
-
-      this.stats.children
-        ?.filter(
-          child => isNumber(child.errorsCount) && child.errorsCount > 0,
-        )
-        .forEach(child => {
-          try {
-            const error = child.errors?.shift()
-            if (!error) return
-
-            this.app.notifier.notify({
-              group: `${this.app.label}-${child.name}`,
-              message: stripAnsi(error.message),
-              open: error.file ? pathToFileURL(error.file) : ``,
-              subtitle: error.file ? `Error in ${error.name}` : error.name,
-              title: makeNoticeTitle(child),
-            })
-
-            error.file && this.app.notifier.openEditor(error.file)
-          } catch (error) {
-            this.logger.error(error)
-          }
-        })
-    }
-
-    this.stats.children
-      ?.filter(child => child.errorsCount === 0)
-      .forEach(child => {
-        try {
-          this.app.notifier.notify({
-            group: `${this.app.label}-${child.name}`,
-            message: child.modules
-              ? `${child.modules.length} modules compiled`
-              : `Modules compiled successfully`,
-            open: this.app.server?.publicUrl.href,
-            subtitle: `Build successful`,
-            title: makeNoticeTitle(child),
-          })
-
-          this.app.server?.publicUrl.href &&
-            this.app.context.browser &&
-            this.app.notifier.openBrowser(this.app.server?.publicUrl.href)
-        } catch (error) {
-          this.logger.error(error)
-        }
-      })
-  }
-  /**
-   * {@link BudCompiler.compile}
-   */
-  @bind
-  public async compile(bud: Bud): Promise<MultiCompiler> {
-    const config = !bud.hasChildren
-      ? [await bud.build.make()]
-      : await Promise.all(
-          Object.values(bud.children).map(
-            async (child: Bud) =>
-              await child.build.make().catch(error => {
-                throw error
-              }),
-          ),
-        )
-
-    this.config = config?.filter(Boolean)
-
-    if (this.config.length > 1) {
-      this.config.parallelism = Math.max(cpus().length - 1, 1)
-      this.logger.info(`parallel compilations: ${this.config.parallelism}`)
-    }
-
-    await bud.hooks.fire(`compiler.before`, bud).catch(error => {
-      throw error
-    })
-
-    this.logger.timeEnd(`initialize`)
-
-    this.instance = this.implementation(this.config)
-
-    this.instance.hooks.done.tap(bud.label, (stats: any) => {
-      this.onStats(stats)
-      bud.hooks
-        .fire(`compiler.done`, bud, this.stats)
-        .catch(this.app.catch)
-    })
-
-    return this.instance
-  }
-
-  /**
-   * {@link Service.register}
-   */
-  @bind
-  public override async register?(bud: Bud): Promise<any> {
-    this.implementation = await bud.module
-      .import(`@roots/bud-support/webpack`, import.meta.url)
-      .catch(error => {
-        throw BudError.normalize(error)
-      })
-  }
-
-  @bind
-  public sourceErrors?(
-    errors: Array<StatsError> | undefined,
-  ): Array<ErrorWithSourceFile | StatsError> {
-    if (!errors || !errors.length) return []
-
-    try {
-      return errors
-        ?.map((error: StatsError): ErrorWithSourceFile | StatsError => {
-          let file: SourceFile[`file`] | undefined
-          let module: undefined | Webpack.StatsModule
-
-          const ident = error.moduleId ?? error.moduleName
-
-          /**
-           * In a perfect world webpack plugins would use the
-           * `nameForCondition` property to identify the module.
-           */
-          if (ident && this.stats?.children) {
-            module = this.stats.children
-              .flatMap(child => child?.modules)
-              .find(module => [module?.id, module?.name].includes(ident))
-          }
-
-          /**
-           * If the module is not found, we try to parse the error message
-           */
-          if (!ident && error.message?.includes(`[stylelint]`)) {
-            // try to get the origin of the stylelint error,
-            // which is contained in the second line of the error message
-            const unparsedOrigin = error.message?.split(`\n`)?.[1]
-
-            // if the origin is not a string or too long, we return the error as-is
-            if (!isString(unparsedOrigin) || unparsedOrigin.length > 100)
-              return error
-
-            // extract absolute path and context relative name of module
-            const styleError = unparsedOrigin.match(
-              /file:\/\/(.*)\x07(.*)\x1B]8;;/,
-            )
-            if (isNull(styleError)) return error
-
-            // get parts of matched error
-            const [, file, name] = styleError
-            // return enriched error
-            return {...error, file, name, nameForCondition: file}
-          }
-
-          /**
-           * If the module is still not found, we return the error as-is
-           */
-          if (!module) return error
-
-          /**
-           * We'll prefer the `nameForCondition` property if it exists,
-           * otherwise we'll use the `name` property.
-           */
-          if (module.nameForCondition) {
-            file = module.nameForCondition
-          } else if (module.name) {
-            file = this.app.path(`@src`, module.name)
-          }
-
-          const name = module.name ?? error.name ?? `error`
-          return {...error, file, name}
-        })
-        .filter(Boolean)
-    } catch (error) {
-      this.logger.warn(
-        `Problem parsing errors. This probably won't break anything but please report it: https://github.com/roots/bud/issues/new`,
-        error,
-      )
-      return errors
-    }
-  }
-}
-
-const statsOptions = {
-  all: false,
-  children: {
-    all: false,
-    assets: true,
-    cached: true,
-    cachedAssets: true,
-    cachedModules: true,
-    entrypoints: true,
-    errorDetails: false,
-    errors: true,
-    errorsCount: true,
-    hash: true,
-    modules: true,
-    name: true,
-    outputPath: true,
-    timings: true,
-    warnings: true,
-    warningsCount: true,
-  },
-}
-
-export {Compiler as default}