@simplysm/sd-cli 14.1.9 → 14.1.10

package/src/deps/replace-deps/replace-deps-resolve.ts

@@ -3,6 +3,7 @@ import path from "path";
 import { glob } from "glob";
 import type { ConsolaInstance } from "consola";
 import { fsx, pathx } from "@simplysm/core-node";
+import { collectWorkspacePackages } from "../../utils/workspace-utils";
 
 /**
  * replaceDeps 설정의 glob 패턴을 대상 패키지 목록과 매칭하여
@@ -44,45 +45,6 @@ export function resolveReplaceDepEntries(
   return results;
 }
 
-/**
- * pnpm-workspace.yaml 내용을 파싱하여 워크스페이스 패키지 glob 배열을 반환한다.
- * 별도 YAML 라이브러리 없이 간단한 줄 파싱으로 처리한다.
- *
- * @param content - pnpm-workspace.yaml 파일 내용
- * @returns glob 패턴 배열 (예: ["packages/*", "tools/*"])
- */
-export function parseWorkspaceGlobs(content: string): string[] {
-  const lines = content.split("\n");
-  const globs: string[] = [];
-  let inPackages = false;
-
-  for (const line of lines) {
-    const trimmed = line.trim();
-
-    if (trimmed === "packages:") {
-      inPackages = true;
-      continue;
-    }
-
-    // packages 섹션의 목록 항목
-    if (inPackages && trimmed.startsWith("- ")) {
-      const value = trimmed
-        .slice(2)
-        .trim()
-        .replace(/^["']|["']$/g, "");
-      globs.push(value);
-      continue;
-    }
-
-    // 다른 섹션이 시작되면 종료
-    if (inPackages && trimmed !== "" && !trimmed.startsWith("#")) {
-      break;
-    }
-  }
-
-  return globs;
-}
-
 /**
  * replaceDeps 복사/교체 항목
  */
@@ -97,26 +59,21 @@ export interface ReplaceDepEntry {
 /**
  * 프로젝트 루트 및 워크스페이스 패키지 경로를 수집한다.
  *
- * pnpm-workspace.yaml을 파싱하여 워크스페이스 패키지의 절대 경로를 수집한다.
- * 파일이 없거나 파싱 실패 시 루트 경로만 반환한다.
+ * package.json#workspaces를 기준으로 워크스페이스 패키지의 절대 경로를 수집한다.
+ * 설정이 없거나 파싱 실패 시 루트 경로만 반환한다.
  *
  * @param projectRoot - 프로젝트 루트 경로
  * @returns [루트, ...워크스페이스 패키지 경로] 배열
  */
-export async function collectSearchRoots(projectRoot: string): Promise<string[]> {
-  const searchRoots = [projectRoot];
+export function collectSearchRoots(projectRoot: string): string[] {
+  const root = pathx.posix(projectRoot);
+  const searchRoots: string[] = [root];
 
-  const workspaceYamlPath = pathx.posix(path.join(projectRoot, "pnpm-workspace.yaml"));
   try {
-    const yamlContent = await fsx.read(workspaceYamlPath);
-    const workspaceGlobs = parseWorkspaceGlobs(yamlContent);
-
-    for (const pattern of workspaceGlobs) {
-      const dirs = await fsx.glob(pattern, { cwd: projectRoot });
-      searchRoots.push(...dirs);
-    }
+    const workspacePackages = collectWorkspacePackages(root);
+    searchRoots.push(...workspacePackages.map((item) => item.absPath));
   } catch {
-    // pnpm-workspace.yaml이 존재하지 않으면 루트만 처리
+    // workspace 설정이 없거나 파싱할 수 없으면 루트만 처리
   }
 
   return searchRoots;
@@ -125,7 +82,7 @@ export async function collectSearchRoots(projectRoot: string): Promise<string[]>
 /**
  * replaceDeps 설정에서 모든 교체 대상 항목을 해결한다.
  *
- * 1. pnpm-workspace.yaml 파싱 → 워크스페이스 패키지 경로
+ * 1. package.json#workspaces 파싱 → 워크스페이스 패키지 경로
  * 2. [루트, ...워크스페이스 패키지] node_modules에서 매칭 패키지 탐색
  * 3. 패턴 매칭 + 소스 경로 존재 확인 + symlink 해결
  *
@@ -144,7 +101,7 @@ export async function resolveAllReplaceDepEntries(
   const searchedDirs = new Set<string>();
 
   // 초기 탐색 대상: 프로젝트 루트 + workspace 패키지들의 node_modules
-  const searchRoots = await collectSearchRoots(projectRoot);
+  const searchRoots = collectSearchRoots(projectRoot);
   const pendingDirs: string[] = searchRoots.map((root) =>
     pathx.posix(path.join(root, "node_modules")),
   );
@@ -188,7 +145,7 @@ export async function resolveAllReplaceDepEntries(
         continue;
       }
 
-      // targetPath가 symlink이면 실제 .pnpm 저장소 경로로 해결
+      // targetPath가 symlink이면 실제 패키지 저장소 경로로 해결
       let actualTargetPath = targetPath;
       try {
         const stat = await fs.promises.lstat(targetPath);
@@ -199,7 +156,7 @@ export async function resolveAllReplaceDepEntries(
         // targetPath가 존재하지 않으면 그대로 사용
       }
 
-      // 동일 actualTargetPath가 이미 등록된 경우 건너뜀 (pnpm 중복 방지)
+      // 동일 actualTargetPath가 이미 등록된 경우 건너뜀
       if (seenTargetPaths.has(actualTargetPath)) continue;
       seenTargetPaths.add(actualTargetPath);
 

package/src/deps/replace-deps/replace-deps.ts

@@ -32,7 +32,7 @@ async function isFileContentSame(pathA: string, pathB: string): Promise<boolean>
 }
 
 /**
- * pnpm hard link를 끊으면서 파일/디렉토리를 복사한다.
+ * package manager hard link를 끊으면서 파일/디렉토리를 복사한다.
  * 대상 파일을 먼저 unlink하여 글로벌 store의 hard link를 끊고 새 파일을 생성한다.
  * 다른 프로젝트의 node_modules에 영향을 주지 않기 위함이다.
  */
@@ -160,7 +160,7 @@ export interface WatchReplaceDepResult {
 /**
  * replaceDeps 설정에 따라 node_modules의 패키지를 소스 디렉토리로 교체한다.
  *
- * 1. pnpm-workspace.yaml 파싱 → 워크스페이스 패키지 경로
+ * 1. package.json#workspaces 파싱 → 워크스페이스 패키지 경로
  * 2. [루트, ...워크스페이스 패키지] node_modules에서 매칭 패키지 탐색
  * 3. 소스 package.json의 files 필드 + npm 기본 파일만 대상 경로에 복사 (package.json 제외)
  *
@@ -207,7 +207,7 @@ export async function setupReplaceDeps(
 /**
  * replaceDeps 설정에 따라 소스 디렉토리를 감시하고 변경사항을 대상 경로에 복사한다.
  *
- * 1. pnpm-workspace.yaml 파싱 → 워크스페이스 패키지 경로
+ * 1. package.json#workspaces 파싱 → 워크스페이스 패키지 경로
  * 2. [루트, ...워크스페이스 패키지] node_modules에서 매칭 패키지 탐색
  * 3. FsWatcher로 files 항목 경로만 감시 (300ms 딜레이)
  * 4. 변경사항을 대상 경로에 복사

package/src/deps/server-externals/server-production-files.ts

@@ -29,30 +29,43 @@ export function collectAllExternals(
   };
 }
 
+interface BunLockFile {
+  packages?: Record<string, unknown>;
+}
+
+function parsePackageReferenceVersion(reference: string): string | undefined {
+  const normalized = reference.split("(")[0];
+  const match = /^(.+?)@(\d[^@]*)$/.exec(normalized);
+  return match?.[2];
+}
+
+function parsePackageKeyName(key: string): string {
+  const match = /^(.+?)@(\d.+)$/.exec(key);
+  return match?.[1] ?? key;
+}
+
 /**
- * pnpm-lock.yaml의 packages 섹션을 파싱하여 name→version 맵을 생성한다.
- * 키 형태: "name@version" · "@scope/name@version" · "name@version(peer@ver)..."
+ * bun.lock의 packages 섹션을 파싱하여 name→version 맵을 생성한다.
+ * 키 형태는 일반 패키지명 또는 alias이고, 실제 버전은 package entry의 resolution에서 확인한다.
  */
 export function parseLockfileVersions(cwd: string): Map<string, string> {
-  const lockfilePath = path.join(cwd, "pnpm-lock.yaml");
+  const lockfilePath = path.join(cwd, "bun.lock");
   if (!fsx.existsSync(lockfilePath)) {
-    throw new Error(`pnpm-lock.yaml not found in ${cwd}. Run "pnpm install" first.`);
+    throw new Error(`bun.lock not found in ${cwd}. Run "bun install" first.`);
   }
 
   const content = fsx.readSync(lockfilePath);
-  const parsed = YAML.parse(content) as { packages?: Record<string, unknown> };
+  const parsed = YAML.parse(content) as BunLockFile;
   const map = new Map<string, string>();
 
-  for (const key of Object.keys(parsed.packages ?? {})) {
-    // 첫 번째 @숫자 기준으로 name / version 분리 (scope 패키지의 선두 @ 보존)
-    const m = /^(.+?)@(\d.+)$/.exec(key);
-    if (m == null) continue;
-    const name = m[1];
-    // peerDep suffix "(peer@ver)..." 제거
-    const parenIdx = m[2].indexOf("(");
-    const version = parenIdx === -1 ? m[2] : m[2].substring(0, parenIdx);
-    if (!map.has(name)) {
-      map.set(name, version);
+  for (const [key, entry] of Object.entries(parsed.packages ?? {})) {
+    if (!Array.isArray(entry) || typeof entry[0] !== "string") continue;
+    const version = parsePackageReferenceVersion(entry[0]);
+    if (version == null) continue;
+
+    const keyName = parsePackageKeyName(key);
+    if (!map.has(keyName)) {
+      map.set(keyName, version);
     }
   }
 
@@ -60,7 +73,7 @@ export function parseLockfileVersions(cwd: string): Map<string, string> {
 }
 
 /**
- * pnpm-lock.yaml에서 주어진 모든 패키지의 잠긴 버전을 확인한다.
+ * bun.lock에서 주어진 모든 패키지의 잠긴 버전을 확인한다.
  * lockfile에서 패키지를 찾을 수 없으면 에러를 던진다.
  */
 export function resolveLockedVersions(cwd: string, pkgNames: string[]): Record<string, string> {
@@ -70,8 +83,8 @@ export function resolveLockedVersions(cwd: string, pkgNames: string[]): Record<s
     const version = versionMap.get(name);
     if (version == null) {
       throw new Error(
-        `External dependency "${name}" not found in pnpm-lock.yaml. ` +
-          `Run "pnpm install" and try again.`,
+        `External dependency "${name}" not found in bun.lock. ` +
+          `Run "bun install" and try again.`,
       );
     }
     result[name] = version;

package/src/electron/electron.ts

@@ -68,20 +68,14 @@ export class Electron {
     await this._setupNpmConf();
     Electron._logger.debug("package.json 설정 완료");
 
-    // pnpm-workspace.yaml 생성 (상위 workspace 탐색 차단)
-    const workspaceYamlPath = pathx.posixResolve(this._srcPath, "pnpm-workspace.yaml");
-    if (!(await fsx.exists(workspaceYamlPath))) {
-      await fsx.write(workspaceYamlPath, "");
-    }
-
-    Electron._logger.debug("pnpm install 시작");
-    await this._exec("pnpm", ["install", "--config.dangerously-allow-all-builds=true"], this._srcPath);
-    Electron._logger.debug("pnpm install 완료");
+    Electron._logger.debug("bun install 시작");
+    await this._exec("bun", ["install"], this._srcPath);
+    Electron._logger.debug("bun install 완료");
 
     const reinstallDeps = this._config.reinstallDependencies ?? [];
     if (reinstallDeps.length > 0) {
       Electron._logger.debug(`electron-rebuild 시작 (${reinstallDeps.join(", ")})`);
-      await this._exec("pnpm", ["exec", "electron-rebuild"], this._srcPath);
+      await this._exec("bun", ["run", "electron-rebuild"], this._srcPath);
       Electron._logger.debug("electron-rebuild 완료");
     }
     Electron._logger.success("initialize 완료");
@@ -102,7 +96,7 @@ export class Electron {
 
     const spawnElectron = () => {
       Electron._logger.debug("Electron 프로세스 시작");
-      currentElectron = shellSpawn("pnpm", ["exec", "electron", "."], {
+      currentElectron = shellSpawn("bun", ["run", "electron", "."], {
         cwd: this._srcPath,
         stdio: "inherit",
         reject: false,
@@ -385,8 +379,8 @@ export class Electron {
 
     Electron._logger.debug(`electron-builder 설정: ${configFilePath}`);
     await this._exec(
-      "pnpm",
-      ["exec", "electron-builder", "--win", "--config", configFilePath],
+      "bun",
+      ["run", "electron-builder", "--win", "--config", configFilePath],
       this._srcPath,
     );
   }

package/src/engines/BaseEngine.ts

@@ -21,7 +21,7 @@ export interface CommonBuildWorkerEvents extends Record<string, unknown> {
     build: { success: boolean; errors?: string[]; warnings?: string[] };
     lint?: LintWithProgramResult;
   };
-  error: { message: string };
+  error: { message: string; stack?: string };
 }
 
 /**
@@ -180,7 +180,8 @@ export abstract class BaseEngine<
     });
 
     this._callStartWatch(output).catch((err: unknown) => {
-      logger.debug(`[${this._pkg.name}] startWatch 실패:`, errNs.message(err));
+      logger.debug(`[${this._pkg.name}] startWatch 실패: ${errNs.message(err)}`);
+      logger.debug(`[${this._pkg.name}] startWatch 실패 스택:\n${errNs.stack(err)}`);
       this._resultCollector?.add({
         name: this._pkg.name,
         target: this._getTarget(),

package/src/esbuild/esbuild-config.ts

@@ -7,18 +7,27 @@ import { addJsExtensionToImports } from "../utils/output-path-rewriter";
 
 const logger = createLogger("sd:cli:esbuild-config");
 
+export interface WriteChangedOutputFilesOptions {
+  /** .js 파일의 확장자 없는 상대 import/export 경로에 .js를 붙일지 여부 */
+  rewriteJsExtensions?: boolean;
+}
+
 /**
  * esbuild outputFiles에서 변경된 파일만 디스크에 쓴다.
  *
- * - .js 파일: 비교 전 ESM 상대 import 경로에 .js 확장자를 추가한다
+ * - .js 파일: 기본적으로 비교 전 ESM 상대 import 경로에 .js 확장자를 추가한다
  * - 기타 파일(.js.map 등): 원본 내용을 그대로 비교한다
  * - 기존 파일과 내용이 동일하면 타임스탬프 보존을 위해 쓰기를 스킵한다
  */
-export async function writeChangedOutputFiles(outputFiles: esbuild.OutputFile[]): Promise<void> {
+export async function writeChangedOutputFiles(
+  outputFiles: esbuild.OutputFile[],
+  options?: WriteChangedOutputFilesOptions,
+): Promise<void> {
+  const rewriteJsExtensions = options?.rewriteJsExtensions ?? true;
   logger.debug(`변경된 출력 파일 쓰기 시작 (${outputFiles.length}개)`);
   await Promise.all(
     outputFiles.map(async (file) => {
-      const finalText = file.path.endsWith(".js")
+      const finalText = file.path.endsWith(".js") && rewriteJsExtensions
         ? addJsExtensionToImports(file.text)
         : file.text;
 

package/src/esbuild/esbuild-tsc-plugin.ts

@@ -1,12 +1,14 @@
 import type esbuild from "esbuild";
 import type ts from "typescript";
-import { err as errNs } from "@simplysm/core-common";
+import { createLogger, err as errNs } from "@simplysm/core-common";
 import { SdTsCompiler } from "../ts-compiler/SdTsCompiler";
 import type { ISdTsCompilerResult } from "../ts-compiler/sd-ts-compiler-result";
 import type { SerializedDiagnostic } from "../typecheck/typecheck-serialization";
 import type { LintWithProgramResult } from "../lint/lint-with-program";
 import type { TypecheckEnv } from "../utils/tsconfig";
 
+const logger = createLogger("sd:cli:esbuild-tsc-plugin");
+
 export interface TscPluginOptions {
   pkgDir: string;
   cwd: string;
@@ -69,6 +71,7 @@ export function createTscPlugin(options: TscPluginOptions): TscPluginResult {
           lastErrors = result.errors;
           lastLintResult = result.lint;
         } catch (err) {
+          logger.debug(`tsc plugin 예외 스택:\n${errNs.stack(err)}`);
           lastProgram = undefined;
           lastAffectedFiles = undefined;
           lastDiagnostics = [];

package/src/orchestrators/BaseOrchestrator.ts

@@ -57,6 +57,7 @@ export abstract class BaseOrchestrator {
       this._logger.debug("sd.config.ts 로드 완료");
     } catch (err) {
       this._logger.error(`sd.config.ts 로드 실패: ${errNs.message(err)}`);
+      this._logger.debug(`sd.config.ts 로드 실패 스택:\n${errNs.stack(err)}`);
       process.exitCode = 1;
       throw err;
     }

package/src/orchestrators/BuildOrchestrator.ts

@@ -152,6 +152,7 @@ export class BuildOrchestrator implements OrchestratorLifecycle<boolean> {
       this._logger.debug("sd.config.ts 로드 완료");
     } catch (err) {
       this._logger.error(`sd.config.ts 로드 실패: ${errNs.message(err)}`);
+      this._logger.debug(`sd.config.ts 로드 실패 스택:\n${errNs.stack(err)}`);
       process.exitCode = 1;
       throw err;
     }
@@ -238,13 +239,10 @@ export class BuildOrchestrator implements OrchestratorLifecycle<boolean> {
     for (const settledResult of buildResults) {
       if (settledResult.status === "rejected") {
         const err = settledResult.reason;
-        const stack = err instanceof Error ? err.stack : undefined;
         this._logger.error("빌드 중 예기치 않은 에러", {
-          error: String(err),
+          error: errNs.message(err),
         });
-        if (stack != null) {
-          this._logger.debug(`빌드 예외 스택:\n${stack}`);
-        }
+        this._logger.debug(`빌드 예외 스택:\n${errNs.stack(err)}`);
         hasUntrackedError.value = true;
       }
     }

package/src/orchestrators/DevOrchestrator.ts

@@ -246,6 +246,7 @@ export class DevOrchestrator extends BaseOrchestrator implements OrchestratorLif
             onServerReady: () => this._schedulePrintServers(),
           }).catch((err: unknown) => {
             this._logger.error(`[${name}] 서버 런타임 시작 실패:`, errNs.message(err));
+            this._logger.debug(`[${name}] 서버 런타임 시작 실패 스택:\n${errNs.stack(err)}`);
             this._resultCollector.add({
               name,
               target: "server",

package/src/orchestrators/ServerRuntimeManager.ts

@@ -52,6 +52,9 @@ export class ServerRuntimeManager {
     });
 
     runtimeWorker.on("error", (errorData) => {
+      if (errorData.stack != null) {
+        this._logger.debug(`[${params.serverName}] 서버 런타임 에러 스택:\n${errorData.stack}`);
+      }
       params.resultCollector.add({
         name: params.serverName,
         target: "server",
@@ -65,6 +68,7 @@ export class ServerRuntimeManager {
       .start({ mainJsPath: params.mainJsPath, clientPorts: params.clientPorts, env: params.env })
       .catch((err: unknown) => {
         this._logger.error(`[${params.serverName}] 서버 런타임 워커 비정상 종료:`, errNs.message(err));
+        this._logger.debug(`[${params.serverName}] 서버 런타임 워커 비정상 종료 스택:\n${errNs.stack(err)}`);
         params.resultCollector.add({
           name: params.serverName,
           target: "server",

package/src/orchestrators/TypecheckOrchestrator.ts

@@ -51,12 +51,13 @@ export interface TypecheckResult {
 
 //#region Utilities
 
-const TARGET_PATH_PATTERN = /^(?:packages|tests)\/([^/]+)/;
+const TARGET_PATH_PATTERN = /^[^/]+\/([^/]+)/;
 
 /**
- * 대상 경로에서 패키지명을 추출한다.
+ * 대상 경로에서 패키지명을 추출한다. 워크스페이스 종류(packages/·tests/·plugins/ 등)를 가리지 않는다.
  * "packages/core-common" → "core-common"
  * "tests/orm" → "orm"
+ * "plugins/sd" → "sd"
  */
 function extractTargetPackageNames(targets: string[]): Set<string> {
   const names = new Set<string>();
@@ -229,11 +230,8 @@ export class TypecheckOrchestrator implements OrchestratorLifecycle<TypecheckRes
         return result;
       } catch (err) {
         const message = errNs.message(err);
-        const stack = err instanceof Error ? err.stack : undefined;
         this._logger.error(`[${label}] 엔진 작업 실패: ${message}`);
-        if (stack != null) {
-          this._logger.debug(`[${label}] 스택 트레이스:\n${stack}`);
-        }
+        this._logger.debug(`[${label}] 스택 트레이스:\n${errNs.stack(err)}`);
         return {
           build: {
             success: false,

package/src/runtime/engine-watch-events.ts

@@ -1,6 +1,9 @@
+import { createLogger } from "@simplysm/core-common";
 import type { BuildResult, ResultCollector } from "../runtime/ResultCollector";
 import type { RebuildManager } from "./rebuild-manager";
 
+const logger = createLogger("sd:cli:watch-events");
+
 /**
  * worker.on()으로 이벤트를 구독할 수 있는 최소 인터페이스
  */
@@ -84,7 +87,10 @@ export function setupWatchEvents(
   });
 
   worker.on("error", (data: unknown) => {
-    const event = data as { message: string };
+    const event = data as { message: string; stack?: string };
+    if (event.stack != null) {
+      logger.debug(`[${name}] 워커 에러 스택:\n${event.stack}`);
+    }
 
     const buildResult: BuildResult = {
       name,

package/src/runtime/worker-events.ts

@@ -8,6 +8,7 @@ export interface BuildEventData {
 /** 워커 에러 이벤트 데이터 */
 export interface ErrorEventData {
   message: string;
+  stack?: string;
 }
 
 /** 워커 서버 준비 완료 이벤트 데이터 */

package/src/sd-cli-entry.ts

@@ -12,7 +12,6 @@ import { runInit } from "./commands/init/init";
 import { runInitClient } from "./commands/init/init-client";
 import { runPublish } from "./commands/publish/publish-command";
 import { runReplaceDeps } from "./commands/replace-deps";
-import { runReinstall } from "./commands/reinstall";
 import path from "path";
 import fs from "fs";
 import { fileURLToPath } from "url";
@@ -286,14 +285,6 @@ export function createCliParser(argv: string[]): Argv {
         });
       },
     )
-    .command(
-      "reinstall",
-      "Clean reinstall: delete node_modules/lock/dist/.cache then reinstall with build approval",
-      (cmd) => cmd.version(false).hide("help"),
-      async () => {
-        await runReinstall();
-      },
-    )
     .command(
       "init [kind]",
       "Bootstrap a new SI workspace via interactive prompts (kind=client: add a client package to an existing workspace)",

package/src/sd-cli.ts

@@ -44,6 +44,7 @@ if (isDev) {
       const code = err instanceof Error && "code" in err ? (err as NodeJS.ErrnoException).code : undefined;
       if (code !== "MODULE_NOT_FOUND" && code !== "ERR_MODULE_NOT_FOUND") {
         logger.warn("replaceDeps 사전 설정 실패:", errNs.message(err));
+        logger.debug(`replaceDeps 사전 설정 실패 스택:\n${errNs.stack(err)}`);
       }
     }
   }
@@ -109,5 +110,6 @@ function configureAffinityAndPriority(pid: number): void {
       "CPU affinity/priority 설정 실패:",
       errNs.message(err),
     );
+    logger.debug(`CPU affinity/priority 설정 실패 스택:\n${errNs.stack(err)}`);
   });
 }

package/src/typecheck/typecheck-non-package.ts

@@ -3,6 +3,7 @@ import ts from "typescript";
 import { pathx } from "@simplysm/core-node";
 import { createLogger } from "@simplysm/core-common";
 import { parseTsconfig } from "../utils/tsconfig";
+import { collectWorkspacePackages } from "../utils/workspace-utils";
 import { serializeDiagnostic, type SerializedDiagnostic } from "./typecheck-serialization";
 
 const logger = createLogger("sd:cli:typecheck-non-pkg");
@@ -27,10 +28,20 @@ export function typecheckNonPackageFiles(cwd: string): NonPackageTypecheckResult
   const parsedConfig = parseTsconfig(cwd);
   const packagesDir = path.join(cwd, "packages");
 
+  // packages/(배포 대상)가 아닌 워크스페이스(tests/·plugins/·향후 추가분)는 각자 엔진 타입체크가
+  // 자기 tsconfig로 담당하므로 루트 sweep에서 제외한다. 루트 tsconfig로 검사하면 그 워크스페이스
+  // 고유 옵션(allowImportingTsExtensions 등)이 무시돼 거짓 에러가 난다. 디렉터리명에 의존하지 않는다.
+  const nonDeployWorkspaceDirs = collectWorkspacePackages(cwd)
+    .filter((ws) => !ws.relPath.startsWith("packages/"))
+    .map((ws) => pathx.posixResolve(ws.absPath) + "/");
+
   const isNonPackageFile = (fileName: string): boolean => {
     const normalized = pathx.posixResolve(fileName);
     const normalizedPkgDir = pathx.posixResolve(packagesDir);
 
+    // packages/ 가 아닌 워크스페이스 파일 → 엔진이 자기 tsconfig로 담당, sweep 제외
+    if (nonDeployWorkspaceDirs.some((dir) => normalized.startsWith(dir))) return false;
+
     // packages/ 디렉토리 외부 파일
     if (!normalized.startsWith(normalizedPkgDir + "/")) return true;
 

package/src/utils/package-utils.ts

@@ -3,6 +3,7 @@ import fs from "fs";
 import { SdError } from "@simplysm/core-common";
 import { fsx, pathx } from "@simplysm/core-node";
 import { createLogger } from "@simplysm/core-common";
+import { collectWorkspacePackages } from "./workspace-utils";
 import type {
   SdPackageConfig,
 } from "../sd-config.types";
@@ -19,26 +20,31 @@ export function findPackageRoot(startDir: string): string {
 }
 
 /**
- * packages/ 및 tests/ 디렉토리에서 모든 워크스페이스 패키지를 탐색한다.
- * 디렉토리명 → 상대 경로의 맵을 반환한다 (예: "orm" → "tests/orm").
+ * package.json#workspaces의 모든 워크스페이스 패키지를 탐색한다.
+ * 디렉토리명 → 상대 경로의 맵을 반환한다 (예: "orm" → "tests/orm", "sd" → "plugins/sd").
+ * packages/·tests/·plugins/ 등 종류를 가리지 않고 포함하며, 배포/검사 대상 구분은 소비자가 relPath로 판단한다.
  */
 export function discoverWorkspacePackages(cwd: string): Map<string, string> {
   logger.debug("워크스페이스 패키지 탐색 시작");
   const map = new Map<string, string>();
-  for (const dir of ["packages", "tests"]) {
-    const baseDir = pathx.posix(path.join(cwd, dir));
-    if (!fs.existsSync(baseDir)) continue;
-    for (const entry of fs.readdirSync(baseDir, { withFileTypes: true })) {
-      if (!entry.isDirectory()) continue;
-      if (!fs.existsSync(pathx.posix(path.join(baseDir, entry.name, "package.json")))) continue;
-      if (map.has(entry.name)) {
-        throw new SdError(
-          `Duplicate workspace package name: ${entry.name} (${map.get(entry.name)} and ${dir}/${entry.name})`,
-        );
-      }
-      map.set(entry.name, `${dir}/${entry.name}`);
+
+  const workspacePackages = (() => {
+    try {
+      return collectWorkspacePackages(cwd);
+    } catch {
+      return [];
+    }
+  })();
+
+  for (const item of workspacePackages) {
+    if (map.has(item.dirName)) {
+      throw new SdError(
+        `Duplicate workspace package name: ${item.dirName} (${map.get(item.dirName)} and ${item.relPath})`,
+      );
     }
+    map.set(item.dirName, item.relPath);
   }
+
   logger.debug(`워크스페이스 패키지 탐색 완료 (${map.size}개)`);
   return map;
 }
@@ -57,27 +63,28 @@ export function buildPathMapFromConfig(
 }
 
 /**
- * workspace에서 발견된 tests/ 패키지를 sd.config.ts 패키지에 병합한다.
- * tests 패키지는 기본적으로 `{ target: "node" }`가 할당된다.
- * 모든 패키지의 pathMap(name → 상대 경로)도 함께 구성한다.
- * tests 패키지명이 sd.config.ts 패키지명과 충돌하면 SdError를 던진다.
+ * workspace에서 발견된 비배포 워크스페이스(packages/ 가 아닌 tests/·plugins/ 등)를 sd.config.ts
+ * 패키지에 병합한다. 이들은 빌드 대상이 아니지만 각자 자기 tsconfig로 타입체크하기 위해
+ * `{ target: "node" }`가 할당된다. 모든 패키지의 pathMap(name → 상대 경로)도 함께 구성한다.
+ * 디렉터리명이 sd.config.ts 패키지명과 충돌하면 SdError를 던진다.
+ * 특정 디렉터리명이 아니라 "packages/ 인가"로만 갈라 새 워크스페이스 종류도 자동 포함된다.
  */
 export function mergeTestsPackagesIntoConfig(
   configPackages: Record<string, SdPackageConfig | undefined>,
   workspacePackages: Map<string, string>,
 ): { merged: Record<string, SdPackageConfig | undefined>; pathMap: Map<string, string> } {
-  logger.debug("tests 패키지 병합 시작");
+  logger.debug("비배포 워크스페이스 병합 시작");
   const pathMap = new Map<string, string>();
   const merged: Record<string, SdPackageConfig | undefined> = { ...configPackages };
 
-  // config 패키지의 기본 경로 설정
+  // config 패키지(배포 대상)의 기본 경로 설정
   for (const name of Object.keys(configPackages)) {
     pathMap.set(name, `packages/${name}`);
   }
 
-  // tests 패키지 추가
+  // packages/(배포 대상)가 아닌 워크스페이스 추가
   for (const [name, relPath] of workspacePackages) {
-    if (!relPath.startsWith("tests/")) continue;
+    if (relPath.startsWith("packages/")) continue;
 
     if (name in configPackages) {
       throw new SdError(
@@ -89,7 +96,7 @@ export function mergeTestsPackagesIntoConfig(
     pathMap.set(name, relPath);
   }
 
-  logger.debug(`tests 패키지 병합 완료 (총 ${Object.keys(merged).length}개)`);
+  logger.debug(`비배포 워크스페이스 병합 완료 (총 ${Object.keys(merged).length}개)`);
   return { merged, pathMap };
 }