@simplysm/sd-cli 14.0.29 → 14.0.32

package/src/orchestrators/TypecheckOrchestrator.ts

@@ -2,12 +2,14 @@ import ts from "typescript";
 import { err as errNs } from "@simplysm/core-common";
 import { pathx } from "@simplysm/core-node";
 import { consola } from "consola";
-import { loadSdConfig } from "../utils/sd-config";
-import { deserializeDiagnostic } from "../utils/typecheck-serialization";
-import { createBuildEngine } from "../engines/index";
-import { typecheckNonPackageFiles } from "../utils/typecheck-non-package";
+import { deserializeDiagnostic } from "../typecheck/typecheck-serialization";
+import { createTypecheckEngine } from "../engines/index";
+import { typecheckNonPackageFiles } from "../typecheck/typecheck-non-package";
 import { runWithConcurrency, getMaxConcurrency } from "../utils/concurrency";
 import { discoverWorkspacePackages, mergeTestsPackagesIntoConfig } from "../utils/package-utils";
+import { loadAndValidateConfig } from "../utils/orchestrator-utils";
+import { formatDiagnosticsOutput } from "../utils/diagnostic-utils";
+import type { OrchestratorLifecycle } from "./types";
 import type { EngineResult } from "../engines/types";
 import type { TypecheckEnv } from "../utils/tsconfig";
 import { toTypecheckEnvs } from "../utils/tsconfig";
