@virmator/core 13.16.1 → 14.0.0

package/dist/api/copy-configs.js

@@ -28,8 +28,8 @@ export async function copyPluginConfigs(usedCommands, resolvedConfigs, packageTy
             return;
         }
         else if (packageType === PackageType.MonoRoot &&
-            !config.packageType.includes(PackageType.MonoRoot) &&
-            config.packageType.includes(PackageType.MonoPackage)) {
+            !config.packageType[PackageType.MonoRoot] &&
+            config.packageType[PackageType.MonoPackage]) {
             await Promise.all(monoRepoPackages.map(async (repoPackage) => {
                 await copyConfigFile({
                     ...config,
@@ -37,7 +37,7 @@ export async function copyPluginConfigs(usedCommands, resolvedConfigs, packageTy
                 }, log);
             }));
         }
-        else if (!config.required || !config.packageType.includes(packageType)) {
+        else if (!config.required || !config.packageType[packageType]) {
             return;
         }
         else {

package/dist/api/execute-command.js

@@ -1,14 +1,11 @@
 import { check } from '@augment-vir/assert';
-import { awaitedBlockingMap, extractErrorMessage, filterMap, log, logColors, log as logImport, LogOutputType, mapObjectValues, wrapInTry, } from '@augment-vir/common';
+import { awaitedBlockingMap, extractErrorMessage, log, logColors, log as logImport, LogOutputType, mapObjectValues, wrapInTry, } from '@augment-vir/common';
 import { readPackageJson, runShellCommand } from '@augment-vir/node';
-import chalk from 'chalk';
-import concurrently from 'concurrently';
-import { getRelativePosixPackagePathsInDependencyOrder } from 'mono-vir';
+import { getRelativePosixPackagePathTreeInDependencyOrder } from 'mono-vir';
 import { cpus } from 'node:os';
-import { join, resolve } from 'node:path';
+import { join } from 'node:path';
+import { createCommandLogPrefix, getColorKeyByIndex, KillOn, runCommandMatrix, runCommands, } from 'runstorm';
 import { findClosestPackageDir } from '../augments/index.js';
-import { CallbackWritable } from '../augments/stream/callback-writable.js';
-import { getTerminalColor } from '../colors.js';
 import { hideNoTraceTraces, VirmatorNoTraceError } from '../errors/virmator-no-trace.error.js';
 import { PackageType } from '../plugin/plugin-env.js';
 import { copyPluginConfigs } from './copy-configs.js';
@@ -39,7 +36,7 @@ async function determinePackageType(cwdPackagePath, monoRepoRootPath, cwdPackage
         else {
             if (monoRepoRootPath !== cwdPackagePath) {
                 const parentPackages = await getMonoRepoPackages(monoRepoRootPath);
-                if (parentPackages.some((monoPackage) => {
+                if (parentPackages.flat().some((monoPackage) => {
                     return join(monoRepoRootPath, monoPackage.relativePath) === cwdPackagePath;
                 })) {
                     return PackageType.MonoPackage;
@@ -55,36 +52,55 @@ async function determinePackageType(cwdPackagePath, monoRepoRootPath, cwdPackage
     }
 }
 async function getMonoRepoPackages(cwdPackagePath) {
-    const relativePackagePathsInOrder = await wrapInTry(() => getRelativePosixPackagePathsInDependencyOrder(cwdPackagePath), {
+    const relativePackagePathsInOrder = await wrapInTry(() => getRelativePosixPackagePathTreeInDependencyOrder(cwdPackagePath), {
         handleError(error) {
             log.error(extractErrorMessage(error) + '\n');
             return [];
         },
     });
-    return await Promise.all(relativePackagePathsInOrder.map(async (packagePath) => {
-        const packageJson = await wrapInTry(() => readPackageJson(packagePath), {
-            fallbackValue: undefined,
-        });
+    return await Promise.all(relativePackagePathsInOrder.map(async (dependencyLayer) => {
+        return await Promise.all(dependencyLayer.map(async (packagePath) => {
+            const packageJson = await wrapInTry(() => readPackageJson(packagePath), {
+                fallbackValue: undefined,
+            });
+            return {
+                packageName: packageJson?.name || packagePath,
+                relativePath: packagePath,
+                fullPath: join(cwdPackagePath, packagePath),
+            };
+        }));
+    }));
+}
+async function getMonoRepoDetails(cwdPackagePath, cwdPackageJson) {
+    const monoRepoRootPath = await findMonoRepoDir(cwdPackagePath);
+    const packageType = await determinePackageType(cwdPackagePath, monoRepoRootPath, cwdPackageJson);
+    const monoRepoPackages = packageType === PackageType.MonoRoot ? await getMonoRepoPackages(cwdPackagePath) : [];
+    const isPartOfMonoRepo = monoRepoPackages
+        .flat()
+        .some(({ fullPath }) => fullPath === cwdPackagePath);
+    if (isPartOfMonoRepo || packageType === PackageType.MonoRoot) {
+        return {
+            monoRepoPackages,
+            monoRepoRootPath,
+            packageType,
+        };
+    }
+    else {
         return {
-            packageName: packageJson?.name || packagePath,
-            relativePath: packagePath,
-            fullPath: join(cwdPackagePath, packagePath),
+            monoRepoPackages: [],
+            monoRepoRootPath: cwdPackagePath,
+            packageType,
         };
-    }));
+    }
 }
 async function findMonoRepoDir(cwdPackagePath) {
-    const parentPackageDir = wrapInTry(() => findClosestPackageDir(resolve(cwdPackagePath, '..')), {
+    const parentPackageDir = await wrapInTry(() => findClosestPackageDir({
+        startDirPath: cwdPackagePath,
+        requireWorkspaces: true,
+    }), {
         fallbackValue: undefined,
     });
-    if (parentPackageDir) {
-        const parentPackages = await getMonoRepoPackages(parentPackageDir);
-        if (parentPackages.some((monoPackage) => {
-            return join(parentPackageDir, monoPackage.relativePath) === cwdPackagePath;
-        })) {
-            return parentPackageDir;
-        }
-    }
-    return cwdPackagePath;
+    return parentPackageDir || cwdPackagePath;
 }
 function writeLog(arg, log, logType, extraOptions) {
     const transformed = extraOptions?.logTransform?.[logType]
@@ -116,13 +132,14 @@ export async function executeVirmatorCommand({ log: logParam, entryPointFilePath
     if (!args.commands.length || !plugin) {
         throw new VirmatorNoTraceError(`Missing valid command.`);
     }
-    const cwdPackagePath = findClosestPackageDir(cwd);
+    const cwdPackagePath = await findClosestPackageDir({
+        startDirPath: cwd,
+        requireWorkspaces: false,
+    });
     const cwdPackageJson = await readPackageJson(cwdPackagePath);
     const pluginPackagePath = plugin.pluginPackageRootPath;
     const resolvedConfigs = resolveConfigs({ cwdPackagePath, pluginPackagePath }, plugin.cliCommands);
-    const monoRepoRootPath = await findMonoRepoDir(cwdPackagePath);
-    const packageType = await determinePackageType(cwdPackagePath, monoRepoRootPath, cwdPackageJson);
-    const monoRepoPackages = packageType === PackageType.MonoRoot ? await getMonoRepoPackages(cwdPackagePath) : [];
+    const { monoRepoPackages, monoRepoRootPath, packageType } = await getMonoRepoDetails(cwdPackagePath, cwdPackageJson);
     const outerMaxProcesses = params.concurrency || cpus().length - 1 || 1;
     const filteredArgs = args.filteredCommandArgs.filter(check.isTruthy);
     const executorParams = {
@@ -134,7 +151,7 @@ export async function executeVirmatorCommand({ log: logParam, entryPointFilePath
         cwd,
         package: {
             cwdPackagePath,
-            monoRepoPackages,
+            monoRepoPackages: monoRepoPackages.flat(),
             packageType,
             monoRepoRootPath,
             cwdPackageJson,
@@ -166,13 +183,14 @@ export async function executeVirmatorCommand({ log: logParam, entryPointFilePath
             }
             return result;
         },
-        async runInstallDeps(deps) {
+        async runInstallDeps(deps, packageEnv) {
             await installNpmDeps({
                 deps,
                 cwdPackageJson,
                 cwdPackagePath,
                 log,
                 packageType,
+                packageEnv,
                 pluginName: plugin.name,
                 pluginPackagePath,
             });
@@ -184,63 +202,90 @@ export async function executeVirmatorCommand({ log: logParam, entryPointFilePath
             else if (!monoRepoPackages.length) {
                 throw new Error(`No mono-repo packages found. Make sure to set the 'workspaces' field in your mono-repo package.json and run 'npm i'.`);
             }
-            const commands = (await awaitedBlockingMap(monoRepoPackages, async (monoRepoPackage, index) => {
-                const colorString = getTerminalColor(index);
-                const color = chalk[colorString];
-                const absolutePackagePath = join(cwd, monoRepoPackage.relativePath);
-                const command = await generateCliCommandString({
-                    packageCwd: absolutePackagePath,
-                    packageName: monoRepoPackage.packageName,
-                    color,
+            if (maxProcesses === 'tree') {
+                const commands = await awaitedBlockingMap(monoRepoPackages, async (packageLayer) => {
+                    return (await awaitedBlockingMap(packageLayer, async (monoRepoPackage, index) => {
+                        const color = getColorKeyByIndex(index);
+                        const absolutePackagePath = join(cwd, monoRepoPackage.relativePath);
+                        const command = await generateCliCommandString({
+                            packageCwd: absolutePackagePath,
+                            packageName: monoRepoPackage.packageName,
+                            color,
+                        });
+                        if (!command) {
+                            return undefined;
+                        }
+                        const prefix = createCommandLogPrefix({
+                            color,
+                            name: monoRepoPackage.packageName,
+                        });
+                        log.faint(`${prefix}${logColors.faint}> ${command}`);
+                        return {
+                            command,
+                            cwd: absolutePackagePath,
+                            name: monoRepoPackage.packageName,
+                            color,
+                        };
+                    })).filter(check.isTruthy);
                 });
-                if (!command) {
-                    return undefined;
+                if (!commands.length) {
+                    return;
                 }
-                const prefix = color(`[${monoRepoPackage.packageName}]`);
-                log.faint(`${prefix}${logColors.faint} > ${command}`);
-                return {
-                    command,
-                    cwd: absolutePackagePath,
-                    name: monoRepoPackage.packageName,
-                    prefixColor: colorString,
-                };
-            })).filter(check.isTruthy);
-            const writeStream = new CallbackWritable(log);
-            /** Force concurrently to use color even though it's being run as a subscript. */
-            process.env.FORCE_COLOR = '2';
-            let concurrentlyResults = [];
-            let failed = false;
-            try {
-                if (commands.length) {
-                    concurrentlyResults = await concurrently(commands, {
-                        killOthers: 'failure',
-                        outputStream: writeStream,
-                        maxProcesses: maxProcesses || outerMaxProcesses,
-                    }).result;
+                const { highestExitCode } = await runCommandMatrix(commands, {
+                    killOn: KillOn.Failure,
+                    loggers: {
+                        stderr: log.error,
+                        stdout: log.plain,
+                    },
+                    maxConcurrency: outerMaxProcesses,
+                });
+                if (highestExitCode) {
+                    throw new VirmatorNoTraceError(`Exited with ${highestExitCode}.`);
                 }
             }
-            catch (error) {
-                failed = true;
-                if (Array.isArray(error)) {
-                    concurrentlyResults = error;
+            else {
+                const commands = (await awaitedBlockingMap(monoRepoPackages.flat(), async (monoRepoPackage, index) => {
+                    const color = getColorKeyByIndex(index);
+                    const absolutePackagePath = join(cwd, monoRepoPackage.relativePath);
+                    const command = await generateCliCommandString({
+                        packageCwd: absolutePackagePath,
+                        packageName: monoRepoPackage.packageName,
+                        color,
+                    });
+                    if (!command) {
+                        return undefined;
+                    }
+                    const prefix = createCommandLogPrefix({
+                        color,
+                        name: monoRepoPackage.packageName,
+                    });
+                    log.faint(`${prefix}${logColors.faint}> ${command}`);
+                    return {
+                        command,
+                        cwd: absolutePackagePath,
+                        name: monoRepoPackage.packageName,
+                        color,
+                    };
+                })).filter(check.isTruthy);
+                if (!commands.length) {
+                    return;
                 }
-                else {
-                    throw error;
+                const { highestExitCode } = await runCommands(commands, {
+                    killOn: KillOn.Failure,
+                    loggers: {
+                        stderr: log.error,
+                        stdout: log.plain,
+                    },
+                    maxConcurrency: maxProcesses || outerMaxProcesses,
+                });
+                if (highestExitCode) {
+                    throw new VirmatorNoTraceError(`Exited with ${highestExitCode}.`);
                 }
             }
-            if (!failed) {
-                return;
-            }
-            const failedCommandNames = filterMap(concurrentlyResults, (result) => result.command.name, (commandName, result) => {
-                return result.exitCode !== 0 && !result.killed;
-            });
-            if (failedCommandNames.length) {
-                throw new VirmatorNoTraceError(`${failedCommandNames.join(', ')} failed.`);
-            }
         },
     };
     if (!args.virmatorFlags['--no-configs']) {
-        await copyPluginConfigs(args.usedCommands, resolvedConfigs, packageType, monoRepoPackages, log, filteredArgs);
+        await copyPluginConfigs(args.usedCommands, resolvedConfigs, packageType, monoRepoPackages.flat(), log, filteredArgs);
     }
     if (!args.virmatorFlags['--no-deps']) {
         await installPluginNpmDeps({
@@ -251,6 +296,7 @@ export async function executeVirmatorCommand({ log: logParam, entryPointFilePath
             pluginName: plugin.name,
             pluginPackagePath,
             usedCommands: args.usedCommands,
+            packageEnv: undefined,
         });
     }
     const result = await wrapInTry(() => plugin.executor(executorParams));

package/dist/api/install-deps.d.ts

@@ -1,4 +1,4 @@
-import { type Logger } from '@augment-vir/common';
+import { type Logger, type RuntimeEnv } from '@augment-vir/common';
 import { type PackageJson } from 'type-fest';
 import { type PackageType } from '../plugin/plugin-env.js';
 import { type UsedVirmatorPluginCommands } from '../plugin/plugin-executor.js';
@@ -11,6 +11,7 @@ export declare function installPluginNpmDeps({ usedCommands, ...params }: {
     pluginName: string;
     packageType: PackageType;
     log: Logger;
+    packageEnv: RuntimeEnv | undefined;
     usedCommands: Readonly<UsedVirmatorPluginCommands>;
 }): Promise<void>;
 /**
@@ -18,12 +19,13 @@ export declare function installPluginNpmDeps({ usedCommands, ...params }: {
  *
  * @returns `true` if new deps were installed, otherwise `false`.
  */
-export declare function installNpmDeps({ cwdPackagePath, cwdPackageJson, pluginPackagePath, pluginName, packageType, log, deps, }: {
+export declare function installNpmDeps({ cwdPackagePath, cwdPackageJson, pluginPackagePath, pluginName, packageType, packageEnv, log, deps, }: {
     cwdPackagePath: string;
     cwdPackageJson: PackageJson;
     pluginPackagePath: string;
     pluginName: string;
     packageType: PackageType;
+    packageEnv: RuntimeEnv | undefined;
     log: Logger;
     deps: Partial<PluginNpmDeps>;
 }): Promise<boolean>;

package/dist/api/install-deps.js

@@ -24,7 +24,7 @@ export async function installPluginNpmDeps({ usedCommands, ...params }) {
  *
  * @returns `true` if new deps were installed, otherwise `false`.
  */
-export async function installNpmDeps({ cwdPackagePath, cwdPackageJson, pluginPackagePath, pluginName, packageType, log, deps, }) {
+export async function installNpmDeps({ cwdPackagePath, cwdPackageJson, pluginPackagePath, pluginName, packageType, packageEnv, log, deps, }) {
     const neededDeps = getObjectTypedEntries(deps);
     if (!neededDeps.length) {
         return false;
@@ -33,7 +33,9 @@ export async function installNpmDeps({ cwdPackagePath, cwdPackageJson, pluginPac
     const pluginPackageJson = await readPackageJson(pluginPackagePath);
     const currentPluginPackageDeps = combineDeps(pluginPackageJson);
     const depsThatNeedInstalling = neededDeps.reduce((accum, [depName, depOptions,]) => {
-        if (!depOptions.packageType.includes(packageType)) {
+        const matchesPackageType = depOptions.packageType[packageType];
+        const matchesPackageEnv = packageEnv ? depOptions.env[packageEnv] : true;
+        if (!matchesPackageType || !matchesPackageEnv) {
             return accum;
         }
         const baselineVersion = semver.coerce(currentPluginPackageDeps[depName] || '');

package/dist/augments/fs/search.d.ts

@@ -1,4 +1,7 @@
 /** Finds the closest ancestor directory with a `package.json` file. */
-export declare function findClosestPackageDir(startDirPath: string): string;
+export declare function findClosestPackageDir({ requireWorkspaces, startDirPath, }: {
+    startDirPath: string;
+    requireWorkspaces: boolean;
+}): Promise<string>;
 /** Finds the closest ancestor `node_modules` directory. */
 export declare function findClosestNodeModulesDir(startDirPath: string): string;

package/dist/augments/fs/search.js

@@ -1,11 +1,21 @@
-import { assert } from '@augment-vir/assert';
-import { findAncestor } from '@augment-vir/node';
+import { assert, check } from '@augment-vir/assert';
+import { findAncestor, readJsonFile } from '@augment-vir/node';
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 /** Finds the closest ancestor directory with a `package.json` file. */
-export function findClosestPackageDir(startDirPath) {
-    const ancestor = findAncestor(startDirPath, (dir) => {
-        return existsSync(join(dir, 'package.json'));
+export async function findClosestPackageDir({ requireWorkspaces, startDirPath, }) {
+    const ancestor = await findAncestor(startDirPath, async (dir) => {
+        const jsonFilePath = join(dir, 'package.json');
+        if (!existsSync(jsonFilePath)) {
+            return false;
+        }
+        else if (requireWorkspaces) {
+            const contents = await readJsonFile(jsonFilePath);
+            return check.isObject(contents) ? 'workspaces' in contents : false;
+        }
+        else {
+            return true;
+        }
     });
     assert.isDefined(ancestor, 'Failed to find ancestor package root.');
     return ancestor;

package/dist/augments/index.d.ts

@@ -1,4 +1,3 @@
 export * from './fs/search.js';
 export * from './object/access.js';
-export * from './stream/callback-writable.js';
 export * from './tsconfig/parse-tsconfig.js';

package/dist/augments/index.js

@@ -1,4 +1,3 @@
 export * from './fs/search.js';
 export * from './object/access.js';
-export * from './stream/callback-writable.js';
 export * from './tsconfig/parse-tsconfig.js';

package/dist/index.d.ts

@@ -1,5 +1,4 @@
 export * from './api/index.js';
 export * from './augments/index.js';
-export * from './colors.js';
 export * from './errors/index.js';
 export * from './plugin/index.js';

package/dist/index.js

@@ -1,5 +1,4 @@
 export * from './api/index.js';
 export * from './augments/index.js';
-export * from './colors.js';
 export * from './errors/index.js';
 export * from './plugin/index.js';

package/dist/plugin/plugin-configs.d.ts

@@ -13,9 +13,9 @@ export type VirmatorPluginConfigFile = {
      */
     copyToPath: string;
     /** The environments in which this config should be used. */
-    env: RuntimeEnv[];
+    env: Partial<Record<RuntimeEnv, boolean>>;
     /** The package type for which this config should be used. */
-    packageType: PackageType[];
+    packageType: Partial<Record<PackageType, boolean>>;
     /**
      * If set to `true`, this config will be copied over every time the command is run, if the
      * config doesn't exist, unless `'--no-configs'` was set.

package/dist/plugin/plugin-executor.d.ts

@@ -1,6 +1,6 @@
-import { type AnyObject, type Logger, type LogOutputType, type MaybePromise, type PartialWithUndefined, type TypedFunction } from '@augment-vir/common';
+import { type AnyObject, type Logger, type LogOutputType, type MaybePromise, type PartialWithUndefined, type RuntimeEnv, type TypedFunction } from '@augment-vir/common';
 import { type runShellCommand } from '@augment-vir/node';
-import { type ChalkInstance } from 'chalk';
+import { type ColorKey } from 'runstorm';
 import { type EmptyObject, type PackageJson, type SetRequired } from 'type-fest';
 import { type VirmatorPluginResolvedConfigFile } from './plugin-configs.js';
 import { type PackageType } from './plugin-env.js';
@@ -37,8 +37,8 @@ export type MonoRepoPackage = {
 export type RunPerPackage = (generateCliCommandString: (params: {
     packageCwd: string;
     packageName: string;
-    color: ChalkInstance;
-}) => MaybePromise<string | undefined>, maxProcesses?: number | undefined) => Promise<void>;
+    color: ColorKey;
+}) => MaybePromise<string | undefined>, maxProcesses?: number | undefined | 'tree') => Promise<void>;
 /** Extra, optional options for a plugin's `runShellCommand` param. */
 export type ExtraRunShellCommandOptions = {
     /** Optional prefix before every log. */
@@ -87,7 +87,7 @@ export type VirmatorPluginExecutorParams<Commands extends VirmatorPluginCliComma
     /** Runs the given command for each package within a mono repo, if it has any. */
     runPerPackage: RunPerPackage;
     /** Installs the given list of deps within the current package directory. */
-    runInstallDeps: (deps: Readonly<Partial<PluginNpmDeps>>) => Promise<void>;
+    runInstallDeps: (deps: Readonly<Partial<PluginNpmDeps>>, packageEnv: RuntimeEnv) => Promise<void>;
     log: Logger;
     configs: VirmatorPluginResolvedConfigs<Commands>;
     virmator: Readonly<{

package/dist/plugin/plugin-init.d.ts

@@ -14,8 +14,8 @@ export type PluginCommandDocs = {
 /** A list of npm deps. Used for virmator plugin command lists. */
 export type PluginNpmDeps = Record<string, {
     type: NpmDepType;
-    packageType: ReadonlyArray<PackageType>;
-    env: ReadonlyArray<RuntimeEnv>;
+    packageType: Partial<Record<PackageType, boolean>>;
+    env: Partial<Record<RuntimeEnv, boolean>>;
 }>;
 /** An individual virmator plugin cli command definition. Can nest recursive commands. */
 export type IndividualPluginCommand = {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@virmator/core",
-    "version": "13.16.1",
+    "version": "14.0.0",
     "description": "Shared core functionality for all virmator plugins and the virmator CLI.",
     "keywords": [
         "automation",
@@ -32,21 +32,20 @@
         "test:update": "npm test update"
     },
     "dependencies": {
-        "@augment-vir/assert": "^31.31.0",
-        "@augment-vir/common": "^31.31.0",
-        "@augment-vir/node": "^31.31.0",
-        "chalk": "^5.5.0",
-        "concurrently": "^9.2.0",
-        "mono-vir": "^2.0.6",
+        "@augment-vir/assert": "^31.32.3",
+        "@augment-vir/common": "^31.32.3",
+        "@augment-vir/node": "^31.32.3",
+        "mono-vir": "^2.2.1",
+        "runstorm": "^0.6.1",
         "semver": "^7.7.2",
         "type-fest": "^4.41.0",
         "typescript": "^5.9.2"
     },
     "devDependencies": {
-        "@augment-vir/test": "^31.31.0",
-        "@types/node": "^24.2.0",
+        "@augment-vir/test": "^31.32.3",
+        "@types/node": "^24.3.0",
         "@types/semver": "^7.7.0",
-        "esbuild": "^0.25.8"
+        "esbuild": "^0.25.9"
     },
     "engines": {
         "node": ">=22"

package/dist/augments/stream/callback-writable.d.ts

@@ -1,13 +0,0 @@
-import { type Logger } from '@augment-vir/common';
-import { Writable } from 'node:stream';
-/**
- * A [Writable](https://nodejs.org/api/stream.html#class-streamwritable) implementation that writes
- * to the provided plugin logger.
- */
-export declare class CallbackWritable extends Writable {
-    private readonly logger;
-    private chunks;
-    /** Special write implementation that writs to the given logger. */
-    _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
-    constructor(logger: Logger);
-}

package/dist/augments/stream/callback-writable.js

@@ -1,24 +0,0 @@
-import { Writable } from 'node:stream';
-/**
- * A [Writable](https://nodejs.org/api/stream.html#class-streamwritable) implementation that writes
- * to the provided plugin logger.
- */
-export class CallbackWritable extends Writable {
-    logger;
-    chunks = [];
-    /** Special write implementation that writs to the given logger. */
-    _write(chunk, encoding, callback) {
-        const chunkString = String(chunk);
-        this.chunks.push(chunkString);
-        if (chunkString.endsWith('\n')) {
-            const fullString = this.chunks.join('');
-            this.chunks = [];
-            this.logger.faint(fullString.trim());
-        }
-        callback();
-    }
-    constructor(logger) {
-        super();
-        this.logger = logger;
-    }
-}

package/dist/colors.d.ts

@@ -1,10 +0,0 @@
-import { type ArrayElement } from '@augment-vir/common';
-/**
- * All terminal colors passed to concurrently and other concurrent operations used within virmator
- * plugins.
- */
-export declare const terminalColors: readonly ["red", "yellow", "greenBright", "cyan", "blueBright", "magentaBright", "grey"];
-/** The supported terminal colors for virmator concurrent commands. */
-export type TerminalColor = ArrayElement<typeof terminalColors>;
-/** Gets a supported virmator terminal color, with support for overflowing indexes. */
-export declare function getTerminalColor(index: number): TerminalColor;

package/dist/colors.js

@@ -1,19 +0,0 @@
-/**
- * All terminal colors passed to concurrently and other concurrent operations used within virmator
- * plugins.
- */
-export const terminalColors = [
-    // Text colors
-    'red',
-    'yellow',
-    'greenBright',
-    'cyan',
-    'blueBright',
-    'magentaBright',
-    'grey',
-];
-/** Gets a supported virmator terminal color, with support for overflowing indexes. */
-export function getTerminalColor(index) {
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    return terminalColors[index % terminalColors.length];
-}