@simplysm/sd-cli 14.0.44 → 14.0.46

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

@@ -0,0 +1,419 @@
+import path from "path";
+import fs from "fs";
+import type esbuild from "esbuild";
+import * as acorn from "acorn";
+import * as walk from "acorn-walk";
+
+//#region AST 기반 Worker 패턴 탐지
+
+/**
+ * AST에서 탐지된 Worker 패턴 하나를 나타낸다.
+ */
+export interface WorkerMatch {
+  type: "browser" | "node";
+  /** 전체 표현식의 start/end (치환 범위) */
+  start: number;
+  end: number;
+  /** Worker/SharedWorker 이름 (browser만) */
+  workerType?: string;
+  /** URL 경로 문자열 값 */
+  urlPath: string;
+  /** 옵션 객체의 원본 소스 텍스트 (browser만, 없으면 undefined) */
+  existingOpts?: string;
+}
+
+/**
+ * MemberExpression이 import.meta.url인지 확인한다.
+ */
+function isImportMetaUrl(node: any): boolean {
+  return (
+    node.type === "MemberExpression" &&
+    node.object.type === "MetaProperty" &&
+    node.object.meta.name === "import" &&
+    node.object.property.name === "meta" &&
+    node.property.type === "Identifier" &&
+    node.property.name === "url"
+  );
+}
+
+/**
+ * acorn AST를 사용하여 소스 코드에서 Worker/SharedWorker 및 import.meta.resolve 패턴을 탐지한다.
+ *
+ * 정규식과 달리 주석, 문자열 리터럴 내부의 패턴을 오탐하지 않는다.
+ * 파싱 실패 시 빈 배열을 반환한다.
+ */
+export function findWorkerPatterns(content: string): WorkerMatch[] {
+  let ast: acorn.Node;
+  try {
+    ast = acorn.parse(content, {
+      ecmaVersion: "latest",
+      sourceType: "module",
+    });
+  } catch {
+    return [];
+  }
+
+  const matches: WorkerMatch[] = [];
+
+  walk.simple(ast, {
+    NewExpression(node: any) {
+      // new Worker(new URL("path", import.meta.url), opts?)
+      // new SharedWorker(new URL("path", import.meta.url), opts?)
+      if (
+        node.callee.type !== "Identifier" ||
+        (node.callee.name !== "Worker" && node.callee.name !== "SharedWorker")
+      ) {
+        return;
+      }
+
+      const args = node.arguments;
+      if (args.length < 1) return;
+
+      const urlArg = args[0];
+      if (
+        urlArg.type !== "NewExpression" ||
+        urlArg.callee.type !== "Identifier" ||
+        urlArg.callee.name !== "URL"
+      ) {
+        return;
+      }
+
+      const urlArgs = urlArg.arguments;
+      if (urlArgs.length < 2) return;
+
+      // 첫 번째 인자: 문자열 리터럴 (경로)
+      if (urlArgs[0].type !== "Literal" || typeof urlArgs[0].value !== "string") return;
+
+      // 두 번째 인자: import.meta.url
+      if (!isImportMetaUrl(urlArgs[1])) return;
+
+      const match: WorkerMatch = {
+        type: "browser",
+        start: node.start,
+        end: node.end,
+        workerType: node.callee.name,
+        urlPath: urlArgs[0].value,
+      };
+
+      // 옵션 객체 (두 번째 인자)
+      if (args.length >= 2) {
+        match.existingOpts = content.slice(args[1].start, args[1].end);
+      }
+
+      matches.push(match);
+    },
+
+    CallExpression(node: any) {
+      // import.meta.resolve("./relative-path")
+      const callee = node.callee;
+      if (
+        callee.type !== "MemberExpression" ||
+        callee.object.type !== "MetaProperty" ||
+        callee.object.meta.name !== "import" ||
+        callee.object.property.name !== "meta" ||
+        callee.property.type !== "Identifier" ||
+        callee.property.name !== "resolve"
+      ) {
+        return;
+      }
+
+      const args = node.arguments;
+      if (args.length < 1) return;
+
+      if (args[0].type !== "Literal" || typeof args[0].value !== "string") return;
+
+      const urlPath = args[0].value as string;
+      // 상대 경로만 처리
+      if (!urlPath.startsWith("./") && !urlPath.startsWith("../")) return;
+
+      matches.push({
+        type: "node",
+        start: node.start,
+        end: node.end,
+        urlPath,
+      });
+    },
+  });
+
+  return matches.sort((a, b) => a.start - b.start);
+}
+
+//#endregion
+
+/**
+ * Worker 번들 빌드 결과를 포함하는 transform 결과.
+ */
+export interface TransformWorkerResult {
+  contents: string;
+  errors: esbuild.PartialMessage[];
+  warnings: esbuild.PartialMessage[];
+  /** write: false일 때 Worker 번들의 outputFiles (onEnd에서 병합용) */
+  workerOutputFiles?: esbuild.OutputFile[];
+  /** Worker 번들의 metafile (onEnd에서 병합용) */
+  workerMetafile?: esbuild.Metafile;
+}
+
+/**
+ * Worker 파일을 esbuild.buildSync()로 별도 ESM 번들로 빌드한다.
+ * esbuild-angular-compiler-plugin.ts의 bundleWebWorker를 기반으로 작성.
+ */
+function bundleWorker(
+  build: esbuild.PluginBuild,
+  workerFile: string,
+  platform: esbuild.Platform,
+): esbuild.BuildResult {
+  const sourcemap =
+    build.initialOptions.sourcemap != null &&
+    build.initialOptions.sourcemap !== false;
+  const write = build.initialOptions.write !== false;
+
+  try {
+    return build.esbuild.buildSync({
+      ...build.initialOptions,
+      platform,
+      write,
+      bundle: true,
+      metafile: true,
+      format: "esm",
+      entryNames: "worker-[hash]",
+      entryPoints: [workerFile],
+      sourcemap,
+      // 메인 빌드에서 상속하지 않는 옵션
+      external: undefined,
+      supported: undefined,
+      plugins: undefined,
+      outbase: undefined,
+      inject: undefined,
+    });
+  } catch (error) {
+    if (
+      error != null &&
+      typeof error === "object" &&
+      "errors" in error &&
+      "warnings" in error
+    ) {
+      return error as esbuild.BuildResult;
+    }
+    throw error;
+  }
+}
+
+/**
+ * 파일 내용에서 Worker/SharedWorker 패턴을 감지하여 Worker 파일을 번들링하고
+ * URL 경로를 번들된 파일 경로로 치환한다.
+ *
+ * Angular 플러그인 등 외부에서 직접 호출할 수 있도록 export한다 (D2).
+ *
+ * @returns 변환 결과. 패턴이 없으면 undefined.
+ */
+export function transformWorkerPatterns(
+  content: string,
+  filePath: string,
+  build: esbuild.PluginBuild,
+): TransformWorkerResult | undefined {
+  // 빠른 사전 필터 — AST 파싱 전에 키워드 존재 여부로 걸러냄 (원본 TS content 기준)
+  if (!content.includes("Worker") && !content.includes("import.meta.resolve")) {
+    return undefined;
+  }
+
+  const errors: esbuild.PartialMessage[] = [];
+  const warnings: esbuild.PartialMessage[] = [];
+
+  // TS(.ts/.cts/.mts)는 JS로 변환한 후 AST 파싱. acorn은 TS 구문을 처리하지 못하므로
+  // import type, 타입 어노테이션 등이 있으면 파싱 실패로 Worker 패턴이 조용히 누락된다.
+  let effectiveContent = content;
+  if (/\.[cm]?ts$/.test(filePath)) {
+    try {
+      const transformed = build.esbuild.transformSync(content, {
+        loader: "ts",
+        sourcemap: false,
+      });
+      effectiveContent = transformed.code;
+      warnings.push(...transformed.warnings);
+    } catch (e) {
+      const failure = e as {
+        errors?: esbuild.PartialMessage[];
+        warnings?: esbuild.PartialMessage[];
+      };
+      return {
+        contents: content,
+        errors: failure.errors ?? [
+          { text: `TS transform failed: ${String(e)}`, location: null },
+        ],
+        warnings: failure.warnings ?? [],
+      };
+    }
+  }
+
+  // AST 기반 패턴 탐지 (변환된 JS 기준)
+  const matches = findWorkerPatterns(effectiveContent);
+  if (matches.length === 0) {
+    return undefined;
+  }
+
+  const allOutputFiles: esbuild.OutputFile[] = [];
+  let mergedMetafile: esbuild.Metafile | undefined;
+
+  const write = build.initialOptions.write !== false;
+  const outdir = build.initialOptions.outdir ?? "";
+  const containingDir = path.dirname(filePath);
+
+  /**
+   * Worker 번들을 빌드하고, 결과에서 출력 파일 경로를 찾아 반환한다.
+   * 에러/경고/outputFiles/metafile을 외부 변수에 수집한다.
+   */
+  function processWorkerBundle(
+    fullWorkerPath: string,
+    platform: esbuild.Platform,
+  ): string | undefined {
+    const workerResult = bundleWorker(build, fullWorkerPath, platform);
+
+    warnings.push(...workerResult.warnings);
+
+    if (workerResult.errors.length > 0) {
+      errors.push(...workerResult.errors);
+      return undefined;
+    }
+
+    if (!write && workerResult.outputFiles != null) {
+      allOutputFiles.push(...workerResult.outputFiles);
+    }
+
+    if (workerResult.metafile != null) {
+      if (mergedMetafile == null) {
+        mergedMetafile = { inputs: {}, outputs: {} };
+      }
+      Object.assign(mergedMetafile.inputs, workerResult.metafile.inputs);
+      Object.assign(mergedMetafile.outputs, workerResult.metafile.outputs);
+    }
+
+    const workerCodeFile =
+      workerResult.outputFiles?.find((file) =>
+        /^worker-[a-z0-9]+\.[cm]?js$/i.test(path.basename(file.path)),
+      ) ??
+      (workerResult.metafile != null
+        ? (() => {
+            const outputKey = Object.keys(workerResult.metafile.outputs).find(
+              (key) => /worker-[a-z0-9]+\.[cm]?js$/i.test(path.basename(key)),
+            );
+            return outputKey != null ? { path: path.resolve(outputKey) } : undefined;
+          })()
+        : undefined);
+
+    if (workerCodeFile == null) {
+      errors.push({
+        text: `Worker 번들 출력 파일을 찾을 수 없습니다: ${fullWorkerPath}`,
+        location: null,
+      });
+      return undefined;
+    }
+
+    // outdir 루트 기준 상대 경로. bundleWorker에서 outbase: undefined를 설정하여
+    // Worker 파일이 항상 outdir 루트에 출력됨을 보장한다.
+    return path.relative(outdir, workerCodeFile.path).replaceAll("\\", "/");
+  }
+
+  // 정방향 chunks 패턴으로 치환 (esbuild-postcss-plugin.ts 동일 패턴)
+  const replacements: Array<{ start: number; end: number; text: string }> = [];
+
+  for (const match of matches) {
+    if (match.type === "browser") {
+      const fullWorkerPath = path.resolve(containingDir, match.urlPath);
+      const workerCodePath = processWorkerBundle(fullWorkerPath, "browser");
+      if (workerCodePath == null) continue;
+
+      const optsStr = match.existingOpts ?? '{ type: "module" }';
+      replacements.push({
+        start: match.start,
+        end: match.end,
+        text: `new ${match.workerType}(new URL("${workerCodePath}", import.meta.url), ${optsStr})`,
+      });
+    } else {
+      const fullWorkerPath = path.resolve(containingDir, match.urlPath);
+      const workerCodePath = processWorkerBundle(
+        fullWorkerPath,
+        build.initialOptions.platform ?? "browser",
+      );
+      if (workerCodePath == null) continue;
+
+      replacements.push({
+        start: match.start,
+        end: match.end,
+        text: `new URL("${workerCodePath}", import.meta.url).href`,
+      });
+    }
+  }
+
+  // chunks 조립 (변환된 JS 기준 — 매치의 start/end는 effectiveContent 오프셋)
+  const chunks: string[] = [];
+  let cursor = 0;
+  for (const rep of replacements) {
+    chunks.push(effectiveContent.slice(cursor, rep.start));
+    chunks.push(rep.text);
+    cursor = rep.end;
+  }
+  chunks.push(effectiveContent.slice(cursor));
+
+  return {
+    contents: chunks.join(""),
+    errors,
+    warnings,
+    workerOutputFiles: allOutputFiles.length > 0 ? allOutputFiles : undefined,
+    workerMetafile: mergedMetafile,
+  };
+}
+
+/**
+ * esbuild Worker 번들링 플러그인을 생성한다.
+ *
+ * onLoad에서 .js/.ts 파일의 Worker/SharedWorker 패턴을 감지하여
+ * Worker 파일을 별도 ESM 번들로 빌드하고, URL 경로를 번들된 파일로 치환한다.
+ */
+export function createWorkerBundlePlugin(): esbuild.Plugin {
+  return {
+    name: "sd-worker-bundle",
+    setup(build) {
+      const pendingWorkerResults: Array<{
+        outputFiles?: esbuild.OutputFile[];
+        metafile?: esbuild.Metafile;
+      }> = [];
+
+      build.onLoad({ filter: /\.[cm]?[jt]sx?$/ }, (args) => {
+        const content = fs.readFileSync(args.path, "utf-8");
+        const result = transformWorkerPatterns(content, args.path, build);
+        if (result == null) return undefined;
+
+        // write: false일 때 Worker outputFiles를 모아뒀다가 onEnd에서 병합
+        if (result.workerOutputFiles != null || result.workerMetafile != null) {
+          pendingWorkerResults.push({
+            outputFiles: result.workerOutputFiles,
+            metafile: result.workerMetafile,
+          });
+        }
+
+        // TS(.ts/.cts/.mts)는 transformWorkerPatterns 내부에서 JS로 변환되어 반환되므로
+        // loader는 "js". .tsx/.jsx는 변환하지 않으므로 esbuild가 JSX를 처리하도록 "tsx".
+        const isJsx = /\.[cm]?tsx$/.test(args.path) || args.path.endsWith(".jsx");
+        return {
+          contents: result.contents,
+          loader: isJsx ? ("tsx" as const) : ("js" as const),
+          errors: result.errors.length > 0 ? result.errors : undefined,
+          warnings: result.warnings.length > 0 ? result.warnings : undefined,
+        };
+      });
+
+      build.onEnd((result) => {
+        for (const wr of pendingWorkerResults) {
+          if (wr.outputFiles != null && wr.outputFiles.length > 0) {
+            result.outputFiles?.push(...wr.outputFiles);
+          }
+          if (result.metafile != null && wr.metafile != null) {
+            Object.assign(result.metafile.inputs, wr.metafile.inputs);
+            Object.assign(result.metafile.outputs, wr.metafile.outputs);
+          }
+        }
+        pendingWorkerResults.length = 0;
+      });
+    },
+  };
+}

