@simplysm/sd-cli 14.0.7 → 14.0.9

package/src/orchestrators/BuildOrchestrator.ts

@@ -1,6 +1,5 @@
-import path from "path";
 import ts from "typescript";
-import { fsx } from "@simplysm/core-node";
+import { fsx, pathx } from "@simplysm/core-node";
 import { consola } from "consola";
 import type {
   SdConfig,
@@ -37,7 +36,7 @@ export interface BuildOrchestratorOptions {
 interface BuildStepResult {
   name: string;
   target: string;
-  type: "js" | "dts" | "lint";
+  type: "build" | "lint";
   success: boolean;
   errors?: string[];
   warnings?: string[];
@@ -101,7 +100,7 @@ export function classifyPackages(
  * Delete dist folders
  */
 async function cleanDistFolders(cwd: string, packageNames: string[]): Promise<void> {
-  await Promise.all(packageNames.map((name) => fsx.rm(path.join(cwd, "packages", name, "dist"))));
+  await Promise.all(packageNames.map((name) => fsx.rm(pathx.posixResolve(cwd, "packages", name, "dist"))));
 }
 
 //#endregion
@@ -227,7 +226,7 @@ export class BuildOrchestrator {
 
     // buildPackages: JS build + dts generation via BuildEngine
     for (const { name, config } of classified.buildPackages) {
-      const pkgDir = path.join(this._cwd, "packages", name);
+      const pkgDir = pathx.posixResolve(this._cwd, "packages", name);
 
       buildTasks.push(async () => {
         this._logger.debug(`[${name}] (${config.target}) 빌드 시작`);
@@ -239,28 +238,18 @@ export class BuildOrchestrator {
         try {
           const engineResult = await engine.run({ js: true, dts: true, lint: true });
 
-          // JS 빌드 결과 처리
+          // 빌드 결과 처리
+          const diagnostics = engineResult.build.diagnostics.map((d) => deserializeDiagnostic(d, fileCache));
           results.push({
             name,
             target: config.target,
-            type: "js",
-            success: engineResult.js.success,
-            errors: engineResult.js.errors.length > 0 ? engineResult.js.errors : undefined,
-            warnings: engineResult.js.warnings.length > 0 ? engineResult.js.warnings : undefined,
-          });
-          if (!engineResult.js.success) state.hasError = true;
-
-          // DTS 결과 처리
-          const diagnostics = engineResult.dts.diagnostics.map((d) => deserializeDiagnostic(d, fileCache));
-          results.push({
-            name,
-            target: config.target,
-            type: "dts",
-            success: engineResult.dts.success,
-            errors: engineResult.dts.errors.length > 0 ? engineResult.dts.errors : undefined,
+            type: "build",
+            success: engineResult.build.success,
+            errors: engineResult.build.errors.length > 0 ? engineResult.build.errors : undefined,
+            warnings: engineResult.build.warnings.length > 0 ? engineResult.build.warnings : undefined,
             diagnostics,
           });
-          if (!engineResult.dts.success) state.hasError = true;
+          if (!engineResult.build.success) state.hasError = true;
 
           // 린트 결과 처리
           if (engineResult.lint != null) {
@@ -289,7 +278,7 @@ export class BuildOrchestrator {
 
     // serverPackages: JS build + typecheck via BuildEngine
     for (const { name, config } of classified.serverPackages) {
-      const pkgDir = path.join(this._cwd, "packages", name);
+      const pkgDir = pathx.posixResolve(this._cwd, "packages", name);
 
       buildTasks.push(async () => {
         this._logger.debug(`[${name}] (server) 빌드 시작`);
@@ -301,28 +290,18 @@ export class BuildOrchestrator {
         try {
           const engineResult = await engine.run({ js: true, dts: false, lint: true });
 
-          // JS 빌드 결과 처리
+          // 빌드 결과 처리
+          const diagnostics = engineResult.build.diagnostics.map((d) => deserializeDiagnostic(d, fileCache));
           results.push({
             name,
             target: "server",
-            type: "js",
-            success: engineResult.js.success,
-            errors: engineResult.js.errors.length > 0 ? engineResult.js.errors : undefined,
-            warnings: engineResult.js.warnings.length > 0 ? engineResult.js.warnings : undefined,
-          });
-          if (!engineResult.js.success) state.hasError = true;
-
-          // DTS/타입체크 결과 처리
-          const diagnostics = engineResult.dts.diagnostics.map((d) => deserializeDiagnostic(d, fileCache));
-          results.push({
-            name,
-            target: "server",
-            type: "dts",
-            success: engineResult.dts.success,
-            errors: engineResult.dts.errors.length > 0 ? engineResult.dts.errors : undefined,
+            type: "build",
+            success: engineResult.build.success,
+            errors: engineResult.build.errors.length > 0 ? engineResult.build.errors : undefined,
+            warnings: engineResult.build.warnings.length > 0 ? engineResult.build.warnings : undefined,
             diagnostics,
           });
-          if (!engineResult.dts.success) state.hasError = true;
+          if (!engineResult.build.success) state.hasError = true;
 
           // 린트 결과 처리
           if (engineResult.lint != null) {
@@ -345,7 +324,7 @@ export class BuildOrchestrator {
 
     // clientPackages: Vite production build via ViteEngine (no dts)
     for (const { name, config } of classified.clientPackages) {
-      const pkgDir = path.join(this._cwd, "packages", name);
+      const pkgDir = pathx.posixResolve(this._cwd, "packages", name);
 
       buildTasks.push(async () => {
         this._logger.debug(`[${name}] (client) 빌드 시작`);
@@ -357,28 +336,18 @@ export class BuildOrchestrator {
         try {
           const engineResult = await engine.run({ js: true, dts: false, lint: true });
 
-          // JS 빌드 결과 처리
-          results.push({
-            name,
-            target: "client",
-            type: "js",
-            success: engineResult.js.success,
-            errors: engineResult.js.errors.length > 0 ? engineResult.js.errors : undefined,
-            warnings: engineResult.js.warnings.length > 0 ? engineResult.js.warnings : undefined,
-          });
-          if (!engineResult.js.success) state.hasError = true;
-
-          // DTS 결과 처리
-          const diagnostics = engineResult.dts.diagnostics.map((d) => deserializeDiagnostic(d, fileCache));
+          // 빌드 결과 처리
+          const diagnostics = engineResult.build.diagnostics.map((d) => deserializeDiagnostic(d, fileCache));
           results.push({
             name,
             target: "client",
-            type: "dts",
-            success: engineResult.dts.success,
-            errors: engineResult.dts.errors.length > 0 ? engineResult.dts.errors : undefined,
+            type: "build",
+            success: engineResult.build.success,
+            errors: engineResult.build.errors.length > 0 ? engineResult.build.errors : undefined,
+            warnings: engineResult.build.warnings.length > 0 ? engineResult.build.warnings : undefined,
             diagnostics,
           });
-          if (!engineResult.dts.success) state.hasError = true;
+          if (!engineResult.build.success) state.hasError = true;
 
           // 린트 결과 처리
           if (engineResult.lint != null) {
@@ -392,9 +361,9 @@ export class BuildOrchestrator {
             if (!engineResult.lint.success) state.hasError = true;
           }
 
-          // 네이티브 빌드 (JS 빌드 성공 시에만 실행)
-          if (engineResult.js.success) {
-            const distPath = path.join(pkgDir, "dist");
+          // 네이티브 빌드 (빌드 성공 시에만 실행)
+          if (engineResult.build.success) {
+            const distPath = pathx.posixResolve(pkgDir, "dist");
             const nativeBuildPromises: Array<Promise<void>> = [];
 
             if (config.capacitor != null) {
@@ -462,7 +431,7 @@ export class BuildOrchestrator {
     // 결과 출력
     const allDiagnostics: ts.Diagnostic[] = [];
     for (const result of results) {
-      const typeLabel = result.type === "dts" ? "dts" : result.type === "lint" ? "lint" : result.target;
+      const typeLabel = result.type === "lint" ? "lint" : result.target;
 
       // 경고 출력
       if (result.warnings != null) {

package/src/orchestrators/DevWatchOrchestrator.ts

@@ -1,7 +1,6 @@
-import path from "path";
 import { spawn, type ChildProcess } from "child_process";
 import { consola } from "consola";
-import { Worker, type WorkerProxy } from "@simplysm/core-node";
+import { Worker, type WorkerProxy, pathx } from "@simplysm/core-node";
 import { FsWatcher } from "@simplysm/core-node";
 import { err as errNs } from "@simplysm/core-common";
 import type {
@@ -12,7 +11,7 @@ import type {
   SdServerPackageConfig,
 } from "../sd-config.types";
 import { loadSdConfig } from "../utils/sd-config";
-import { discoverWorkspacePackages, filterPackagesByTargets, mergeTestsPackagesIntoConfig, validateTargets, classifyWatchPackages, classifyDevPackages } from "../utils/package-utils";
+import { filterPackagesByTargets, validateTargets, classifyWatchPackages, classifyDevPackages, buildPathMapFromConfig } from "../utils/package-utils";
 import { getVersion } from "../utils/build-env";
 import { watchReplaceDeps, type WatchReplaceDepResult } from "../utils/replace-deps";
 import { printErrors, printServers } from "../utils/output-utils";
@@ -72,6 +71,7 @@ export class DevWatchOrchestrator {
   private _baseEnv: { VER: string; DEV: string } | undefined;
   private readonly _serverRuntimeWorkers = new Map<string, WorkerProxy<typeof ServerRuntimeWorkerModule>>();
   private _printServersTimer: ReturnType<typeof setTimeout> | undefined;
+  private _serverRestartTimer: ReturnType<typeof setTimeout> | undefined;
 
   // Watchers
   private _copySrcWatchers: FsWatcher[] = [];
@@ -107,13 +107,11 @@ export class DevWatchOrchestrator {
       throw err;
     }
 
-    // Discover tests packages and merge into config
-    const workspacePackages = discoverWorkspacePackages(this._cwd);
-    const { merged, pathMap } = mergeTestsPackagesIntoConfig(sdConfig.packages, workspacePackages);
-    this._pathMap = pathMap;
+    // Build pathMap from config packages only (tests packages are excluded from watch/dev)
+    this._pathMap = buildPathMapFromConfig(sdConfig.packages);
 
     // Validate targets
-    validateTargets(this._options.targets, merged);
+    validateTargets(this._options.targets, sdConfig.packages);
 
     // Store replaceDeps for engine creation
     this._replaceDeps = sdConfig.replaceDeps;
@@ -130,7 +128,7 @@ export class DevWatchOrchestrator {
     }
 
     // Filter by targets
-    const allPackages = filterPackagesByTargets(merged, this._options.targets);
+    const allPackages = filterPackagesByTargets(sdConfig.packages, this._options.targets);
 
     // Classify packages based on mode
     if (this._options.mode === "watch") {
@@ -161,12 +159,12 @@ export class DevWatchOrchestrator {
 
     // Batch complete handler
     if (this._options.mode === "watch") {
-      this._rebuildManager.on("batchComplete", () => {
+      this._rebuildManager.on("batchComplete", (_completedKeys) => {
         printErrors(this._resultCollector.toMap());
       });
     } else {
-      this._rebuildManager.on("batchComplete", () => {
-        this._onDevBatchComplete();
+      this._rebuildManager.on("batchComplete", (completedKeys) => {
+        this._onDevBatchComplete(completedKeys);
       });
     }
 
@@ -223,8 +221,10 @@ export class DevWatchOrchestrator {
 
   async start(): Promise<void> {
     if (!this._hasPackages) {
+      this._logger.debug("대상 패키지 없음, start 건너뜀");
       return;
     }
+    this._logger.debug("start 시작");
 
     if (this._options.mode === "watch") {
       await this._startWatchMode();
@@ -244,6 +244,7 @@ export class DevWatchOrchestrator {
     if (!this._hasPackages) {
       return;
     }
+    this._logger.debug("shutdown 시작");
 
     process.stdout.write("⏳ 종료 중...\n");
 
@@ -280,6 +281,7 @@ export class DevWatchOrchestrator {
   // --- Watch mode ---
 
   private async _startWatchMode(): Promise<void> {
+    this._logger.debug("watch 모드 시작");
     // Start copySrc watchers for library packages
     for (const pkg of this._libraryPackages) {
       if (pkg.config.copySrc != null && pkg.config.copySrc.length > 0) {
@@ -295,7 +297,7 @@ export class DevWatchOrchestrator {
 
     const watchPromises = this._libraryEngines.map(async (engine, i) => {
       const pkgName = this._libraryPackages[i].name;
-      await engine.startWatch({ js: true, dts: true, lint: true });
+      await engine.startWatch({ js: true, dts: true, lint: false });
       completed++;
       this._logger.info(`  [${completed}/${total}] ${pkgName} 완료`);
     });
@@ -309,7 +311,7 @@ export class DevWatchOrchestrator {
     // Start watch hook watchers for scripts+watch packages
     for (const pkg of this._watchHookPackages) {
       const watchConfig = pkg.config.watch!;
-      const watchTargets = watchConfig.target.map((t) => path.resolve(pkg.dir, t));
+      const watchTargets = watchConfig.target.map((t) => pathx.posixResolve(pkg.dir, t));
 
       // Run initial hook
       this._runWatchHookCmd(pkg.name, pkg.dir, watchConfig.cmd, watchConfig.args);
@@ -355,14 +357,14 @@ export class DevWatchOrchestrator {
     for (const [name, engine] of this._clientEngines) {
       initialBuildPromises.push({
         name: `${name} (client)`,
-        promise: engine.startWatch({ js: true, dts: false, lint: true }),
+        promise: engine.startWatch({ js: true, dts: false, lint: false }),
       });
     }
 
     for (const [name, engine] of this._serverEngines) {
       initialBuildPromises.push({
         name: `${name} (server)`,
-        promise: engine.startWatch({ js: true, dts: false, lint: true }),
+        promise: engine.startWatch({ js: true, dts: false, lint: false }),
       });
     }
 
@@ -398,34 +400,13 @@ export class DevWatchOrchestrator {
       }
     }
 
-    // Start runtimes for successful initial builds
-    for (const { name, config } of this._serverPackages) {
-      const buildResult = this._resultCollector.get(`${name}:build`);
-      if (buildResult?.status === "success") {
-        const mainJsPath = path.join(this._cwd, "packages", name, "dist", "main.js");
-        const clientPorts = this._collectClientPorts(name);
-        try {
-          await this._startServerRuntime(name, mainJsPath, { ...this._baseEnv, ...config.env }, clientPorts);
-        } catch (err) {
-          this._logger.error(`[${name}] 서버 런타임 시작 실패:`, errNs.message(err));
-          this._resultCollector.add({
-            name,
-            target: "server",
-            type: "server",
-            status: "error",
-            message: errNs.message(err),
-          });
-        }
-      }
-    }
-
     // Start native apps for client packages with capacitor/electron config
     for (const { name, config } of this._clientPackages) {
       const port = this._getClientPort(name);
       if (port == null) continue;
 
       const devServerUrl = `http://localhost:${port}`;
-      const pkgDir = path.join(this._cwd, "packages", name);
+      const pkgDir = pathx.posixResolve(this._cwd, "packages", name);
 
       if (config.capacitor != null) {
         try {
@@ -466,12 +447,28 @@ export class DevWatchOrchestrator {
     printServers(this._resultCollector.toMap(), this._serverClientsMap);
   }
 
-  private _onDevBatchComplete(): void {
+  private _onDevBatchComplete(completedKeys: string[]): void {
+    this._logger.debug(`배치 완료 (${completedKeys.join(", ")})`);
+    const serverBuildKeys = this._serverPackages.map((p) => `${p.name}:build`);
+    if (!completedKeys.some((k) => serverBuildKeys.includes(k))) {
+      printErrors(this._resultCollector.toMap());
+      return;
+    }
+
+    if (this._serverRestartTimer != null) clearTimeout(this._serverRestartTimer);
+    this._serverRestartTimer = setTimeout(() => {
+      this._serverRestartTimer = undefined;
+      void this._restartServers();
+    }, 100);
+  }
+
+  private async _restartServers(): Promise<void> {
+    this._logger.debug("서버 재시작 시작");
     const restartPromises: Array<Promise<void>> = [];
     for (const { name, config } of this._serverPackages) {
       const buildResult = this._resultCollector.get(`${name}:build`);
       if (buildResult?.status === "success") {
-        const mainJsPath = path.join(this._cwd, "packages", name, "dist", "main.js");
+        const mainJsPath = pathx.posixResolve(this._cwd, "packages", name, "dist", "main.js");
         const clientPorts = this._collectClientPorts(name);
         restartPromises.push(
           this._startServerRuntime(name, mainJsPath, { ...this._baseEnv, ...config.env }, clientPorts)
@@ -488,10 +485,10 @@ export class DevWatchOrchestrator {
         );
       }
     }
-    void Promise.all(restartPromises).then(() => {
-      printErrors(this._resultCollector.toMap());
-      this._schedulePrintServers();
-    });
+    await Promise.all(restartPromises);
+    this._logger.debug("서버 재시작 완료");
+    printErrors(this._resultCollector.toMap());
+    this._schedulePrintServers();
   }
 
   private _schedulePrintServers(): void {

package/src/sd-cli-entry.ts

@@ -16,22 +16,12 @@ import fs from "fs";
 import { fileURLToPath } from "url";
 import { EventEmitter } from "node:events";
 import { consola, LogLevels } from "consola";
+import { SdCliReporter } from "./utils/SdCliReporter";
 
 Error.stackTraceLimit = Infinity;
 EventEmitter.defaultMaxListeners = 100;
 
-// consola 타임스탬프에 밀리초 포함
-for (const reporter of consola.options.reporters) {
-  const r = reporter as { formatDate?: (date: Date, opts: { date?: boolean }) => string };
-  if (typeof r.formatDate === "function") {
-    const orig = r.formatDate.bind(r);
-    r.formatDate = (date: Date, opts: { date?: boolean }) => {
-      const base = orig(date, opts);
-      if (base === "") return "";
-      return `${base}.${String(date.getMilliseconds()).padStart(3, "0")}`;
-    };
-  }
-}
+consola.options.reporters = [new SdCliReporter()];
 
 const COMMAND_NAMES = ["check", "watch", "dev", "build", "publish", "replace-deps"];
 

package/src/sd-cli.ts

@@ -7,7 +7,7 @@
  * .js execution (production): run replaceDeps then spawn sd-cli-entry in new process
  */
 
-import { execa } from "execa";
+import { cpx } from "@simplysm/core-node";
 import os from "os";
 import path from "path";
 import { fileURLToPath } from "url";
@@ -40,7 +40,7 @@ if (isDev) {
 
   // Phase 2: Run actual CLI in new process (reset module cache)
   const cliEntryFilePath = path.join(__dirname, "sd-cli-entry.js");
-  const subprocess = execa(
+  const subprocess = cpx.exec(
     "node",
     [
       "--max-old-space-size=8192",
@@ -52,7 +52,7 @@ if (isDev) {
   );
   if (subprocess.pid != null) configureAffinityAndPriority(subprocess.pid);
   const result = await subprocess;
-  process.exitCode = result.exitCode ?? 0;
+  process.exitCode = result.exitCode;
 }
 
 /**
@@ -94,8 +94,11 @@ function configureAffinityAndPriority(pid: number): void {
     command = `taskset -p ${mask} ${pid} && renice +10 -p ${pid}`;
   }
 
-  execa({ shell: true })`${command}`.catch((err: Error) => {
+  cpx.exec(command, [], { shell: true }).catch((err: unknown) => {
     // eslint-disable-next-line no-console
-    console.warn("Failed to configure CPU affinity/priority:", err.message);
+    console.warn(
+      "Failed to configure CPU affinity/priority:",
+      err instanceof Error ? err.message : String(err),
+    );
   });
 }

package/src/utils/SdCliReporter.ts

@@ -0,0 +1,177 @@
+import type { ConsolaReporter, LogObject, ConsolaOptions } from "consola";
+import { formatWithOptions } from "node:util";
+import { sep } from "node:path";
+
+// -- Constants ----------------------------------------------------------------
+
+const TYPE_ICONS: Record<string, string> = {
+  error: "✖",
+  fatal: "✖",
+  ready: "✔",
+  warn: "⚠",
+  info: "ℹ",
+  success: "✔",
+  debug: "⚙",
+  trace: "→",
+  fail: "✖",
+  start: "◐",
+  log: "",
+};
+
+type AnsiColor = "gray" | "red" | "green" | "yellow" | "cyan" | "magenta";
+
+const TYPE_COLORS: Record<string, AnsiColor | undefined> = {
+  info: "cyan",
+  fail: "red",
+  success: "green",
+  ready: "green",
+  start: "magenta",
+};
+
+const LEVEL_COLORS: Record<number, AnsiColor | undefined> = {
+  0: "red",
+  1: "yellow",
+};
+
+const ANSI_CODES: Record<AnsiColor, string> = {
+  gray: "\x1b[90m",
+  red: "\x1b[31m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  cyan: "\x1b[36m",
+  magenta: "\x1b[35m",
+};
+
+const ANSI_RESET = "\x1b[0m";
+
+// -- Helpers ------------------------------------------------------------------
+
+function colorize(color: AnsiColor, text: string, enabled: boolean): string {
+  if (!enabled) return text;
+  return `${ANSI_CODES[color]}${text}${ANSI_RESET}`;
+}
+
+function writeStream(data: string, stream: NodeJS.WritableStream): void {
+  const s = stream as NodeJS.WritableStream & { __write?: typeof stream.write };
+  const write = s.__write ?? s.write;
+  write.call(stream, data);
+}
+
+function detectColorSupport(): boolean {
+  if (process.env["NO_COLOR"] != null) return false;
+  if (process.env["FORCE_COLOR"] != null) return true;
+  if (process.stdout.isTTY === true) return true;
+  // 워커 스레드에서는 process.stdout.isTTY가 없음. Windows 터미널은 ANSI 지원.
+  return process.platform === "win32";
+}
+
+// -- Reporter -----------------------------------------------------------------
+
+interface FormatOpts {
+  date?: boolean;
+  colors: boolean;
+  compact?: boolean | number;
+  errorLevel?: number;
+}
+
+/**
+ * sd-cli 전용 consola reporter.
+ * 모든 로그를 `[tag] icon message     time` 형식으로 통일한다.
+ */
+export class SdCliReporter implements ConsolaReporter {
+  log(logObj: LogObject, ctx: { options: ConsolaOptions }): void {
+    const opts: FormatOpts = {
+      ...ctx.options.formatOptions,
+      colors: detectColorSupport(),
+    };
+
+    const line = this._formatLogObj(logObj, opts);
+    const stream =
+      logObj.level < 2
+        ? ctx.options.stderr ?? process.stderr
+        : ctx.options.stdout ?? process.stdout;
+
+    writeStream(line + "\n", stream);
+  }
+
+  private _formatLogObj(logObj: LogObject, opts: FormatOpts): string {
+    const formattedArgs = this._formatArgs(logObj.args, opts);
+    const [message, ...additional] = formattedArgs.split("\n");
+
+    if (logObj.type === "box") {
+      return this._formatBox(logObj, formattedArgs);
+    }
+
+    // Build: [tag] icon message time
+    const tag = logObj.tag !== "" ? colorize("gray", `[${logObj.tag}]`, opts.colors) : "";
+    const icon = this._formatIcon(logObj, opts.colors);
+    const date = this._formatDate(logObj.date, opts);
+    const coloredDate = date !== "" ? colorize("gray", date, opts.colors) : "";
+
+    let fullLine = [tag, icon, message, coloredDate].filter(Boolean).join(" ");
+
+    if (additional.length > 0) {
+      fullLine += "\n" + additional.join("\n");
+    }
+
+    if (logObj.type === "trace") {
+      const err = new Error("Trace: " + logObj.message);
+      fullLine += this._formatStack(err.stack ?? "", err.message);
+    }
+
+    const isBadge = (logObj as LogObject & { badge?: boolean }).badge ?? logObj.level < 2;
+    return isBadge ? "\n" + fullLine + "\n" : fullLine;
+  }
+
+  private _formatArgs(args: unknown[], opts: FormatOpts): string {
+    const processed = args.map((arg) => {
+      if (arg != null && typeof arg === "object" && typeof (arg as Error).stack === "string") {
+        return this._formatError(arg as Error, opts);
+      }
+      return arg;
+    });
+    return formatWithOptions({ colors: opts.colors, compact: opts.compact }, ...processed);
+  }
+
+  private _formatError(err: Error, opts: FormatOpts): string {
+    const message = err.message;
+    const stack = err.stack != null ? this._formatStack(err.stack, message, opts) : "";
+    const level = opts.errorLevel ?? 0;
+    const prefix = level > 0 ? `${"  ".repeat(level)}[cause]: ` : "";
+    const cause =
+      err.cause instanceof Error
+        ? "\n\n" + this._formatError(err.cause, { ...opts, errorLevel: level + 1 })
+        : "";
+    return prefix + message + "\n" + stack + cause;
+  }
+
+  private _formatStack(stack: string, message: string, opts?: FormatOpts): string {
+    const cwd = process.cwd() + sep;
+    const indent = "  ".repeat((opts?.errorLevel ?? 0) + 1);
+    const lines = stack
+      .split("\n")
+      .splice(message.split("\n").length)
+      .map((l) => l.trim().replace("file://", "").replace(cwd, ""));
+    return `\n${indent}` + lines.map((l) => `  ${l}`).join(`\n${indent}`);
+  }
+
+  private _formatIcon(logObj: LogObject, useColors: boolean): string {
+    const icon = TYPE_ICONS[logObj.type] ?? "";
+    if (icon === "") return "";
+    const color: AnsiColor = TYPE_COLORS[logObj.type] ?? LEVEL_COLORS[logObj.level] ?? "gray";
+    return colorize(color, icon, useColors);
+  }
+
+  private _formatDate(date: Date, opts: FormatOpts): string {
+    if (!opts.date) return "";
+    const base = date.toLocaleTimeString();
+    return `${base}.${String(date.getMilliseconds()).padStart(3, "0")}`;
+  }
+
+  private _formatBox(logObj: LogObject, message: string): string {
+    const tag = logObj.tag !== "" ? `[${logObj.tag}]` : "";
+    const title = (logObj as LogObject & { title?: string }).title;
+    const lines = [tag, title, ...message.split("\n")].filter(Boolean);
+    return "\n" + lines.map((l) => ` > ${l}`).join("\n") + "\n";
+  }
+}