@simplysm/sd-cli 12.13.13 → 12.13.15

package/src/pkg-builders/commons/build-runner.base.ts

@@ -1,11 +1,20 @@
 import { EventEmitter } from "events";
-import { FsUtils, ISdFsWatcherChangeInfo, PathUtils, SdFsWatcher, SdLogger, TNormPath } from "@simplysm/sd-core-node";
+import {
+  FsUtils,
+  ISdFsWatcherChangeInfo,
+  PathUtils,
+  SdFsWatcher,
+  SdLogger,
+  TNormPath,
+} from "@simplysm/sd-core-node";
 import { ISdProjectConfig, TSdPackageConfig } from "../../types/config.types";
 import { ISdBuildMessage, ISdBuildRunnerResult } from "../../types/build.types";
 import path from "path";
 import { ScopePathSet } from "./scope-path";
 
-export abstract class BuildRunnerBase<T extends "server" | "library" | "client"> extends EventEmitter {
+export abstract class BuildRunnerBase<
+  T extends "server" | "library" | "client",
+> extends EventEmitter {
   protected abstract _logger: SdLogger;
 
   protected _pkgName: string;
@@ -24,6 +33,8 @@ export abstract class BuildRunnerBase<T extends "server" | "library" | "client">
     projConf: ISdProjectConfig,
     protected _pkgPath: TNormPath,
     workspaceGlobs: string[],
+    protected _emitOnly: boolean,
+    protected _noEmit: boolean,
   ) {
     super();
 
@@ -31,24 +42,27 @@ export abstract class BuildRunnerBase<T extends "server" | "library" | "client">
     this._pkgConf = projConf.packages[this._pkgName] as TSdPackageConfig<T>;
 
     const workspacePaths = workspaceGlobs
-      .map((item) => PathUtils.posix(this._pkgPath, "../../", item))
+      .map((item) => PathUtils.posix(this._pkgPath, "../../", item, "src"))
       .mapMany((item) => FsUtils.glob(item));
-    const localUpdatePaths = Object.keys(projConf.localUpdates ?? {}).mapMany((key) =>
-      FsUtils.glob(path.resolve(this._pkgPath, "../../node_modules", key)),
-    );
+    const localUpdatePaths = Object.keys(projConf.localUpdates ?? {}).mapMany((key) => [
+      ...FsUtils.glob(path.resolve(this._pkgPath, "../../node_modules", key, "dist")),
+      ...FsUtils.glob(path.resolve(this._pkgPath, "../../node_modules", key, "src/**/*.scss")),
+    ]);
     this._watchScopePathSet = new ScopePathSet(
       [...workspacePaths, ...localUpdatePaths].map((item) => PathUtils.norm(item)),
     );
   }
 
   async buildAsync(): Promise<ISdBuildRunnerResult> {
-    const distPath = path.resolve(this._pkgPath, "dist");
-    if (FsUtils.exists(distPath)) {
-      this._debug("dist 초기화...");
-      FsUtils.remove(distPath);
+    if (!this._noEmit) {
+      const distPath = path.resolve(this._pkgPath, "dist");
+      if (FsUtils.exists(distPath)) {
+        this._debug("dist 초기화...");
+        FsUtils.remove(distPath);
+      }
     }
 
-    const result = await this._runAsync(false);
+    const result = await this._runAsync(false, false, false);
     return {
       affectedFilePathSet: result.affectedFileSet,
       buildMessages: result.buildMessages,
@@ -59,13 +73,19 @@ export abstract class BuildRunnerBase<T extends "server" | "library" | "client">
   async watchAsync() {
     this.emit("change");
 
-    const distPath = path.resolve(this._pkgPath, "dist");
-    if (FsUtils.exists(distPath)) {
-      this._debug("dist 초기화...");
-      FsUtils.remove(distPath);
+    if (!this._noEmit) {
+      const distPath = path.resolve(this._pkgPath, "dist");
+      if (FsUtils.exists(distPath)) {
+        this._debug("dist 초기화...");
+        FsUtils.remove(distPath);
+      }
     }
 
-    const result = await this._runAsync(!this._pkgConf.forceProductionMode);
+    const result = await this._runAsync(
+      !this._pkgConf.forceProductionMode,
+      this._emitOnly,
+      this._noEmit,
+    );
     const res: ISdBuildRunnerResult = {
       affectedFilePathSet: result.affectedFileSet,
       buildMessages: result.buildMessages,
@@ -77,17 +97,17 @@ export abstract class BuildRunnerBase<T extends "server" | "library" | "client">
     let lastWatchFileSet = result.watchFileSet;
     SdFsWatcher.watch(this._watchScopePathSet.toArray(), {
       ignore: (filePath) =>
-        filePath === path.resolve(this._pkgPath, ".cache") ||
-        filePath === path.resolve(this._pkgPath, ".cordova") ||
-        filePath === path.resolve(this._pkgPath, ".electron") ||
-        filePath === path.resolve(this._pkgPath, "dist") ||
-        (this._pkgConf.type === "client" && filePath === path.resolve(this._pkgPath, "src", "routes.ts")) ||
+        (this._pkgConf.type === "client" &&
+          path.dirname(path.basename(filePath)) === "src" &&
+          path.basename(filePath) === `routes.ts`) ||
         (this._pkgConf.type === "library" &&
           this._pkgConf.dbContext != null &&
-          filePath === path.resolve(this._pkgPath, "src", `${this._pkgConf.dbContext}.ts`)) ||
+          path.dirname(path.basename(filePath)) === "src" &&
+          path.basename(filePath) === `${this._pkgConf.dbContext}.ts`) ||
         (this._pkgConf.type === "library" &&
           !this._pkgConf.noGenIndex &&
-          filePath === path.resolve(this._pkgPath, "src", "index.ts")),
+          path.dirname(path.basename(filePath)) === "src" &&
+          path.basename(filePath) === "index.ts"),
     }).onChange({ delay: 100 }, async (changeInfos) => {
       const modifiedFileSet = this._getModifiedFileSet(changeInfos, lastWatchFileSet);
 
@@ -97,7 +117,12 @@ export abstract class BuildRunnerBase<T extends "server" | "library" | "client">
 
       let watchResult: IBuildRunnerRunResult;
       try {
-        watchResult = await this._runAsync(!this._pkgConf.forceProductionMode, modifiedFileSet);
+        watchResult = await this._runAsync(
+          !this._pkgConf.forceProductionMode,
+          this._emitOnly,
+          this._noEmit,
+          modifiedFileSet,
+        );
 
         lastWatchFileSet = watchResult.watchFileSet;
       } catch (err) {
@@ -126,18 +151,38 @@ export abstract class BuildRunnerBase<T extends "server" | "library" | "client">
     });
   }
 
-  protected _getModifiedFileSet(changeInfos: ISdFsWatcherChangeInfo[], lastWatchFileSet?: Set<TNormPath>) {
-    return new Set(
-      (lastWatchFileSet
-        ? changeInfos.filter((item) =>
-            Array.from(lastWatchFileSet).some((item1) => item.path.startsWith(path.dirname(item1))),
+  protected _getModifiedFileSet(
+    changeInfos: ISdFsWatcherChangeInfo[],
+    lastWatchFileSet?: Set<TNormPath>,
+  ) {
+    if (!lastWatchFileSet) {
+      return new Set(changeInfos.map((item) => item.path));
+    } else {
+      return new Set(
+        changeInfos
+          .filter(
+            (item) =>
+              Array.from(lastWatchFileSet).some((item1) =>
+                item.path.startsWith(path.dirname(item1)),
+              ) ||
+              ((this._pkgConf.type === "client" ||
+                (this._pkgConf.type === "library" && this._pkgConf.dbContext != null) ||
+                (this._pkgConf.type === "library" && this._pkgConf.noGenIndex)) &&
+                item.path.startsWith(path.resolve(this._pkgPath, "src")) &&
+                item.path.endsWith(".ts") &&
+                item.event === "add"),
           )
-        : changeInfos
-      ).map((item) => item.path),
-    );
+          .map((item) => item.path),
+      );
+    }
   }
 
-  protected abstract _runAsync(dev: boolean, modifiedFileSet?: Set<TNormPath>): Promise<IBuildRunnerRunResult>;
+  protected abstract _runAsync(
+    dev: boolean,
+    emitOnly: boolean,
+    noEmit: boolean,
+    modifiedFileSet?: Set<TNormPath>,
+  ): Promise<IBuildRunnerRunResult>;
 
   protected _debug(msg: string): void {
     this._logger.debug(`[${path.basename(this._pkgPath)}] ${msg}`);

package/src/pkg-builders/lib/sd-js-lib.build-runner.ts

@@ -16,11 +16,25 @@ export class SdJsLibBuildRunner extends BuildRunnerBase<"library"> {
 
   protected override async _runAsync(
     dev: boolean,
+    emitOnly: boolean,
+    noEmit: boolean,
     modifiedFileSet?: Set<TNormPath>,
   ): Promise<IBuildRunnerRunResult> {
-    const filePathSet = modifiedFileSet ?? new Set(
-      FsUtils.glob(path.resolve(this._pkgPath, "src/**/*.js")).map(item => PathUtils.norm(item)),
-    );
+    if (emitOnly) {
+      return {
+        affectedFileSet: new Set(),
+        buildMessages: [],
+        emitFileSet: new Set(),
+      };
+    }
+
+    const filePathSet =
+      modifiedFileSet ??
+      new Set(
+        FsUtils.glob(path.resolve(this._pkgPath, "src/**/*.js")).map((item) =>
+          PathUtils.norm(item),
+        ),
+      );
 
     this._debug("LINT...");
 
@@ -38,10 +52,13 @@ export class SdJsLibBuildRunner extends BuildRunnerBase<"library"> {
 
   protected override _getModifiedFileSet(changeInfos: ISdFsWatcherChangeInfo[]) {
     return new Set(
-      changeInfos.filter((item) =>
-        FsUtils.exists(item.path)
-        && PathUtils.isChildPath(item.path, path.resolve(this._pkgPath, "src")),
-      ).map(item => item.path),
+      changeInfos
+        .filter(
+          (item) =>
+            FsUtils.exists(item.path) &&
+            PathUtils.isChildPath(item.path, path.resolve(this._pkgPath, "src")),
+        )
+        .map((item) => item.path),
     );
   }
 

package/src/pkg-builders/lib/sd-ts-lib.build-runner.ts

@@ -14,59 +14,53 @@ export class SdTsLibBuildRunner extends BuildRunnerBase<"library"> {
   #hasGenIndexError = false;
   #hasGenDbContextError = false;
 
-  protected override async _runAsync(dev: boolean, modifiedFileSet?: Set<TNormPath>): Promise<IBuildRunnerRunResult> {
-    /*if (!modifiedFileSet) {
-      if (!dev) {
-        if (!this._pkgConf.noGenIndex) {
-          this._debug("GEN index.ts...");
-          this.#indexFileGenerator.run(this._pkgPath, this._pkgConf.polyfills);
-        }
-
-        if (this._pkgConf.dbContext != null) {
-          this._debug(`GEN ${this._pkgConf.dbContext}.ts...`);
-          this.#dbContextGenerator.run(this._pkgPath, this._pkgConf.dbContext);
-        }
-      } else {
-        if (!this._pkgConf.noGenIndex) {
-          this._debug("Watch for GEN index.ts...");
-          this.#indexFileGenerator.watch(this._pkgPath, this._pkgConf.polyfills);
-        }
-
-        if (this._pkgConf.dbContext != null) {
-          this._debug(`Watch for GEN ${this._pkgConf.dbContext}.ts...`);
-          this.#dbContextGenerator.watch(this._pkgPath, this._pkgConf.dbContext);
-        }
-      }
-    }*/
-
+  protected override async _runAsync(
+    dev: boolean,
+    emitOnly: boolean,
+    noEmit: boolean,
+    modifiedFileSet?: Set<TNormPath>,
+  ): Promise<IBuildRunnerRunResult> {
     let indexFileNPath: TNormPath | undefined;
-    if (!this._pkgConf.noGenIndex) {
-      this._debug("GEN index.ts...");
-      const genIndexResult = this.#indexFileGenerator.run(this._pkgPath, this._pkgConf.polyfills);
-      if (modifiedFileSet && (genIndexResult.changed || this.#hasGenIndexError)) {
-        modifiedFileSet.add(PathUtils.norm(genIndexResult.filePath));
+    let dbContentFileNPath: TNormPath | undefined;
+    if (!noEmit) {
+      if (!this._pkgConf.noGenIndex) {
+        this._debug("GEN index.ts...");
+        const genIndexResult = this.#indexFileGenerator.run(this._pkgPath, this._pkgConf.polyfills);
+        if (modifiedFileSet && (genIndexResult.changed || this.#hasGenIndexError)) {
+          modifiedFileSet.add(PathUtils.norm(genIndexResult.filePath));
+        }
+        indexFileNPath = PathUtils.norm(genIndexResult.filePath);
       }
-      indexFileNPath = PathUtils.norm(genIndexResult.filePath);
-    }
 
-    let dbContentFileNPath: TNormPath | undefined;
-    if (this._pkgConf.dbContext != null) {
-      this._debug(`GEN ${this._pkgConf.dbContext}.ts...`);
-      const genDbContextResult = this.#dbContextGenerator.run(this._pkgPath, this._pkgConf.dbContext);
-      if (modifiedFileSet && (genDbContextResult.changed || this.#hasGenDbContextError)) {
-        modifiedFileSet.add(PathUtils.norm(genDbContextResult.filePath));
+      if (this._pkgConf.dbContext != null) {
+        this._debug(`GEN ${this._pkgConf.dbContext}.ts...`);
+        const genDbContextResult = this.#dbContextGenerator.run(
+          this._pkgPath,
+          this._pkgConf.dbContext,
+        );
+        if (modifiedFileSet && (genDbContextResult.changed || this.#hasGenDbContextError)) {
+          modifiedFileSet.add(PathUtils.norm(genDbContextResult.filePath));
+        }
+        dbContentFileNPath = PathUtils.norm(genDbContextResult.filePath);
       }
-      dbContentFileNPath = PathUtils.norm(genDbContextResult.filePath);
     }
 
     this._debug(`BUILD...`);
-    this.#builder ??= new SdTsLibBuilder(PathUtils.norm(this._pkgPath), dev, this._watchScopePathSet);
+    this.#builder ??= new SdTsLibBuilder(
+      PathUtils.norm(this._pkgPath),
+      dev,
+      emitOnly,
+      noEmit,
+      this._watchScopePathSet,
+    );
     const buildResult = await this.#builder.buildAsync(modifiedFileSet ?? new Set());
 
     this.#hasGenIndexError =
-      indexFileNPath != null && buildResult.results.map((item) => item.filePath).includes(indexFileNPath);
+      indexFileNPath != null &&
+      buildResult.results.map((item) => item.filePath).includes(indexFileNPath);
     this.#hasGenDbContextError =
-      dbContentFileNPath != null && buildResult.results.map((item) => item.filePath).includes(dbContentFileNPath);
+      dbContentFileNPath != null &&
+      buildResult.results.map((item) => item.filePath).includes(dbContentFileNPath);
 
     this._debug(`빌드 완료`);
     const watchFileSet = new Set(

package/src/pkg-builders/lib/sd-ts-lib.builder.ts

@@ -12,12 +12,16 @@ export class SdTsLibBuilder {
   constructor(
     private readonly _pkgPath: TNormPath,
     dev: boolean,
+    emitOnly: boolean,
+    noEmit: boolean,
     watchScopePathSet: ScopePathSet,
   ) {
     this.#tsCompiler = new SdTsCompiler({
       pkgPath: this._pkgPath,
       additionalOptions: { declaration: true },
       isDevMode: dev,
+      isEmitOnly: emitOnly,
+      isNoEmit: noEmit,
       globalStyleFilePath: PathUtils.norm(this._pkgPath, "src/styles.scss"),
       isForBundle: false,
       watchScopePathSet,

package/src/pkg-builders/sd-multi.build-runner.ts

@@ -20,6 +20,8 @@ export class SdMultiBuildRunner extends EventEmitter {
       worker?: SdWorker<TServerWorkerType>; // persist
       port?: number; // run server result
       hasChanges: boolean;
+
+      clientPath?: string;
       clientChangedFileSet: Set<string>;
 
       // from client
@@ -28,6 +30,7 @@ export class SdMultiBuildRunner extends EventEmitter {
         {
           buildTypes: ("web" | "electron" | "cordova")[];
           path: string;
+          changedFileSet: Set<string>;
         }
       >; // persist
     }
@@ -43,8 +46,9 @@ export class SdMultiBuildRunner extends EventEmitter {
   async runAsync(req: ISdBuildRunnerWorkerRequest & { cmd: "watch" }): Promise<void>;
   async runAsync(req: ISdBuildRunnerWorkerRequest & { cmd: "build" }): Promise<ISdBuildMessage[]>;
   async runAsync(req: ISdBuildRunnerWorkerRequest): Promise<ISdBuildMessage[] | void> {
-    const worker = new SdWorker<TSdBuildRunnerWorkerType>(import.meta.resolve(
-      "../workers/build-runner.worker"))
+    const worker = new SdWorker<TSdBuildRunnerWorkerType>(
+      import.meta.resolve("../workers/build-runner.worker"),
+    )
       .on("change", () => {
         if (this.#busyCount === 0) {
           this.emit("change");
@@ -81,135 +85,161 @@ export class SdMultiBuildRunner extends EventEmitter {
   #onComplete(req: ISdBuildRunnerWorkerRequest, result: ISdBuildRunnerResult) {
     this.#resultCache.delete(req.pkgPath);
     for (const affectedFilePath of result.affectedFilePathSet) {
-      if (PathUtils.isChildPath(affectedFilePath, req.pkgPath)) {
-        this.#resultCache.delete(affectedFilePath);
-      }
+      this.#resultCache.delete(affectedFilePath);
     }
 
     for (const buildMessage of result.buildMessages) {
-      const cacheItem = this.#resultCache.getOrCreate(buildMessage.filePath ?? req.pkgPath, []);
-      cacheItem.push(buildMessage);
+      if (!buildMessage.filePath || PathUtils.isChildPath(buildMessage.filePath, req.pkgPath)) {
+        const cacheItem = this.#resultCache.getOrCreate(buildMessage.filePath ?? req.pkgPath, []);
+        cacheItem.push(buildMessage);
+      }
     }
 
-    const pkgConf = req.projConf.packages[path.basename(req.pkgPath)]!;
+    if (req.noEmit) {
+      setTimeout(() => {
+        this.#busyCount--;
+        if (this.#busyCount === 0) {
+          const messages = Array.from(this.#resultCache.values()).mapMany();
+          this.emit("complete", messages);
+        }
+      }, 300);
+    } else {
+      const pkgConf = req.projConf.packages[path.basename(req.pkgPath)]!;
 
-    if (pkgConf.type === "server") {
-      const pkgName = path.basename(req.pkgPath);
-      const serverInfo = this.#serverInfoMap.getOrCreate(pkgName, {
-        hasChanges: true,
-        clientChangedFileSet: new Set(),
-        clients: {},
-      });
+      if (pkgConf.type === "server") {
+        const pkgName = path.basename(req.pkgPath);
+        const serverInfo = this.#serverInfoMap.getOrCreate(pkgName, {
+          hasChanges: true,
+          clientChangedFileSet: new Set(),
+          clients: {},
+        });
 
-      const serverPkgConf = req.projConf.packages[pkgName] as ISdServerPackageConfig;
-      serverInfo.pkgInfo = {
-        path: req.pkgPath,
-        conf: serverPkgConf,
-      };
+        const serverPkgConf = req.projConf.packages[pkgName] as ISdServerPackageConfig;
+        serverInfo.pkgInfo = {
+          path: req.pkgPath,
+          conf: serverPkgConf,
+        };
 
-      serverInfo.hasChanges = true;
-    }
-    else if (pkgConf.type === "client") {
-      const pkgName = path.basename(req.pkgPath);
+        serverInfo.hasChanges = true;
+      } else if (pkgConf.type === "client") {
+        const pkgName = path.basename(req.pkgPath);
+
+        if (pkgConf.server != null) {
+          const serverInfo = this.#serverInfoMap.getOrCreate(
+            typeof pkgConf.server === "string" ? pkgConf.server : pkgConf.server.port.toString(),
+            {
+              hasChanges: true,
+              clientChangedFileSet: new Set(),
+              clients: {},
+            },
+          );
+
+          if (typeof pkgConf.server !== "string") {
+            serverInfo.pkgInfo = pkgConf.server;
+          }
 
-      if (pkgConf.server !== undefined) {
-        const serverInfo = this.#serverInfoMap.getOrCreate(
-          typeof pkgConf.server === "string" ? pkgConf.server : pkgConf.server.port.toString(),
-          {
+          serverInfo.clients[pkgName] = {
+            path: path.resolve(req.pkgPath, "dist"),
+            buildTypes: (pkgConf.builder ? Object.keys(pkgConf.builder) : ["web"]) as any,
+            changedFileSet: result.emitFileSet,
+          };
+        } else {
+          const serverInfo = this.#serverInfoMap.getOrCreate(pkgName, {
             hasChanges: true,
+            clientPath: path.resolve(req.pkgPath, "dist"),
             clientChangedFileSet: new Set(),
             clients: {},
-          },
-        );
+          });
 
-        if (typeof pkgConf.server !== "string") {
-          serverInfo.pkgInfo = pkgConf.server;
+          serverInfo.clientChangedFileSet = result.emitFileSet;
         }
-
-        serverInfo.clients[pkgName] = {
-          path: path.resolve(req.pkgPath, "dist"),
-          buildTypes: (pkgConf.builder ? Object.keys(pkgConf.builder) : ["web"]) as any,
-        };
-
-        serverInfo.clientChangedFileSet.adds(...result.emitFileSet);
-      }
-      else {
-        const serverInfo = this.#serverInfoMap.getOrCreate(pkgName, {
-          hasChanges: true,
-          clientChangedFileSet: new Set(),
-          clients: {},
-        });
-
-        serverInfo.clientChangedFileSet.adds(...result.emitFileSet);
       }
-    }
 
-    setTimeout(async () => {
-      this.#busyCount--;
-      if (this.#busyCount === 0) {
-        for (const serverPkgNameOrPort of this.#serverInfoMap.keys()) {
-          const serverInfo = this.#serverInfoMap.get(serverPkgNameOrPort)!;
-          if (serverInfo.pkgInfo && serverInfo.hasChanges) {
-            this.#logger.debug("서버 재시작...");
-            try {
-              const restartServerResult = await this.#restartServerAsync(
-                serverInfo.pkgInfo,
-                serverInfo.worker,
-              );
-              serverInfo.worker = restartServerResult.worker;
-              serverInfo.port = restartServerResult.port;
-              serverInfo.hasChanges = false;
-            }
-            catch (err) {
-              this.#logger.error(err);
+      setTimeout(async () => {
+        this.#busyCount--;
+        if (this.#busyCount === 0) {
+          for (const serverPkgNameOrPort of this.#serverInfoMap.keys()) {
+            const serverInfo = this.#serverInfoMap.get(serverPkgNameOrPort)!;
+            if (serverInfo.pkgInfo && serverInfo.hasChanges) {
+              this.#logger.debug("서버 재시작...");
+              try {
+                const restartServerResult = await this.#restartServerAsync(
+                  serverInfo.pkgInfo,
+                  serverInfo.worker,
+                );
+                serverInfo.worker = restartServerResult.worker;
+                serverInfo.port = restartServerResult.port;
+                serverInfo.hasChanges = false;
+              } catch (err) {
+                this.#logger.error(err);
+              }
             }
-          }
 
-          if (serverInfo.worker) {
-            this.#logger.debug("클라이언트 설정...");
-            await serverInfo.worker.run("setPathProxy", [
-              {
-                ...Object.keys(serverInfo.clients).toObject(
-                  (key) => key,
-                  (key) => serverInfo.clients[key].path,
-                ),
-                node_modules: path.resolve(process.cwd(), "node_modules"),
-              },
-            ]);
-
-            if (serverInfo.clientChangedFileSet.size > 0) {
-              this.#logger.debug("클라이언트 새로고침...");
-              await serverInfo.worker.run("broadcastReload", [serverInfo.clientChangedFileSet]);
+            if (serverInfo.worker) {
+              this.#logger.debug("클라이언트 설정...");
+              await serverInfo.worker.run("setPathProxy", [
+                {
+                  ...Object.keys(serverInfo.clients).toObject(
+                    (key) => key,
+                    (key) => serverInfo.clients[key].path,
+                  ),
+                  node_modules: path.resolve(process.cwd(), "node_modules"),
+                },
+              ]);
+
+              if (Object.keys(serverInfo.clients).length > 0) {
+                for (const clientName of Object.keys(serverInfo.clients)) {
+                  this.#logger.debug(`${clientName} 클라이언트 새로고침...`);
+                  await serverInfo.worker.run("broadcastReload", [
+                    clientName,
+                    new Set(
+                      Array.from(serverInfo.clients[clientName].changedFileSet)
+                        .filter((item) => !item.endsWith(".map"))
+                        .map((item) => path.relative(serverInfo.clients[clientName].path, item)),
+                    ),
+                  ]);
+                }
+              } else if (serverInfo.clientChangedFileSet.size > 0) {
+                this.#logger.debug("클라이언트 새로고침...");
+                await serverInfo.worker.run("broadcastReload", [
+                  undefined,
+                  new Set(
+                    Array.from(serverInfo.clientChangedFileSet)
+                      .filter((item) => !item.endsWith(".map"))
+                      .map((item) => path.relative(serverInfo.clientPath!, item)),
+                  ),
+                ]);
+              }
             }
           }
-        }
 
-        const clientPaths: string[] = [];
-        for (const serverInfo of this.#serverInfoMap.values()) {
-          if (Object.keys(serverInfo.clients).length > 0) {
-            for (const clientPkgName of Object.keys(serverInfo.clients)) {
-              for (const buildType of serverInfo.clients[clientPkgName].buildTypes) {
-                if (buildType === "web") {
-                  clientPaths.push(`http://localhost:${serverInfo.port}/${clientPkgName}/`);
-                }
-                else {
-                  clientPaths.push(`http://localhost:${serverInfo.port}/${clientPkgName}/${buildType}/`);
+          const clientPaths: string[] = [];
+          for (const serverInfo of this.#serverInfoMap.values()) {
+            if (Object.keys(serverInfo.clients).length > 0) {
+              for (const clientPkgName of Object.keys(serverInfo.clients)) {
+                for (const buildType of serverInfo.clients[clientPkgName].buildTypes) {
+                  if (buildType === "web") {
+                    clientPaths.push(`http://localhost:${serverInfo.port}/${clientPkgName}/`);
+                  } else {
+                    clientPaths.push(
+                      `http://localhost:${serverInfo.port}/${clientPkgName}/${buildType}/`,
+                    );
+                  }
                 }
               }
+            } else {
+              clientPaths.push(`http://localhost:${serverInfo.port}/`);
             }
           }
-          else {
-            clientPaths.push(`http://localhost:${serverInfo.port}/`);
+          if (clientPaths.length > 0) {
+            this.#logger.info("클라이언트 개발 서버 접속 주소\n" + clientPaths.join("\n"));
           }
-        }
-        if (clientPaths.length > 0) {
-          this.#logger.info("클라이언트 개발 서버 접속 주소\n" + clientPaths.join("\n"));
-        }
 
-        const messages = Array.from(this.#resultCache.values()).mapMany();
-        this.emit("complete", messages);
-      }
-    }, 300);
+          const messages = Array.from(this.#resultCache.values()).mapMany();
+          this.emit("complete", messages);
+        }
+      }, 300);
+    }
   }
 
   async #restartServerAsync(
@@ -231,10 +261,9 @@ export class SdMultiBuildRunner extends EventEmitter {
     }
 
     const npmConf =
-      "path" in pkgInfo ? (FsUtils.readJson(path.resolve(
-        pkgInfo.path,
-        "package.json",
-      )) as INpmConfig) : undefined;
+      "path" in pkgInfo
+        ? (FsUtils.readJson(path.resolve(pkgInfo.path, "package.json")) as INpmConfig)
+        : undefined;
 
     const worker = new SdWorker<TServerWorkerType>(
       import.meta.resolve("../workers/server.worker"),