@@ -72,10 +74,10 @@ function extractTargetPackageNames(targets: string[]): Set<string> {
 /**
  * 타입체크를 조율하는 Orchestrator
  *
- * BuildOrchestrator/DevWatchOrchestrator와 동일한 initialize() → start() → shutdown() 생명주기를 따른다.
+ * BuildOrchestrator/WatchOrchestrator/DevOrchestrator와 동일한 initialize() → start() → shutdown() 생명주기를 따른다.
  * sd.config.ts 기반으로 패키지를 분류하고, BuildEngine을 사용하여 타입체크를 실행한다.
  */
-export class TypecheckOrchestrator {
+export class TypecheckOrchestrator implements OrchestratorLifecycle<TypecheckResult> {
   private readonly _cwd: string;
   private readonly _options: TypecheckOptions;
   private readonly _logger = consola.withTag("sd:cli:typecheck");
@@ -104,8 +106,10 @@ export class TypecheckOrchestrator {
 
     this._logger.debug(`${phaseLabel} 시작`, { targets, lint: this._options.lint });
 
-    // sd.config.ts 로드
-    const sdConfig = await loadSdConfig({ cwd: this._cwd, dev: false, opt: this._options.options });
+    // sd.config.ts 로드 (targets=[] — check.ts에서 이미 검증 완료)
+    const sdConfig = await loadAndValidateConfig({
+      cwd: this._cwd, dev: false, options: this._options.options, targets: [],
+    });
     this._logger.debug("sd.config.ts 로드 완료");
 
     // 워크스페이스 패키지 탐색 및 tests/를 설정에 병합
@@ -131,15 +135,12 @@ export class TypecheckOrchestrator {
       if (targets.length > 0 && !targetNames.has(name)) continue;
 
       const relPath = pathMap.get(name) ?? `packages/${name}`;
-      // 클라이언트 패키지의 경우 browser 타겟을 사용하여 createBuildEngine이 ViteEngine 대신 NgtscEngine으로 라우팅되도록 함
-      const typecheckConfig =
-        config.target === "client" ? { target: "browser" as const } : config;
       const envs = toTypecheckEnvs(config.target);
       for (const env of envs) {
         this._typecheckTasks.push({
           name,
           dir: pathx.posixResolve(this._cwd, relPath),
-          config: typecheckConfig,
+          config,
           env,
         });
       }
@@ -159,11 +160,6 @@ export class TypecheckOrchestrator {
    */
   async start(): Promise<TypecheckResult> {
     const phaseLabel = this._options.lint === true ? "타입체크/린트" : "타입체크";
-    const formatHost: ts.FormatDiagnosticsHost = {
-      getCanonicalFileName: (f) => f,
-      getCurrentDirectory: () => this._cwd,
-      getNewLine: () => ts.sys.newLine,
-    };
 
     if (this._typecheckTasks.length === 0 && !this._includeNonPackage) {
       this._logger.info(`${phaseLabel} 대상 없음`);
@@ -177,123 +173,180 @@ export class TypecheckOrchestrator {
       };
     }
 
-    // 동시성 제한이 있는 BuildEngine 작업 생성
+    const fileCache = new Map<string, string>();
+    const packageResults = await this._executePackageTypechecks(fileCache, phaseLabel);
+    const nonPkgResults = this._executeNonPackageTypecheck(fileCache);
+    return this._aggregateTypecheckResults(packageResults, nonPkgResults, phaseLabel);
+  }
+
+  /**
+   * 패키지 타입체크 실행
+   * - 엔진 생성 및 동시성 제어된 실행
+   * - 결과 역직렬화 및 집계
+   */
+  private async _executePackageTypechecks(
+    fileCache: Map<string, string>,
+    phaseLabel: string,
+  ): Promise<{
+    allDiagnostics: ts.Diagnostic[];
+    totalErrorCount: number;
+    totalWarningCount: number;
+    lintErrorCount: number;
+    lintWarningCount: number;
+    lintSuccess: boolean;
+    lintOutputs: string[];
+  }> {
     const allDiagnostics: ts.Diagnostic[] = [];
     let totalErrorCount = 0;
     let totalWarningCount = 0;
-    const fileCache = new Map<string, string>();
-
-    // Lint 결과 집계
     let lintErrorCount = 0;
     let lintWarningCount = 0;
     let lintSuccess = true;
     const lintOutputs: string[] = [];
 
-    if (this._typecheckTasks.length > 0) {
-      const tasks = this._typecheckTasks.map((task) => async (): Promise<EngineResult> => {
-        const label = `${task.name}:${task.env}`;
-        const engine = createBuildEngine(
-          { name: task.name, dir: task.dir, config: task.config },
-          { cwd: this._cwd },
+    if (this._typecheckTasks.length === 0) {
+      return { allDiagnostics, totalErrorCount, totalWarningCount, lintErrorCount, lintWarningCount, lintSuccess, lintOutputs };
+    }
+
+    const tasks = this._typecheckTasks.map((task) => async (): Promise<EngineResult> => {
+      const label = `${task.name}:${task.env}`;
+      const engine = createTypecheckEngine(
+        { name: task.name, dir: task.dir, config: task.config },
+        { cwd: this._cwd },
+      );
+      try {
+        this._logger.debug(`[${label}] 타입체크 시작됨`);
+        const result = await engine.run({
+          js: false,
+          dts: false,
+          env: task.env,
+          includeTests: true,
+          ...(this._options.lint === true ? { lint: true } : {}),
+        });
+        this._logger.debug(
+          `[${label}] 타입체크 ${result.build.success ? "완료" : "실패"}`,
         );
-        try {
-          this._logger.debug(`[${label}] 타입체크 시작됨`);
-          const result = await engine.run({
-            js: false,
-            dts: false,
-            env: task.env,
-            includeTests: true,
-            ...(this._options.lint === true ? { lint: true } : {}),
-          });
-          this._logger.debug(
-            `[${label}] 타입체크 ${result.build.success ? "완료" : "실패"}`,
-          );
-          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}`);
-          }
-          return {
-            build: {
-              success: false,
-              errors: [`[${label}] ${message}`],
-              warnings: [],
-              diagnostics: [],
-            },
-          };
-        } finally {
-          await engine.stop();
+        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}`);
         }
-      });
+        return {
+          build: {
+            success: false,
+            errors: [`[${label}] ${message}`],
+            warnings: [],
+            diagnostics: [],
+          },
+        };
+      } finally {
+        await engine.stop();
+      }
+    });
 
-      const concurrency = getMaxConcurrency();
-      this._logger.start(
-        `${phaseLabel} 실행 중... (${tasks.length}개 작업, 동시성: ${concurrency})`,
+    const concurrency = getMaxConcurrency();
+    this._logger.start(
+      `${phaseLabel} 실행 중... (${tasks.length}개 작업, 동시성: ${concurrency})`,
+    );
+    const results = await runWithConcurrency(tasks, concurrency);
+    this._logger.success(`${phaseLabel} 실행 완료`);
+
+    // 엔진 결과 집계 (모든 task는 catch로 인해 항상 fulfilled)
+    for (const settled of results) {
+      if (settled.status !== "fulfilled") continue;
+      const engineResult = settled.value;
+      const buildDiags = engineResult.build.diagnostics.map((d) =>
+        deserializeDiagnostic(d, fileCache),
       );
-      const results = await runWithConcurrency(tasks, concurrency);
-      this._logger.success(`${phaseLabel} 실행 완료`);
-
-      // 엔진 결과 집계 (모든 task는 catch로 인해 항상 fulfilled)
-      for (const settled of results) {
-        if (settled.status !== "fulfilled") continue;
-        const engineResult = settled.value;
-        const buildDiags = engineResult.build.diagnostics.map((d) =>
-          deserializeDiagnostic(d, fileCache),
-        );
-        allDiagnostics.push(...buildDiags);
-        // 역직렬화된 진단 정보에서 에러/경고 수 집계
-        // 숫자 카테고리 값 사용 (ts.DiagnosticCategory: Error=1, Warning=0)
-        totalErrorCount += buildDiags.filter((d) => d.category === 1).length;
-        totalWarningCount += buildDiags.filter((d) => d.category === 0).length;
-        if (!engineResult.build.success && buildDiags.length === 0) {
-          for (const errMsg of engineResult.build.errors) {
-            allDiagnostics.push({
-              category: 1,
-              code: 0,
-              messageText: errMsg,
-              file: undefined,
-              start: undefined,
-              length: undefined,
-            });
-          }
-          totalErrorCount += engineResult.build.errors.length || 1;
+      allDiagnostics.push(...buildDiags);
+      totalErrorCount += buildDiags.filter((d) => d.category === 1).length;
+      totalWarningCount += buildDiags.filter((d) => d.category === 0).length;
+      if (!engineResult.build.success && buildDiags.length === 0) {
+        for (const errMsg of engineResult.build.errors) {
+          allDiagnostics.push({
+            category: 1,
+            code: 0,
+            messageText: errMsg,
+            file: undefined,
+            start: undefined,
+            length: undefined,
+          });
         }
+        totalErrorCount += engineResult.build.errors.length || 1;
+      }
 
-        // Lint 결과 수집
-        if (engineResult.lint != null) {
-          lintErrorCount += engineResult.lint.errorCount;
-          lintWarningCount += engineResult.lint.warningCount;
-          if (!engineResult.lint.success) lintSuccess = false;
-          if (engineResult.lint.formattedOutput !== "") {
-            lintOutputs.push(engineResult.lint.formattedOutput);
-          }
+      if (engineResult.lint != null) {
+        lintErrorCount += engineResult.lint.errorCount;
+        lintWarningCount += engineResult.lint.warningCount;
+        if (!engineResult.lint.success) lintSuccess = false;
+        if (engineResult.lint.formattedOutput !== "") {
+          lintOutputs.push(engineResult.lint.formattedOutput);
         }
       }
     }
 
-    // 비패키지 타입체크
-    if (this._includeNonPackage) {
-      this._logger.debug("비패키지 타입체크 실행 중");
-      const nonPkgResult = typecheckNonPackageFiles(this._cwd);
-      totalErrorCount += nonPkgResult.errorCount;
-      totalWarningCount += nonPkgResult.warningCount;
-      const nonPkgDiags = nonPkgResult.diagnostics.map((d) =>
-        deserializeDiagnostic(d, fileCache),
-      );
-      allDiagnostics.push(...nonPkgDiags);
+    return { allDiagnostics, totalErrorCount, totalWarningCount, lintErrorCount, lintWarningCount, lintSuccess, lintOutputs };
+  }
+
+  /**
+   * 비패키지 타입체크 실행 (sd.config.ts에 없는 루트 파일들)
+   */
+  private _executeNonPackageTypecheck(fileCache: Map<string, string>): {
+    diagnostics: ts.Diagnostic[];
+    errorCount: number;
+    warningCount: number;
+  } {
+    if (!this._includeNonPackage) {
+      return { diagnostics: [], errorCount: 0, warningCount: 0 };
     }
 
+    this._logger.debug("비패키지 타입체크 실행 중");
+    const nonPkgResult = typecheckNonPackageFiles(this._cwd);
+    const diagnostics = nonPkgResult.diagnostics.map((d) =>
+      deserializeDiagnostic(d, fileCache),
+    );
+    return {
+      diagnostics,
+      errorCount: nonPkgResult.errorCount,
+      warningCount: nonPkgResult.warningCount,
+    };
+  }
+
+  /**
+   * 타입체크 결과 집계 및 포맷 출력 생성
+   */
+  private _aggregateTypecheckResults(
+    packageResults: {
+      allDiagnostics: ts.Diagnostic[];
+      totalErrorCount: number;
+      totalWarningCount: number;
+      lintErrorCount: number;
+      lintWarningCount: number;
+      lintSuccess: boolean;
+      lintOutputs: string[];
+    },
+    nonPkgResults: {
+      diagnostics: ts.Diagnostic[];
+      errorCount: number;
+      warningCount: number;
+    },
+    phaseLabel: string,
+  ): TypecheckResult {
+    const allDiagnostics = [...packageResults.allDiagnostics, ...nonPkgResults.diagnostics];
+    const totalErrorCount = packageResults.totalErrorCount + nonPkgResults.errorCount;
+    const totalWarningCount = packageResults.totalWarningCount + nonPkgResults.warningCount;
+
     // 요약 로그
     const resultMeta: Record<string, number> = {
       errorCount: totalErrorCount,
       warningCount: totalWarningCount,
     };
     if (this._options.lint === true) {
-      resultMeta["lintErrorCount"] = lintErrorCount;
-      resultMeta["lintWarningCount"] = lintWarningCount;
+      resultMeta["lintErrorCount"] = packageResults.lintErrorCount;
+      resultMeta["lintWarningCount"] = packageResults.lintWarningCount;
     }
     if (totalErrorCount > 0) {
       this._logger.error(`${phaseLabel} 에러 발생`, resultMeta);
@@ -302,20 +355,16 @@ export class TypecheckOrchestrator {
     }
 
     // 진단 출력 포매팅
-    let formattedOutput = "";
-    if (allDiagnostics.length > 0) {
-      const uniqueDiagnostics = ts.sortAndDeduplicateDiagnostics(allDiagnostics);
-      formattedOutput = ts.formatDiagnosticsWithColorAndContext(uniqueDiagnostics, formatHost);
-    }
+    const formattedOutput = formatDiagnosticsOutput(allDiagnostics, this._cwd);
 
     // lint가 요청된 경우 lint 결과 생성
     const lintResult =
       this._options.lint === true
         ? {
-            success: lintSuccess,
-            errorCount: lintErrorCount,
-            warningCount: lintWarningCount,
-            formattedOutput: lintOutputs.join("\n"),
+            success: packageResults.lintSuccess,
+            errorCount: packageResults.lintErrorCount,
+            warningCount: packageResults.lintWarningCount,
+            formattedOutput: packageResults.lintOutputs.join("\n"),
           }
         : undefined;
 

package/src/orchestrators/WatchOrchestrator.ts

@@ -0,0 +1,203 @@
+import { spawn, type ChildProcess } from "child_process";
+import { FsWatcher, pathx } from "@simplysm/core-node";
+import type {
+  SdBuildPackageConfig,
+  SdConfig,
+  SdScriptsPackageConfig,
+} from "../sd-config.types";
+import { filterPackagesByTargets, classifyWatchPackages } from "../utils/package-classify";
+import { printErrors } from "../utils/output-utils";
+import { createBuildEngine, type BuildEngine, type BuildPackageInfo } from "../engines/index";
+import { watchCopySrcFiles } from "../utils/copy-src";
+import { BaseOrchestrator } from "./BaseOrchestrator";
+import type { OrchestratorLifecycle } from "./types";
+
+/**
+ * WatchOrchestrator 옵션
+ */
+export interface WatchOrchestratorOptions {
+  targets: string[];
+  options: string[];
+}
+
+/**
+ * watch 모드 전용 Orchestrator
+ *
+ * 라이브러리(JS+DTS) + Scripts(watch hook) + copySrc + replaceDeps 감시
+ */
+export class WatchOrchestrator extends BaseOrchestrator implements OrchestratorLifecycle {
+  private readonly _options: WatchOrchestratorOptions;
+
+  // watch 전용 상태
+  private readonly _libraryEngines: BuildEngine[] = [];
+  private _libraryPackages: BuildPackageInfo[] = [];
+  private _watchHookPackages: Array<{ name: string; dir: string; config: SdScriptsPackageConfig | SdBuildPackageConfig }> = [];
+  private _copySrcWatchers: FsWatcher[] = [];
+  private _distDeleteWatchers: FsWatcher[] = [];
+  private readonly _watchHookWatchers: FsWatcher[] = [];
+  private readonly _watchHookChildren = new Map<string, ChildProcess>();
+
+  constructor(options: WatchOrchestratorOptions) {
+    super("sd:cli:watch");
+    this._options = options;
+  }
+
+  override async initialize(): Promise<void> {
+    await super.initialize({
+      targets: this._options.targets,
+      options: this._options.options,
+      dev: true,
+    });
+  }
+
+  protected _initializeMode(
+    config: SdConfig,
+    targets: string[],
+  ): void {
+    // 대상으로 필터링
+    const allPackages = filterPackagesByTargets(config.packages, targets);
+
+    // watch 모드 패키지 분류
+    const classified = classifyWatchPackages(allPackages, this._cwd, this._pathMap);
+    this._libraryPackages = classified.libraryPackages;
+    this._watchHookPackages = classified.watchHookPackages;
+
+    // 처리할 패키지가 있는지 확인
+    const totalPackages = this._libraryPackages.length + this._watchHookPackages.length;
+    if (totalPackages === 0) {
+      process.stdout.write("⚠ 워치 대상 패키지가 없습니다.\n");
+      return;
+    }
+
+    this._hasPackages = true;
+  }
+
+  protected _initializeEngines(_config: SdConfig): void {
+    // 배치 완료 핸들러 등록
+    this._rebuildManager.on("batchComplete", (_completedKeys) => {
+      printErrors(this._resultCollector.toMap());
+    });
+
+    // 라이브러리 패키지용 BuildEngine 생성
+    for (const pkg of this._libraryPackages) {
+      const engine = createBuildEngine(pkg, {
+        cwd: this._cwd,
+        replaceDeps: this._replaceDeps,
+        resultCollector: this._resultCollector,
+        rebuildManager: this._rebuildManager,
+      });
+      this._libraryEngines.push(engine);
+    }
+  }
+
+  async start(): Promise<void> {
+    if (!this._hasPackages) {
+      this._logger.debug("대상 패키지 없음, start 건너뜀");
+      return;
+    }
+    this._logger.debug("watch 모드 시작");
+
+    // 라이브러리 패키지 dist 삭제 감지 워처
+    for (const pkg of this._libraryPackages) {
+      const distDir = pathx.posixResolve(pkg.dir, "dist");
+      const watcher = await FsWatcher.watch([distDir]);
+      watcher.onChange({ delay: 100 }, (changes) => {
+        for (const c of changes) {
+          if (c.event === "unlink" || c.event === "unlinkDir") {
+            this._logger.error(`[dist-delete:${pkg.name}] ${c.event}: ${c.path}\n${new Error().stack}`);
+          }
+        }
+      });
+      this._distDeleteWatchers.push(watcher);
+    }
+
+    // Start copySrc watchers for library packages
+    for (const pkg of this._libraryPackages) {
+      if (pkg.config.copySrc != null && pkg.config.copySrc.length > 0) {
+        const watcher = await watchCopySrcFiles(pkg.dir, pkg.config.copySrc);
+        this._copySrcWatchers.push(watcher);
+      }
+    }
+
+    // Start all engines
+    const total = this._libraryEngines.length;
+    this._logger.start(`초기 빌드 실행 중... (${total}개 패키지)`);
+    let completed = 0;
+
+    const watchPromises = this._libraryEngines.map(async (engine, i) => {
+      const pkgName = this._libraryPackages[i].name;
+      await engine.startWatch({ js: true, dts: true, lint: false });
+      completed++;
+      this._logger.info(`  [${completed}/${total}] ${pkgName} 완료`);
+    });
+
+    await Promise.allSettled(watchPromises);
+    this._logger.success("초기 빌드 실행 완료");
+
+    // Print initial build results
+    printErrors(this._resultCollector.toMap());
+
+    // 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) => pathx.posixResolve(pkg.dir, t));
+
+      // Run initial hook
+      this._runWatchHookCmd(pkg.name, pkg.dir, watchConfig.cmd, watchConfig.args);
+
+      // Start watching
+      const watcher = await FsWatcher.watch(watchTargets);
+      watcher.onChange({ delay: 300 }, () => {
+        this._runWatchHookCmd(pkg.name, pkg.dir, watchConfig.cmd, watchConfig.args);
+      });
+      this._watchHookWatchers.push(watcher);
+
+      this._logger.success(`워치 훅 시작됨: ${pkg.name}`);
+    }
+  }
+
+  protected async _shutdownMode(): Promise<void> {
+    const shutdownTasks: Array<Promise<void>> = [];
+
+    // 모든 엔진 중지
+    shutdownTasks.push(...this._libraryEngines.map((e) => e.stop()));
+
+    // 워처 종료
+    shutdownTasks.push(...this._copySrcWatchers.map((w) => w.close()));
+    shutdownTasks.push(...this._distDeleteWatchers.map((w) => w.close()));
+    shutdownTasks.push(...this._watchHookWatchers.map((w) => w.close()));
+
+    // hook 자식 프로세스 종료
+    for (const child of this._watchHookChildren.values()) {
+      if (child.exitCode == null) {
+        child.kill();
+      }
+    }
+    this._watchHookChildren.clear();
+
+    await Promise.all(shutdownTasks);
+    this._copySrcWatchers = [];
+    this._distDeleteWatchers = [];
+    this._watchHookWatchers.length = 0;
+  }
+
+  private _runWatchHookCmd(pkgName: string, cwd: string, cmd: string, args?: string[]): void {
+    // Kill previous hook process if still running
+    const prev = this._watchHookChildren.get(pkgName);
+    if (prev != null && prev.exitCode == null) {
+      prev.kill();
+    }
+
+    const child = spawn(cmd, args ?? [], { cwd, stdio: "inherit", shell: true });
+    this._watchHookChildren.set(pkgName, child);
+
+    child.on("error", (err) => {
+      this._logger.error(`[${pkgName}] 워치 훅 에러: ${err.message}`);
+    });
+    child.on("close", (code) => {
+      if (code !== 0 && code !== null) {
+        this._logger.warn(`[${pkgName}] 워치 훅이 코드 ${String(code)}로 종료됨`);
+      }
+    });
+  }
+}

package/src/orchestrators/types.ts

@@ -0,0 +1,18 @@
+/**
+ * Orchestrator 공통 생명주기 인터페이스
+ *
+ * 모든 Orchestrator(Build, Watch, Dev, Typecheck)가 따르는 계약.
+ * initialize() → start() → shutdown() 순서로 호출한다.
+ *
+ * @typeParam TStartResult start()의 반환 타입. 기본값 void.
+ */
+export interface OrchestratorLifecycle<TStartResult = void> {
+  /** 초기화: config 로드, 패키지 분류, 엔진 생성 등 */
+  initialize(): Promise<void>;
+
+  /** 실행: 빌드/타입체크/watch 시작 */
+  start(): Promise<TStartResult>;
+
+  /** 종료: 리소스 정리 */
+  shutdown(): Promise<void>;
+}

package/src/{utils → runtime}/engine-stop.ts

@@ -1,5 +1,5 @@
 /**
- * 빌드 엔진(BaseEngine, ViteEngine)의 공유 중지 로직.
+ * 빌드 엔진(BaseEngine, EsbuildClientEngine)의 공유 중지 로직.
  *
  * 엔진 구현체 간 shutdown 타임아웃 + stopWatch 경쟁 + terminate
  * 패턴의 중복을 방지하기 위해 추출하였다.