package/src/utils/output-path-rewriter.ts

@@ -1,39 +1,87 @@
 import path from "path";
 import { pathx } from "@simplysm/core-node";
+import { init, parse } from "es-module-lexer";
+
+await init;
+
+const KNOWN_JS_EXTENSIONS = /\.(js|mjs|cjs|json|css|scss|wasm|node)$/i;
+
+/**
+ * es-module-lexer의 import에서 specifier 내용의 시작/끝 위치를 반환한다.
+ *
+ * static import (d === -1): s..e가 따옴표 없는 specifier 내용
+ * dynamic import (d >= 0): s..e가 따옴표를 포함한 문자열 리터럴
+ */
+function getSpecifierRange(imp: { s: number; e: number; d: number }): [number, number] {
+  if (imp.d >= 0) {
+    return [imp.s + 1, imp.e - 1];
+  }
+  return [imp.s, imp.e];
+}
 
 /**
  * ESM 출력에서 확장자가 없는 상대 import/export 경로에 .js 확장자를 추가한다.
  *
- * 매칭: from "./foo", import("./bar"), from "../baz"
+ * es-module-lexer를 사용하여 import/export specifier 위치를 정확히 파악한다.
+ * 주석, 문자열 리터럴 내부의 패턴은 무시된다.
+ *
+ * 매칭: from "./foo", import("./bar"), from "../baz", export { x } from "./qux"
  * 스킵: bare 지정자("lodash"), 이미 알려진 확장자로 끝나는 경로 (.js, .json, .css 등)
  */
 export function addJsExtensionToImports(text: string): string {
-  return text.replace(
-    /((?:from|import)\s*(?:\(\s*)?["'])(\.\.?\/[^"']*?)(["'](?:\s*\))?)/g,
-    (_match, prefix: string, importPath: string, suffix: string) => {
-      if (/\.(js|mjs|cjs|json|css|scss|wasm|node)$/i.test(importPath)) return _match;
-      return `${prefix}${importPath}.js${suffix}`;
-    },
-  );
+  const [imports] = parse(text);
+  if (imports.length === 0) return text;
+
+  // 역순으로 치환하여 위치 밀림 방지
+  const sorted = [...imports].sort((a, b) => b.s - a.s);
+  let result = text;
+
+  for (const imp of sorted) {
+    const specifier = imp.n;
+    if (specifier == null) continue;
+    if (!specifier.startsWith("./") && !specifier.startsWith("../")) continue;
+    if (KNOWN_JS_EXTENSIONS.test(specifier)) continue;
+
+    const [start, end] = getSpecifierRange(imp);
+    result = result.slice(0, start) + specifier + ".js" + result.slice(end);
+  }
+
+  return result;
 }
 
 /**
  * emit된 JS 텍스트에서 상대 .scss import를 .css로 변환한다.
  * 변환된 텍스트와 원본 .scss import 경로 목록을 반환한다.
  *
- * 매칭: import "./foo.scss", import("./bar.scss"), from "../baz.scss"
+ * es-module-lexer를 사용하여 import specifier 위치를 정확히 파악한다.
  * 상대 import(./ 또는 ../ 시작)만 처리한다.
  */
 export function rewriteScssImports(text: string): { text: string; scssImports: string[] } {
+  const [imports] = parse(text);
+  if (imports.length === 0) return { text, scssImports: [] };
+
   const scssImports: string[] = [];
-  const rewritten = text.replace(
-    /((?:from|import)\s*(?:\(\s*)?["'])(\.\.?\/[^"']*?)(\.scss)(["'](?:\s*\))?)/g,
-    (_match, prefix: string, importBase: string, _ext: string, suffix: string) => {
-      scssImports.push(`${importBase}.scss`);
-      return `${prefix}${importBase}.css${suffix}`;
-    },
-  );
-  return { text: rewritten, scssImports };
+
+  // 역순으로 치환하여 위치 밀림 방지
+  const sorted = [...imports].sort((a, b) => b.s - a.s);
+  let result = text;
+
+  for (const imp of sorted) {
+    const specifier = imp.n;
+    if (specifier == null) continue;
+    if (!specifier.startsWith("./") && !specifier.startsWith("../")) continue;
+    if (!specifier.endsWith(".scss")) continue;
+
+    scssImports.push(specifier);
+    const newSpec = specifier.slice(0, -5) + ".css";
+    const [start, end] = getSpecifierRange(imp);
+    result = result.slice(0, start) + newSpec + result.slice(end);
+  }
+
+  // 역순으로 수집되었으므로 원래 순서로 복원
+  scssImports.reverse();
+
+  return { text: result, scssImports };
 }
 
 /**

package/src/workers/server-build.worker.ts

@@ -18,6 +18,7 @@ import {
 import { collectAllExternals, generateProductionFiles } from "../deps/server-externals/server-production-files";
 import { SdTsCompiler } from "../ts-compiler/SdTsCompiler";
 import { createTscPlugin } from "../esbuild/esbuild-tsc-plugin";
+import { createWorkerBundlePlugin } from "../esbuild/esbuild-worker-plugin";
 import { setupWorkerLifecycle } from "./shared-worker-lifecycle";
 import { buildWatchPaths } from "./build-watch-paths";
 import { copyPublicFiles, watchPublicFiles } from "../utils/copy-public";
@@ -140,7 +141,7 @@ async function build(info: ServerBuildInfo): Promise<ServerBuildResult> {
     const entryPoints = getPackageSourceFiles(info.pkgDir, parsedConfig);
 
     // 외부 모듈 수집
-    const external = collectAllExternals(info.pkgDir, info.externals);
+    const { bundleExternals, prodDependencies } = collectAllExternals(info.pkgDir, info.externals);
 
     let jsResult: { success: boolean; errors?: string[]; warnings?: string[] };
     let tscErrors: string[];
@@ -162,10 +163,10 @@ async function build(info: ServerBuildInfo): Promise<ServerBuildResult> {
         pkgDir: info.pkgDir,
         entryPoints,
         env: info.env,
-        external,
+        external: bundleExternals,
       });
 
-      jsResult = await esbuild.build({ ...esbuildOptions, plugins: [tscPlugin.plugin] })
+      jsResult = await esbuild.build({ ...esbuildOptions, plugins: [createWorkerBundlePlugin(), tscPlugin.plugin] })
         .then(async (result) => {
           if (result.outputFiles) {
             await writeChangedOutputFiles(result.outputFiles);
@@ -212,7 +213,7 @@ async function build(info: ServerBuildInfo): Promise<ServerBuildResult> {
 
       await copyPublicFiles(info.pkgDir, false);
 
-      generateProductionFiles(info, external);
+      generateProductionFiles(info, prodDependencies);
     }
 
     const allErrors = [...(jsResult.errors ?? []), ...tscErrors];
@@ -310,7 +311,7 @@ async function startWatch(info: ServerWatchInfo): Promise<void> {
     const entryPoints = getPackageSourceFiles(info.pkgDir, parsedConfig);
 
     // 외부 모듈 수집 (watch 모드용 — watch manager가 자체 캐시를 유지)
-    const cachedExternal = collectAllExternals(info.pkgDir, info.externals);
+    const { bundleExternals: cachedExternal } = collectAllExternals(info.pkgDir, info.externals);
 
     // esbuild 컨텍스트 생성 (JS 출력 필요 시, tsc 플러그인 포함)
     if (info.output.js) {

package/src/workers/server-esbuild-context.ts

@@ -10,6 +10,7 @@ import { createTscPlugin, type TscPluginResult } from "../esbuild/esbuild-tsc-pl
 import type { TypecheckEnv } from "../utils/tsconfig";
 import type { SerializedDiagnostic } from "../typecheck/typecheck-serialization";
 import type { LintWithProgramResult } from "../lint/lint-with-program";
+import { createWorkerBundlePlugin } from "../esbuild/esbuild-worker-plugin";
 
 /**
  * esbuild watch context 생성 옵션
@@ -62,9 +63,10 @@ export async function createContext(options: EsbuildContextOptions): Promise<voi
     dev: true,
   });
 
+  const workerPlugin = createWorkerBundlePlugin();
   context = await esbuild.context({
     ...baseOptions,
-    plugins: tscPlugin != null ? [tscPlugin.plugin] : [],
+    plugins: tscPlugin != null ? [workerPlugin, tscPlugin.plugin] : [workerPlugin],
     metafile: true,
     write: false,
   });

package/src/workers/server-watch-manager.ts

@@ -59,7 +59,7 @@ export async function startServerWatchLoop(config: ServerWatchLoopConfig): Promi
           c.path.endsWith("package.json"),
         );
         if (hasPackageJsonChange) {
-          cachedExternal = collectAllExternals(info.pkgDir, info.externals);
+          cachedExternal = collectAllExternals(info.pkgDir, info.externals).bundleExternals;
         }
 
         if (info.output.js) {

package/tests/deps/server-externals/mise-toml-parse-intent.verify.md

@@ -0,0 +1,16 @@
+# mise.toml 파싱 실패 시 명시적 크래시 의도 — LLM 검증
+
+대상: `packages/sd-cli/src/deps/server-externals/server-production-files.ts` `generateProductionFiles()` 내 `TOML.parse(miseContent)` 호출부
+
+근거: `.tasks/260417132441_review-regex-to-parser/1.3-toml-parse-intent-comment.md`
+
+## 검증 항목
+
+- [x] **WHY 주석 존재**: `server-production-files.ts:114`에 `// mise.toml은 저장소에서 관리되는 설정 파일이므로, 파싱 실패 시 폴백하지 않고 예외를 전파하여 설정 오류를 즉시 드러낸다.` 주석이 `TOML.parse(miseContent)` 호출(`:115`) 직전에 존재함을 확인
+- [x] **명시적 크래시 의도 서술**: 주석이 "저장소에서 관리되는 설정 파일", "폴백하지 않고", "예외를 전파", "설정 오류를 즉시 드러낸다" 표현을 모두 포함하여 wbs에 명시된 WHY를 서술
+- [x] **WHAT 서술 지양**: "TOML을 파싱한다" 같은 코드 재서술이 아니라, 폴백을 의도적으로 하지 않는 이유(설정 오류 즉시 노출)를 설명
+- [x] **try-catch 미추가**: `:109-121` 블록 전체에 try 키워드 없음을 확인 — 파싱 예외는 상위로 전파됨
+- [x] **주석 스타일**: `//` 한 줄 주석 (JSDoc 아님)
+- [x] **주석 언어**: 한국어
+- [x] **기타 코드 미변경**: `git diff server-production-files.ts` 결과 라인 114의 주석 추가 1줄 외 변경 없음 (아래 명령 실행 결과 참조)
+- [x] **기존 테스트 통과**: `pnpm exec vitest run --project node packages/sd-cli/tests/workers/server-build-worker.spec.ts` 25/25 통과, 특히 `generates dist/mise.toml when packageManager=mise` 테스트(TOML.parse 경로 실행)가 통과하여 파싱 로직 회귀 없음을 확인. 참고: 전체 sd-cli 테스트(`packages/sd-cli/tests/`)에서 1건 실패(`esbuild-worker-plugin.acc.spec.ts:143`)가 있으나 이는 Feature 1.1 영역이며 본 Feature 1.3 변경(주석 1줄 추가)과 무관