@zenithbuild/cli 0.6.5 → 0.6.7

package/dist/toolchain-paths.js

@@ -2,51 +2,94 @@ import { existsSync, readFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const CLI_ROOT = resolve(__dirname, '..');
 const localRequire = createRequire(import.meta.url);
-
+const IS_WINDOWS = process.platform === 'win32';
+const COMPILER_BRIDGE_RUNNER = resolve(__dirname, 'compiler-bridge-runner.js');
 function safeCreateRequire(projectRoot) {
     if (!projectRoot) {
         return localRequire;
     }
     try {
         return createRequire(resolve(projectRoot, 'package.json'));
-    } catch {
+    }
+    catch {
         return localRequire;
     }
 }
-
 function safeResolve(requireFn, specifier) {
     try {
         return requireFn.resolve(specifier);
-    } catch {
+    }
+    catch {
+        return null;
+    }
+}
+function resolveExecutablePath(candidatePath) {
+    if (typeof candidatePath !== 'string' || candidatePath.length === 0) {
+        return '';
+    }
+    if (!IS_WINDOWS || candidatePath.toLowerCase().endsWith('.exe')) {
+        return candidatePath;
+    }
+    if (existsSync(candidatePath)) {
+        return candidatePath;
+    }
+    const exePath = `${candidatePath}.exe`;
+    return existsSync(exePath) ? exePath : candidatePath;
+}
+function createBinaryCandidate(tool, source, candidatePath) {
+    const resolvedPath = resolveExecutablePath(candidatePath);
+    return {
+        tool,
+        mode: 'binary',
+        source,
+        sourceKey: `${tool}:${source}:${resolvedPath}`,
+        label: source,
+        path: resolvedPath,
+        command: resolvedPath,
+        argsPrefix: []
+    };
+}
+function createCompilerBridgeCandidate(modulePath) {
+    if (typeof modulePath !== 'string' || modulePath.length === 0) {
         return null;
     }
+    return {
+        tool: 'compiler',
+        mode: 'node-bridge',
+        source: 'JS bridge',
+        sourceKey: `compiler:js-bridge:${modulePath}`,
+        label: 'JS bridge',
+        path: modulePath,
+        command: process.execPath,
+        argsPrefix: [COMPILER_BRIDGE_RUNNER, '--bridge-module', modulePath]
+    };
 }
-
 export function resolveBinary(candidates) {
     for (const candidate of candidates) {
-        if (existsSync(candidate)) {
-            return candidate;
+        const path = typeof candidate === 'string' ? candidate : candidate.path;
+        if (path && existsSync(path)) {
+            return path;
         }
     }
-    return candidates[0] || '';
+    const first = candidates[0];
+    if (typeof first === 'string') {
+        return first;
+    }
+    return first?.path || '';
 }
-
 export function resolvePackageRoot(packageName, projectRoot = null) {
     const projectRequire = safeCreateRequire(projectRoot);
     const projectPath = safeResolve(projectRequire, `${packageName}/package.json`);
     if (projectPath) {
         return dirname(projectPath);
     }
-
     const localPath = safeResolve(localRequire, `${packageName}/package.json`);
     return localPath ? dirname(localPath) : null;
 }
-
 export function readInstalledPackageVersion(packageName, projectRoot = null) {
     const packageRoot = resolvePackageRoot(packageName, projectRoot);
     if (!packageRoot) {
@@ -55,56 +98,85 @@ export function readInstalledPackageVersion(packageName, projectRoot = null) {
     try {
         const pkg = JSON.parse(readFileSync(resolve(packageRoot, 'package.json'), 'utf8'));
         return typeof pkg.version === 'string' ? pkg.version : null;
-    } catch {
+    }
+    catch {
         return null;
     }
 }
-
 export function readCliPackageVersion() {
     try {
         const pkg = JSON.parse(readFileSync(resolve(CLI_ROOT, 'package.json'), 'utf8'));
         return typeof pkg.version === 'string' ? pkg.version : '0.0.0';
-    } catch {
+    }
+    catch {
         return '0.0.0';
     }
 }
-
-export function compilerBinCandidates(projectRoot = null) {
-    const candidates = [
-        resolve(CLI_ROOT, '../compiler/target/release/zenith-compiler'),
-        resolve(CLI_ROOT, '../zenith-compiler/target/release/zenith-compiler')
+function compilerWorkspaceBinaryCandidates() {
+    return [
+        createBinaryCandidate('compiler', 'workspace binary', resolve(CLI_ROOT, '../compiler/target/release/zenith-compiler')),
+        createBinaryCandidate('compiler', 'workspace binary', resolve(CLI_ROOT, '../zenith-compiler/target/release/zenith-compiler'))
     ];
+}
+function bundlerWorkspaceBinaryCandidates() {
+    return [
+        createBinaryCandidate('bundler', 'workspace binary', resolve(CLI_ROOT, '../bundler/target/release/zenith-bundler')),
+        createBinaryCandidate('bundler', 'workspace binary', resolve(CLI_ROOT, '../zenith-bundler/target/release/zenith-bundler'))
+    ];
+}
+export function compilerCommandCandidates(projectRoot = null, env = process.env) {
+    const candidates = [];
+    const envBin = env.ZENITH_COMPILER_BIN;
+    if (typeof envBin === 'string' && envBin.length > 0) {
+        candidates.push({
+            ...createBinaryCandidate('compiler', 'env override (ZENITH_COMPILER_BIN)', envBin),
+            explicit: true
+        });
+    }
     const installedRoot = resolvePackageRoot('@zenithbuild/compiler', projectRoot);
     if (installedRoot) {
-        candidates.unshift(resolve(installedRoot, 'target/release/zenith-compiler'));
+        candidates.push(createBinaryCandidate('compiler', 'installed package binary', resolve(installedRoot, 'target/release/zenith-compiler')));
+    }
+    candidates.push(...compilerWorkspaceBinaryCandidates());
+    if (installedRoot) {
+        const bridgeCandidate = createCompilerBridgeCandidate(resolve(installedRoot, 'dist/index.js'));
+        if (bridgeCandidate) {
+            candidates.push(bridgeCandidate);
+        }
     }
     return candidates;
 }
-
-export function resolveCompilerBin(projectRoot = null) {
-    return resolveBinary(compilerBinCandidates(projectRoot));
+export function compilerBinCandidates(projectRoot = null, env = process.env) {
+    return compilerCommandCandidates(projectRoot, env)
+        .filter((candidate) => candidate.mode === 'binary')
+        .map((candidate) => candidate.path);
 }
-
-export function bundlerBinCandidates(projectRoot = null, env = process.env) {
+export function resolveCompilerBin(projectRoot = null, env = process.env) {
+    return resolveBinary(compilerBinCandidates(projectRoot, env));
+}
+export function bundlerCommandCandidates(projectRoot = null, env = process.env) {
     const candidates = [];
-    const envBin = env?.ZENITH_BUNDLER_BIN;
+    const envBin = env.ZENITH_BUNDLER_BIN;
     if (typeof envBin === 'string' && envBin.length > 0) {
-        candidates.push(envBin);
+        candidates.push({
+            ...createBinaryCandidate('bundler', 'env override (ZENITH_BUNDLER_BIN)', envBin),
+            explicit: true
+        });
     }
-
     const installedRoot = resolvePackageRoot('@zenithbuild/bundler', projectRoot);
     if (installedRoot) {
-        candidates.push(resolve(installedRoot, 'target/release/zenith-bundler'));
-    }
-
-    candidates.push(
-        resolve(CLI_ROOT, '../bundler/target/release/zenith-bundler'),
-        resolve(CLI_ROOT, '../zenith-bundler/target/release/zenith-bundler')
-    );
-
+        candidates.push(createBinaryCandidate('bundler', 'installed package binary', resolve(installedRoot, 'target/release/zenith-bundler')));
+    }
+    candidates.push(...bundlerWorkspaceBinaryCandidates());
     return candidates;
 }
-
 export function resolveBundlerBin(projectRoot = null, env = process.env) {
-    return resolveBinary(bundlerBinCandidates(projectRoot, env));
+    return resolveBinary(bundlerCommandCandidates(projectRoot, env)
+        .filter((candidate) => candidate.mode === 'binary')
+        .map((candidate) => candidate.path));
+}
+export function bundlerBinCandidates(projectRoot = null, env = process.env) {
+    return bundlerCommandCandidates(projectRoot, env)
+        .filter((candidate) => candidate.mode === 'binary')
+        .map((candidate) => candidate.path);
 }

package/dist/toolchain-runner.d.ts

@@ -0,0 +1,33 @@
+import type { SpawnSyncOptionsWithStringEncoding, SpawnSyncReturns } from 'node:child_process';
+import { type ToolchainCandidate, type ToolchainTool } from './toolchain-paths.js';
+export interface ToolchainLogger {
+    warn?: (message: string, options?: {
+        onceKey?: string;
+    }) => void;
+}
+export interface ToolchainState {
+    tool: ToolchainTool;
+    logger: ToolchainLogger | null;
+    candidates: ToolchainCandidate[];
+    activeIndex: number;
+}
+type SpawnResult = SpawnSyncReturns<string>;
+export declare function createCompilerToolchain({ projectRoot, env, logger }?: {
+    projectRoot?: string | null;
+    env?: NodeJS.ProcessEnv;
+    logger?: ToolchainLogger | null;
+}): ToolchainState;
+export declare function createBundlerToolchain({ projectRoot, env, logger }?: {
+    projectRoot?: string | null;
+    env?: NodeJS.ProcessEnv;
+    logger?: ToolchainLogger | null;
+}): ToolchainState;
+export declare function createToolchainStateForTests(tool: ToolchainTool, candidates: ToolchainCandidate[], logger?: ToolchainLogger | null): ToolchainState;
+export declare function resetToolchainWarningsForTests(): void;
+export declare function getActiveToolchainCandidate(toolchain: ToolchainState): ToolchainCandidate | null;
+export declare function ensureToolchainCompatibility(toolchain: ToolchainState, probeArgs?: string[]): ToolchainCandidate;
+export declare function runToolchainSync(toolchain: ToolchainState, args: string[], spawnOptions?: SpawnSyncOptionsWithStringEncoding): {
+    result: SpawnResult;
+    candidate: ToolchainCandidate;
+};
+export {};

package/dist/toolchain-runner.js

@@ -0,0 +1,170 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { bundlerCommandCandidates, compilerCommandCandidates } from './toolchain-paths.js';
+const FALLBACK_LOG_KEYS = new Set();
+const INCOMPATIBLE_ERROR_CODES = new Set(['ENOEXEC', 'EACCES']);
+const INCOMPATIBLE_STDERR_PATTERNS = [
+    /exec format error/i,
+    /bad cpu type/i,
+    /cannot execute binary file/i,
+    /not a valid win32 application/i
+];
+function currentPlatformLabel() {
+    return `${process.platform}-${process.arch}`;
+}
+function toolEnvVar(tool) {
+    return tool === 'bundler' ? 'ZENITH_BUNDLER_BIN' : 'ZENITH_COMPILER_BIN';
+}
+function candidateExists(candidate) {
+    if (!candidate) {
+        return false;
+    }
+    if (candidate.mode === 'node-bridge') {
+        const [runnerPath] = candidate.argsPrefix;
+        return existsSync(candidate.path) && typeof runnerPath === 'string' && existsSync(runnerPath);
+    }
+    return typeof candidate.path === 'string' && candidate.path.length > 0 && existsSync(candidate.path);
+}
+function candidateSupportsArgs(candidate, args) {
+    if (!candidate || candidate.mode !== 'node-bridge') {
+        return true;
+    }
+    return !args.includes('--embedded-markup-expressions') && !args.includes('--strict-dom-lints');
+}
+function isBinaryIncompatible(result) {
+    const error = result?.error;
+    const errorCode = error?.code;
+    if (typeof errorCode === 'string' && INCOMPATIBLE_ERROR_CODES.has(errorCode)) {
+        return true;
+    }
+    const stderr = `${result?.stderr || ''}\n${error?.message || ''}`;
+    return INCOMPATIBLE_STDERR_PATTERNS.some((pattern) => pattern.test(stderr));
+}
+function emitFallbackWarning(toolchain, nextCandidate) {
+    const message = `[zenith] ${toolchain.tool} binary incompatible for this platform; falling back to ${nextCandidate.label}`;
+    const onceKey = `toolchain-fallback:${toolchain.tool}:${nextCandidate.sourceKey}`;
+    if (toolchain.logger && typeof toolchain.logger.warn === 'function') {
+        toolchain.logger.warn(message, { onceKey });
+        return;
+    }
+    if (FALLBACK_LOG_KEYS.has(onceKey)) {
+        return;
+    }
+    FALLBACK_LOG_KEYS.add(onceKey);
+    console.warn(message);
+}
+function incompatibleBinaryError(toolchain) {
+    return new Error(`[zenith] ${toolchain.tool} binary is incompatible for ${currentPlatformLabel()}; ` +
+        `reinstall or set ${toolEnvVar(toolchain.tool)}=...`);
+}
+function toolchainProbeError(toolchain, result) {
+    const detail = result?.error?.message
+        || String(result?.stderr || '').trim()
+        || `exit code ${result?.status ?? 'unknown'}`;
+    return new Error(`[zenith] ${toolchain.tool} probe failed: ${detail}`);
+}
+function buildToolchainState(tool, candidates, logger = null) {
+    const explicitIndex = candidates.findIndex((candidate) => candidate.explicit === true);
+    const initialIndex = explicitIndex >= 0
+        ? explicitIndex
+        : candidates.findIndex((candidate) => candidateExists(candidate));
+    return {
+        tool,
+        logger,
+        candidates,
+        activeIndex: initialIndex >= 0 ? initialIndex : 0
+    };
+}
+function findNextFallbackIndex(toolchain, args) {
+    for (let index = toolchain.activeIndex + 1; index < toolchain.candidates.length; index += 1) {
+        const candidate = toolchain.candidates[index];
+        if (!candidateExists(candidate)) {
+            continue;
+        }
+        if (!candidateSupportsArgs(candidate, args)) {
+            continue;
+        }
+        return index;
+    }
+    return -1;
+}
+function activeCandidate(toolchain) {
+    return toolchain.candidates[toolchain.activeIndex] || null;
+}
+function runCandidateSync(candidate, args, spawnOptions) {
+    return spawnSync(candidate.command, [...candidate.argsPrefix, ...args], spawnOptions);
+}
+export function createCompilerToolchain({ projectRoot = null, env = process.env, logger = null } = {}) {
+    return buildToolchainState('compiler', compilerCommandCandidates(projectRoot, env), logger);
+}
+export function createBundlerToolchain({ projectRoot = null, env = process.env, logger = null } = {}) {
+    return buildToolchainState('bundler', bundlerCommandCandidates(projectRoot, env), logger);
+}
+export function createToolchainStateForTests(tool, candidates, logger = null) {
+    return buildToolchainState(tool, candidates, logger);
+}
+export function resetToolchainWarningsForTests() {
+    FALLBACK_LOG_KEYS.clear();
+}
+export function getActiveToolchainCandidate(toolchain) {
+    return activeCandidate(toolchain);
+}
+export function ensureToolchainCompatibility(toolchain, probeArgs = ['--version']) {
+    while (toolchain.activeIndex < toolchain.candidates.length) {
+        const candidate = activeCandidate(toolchain);
+        if (!candidate) {
+            break;
+        }
+        if (!candidateSupportsArgs(candidate, probeArgs)) {
+            const nextIndex = findNextFallbackIndex(toolchain, probeArgs);
+            if (nextIndex === -1) {
+                throw incompatibleBinaryError(toolchain);
+            }
+            toolchain.activeIndex = nextIndex;
+            emitFallbackWarning(toolchain, toolchain.candidates[nextIndex]);
+            continue;
+        }
+        const result = runCandidateSync(candidate, probeArgs, { encoding: 'utf8' });
+        if (!isBinaryIncompatible(result)) {
+            if (result.error || result.status !== 0) {
+                throw toolchainProbeError(toolchain, result);
+            }
+            return candidate;
+        }
+        const nextIndex = findNextFallbackIndex(toolchain, probeArgs);
+        if (nextIndex === -1) {
+            throw incompatibleBinaryError(toolchain);
+        }
+        toolchain.activeIndex = nextIndex;
+        emitFallbackWarning(toolchain, toolchain.candidates[nextIndex]);
+    }
+    throw incompatibleBinaryError(toolchain);
+}
+export function runToolchainSync(toolchain, args, spawnOptions = { encoding: 'utf8' }) {
+    while (toolchain.activeIndex < toolchain.candidates.length) {
+        const candidate = activeCandidate(toolchain);
+        if (!candidate) {
+            break;
+        }
+        if (!candidateSupportsArgs(candidate, args)) {
+            const nextIndex = findNextFallbackIndex(toolchain, args);
+            if (nextIndex === -1) {
+                throw incompatibleBinaryError(toolchain);
+            }
+            toolchain.activeIndex = nextIndex;
+            emitFallbackWarning(toolchain, toolchain.candidates[nextIndex]);
+            continue;
+        }
+        const result = runCandidateSync(candidate, args, spawnOptions);
+        if (!isBinaryIncompatible(result)) {
+            return { result, candidate };
+        }
+        const nextIndex = findNextFallbackIndex(toolchain, args);
+        if (nextIndex === -1) {
+            throw incompatibleBinaryError(toolchain);
+        }
+        toolchain.activeIndex = nextIndex;
+        emitFallbackWarning(toolchain, toolchain.candidates[nextIndex]);
+    }
+    throw incompatibleBinaryError(toolchain);
+}

package/dist/types/generate-env-dts.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @param {string} projectRoot
+ * @returns {Promise<void>}
+ */
+export function generateEnvDts(projectRoot: string): Promise<void>;

package/dist/types/generate-env-dts.js

@@ -1,6 +1,9 @@
 import { writeFile, mkdir } from 'node:fs/promises';
 import { join, dirname } from 'node:path';
-
+/**
+ * @param {string} projectRoot
+ * @returns {Promise<void>}
+ */
 export async function generateEnvDts(projectRoot) {
     const content = `// .zenith/zenith-env.d.ts
 // Auto-generated by Zenith. Do not edit.
@@ -45,7 +48,6 @@ declare global {
   }
 }
 `;
-
     const outPath = join(projectRoot, '.zenith', 'zenith-env.d.ts');
     await mkdir(dirname(outPath), { recursive: true });
     await writeFile(outPath, content, 'utf8');

package/dist/types/generate-routes-dts.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param {string} projectRoot
+ * @param {Array<{ path?: string | null }>} [manifest]
+ * @returns {Promise<void>}
+ */
+export function generateRoutesDts(projectRoot: string, manifest?: Array<{
+    path?: string | null;
+}>): Promise<void>;

package/dist/types/generate-routes-dts.js

@@ -1,12 +1,15 @@
 import { writeFile, mkdir } from 'node:fs/promises';
 import { join, dirname } from 'node:path';
-
+/**
+ * @param {string} projectRoot
+ * @param {Array<{ path?: string | null }>} [manifest]
+ * @returns {Promise<void>}
+ */
 export async function generateRoutesDts(projectRoot, manifest) {
-    const routes = (manifest || []).map(r => r.path).filter(Boolean);
+    const routes = (manifest || []).map((route) => route.path).filter(Boolean);
     const typeDef = routes.length > 0
-        ? routes.map(r => '"' + r + '"').join(' | ')
+        ? routes.map((route) => `"${route}"`).join(' | ')
         : 'string';
-
     const content = '// .zenith/zenith-routes.d.ts\\n' +
         '// Auto-generated by Zenith. Do not edit.\\n\\n' +
         'export {};\\n\\n' +
@@ -15,7 +18,6 @@ export async function generateRoutesDts(projectRoot, manifest) {
         '    type RoutePattern = ' + typeDef + ';\\n' +
         '  }\\n' +
         '}\\n';
-
     const outPath = join(projectRoot, '.zenith', 'zenith-routes.d.ts');
     await mkdir(dirname(outPath), { recursive: true });
     await writeFile(outPath, content, 'utf8');

package/dist/types/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @typedef {typeof globalThis & { __zenithTypesWarned?: boolean }} ZenithTypesGlobal
+ */
+/**
+ * @param {string} projectRoot
+ * @param {Array<{ path?: string }>} [manifest]
+ * @returns {Promise<void>}
+ */
+export function ensureZenithTypes(projectRoot: string, manifest?: Array<{
+    path?: string;
+}>): Promise<void>;
+export type ZenithTypesGlobal = typeof globalThis & {
+    __zenithTypesWarned?: boolean;
+};

package/dist/types/index.js

@@ -2,33 +2,42 @@ import { generateEnvDts } from './generate-env-dts.js';
 import { generateRoutesDts } from './generate-routes-dts.js';
 import { join } from 'node:path';
 import { access, constants } from 'node:fs/promises';
-
+/**
+ * @typedef {typeof globalThis & { __zenithTypesWarned?: boolean }} ZenithTypesGlobal
+ */
+/**
+ * @param {string} projectRoot
+ * @param {Array<{ path?: string }>} [manifest]
+ * @returns {Promise<void>}
+ */
 export async function ensureZenithTypes(projectRoot, manifest) {
     try {
         await generateEnvDts(projectRoot);
         if (manifest) {
             await generateRoutesDts(projectRoot, manifest);
         }
-
         // Check if tsconfig.json exists, if it does, check if .zenith is included
         const tsconfigPath = join(projectRoot, 'tsconfig.json');
         let hasTsConfig = false;
         try {
             await access(tsconfigPath, constants.F_OK);
             hasTsConfig = true;
-        } catch {
+        }
+        catch {
             hasTsConfig = false;
         }
-
         if (hasTsConfig) {
             // In a real implementation this would parse the JSON and check "include".
             // For now, we simply inform the user to include it if they haven't.
-            if (!globalThis.__zenithTypesWarned) {
+            /** @type {ZenithTypesGlobal} */
+            const globalScope = globalThis;
+            if (!globalScope.__zenithTypesWarned) {
                 console.warn('\\x1b[33m[zenith]\\x1b[0m For the best TypeScript experience, ensure ".zenith/**/*.d.ts" is in your tsconfig.json "include" array.');
-                globalThis.__zenithTypesWarned = true;
+                globalScope.__zenithTypesWarned = true;
             }
         }
-    } catch (err) {
+    }
+    catch (err) {
         console.error('[zenith] Failed to generate type definitions:', err);
     }
 }

package/dist/ui/env.d.ts

@@ -0,0 +1,18 @@
+export type UiLogLevel = 'quiet' | 'normal' | 'verbose';
+export interface UiMode {
+    plain: boolean;
+    color: boolean;
+    tty: boolean;
+    ci: boolean;
+    spinner: boolean;
+    debug: boolean;
+    logLevel: UiLogLevel;
+}
+export interface UiRuntime {
+    env?: Record<string, string | undefined>;
+    stdout?: {
+        isTTY?: boolean;
+    };
+}
+export declare function getUiMode(runtime?: UiRuntime): UiMode;
+export declare function isUiPlain(runtime?: UiRuntime): boolean;

package/dist/ui/env.js

@@ -1,7 +1,3 @@
-/**
- * UI environment mode detection for deterministic CLI output.
- */
-
 function flagEnabled(value) {
     if (value === undefined || value === null) {
         return false;
@@ -9,7 +5,6 @@ function flagEnabled(value) {
     const normalized = String(value).trim().toLowerCase();
     return normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on';
 }
-
 function parseLogLevel(value) {
     const normalized = String(value || '').trim().toLowerCase();
     if (normalized === 'quiet' || normalized === 'verbose') {
@@ -17,10 +12,6 @@ function parseLogLevel(value) {
     }
     return 'normal';
 }
-
-/**
- * @param {{ env?: Record<string, string | undefined>, stdout?: { isTTY?: boolean } }} runtime
- */
 export function getUiMode(runtime = process) {
     const env = runtime.env || {};
     const tty = Boolean(runtime.stdout?.isTTY);
@@ -30,7 +21,6 @@ export function getUiMode(runtime = process) {
     const forceColor = flagEnabled(env.FORCE_COLOR);
     const debug = flagEnabled(env.ZENITH_DEBUG);
     let logLevel = parseLogLevel(env.ZENITH_LOG_LEVEL);
-
     const plain = noUi || ci || !tty;
     const color = !plain && !noColor && (forceColor || tty);
     const spinner = tty && !plain && !ci;
@@ -40,7 +30,6 @@ export function getUiMode(runtime = process) {
     if (debug && logLevel !== 'quiet') {
         logLevel = 'verbose';
     }
-
     return {
         plain,
         color,
@@ -51,7 +40,6 @@ export function getUiMode(runtime = process) {
         logLevel
     };
 }
-
 export function isUiPlain(runtime = process) {
     return getUiMode(runtime).plain;
 }

package/dist/ui/format.d.ts

@@ -0,0 +1,33 @@
+import pc from 'picocolors';
+import type { UiMode } from './env.js';
+type FormatTag = keyof typeof TAG_COLORS | string;
+interface SummaryRow {
+    label?: unknown;
+    value?: unknown;
+}
+declare const TAG_COLORS: {
+    DEV: (colors: ReturnType<typeof pc.createColors>, value: string) => string;
+    BUILD: (colors: ReturnType<typeof pc.createColors>, value: string) => string;
+    HMR: (colors: ReturnType<typeof pc.createColors>, value: string) => string;
+    ROUTER: (colors: ReturnType<typeof pc.createColors>, value: string) => string;
+    CSS: (colors: ReturnType<typeof pc.createColors>, value: string) => string;
+    OK: (colors: ReturnType<typeof pc.createColors>, value: string) => string;
+    WARN: (colors: ReturnType<typeof pc.createColors>, value: string) => string;
+    ERR: (colors: ReturnType<typeof pc.createColors>, value: string) => string;
+};
+export declare function formatPrefix(mode: UiMode): string;
+export declare function formatLine(mode: UiMode, { glyph, tag, text }: {
+    glyph?: string;
+    tag?: FormatTag;
+    text?: unknown;
+}): string;
+export declare function formatStep(mode: UiMode, text: unknown, tag?: FormatTag): string;
+export declare function formatHint(mode: UiMode, text: unknown): string;
+export declare function formatHeading(mode: UiMode, text: unknown): string;
+export declare function formatSummaryTable(mode: UiMode, rows: SummaryRow[], tag?: FormatTag): string;
+export declare function sanitizeErrorMessage(input: unknown): string;
+export declare function normalizeErrorMessagePaths(message: string): string;
+export declare function normalizeError(err: unknown): Error;
+export declare function formatErrorBlock(err: unknown, mode: UiMode): string;
+export declare function containsAnsi(value: unknown): boolean;
+export {};