@simplysm/sd-cli 12.16.46 → 12.16.52

package/dist/pkg-builders/client/SdNgBundler.js

@@ -21,7 +21,6 @@ import { resolveAssets } from "@angular/build/src/utils/resolve-assets";
 import { createSdNgPlugin } from "./createSdNgPlugin";
 import { SdCliPerformanceTimer } from "../../utils/SdCliPerformanceTimer";
 import nodeModule from "module";
-import { SdWorkerPathPlugin } from "../commons/SdWorkerPathPlugin";
 import { SdPolyfillPlugin } from "./SdPolyfillPlugin";
 export class SdNgBundler {
     constructor(_opt, _conf) {
@@ -436,11 +435,10 @@ export class SdNgBundler {
             plugins: [
                 createSourcemapIgnorelistPlugin(),
                 SdPolyfillPlugin(["Chrome >= 61"]),
-                createSdNgPlugin(this._opt, this._modifiedFileSet, this._ngResultCache),
+                createSdNgPlugin(this._opt, this._modifiedFileSet, this._ngResultCache, this._outputPath),
                 ...(this._conf.builderType === "electron"
                     ? []
                     : [nodeStdLibBrowserPlugin(nodeStdLibBrowser)]),
-                SdWorkerPathPlugin(this._outputPath),
                 // {
                 //   name: "log-circular",
                 //   setup(build) {

package/dist/pkg-builders/client/createSdNgPlugin.d.ts

@@ -2,4 +2,4 @@ import esbuild from "esbuild";
 import { TNormPath } from "@simplysm/sd-core-node";
 import { ISdCliNgPluginResultCache } from "../../types/plugin/ISdCliNgPluginResultCache";
 import { ISdTsCompilerOptions } from "../../types/build/ISdTsCompilerOptions";
-export declare function createSdNgPlugin(opt: ISdTsCompilerOptions, modifiedFileSet: Set<TNormPath>, resultCache: ISdCliNgPluginResultCache): esbuild.Plugin;
+export declare function createSdNgPlugin(opt: ISdTsCompilerOptions, modifiedFileSet: Set<TNormPath>, resultCache: ISdCliNgPluginResultCache, workerOutdir?: string): esbuild.Plugin;

package/dist/pkg-builders/client/createSdNgPlugin.js

@@ -5,7 +5,8 @@ import { FsUtils, PathUtils, SdLogger } from "@simplysm/sd-core-node";
 import { SdCliPerformanceTimer } from "../../utils/SdCliPerformanceTimer";
 import { SdCliConvertMessageUtils } from "../../utils/SdCliConvertMessageUtils";
 import { SdTsCompiler } from "../../ts-compiler/SdTsCompiler";
-export function createSdNgPlugin(opt, modifiedFileSet, resultCache) {
+import { transformWorkerPaths } from "../commons/SdWorkerPathPlugin";
+export function createSdNgPlugin(opt, modifiedFileSet, resultCache, workerOutdir) {
     let perf;
     const logger = SdLogger.get(["simplysm", "sd-cli", "createSdNgPlugin"]);
     const debug = (...msg) => {
@@ -60,7 +61,11 @@ export function createSdNgPlugin(opt, modifiedFileSet, resultCache) {
                 if (output != null) {
                     return { contents: output, loader: "js" };
                 }
-                const contents = emittedFiles?.last()?.text ?? "";
+                const rawContents = emittedFiles?.last()?.text ?? "";
+                // 워커 경로 변환 (import.meta.resolve → string literal)
+                const contents = workerOutdir != null
+                    ? await transformWorkerPaths(rawContents, args.path, workerOutdir, build.initialOptions, "document.baseURI")
+                    : rawContents;
                 const { sideEffects } = await build.resolve(args.path, {
                     kind: "import-statement",
                     resolveDir: build.initialOptions.absWorkingDir ?? "",
@@ -96,6 +101,15 @@ export function createSdNgPlugin(opt, modifiedFileSet, resultCache) {
                     return { errors: [{ text: err?.message ?? String(err) }] };
                 }
             });
+            if (workerOutdir != null) {
+                build.onLoad({ filter: /\.js$/ }, async (args) => {
+                    const source = await FsUtils.readFileAsync(args.path);
+                    const transformed = await transformWorkerPaths(source, args.path, workerOutdir, build.initialOptions, "document.baseURI");
+                    if (transformed === source)
+                        return null;
+                    return { contents: transformed, loader: "js" };
+                });
+            }
             const otherLoaderFilter = new RegExp("(" +
                 Object.keys(build.initialOptions.loader ?? {})
                     .map((ext) => "\\" + ext)

package/dist/pkg-builders/commons/SdWorkerPathPlugin.d.ts

@@ -1,2 +1,3 @@
 import esbuild from "esbuild";
+export declare function transformWorkerPaths(source: string, filePath: string, outdir: string, buildOptions: esbuild.BuildOptions, baseUrlExpr?: string): Promise<string>;
 export declare function SdWorkerPathPlugin(outdir: string): esbuild.Plugin;

package/dist/pkg-builders/commons/SdWorkerPathPlugin.js

@@ -1,67 +1,59 @@
 import esbuild from "esbuild";
 import path from "path";
 import { FsUtils, HashUtils } from "@simplysm/sd-core-node";
+export async function transformWorkerPaths(source, filePath, outdir, buildOptions, baseUrlExpr = "import.meta.url") {
+    // g flag regex는 함수 내에서 생성해야 lastIndex 상태 누출 방지
+    const regex = /import\.meta\.resolve\(\s*(['"])([^'"]+?\.worker)(?:\.[a-z]+)?\1\s*\)/g;
+    if (!regex.test(source)) {
+        return source;
+    }
+    return await replaceAsync(source, regex, async (_match, quote, relPath) => {
+        // 1. 실제 워커 파일 경로 계산
+        const workerSourcePath = path.resolve(path.dirname(filePath), relPath);
+        // 확장자가 없을 경우 자동 탐색 (js, ts 등)
+        const resolvedWorkerPath = resolveFile(workerSourcePath);
+        if (resolvedWorkerPath == null) {
+            // 파일이 없으면 건드리지 않음 (런타임 에러로 넘김)
+            return _match;
+        }
+        // 2. 출력될 워커 파일명 결정 (해시 사용)
+        const fileContent = await FsUtils.readFileBufferAsync(resolvedWorkerPath);
+        const hash = HashUtils.get(fileContent).substring(0, 8);
+        const workerBaseName = path.basename(resolvedWorkerPath, path.extname(resolvedWorkerPath));
+        const outputFileName = `${workerBaseName}-${hash}.js`;
+        const outputFilePath = path.join(outdir, "workers", outputFileName);
+        // 3. 워커 파일 빌드
+        await esbuild.build({
+            ...buildOptions,
+            plugins: buildOptions.plugins?.filter((item) => item.name !== "sd-worker-path-plugin" &&
+                item.name !== "sd-ng-plugin" &&
+                item.name !== "sd-server-plugin") ?? [],
+            outdir: undefined,
+            entryPoints: [resolvedWorkerPath],
+            bundle: true,
+            write: true,
+            splitting: false,
+            outfile: outputFilePath,
+        });
+        // 4. new URL(..., baseUrlExpr).href로 치환
+        // 클라이언트: document.baseURI (esbuild가 import.meta를 빈 객체로 대체하는 문제 회피)
+        // 서버: import.meta.url (Node.js에서 정상 동작)
+        return `new URL(${quote}./workers/${outputFileName}${quote}, ${baseUrlExpr}).href`;
+    });
+}
 export function SdWorkerPathPlugin(outdir) {
     return {
         name: "sd-worker-path-plugin",
         setup(build) {
             build.onLoad({ filter: /\.[cm]?[jt]s$/ }, async (args) => {
                 const originalSource = await FsUtils.readFileAsync(args.path);
-                // 정규식: import.meta.resolve('...') 또는 "..." 캡쳐
-                // 워커 파일뿐만 아니라 필요한 모든 리소스를 처리할 수 있지만, 일단 worker만 타겟팅
-                const regex = /import\.meta\.resolve\(\s*(['"])([^'"]+?\.worker)(?:\.[a-z]+)?\1\s*\)/g;
-                if (!regex.test(originalSource)) {
+                const transformed = await transformWorkerPaths(originalSource, args.path, outdir, build.initialOptions);
+                if (transformed === originalSource) {
                     return null;
                 }
-                // 매칭되는 모든 import.meta.resolve를 찾아서 처리
-                const newSource = await replaceAsync(originalSource, regex, async (match, quote, relPath) => {
-                    // 1. 실제 워커 파일 경로 계산
-                    const workerSourcePath = path.resolve(path.dirname(args.path), relPath);
-                    // 확장자가 없을 경우 자동 탐색 (js, ts 등)
-                    const resolvedWorkerPath = resolveFile(workerSourcePath);
-                    if (resolvedWorkerPath == null) {
-                        // 파일이 없으면 건드리지 않음 (런타임 에러로 넘김)
-                        return match;
-                    }
-                    // 2. 출력될 워커 파일명 결정 (캐싱 및 중복 방지를 위해 해시 사용 권장)
-                    const fileContent = await FsUtils.readFileBufferAsync(resolvedWorkerPath);
-                    const hash = HashUtils.get(fileContent).substring(0, 8);
-                    const workerBaseName = path.basename(resolvedWorkerPath, path.extname(resolvedWorkerPath));
-                    const outputFileName = `${workerBaseName}-${hash}.js`;
-                    const outputFilePath = path.join(outdir, "workers", outputFileName);
-                    // 3. 워커 파일 빌드 (존재하지 않거나 변경되었을 때만)
-                    // (간단하게 하기 위해 매번 빌드 시도하거나, 해시로 체크 가능. 여기선 esbuild 증분 빌드에 맡김)
-                    // *중요*: 워커도 번들링해야 함.
-                    await esbuild.build({
-                        ...build.initialOptions,
-                        plugins: build.initialOptions.plugins?.filter((item) => item.name !== "sd-worker-path-plugin" &&
-                            item.name !== "sd-ng-plugin" &&
-                            item.name !== "sd-server-plugin") ?? [],
-                        outdir: undefined,
-                        entryPoints: [resolvedWorkerPath],
-                        bundle: true,
-                        write: true,
-                        splitting: false,
-                        outfile: outputFilePath,
-                        // platform: build.initialOptions.platform,
-                        // target: build.initialOptions.target,
-                        // format: build.initialOptions.format,
-                        // minify: build.initialOptions.minify,
-                        // banner: build.initialOptions.banner,
-                        // sourcemap: build.initialOptions.sourcemap,
-                        // external: build.initialOptions.external, // 외부 의존성 설정 상속
-                        // 플러그인 상속 주의: 무한 루프 방지를 위해 이 플러그인은 제외해야 함
-                    });
-                    // 4. 경로 치환
-                    // 번들링된 메인 파일(dist/main.js) 기준으로 workers 폴더는 ./workers/ 임
-                    return `import.meta.resolve(${quote}./workers/${outputFileName}${quote})`;
-                });
                 return {
-                    contents: newSource,
-                    loader: "ts", // 또는 js, 파일 확장자에 따라 다르게 처리 가능하나 보통 ts로 넘겨도 됨
-                    // 워커 파일이 변경되면 이 파일도 다시 빌드되어야 함을 알림
-                    // (정확히 하려면 워커의 의존성까지 다 넣어야 하지만, 최소한 워커 엔트리는 넣음)
-                    // watchFiles: ... (esbuild가 내부적으로 처리해주길 기대)
+                    contents: transformed,
+                    loader: "ts",
                 };
             });
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simplysm/sd-cli",
-  "version": "12.16.46",
+  "version": "12.16.52",
   "description": "심플리즘 패키지 - CLI",
   "author": "김석래",
   "repository": {
@@ -17,10 +17,10 @@
     "@angular/compiler-cli": "^20.3.18",
     "@anthropic-ai/sdk": "^0.78.0",
     "@electron/rebuild": "^4.0.3",
-    "@simplysm/sd-core-common": "12.16.46",
-    "@simplysm/sd-core-node": "12.16.46",
-    "@simplysm/sd-service-server": "12.16.46",
-    "@simplysm/sd-storage": "12.16.46",
+    "@simplysm/sd-core-common": "12.16.52",
+    "@simplysm/sd-core-node": "12.16.52",
+    "@simplysm/sd-service-server": "12.16.52",
+    "@simplysm/sd-storage": "12.16.52",
     "abortcontroller-polyfill": "^1.7.8",
     "browserslist": "^4.28.1",
     "cordova": "^13.0.0",

package/src/pkg-builders/client/SdNgBundler.ts

@@ -40,7 +40,6 @@ import { ISdCliNgPluginResultCache } from "../../types/plugin/ISdCliNgPluginResu
 import { INpmConfig } from "../../types/common-config/INpmConfig";
 import { ISdBuildResult } from "../../types/build/ISdBuildResult";
 import { ISdTsCompilerOptions } from "../../types/build/ISdTsCompilerOptions";
-import { SdWorkerPathPlugin } from "../commons/SdWorkerPathPlugin";
 import { SdPolyfillPlugin } from "./SdPolyfillPlugin";
 
 export class SdNgBundler {
@@ -561,11 +560,10 @@ export class SdNgBundler {
       plugins: [
         createSourcemapIgnorelistPlugin(),
         SdPolyfillPlugin(["Chrome >= 61"]),
-        createSdNgPlugin(this._opt, this._modifiedFileSet, this._ngResultCache),
+        createSdNgPlugin(this._opt, this._modifiedFileSet, this._ngResultCache, this._outputPath),
         ...(this._conf.builderType === "electron"
           ? []
           : [nodeStdLibBrowserPlugin(nodeStdLibBrowser)]),
-        SdWorkerPathPlugin(this._outputPath),
         // {
         //   name: "log-circular",
         //   setup(build) {

package/src/pkg-builders/client/createSdNgPlugin.ts

@@ -9,11 +9,13 @@ import { SdTsCompiler } from "../../ts-compiler/SdTsCompiler";
 import { ISdCliNgPluginResultCache } from "../../types/plugin/ISdCliNgPluginResultCache";
 import { ISdTsCompilerResult } from "../../types/build/ISdTsCompilerResult";
 import { ISdTsCompilerOptions } from "../../types/build/ISdTsCompilerOptions";
+import { transformWorkerPaths } from "../commons/SdWorkerPathPlugin";
 
 export function createSdNgPlugin(
   opt: ISdTsCompilerOptions,
   modifiedFileSet: Set<TNormPath>,
   resultCache: ISdCliNgPluginResultCache,
+  workerOutdir?: string,
 ): esbuild.Plugin {
   let perf: SdCliPerformanceTimer;
   const logger = SdLogger.get(["simplysm", "sd-cli", "createSdNgPlugin"]);
@@ -90,7 +92,13 @@ export function createSdNgPlugin(
           return { contents: output, loader: "js" };
         }
 
-        const contents = emittedFiles?.last()?.text ?? "";
+        const rawContents = emittedFiles?.last()?.text ?? "";
+
+        // 워커 경로 변환 (import.meta.resolve → string literal)
+        const contents =
+          workerOutdir != null
+            ? await transformWorkerPaths(rawContents, args.path, workerOutdir, build.initialOptions, "document.baseURI")
+            : rawContents;
 
         const { sideEffects } = await build.resolve(args.path, {
           kind: "import-statement",
@@ -142,6 +150,15 @@ export function createSdNgPlugin(
         }
       });
 
+      if (workerOutdir != null) {
+        build.onLoad({ filter: /\.js$/ }, async (args) => {
+          const source = await FsUtils.readFileAsync(args.path);
+          const transformed = await transformWorkerPaths(source, args.path, workerOutdir, build.initialOptions, "document.baseURI");
+          if (transformed === source) return null;
+          return { contents: transformed, loader: "js" };
+        });
+      }
+
       const otherLoaderFilter = new RegExp(
         "(" +
           Object.keys(build.initialOptions.loader ?? {})

package/src/pkg-builders/commons/SdWorkerPathPlugin.ts

@@ -2,6 +2,64 @@ import esbuild from "esbuild";
 import path from "path";
 import { FsUtils, HashUtils } from "@simplysm/sd-core-node";
 
+export async function transformWorkerPaths(
+  source: string,
+  filePath: string,
+  outdir: string,
+  buildOptions: esbuild.BuildOptions,
+  baseUrlExpr: string = "import.meta.url",
+): Promise<string> {
+  // g flag regex는 함수 내에서 생성해야 lastIndex 상태 누출 방지
+  const regex = /import\.meta\.resolve\(\s*(['"])([^'"]+?\.worker)(?:\.[a-z]+)?\1\s*\)/g;
+
+  if (!regex.test(source)) {
+    return source;
+  }
+
+  return await replaceAsync(source, regex, async (_match, quote, relPath) => {
+    // 1. 실제 워커 파일 경로 계산
+    const workerSourcePath = path.resolve(path.dirname(filePath), relPath);
+
+    // 확장자가 없을 경우 자동 탐색 (js, ts 등)
+    const resolvedWorkerPath = resolveFile(workerSourcePath);
+    if (resolvedWorkerPath == null) {
+      // 파일이 없으면 건드리지 않음 (런타임 에러로 넘김)
+      return _match;
+    }
+
+    // 2. 출력될 워커 파일명 결정 (해시 사용)
+    const fileContent = await FsUtils.readFileBufferAsync(resolvedWorkerPath);
+    const hash = HashUtils.get(fileContent).substring(0, 8);
+    const workerBaseName = path.basename(resolvedWorkerPath, path.extname(resolvedWorkerPath));
+    const outputFileName = `${workerBaseName}-${hash}.js`;
+    const outputFilePath = path.join(outdir, "workers", outputFileName);
+
+    // 3. 워커 파일 빌드
+    await esbuild.build({
+      ...buildOptions,
+      plugins:
+        buildOptions.plugins?.filter(
+          (item) =>
+            item.name !== "sd-worker-path-plugin" &&
+            item.name !== "sd-ng-plugin" &&
+            item.name !== "sd-server-plugin",
+        ) ?? [],
+      outdir: undefined,
+
+      entryPoints: [resolvedWorkerPath],
+      bundle: true,
+      write: true,
+      splitting: false,
+      outfile: outputFilePath,
+    });
+
+    // 4. new URL(..., baseUrlExpr).href로 치환
+    // 클라이언트: document.baseURI (esbuild가 import.meta를 빈 객체로 대체하는 문제 회피)
+    // 서버: import.meta.url (Node.js에서 정상 동작)
+    return `new URL(${quote}./workers/${outputFileName}${quote}, ${baseUrlExpr}).href`;
+  });
+}
+
 export function SdWorkerPathPlugin(outdir: string): esbuild.Plugin {
   return {
     name: "sd-worker-path-plugin",
@@ -9,80 +67,20 @@ export function SdWorkerPathPlugin(outdir: string): esbuild.Plugin {
       build.onLoad({ filter: /\.[cm]?[jt]s$/ }, async (args) => {
         const originalSource = await FsUtils.readFileAsync(args.path);
 
-        // 정규식: import.meta.resolve('...') 또는 "..." 캡쳐
-        // 워커 파일뿐만 아니라 필요한 모든 리소스를 처리할 수 있지만, 일단 worker만 타겟팅
-        const regex = /import\.meta\.resolve\(\s*(['"])([^'"]+?\.worker)(?:\.[a-z]+)?\1\s*\)/g;
+        const transformed = await transformWorkerPaths(
+          originalSource,
+          args.path,
+          outdir,
+          build.initialOptions,
+        );
 
-        if (!regex.test(originalSource)) {
+        if (transformed === originalSource) {
           return null;
         }
 
-        // 매칭되는 모든 import.meta.resolve를 찾아서 처리
-        const newSource = await replaceAsync(
-          originalSource,
-          regex,
-          async (match, quote, relPath) => {
-            // 1. 실제 워커 파일 경로 계산
-            const workerSourcePath = path.resolve(path.dirname(args.path), relPath);
-
-            // 확장자가 없을 경우 자동 탐색 (js, ts 등)
-            const resolvedWorkerPath = resolveFile(workerSourcePath);
-            if (resolvedWorkerPath == null) {
-              // 파일이 없으면 건드리지 않음 (런타임 에러로 넘김)
-              return match;
-            }
-
-            // 2. 출력될 워커 파일명 결정 (캐싱 및 중복 방지를 위해 해시 사용 권장)
-            const fileContent = await FsUtils.readFileBufferAsync(resolvedWorkerPath);
-            const hash = HashUtils.get(fileContent).substring(0, 8);
-            const workerBaseName = path.basename(
-              resolvedWorkerPath,
-              path.extname(resolvedWorkerPath),
-            );
-            const outputFileName = `${workerBaseName}-${hash}.js`;
-            const outputFilePath = path.join(outdir, "workers", outputFileName);
-
-            // 3. 워커 파일 빌드 (존재하지 않거나 변경되었을 때만)
-            // (간단하게 하기 위해 매번 빌드 시도하거나, 해시로 체크 가능. 여기선 esbuild 증분 빌드에 맡김)
-            // *중요*: 워커도 번들링해야 함.
-            await esbuild.build({
-              ...build.initialOptions,
-              plugins:
-                build.initialOptions.plugins?.filter(
-                  (item) =>
-                    item.name !== "sd-worker-path-plugin" &&
-                    item.name !== "sd-ng-plugin" &&
-                    item.name !== "sd-server-plugin",
-                ) ?? [],
-              outdir: undefined,
-
-              entryPoints: [resolvedWorkerPath],
-              bundle: true,
-              write: true,
-              splitting: false,
-              outfile: outputFilePath,
-              // platform: build.initialOptions.platform,
-              // target: build.initialOptions.target,
-              // format: build.initialOptions.format,
-              // minify: build.initialOptions.minify,
-              // banner: build.initialOptions.banner,
-              // sourcemap: build.initialOptions.sourcemap,
-              // external: build.initialOptions.external, // 외부 의존성 설정 상속
-              // 플러그인 상속 주의: 무한 루프 방지를 위해 이 플러그인은 제외해야 함
-            });
-
-            // 4. 경로 치환
-            // 번들링된 메인 파일(dist/main.js) 기준으로 workers 폴더는 ./workers/ 임
-            return `import.meta.resolve(${quote}./workers/${outputFileName}${quote})`;
-          },
-        );
-
         return {
-          contents: newSource,
-          loader: "ts", // 또는 js, 파일 확장자에 따라 다르게 처리 가능하나 보통 ts로 넘겨도 됨
-          // 워커 파일이 변경되면 이 파일도 다시 빌드되어야 함을 알림
-          // (정확히 하려면 워커의 의존성까지 다 넣어야 하지만, 최소한 워커 엔트리는 넣음)
-          // watchFiles: ... (esbuild가 내부적으로 처리해주길 기대)
+          contents: transformed,
+          loader: "ts",
         };
       });
     },

package/tests/client/create-sd-ng-plugin-js-handler-unit.spec.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { transformWorkerPaths } from "../../src/pkg-builders/commons/SdWorkerPathPlugin";
+import path from "path";
+import fs from "fs";
+import os from "os";
+
+/**
+ * .js 핸들러가 사용하는 transformWorkerPaths의 .js 파일 처리를 검증하는 Unit Test.
+ * transformWorkerPaths는 이미 .ts 파일에 대해 테스트되어 있으므로,
+ * .js 파일에서도 동일하게 동작하는지 검증한다.
+ */
+describe("transformWorkerPaths .js 파일 지원", () => {
+  let tmpDir: string;
+
+  beforeAll(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sd-worker-js-unit-"));
+
+    const workersDir = path.join(tmpDir, "src", "workers");
+    fs.mkdirSync(workersDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(workersDir, "client-protocol.worker.js"),
+      "self.onmessage = (e) => { self.postMessage('ok'); };",
+    );
+  });
+
+  afterAll(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it(".js 파일 경로에서 import.meta.resolve 워커 패턴이 정상 변환된다", async () => {
+    const source = `const url = import.meta.resolve("./workers/client-protocol.worker");`;
+    const filePath = path.join(tmpDir, "src", "protocol.js");
+    const outdir = path.join(tmpDir, "dist-js");
+
+    const result = await transformWorkerPaths(source, filePath, outdir, {
+      format: "esm",
+      platform: "browser",
+      logLevel: "silent",
+    });
+
+    expect(result).toMatch(
+      /new URL\(["']\.\/workers\/client-protocol\.worker-[a-f0-9]+\.js["'], import\.meta\.url\)\.href/,
+    );
+    expect(result).not.toContain("import.meta.resolve");
+  });
+
+  it(".js 파일에서 워커 패턴이 없으면 원본 그대로 반환된다", async () => {
+    const source = `const x = 42; export default x;`;
+    const filePath = path.join(tmpDir, "src", "normal.js");
+    const outdir = path.join(tmpDir, "dist-js-no-pattern");
+
+    const result = await transformWorkerPaths(source, filePath, outdir, {
+      format: "esm",
+      platform: "browser",
+      logLevel: "silent",
+    });
+
+    expect(result).toBe(source);
+  });
+
+  it(".js 파일에서 여러 워커 패턴이 동시에 변환된다", async () => {
+    // 두 번째 워커 파일 추가
+    const workersDir = path.join(tmpDir, "src", "workers");
+    fs.writeFileSync(
+      path.join(workersDir, "decode.worker.js"),
+      "self.onmessage = (e) => { self.postMessage('decode'); };",
+    );
+
+    const source = [
+      `const url1 = import.meta.resolve("./workers/client-protocol.worker");`,
+      `const url2 = import.meta.resolve("./workers/decode.worker");`,
+    ].join("\n");
+    const filePath = path.join(tmpDir, "src", "multi.js");
+    const outdir = path.join(tmpDir, "dist-js-multi");
+
+    const result = await transformWorkerPaths(source, filePath, outdir, {
+      format: "esm",
+      platform: "browser",
+      logLevel: "silent",
+    });
+
+    expect(result).not.toContain("import.meta.resolve");
+    expect(result).toMatch(/client-protocol\.worker-[a-f0-9]+\.js/);
+    expect(result).toMatch(/decode\.worker-[a-f0-9]+\.js/);
+  });
+});

package/tests/client/create-sd-ng-plugin-js-handler.spec.ts

@@ -0,0 +1,151 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { createSdNgPlugin } from "../../src/pkg-builders/client/createSdNgPlugin";
+import path from "path";
+import fs from "fs";
+import os from "os";
+import esbuild from "esbuild";
+
+/**
+ * createSdNgPlugin의 .js onLoad 핸들러가
+ * transformWorkerPaths를 적용하는지 검증하는 Acceptance Test.
+ *
+ * 플러그인의 setup()을 호출하여 등록된 핸들러를 캡처한 뒤,
+ * .js 파일에 대해 핸들러를 직접 호출하여 변환 결과를 검증한다.
+ */
+
+interface CapturedHandler {
+  filter: RegExp;
+  handler: (args: esbuild.OnLoadArgs) => Promise<esbuild.OnLoadResult | null>;
+}
+
+function captureOnLoadHandlers(workerOutdir?: string): CapturedHandler[] {
+  const captureTmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sd-ng-capture-"));
+
+  // SdTsCompiler가 tsconfig.json을 읽으므로 최소한의 파일을 제공
+  fs.writeFileSync(
+    path.join(captureTmpDir, "tsconfig.json"),
+    JSON.stringify({ compilerOptions: { target: "ES2022", module: "ESNext" } }),
+  );
+
+  const plugin = createSdNgPlugin(
+    {
+      pkgPath: captureTmpDir as any,
+      tsConfigPath: path.join(captureTmpDir, "tsconfig.json") as any,
+    },
+    new Set(),
+    { affectedFileSet: new Set(), watchFileSet: new Set() },
+    workerOutdir,
+  );
+
+  const handlers: CapturedHandler[] = [];
+  const mockBuild = {
+    initialOptions: {
+      format: "esm" as const,
+      platform: "browser" as const,
+      logLevel: "silent" as const,
+      loader: {},
+    },
+    onStart: () => {},
+    onLoad: (opts: { filter: RegExp }, handler: any) => {
+      handlers.push({ filter: opts.filter, handler });
+    },
+    onEnd: () => {},
+    resolve: async () => ({ sideEffects: false }),
+  };
+
+  plugin.setup(mockBuild as any);
+  fs.rmSync(captureTmpDir, { recursive: true, force: true });
+  return handlers;
+}
+
+describe("createSdNgPlugin .js onLoad 핸들러", () => {
+  let tmpDir: string;
+
+  beforeAll(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sd-ng-js-handler-"));
+
+    // 워커 파일 생성
+    const workersDir = path.join(tmpDir, "src", "workers");
+    fs.mkdirSync(workersDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(workersDir, "client-protocol.worker.js"),
+      "self.onmessage = (e) => { self.postMessage('ok'); };",
+    );
+  });
+
+  afterAll(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("npm 패키지의 .js 파일에서 import.meta.resolve 워커 패턴이 변환된다", async () => {
+    const workerOutdir = path.join(tmpDir, "dist");
+    const handlers = captureOnLoadHandlers(workerOutdir);
+
+    // .js 필터를 가진 핸들러가 등록되어야 한다
+    const jsHandler = handlers.find((h) => h.filter.test("test.js") && !h.filter.test("test.mjs"));
+    expect(jsHandler).toBeDefined();
+
+    // .js 파일에 import.meta.resolve 워커 패턴이 있는 경우
+    const jsFilePath = path.join(tmpDir, "src", "protocol.js");
+    fs.writeFileSync(
+      jsFilePath,
+      `const url = import.meta.resolve("./workers/client-protocol.worker");`,
+    );
+
+    const result = await jsHandler!.handler({
+      path: jsFilePath,
+      namespace: "file",
+      suffix: "",
+      pluginData: undefined,
+      with: {},
+    });
+
+    expect(result).not.toBeNull();
+    expect(result!.contents).toBeDefined();
+    expect(String(result!.contents)).toMatch(
+      /new URL\(["']\.\/workers\/client-protocol\.worker-[a-f0-9]+\.js["'], import\.meta\.url\)\.href/,
+    );
+    expect(String(result!.contents)).not.toContain("import.meta.resolve");
+    expect(result!.loader).toBe("js");
+  });
+
+  it("워커 패턴이 없는 .js 파일은 null을 반환한다", async () => {
+    const workerOutdir = path.join(tmpDir, "dist-no-pattern");
+    const handlers = captureOnLoadHandlers(workerOutdir);
+
+    const jsHandler = handlers.find((h) => h.filter.test("test.js") && !h.filter.test("test.mjs"));
+    expect(jsHandler).toBeDefined();
+
+    // 워커 패턴이 없는 .js 파일
+    const jsFilePath = path.join(tmpDir, "src", "normal.js");
+    fs.writeFileSync(jsFilePath, `const x = 42; export default x;`);
+
+    const result = await jsHandler!.handler({
+      path: jsFilePath,
+      namespace: "file",
+      suffix: "",
+      pluginData: undefined,
+      with: {},
+    });
+
+    expect(result).toBeNull();
+  });
+
+  it("workerOutdir가 없으면 .js 핸들러가 등록되지 않는다", () => {
+    const handlers = captureOnLoadHandlers(undefined);
+
+    // .js 전용 핸들러가 없어야 한다 (기존 .ts, .mjs, otherLoader 필터만 있음)
+    const jsOnlyHandler = handlers.find(
+      (h) => h.filter.test("test.js") && !h.filter.test("test.ts") && !h.filter.test("test.mjs"),
+    );
+    expect(jsOnlyHandler).toBeUndefined();
+  });
+
+  it("기존 .ts 핸들러가 여전히 등록되어 있다", () => {
+    const workerOutdir = path.join(tmpDir, "dist-ts-check");
+    const handlers = captureOnLoadHandlers(workerOutdir);
+
+    const tsHandler = handlers.find((h) => h.filter.test("test.ts"));
+    expect(tsHandler).toBeDefined();
+  });
+});

package/tests/commons/sd-worker-path-angular-integration.spec.md

@@ -0,0 +1,28 @@
+# Worker 경로 변환 Angular 빌드 통합 검증
+
+## 전제 조건
+- Angular 클라이언트 패키지가 `sd-service-client`를 의존하고 있다
+- 서버가 실행 중이며 WebSocket 통신이 가능하다
+
+## 수행 절차
+
+### 1. Angular 클라이언트 빌드
+1. `yarn build --packages {angular-client-package}` 실행
+2. 빌드 출력 디렉토리에서 chunk 파일 검색
+
+### 2. 번들 출력 검증
+1. 빌드된 chunk 파일에서 `import_meta.resolve` 또는 `import.meta.resolve` 검색
+2. 해당 패턴이 없어야 한다
+3. `./workers/client-protocol.worker-` 패턴이 string literal로 존재해야 한다
+4. `dist/workers/` 하위에 `client-protocol.worker-{hash}.js` 파일이 생성되어야 한다
+
+### 3. 런타임 검증
+1. Angular 앱을 브라우저(Chrome)에서 실행
+2. 서버로부터 30KB 이상의 WebSocket 응답을 발생시키는 작업 수행
+3. 콘솔에 `TypeError: import_meta.resolve is not a function` 에러가 발생하지 않아야 한다
+4. 응답이 정상적으로 디코딩되어 화면에 표시되어야 한다
+
+## 기대 결과
+- 빌드 출력에 `import.meta.resolve` 런타임 호출이 없다
+- 워커 파일이 별도 빌드되어 `workers/` 하위에 존재한다
+- 30KB 이상 응답에서 Worker가 정상 동작한다

package/tests/commons/sd-worker-path-plugin.spec.ts

@@ -0,0 +1,141 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { transformWorkerPaths } from "../../src/pkg-builders/commons/SdWorkerPathPlugin";
+import path from "path";
+import fs from "fs";
+import os from "os";
+
+describe("transformWorkerPaths", () => {
+  let tmpDir: string;
+
+  beforeAll(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sd-worker-test-"));
+
+    const workersDir = path.join(tmpDir, "src", "workers");
+    fs.mkdirSync(workersDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(workersDir, "test.worker.ts"),
+      "self.onmessage = (e: MessageEvent) => { self.postMessage('ok'); };",
+    );
+  });
+
+  afterAll(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  describe("서버 패턴 -- import.meta.resolve() 직접 사용", () => {
+    it("치환 결과는 new URL(..., import.meta.url).href 형태이다", async () => {
+      const source = `const url = import.meta.resolve("./workers/test.worker");`;
+      const filePath = path.join(tmpDir, "src", "main.ts");
+      const outdir = path.join(tmpDir, "dist-server");
+
+      const result = await transformWorkerPaths(source, filePath, outdir, {
+        format: "esm",
+        platform: "node",
+        logLevel: "silent",
+      });
+
+      // new URL("./workers/test.worker-{hash}.js", import.meta.url).href 형태여야 함
+      expect(result).toMatch(
+        /new URL\(["']\.\/workers\/test\.worker-[a-f0-9]+\.js["'], import\.meta\.url\)\.href/,
+      );
+    });
+  });
+
+  describe("클라이언트 패턴 -- new URL(import.meta.resolve(...), import.meta.url) 사용", () => {
+    it("import.meta.resolve() 부분만 치환되어 이중 new URL() 래핑이 된다", async () => {
+      const source = `const w = new Worker(new URL(import.meta.resolve("./workers/test.worker"), import.meta.url));`;
+      const filePath = path.join(tmpDir, "src", "main.ts");
+      const outdir = path.join(tmpDir, "dist-client");
+
+      const result = await transformWorkerPaths(source, filePath, outdir, {
+        format: "esm",
+        platform: "browser",
+        logLevel: "silent",
+      });
+
+      // import.meta.resolve() 부분이 new URL(...).href로 치환
+      expect(result).toMatch(
+        /new URL\(new URL\(["']\.\/workers\/test\.worker-[a-f0-9]+\.js["'], import\.meta\.url\)\.href, import\.meta\.url\)/,
+      );
+    });
+  });
+
+  describe("공통 계약", () => {
+    it("변환 후 import.meta.resolve 호출이 제거된다", async () => {
+      const source = `const url = import.meta.resolve("./workers/test.worker");`;
+      const filePath = path.join(tmpDir, "src", "main.ts");
+      const outdir = path.join(tmpDir, "dist-common1");
+
+      const result = await transformWorkerPaths(source, filePath, outdir, {
+        format: "esm",
+        platform: "node",
+        logLevel: "silent",
+      });
+
+      expect(result).not.toContain("import.meta.resolve");
+    });
+
+    it("변환 후 워커 파일명이 해시 포함 string literal로 존재한다", async () => {
+      const source = `const url = import.meta.resolve("./workers/test.worker");`;
+      const filePath = path.join(tmpDir, "src", "main.ts");
+      const outdir = path.join(tmpDir, "dist-common2");
+
+      const result = await transformWorkerPaths(source, filePath, outdir, {
+        format: "esm",
+        platform: "node",
+        logLevel: "silent",
+      });
+
+      expect(result).toMatch(/["']\.\/workers\/test\.worker-[a-f0-9]+\.js["']/);
+    });
+
+    it("변환 후 import.meta.url이 유지된다", async () => {
+      const source = `const url = import.meta.resolve("./workers/test.worker");`;
+      const filePath = path.join(tmpDir, "src", "main.ts");
+      const outdir = path.join(tmpDir, "dist-common3");
+
+      const result = await transformWorkerPaths(source, filePath, outdir, {
+        format: "esm",
+        platform: "node",
+        logLevel: "silent",
+      });
+
+      expect(result).toContain("import.meta.url");
+    });
+  });
+
+  it("매칭 없으면 원본을 그대로 반환한다", async () => {
+    const source = `const x = 42;`;
+    const result = await transformWorkerPaths(source, "/tmp/main.ts", "/tmp/dist", {});
+    expect(result).toBe(source);
+  });
+
+  it("워커 내용 변경 시 다른 hash가 생성된다", async () => {
+    const source = `import.meta.resolve("./workers/test.worker")`;
+    const filePath = path.join(tmpDir, "src", "main.ts");
+    const outdir = path.join(tmpDir, "dist-hash-test");
+    const workerPath = path.join(tmpDir, "src", "workers", "test.worker.ts");
+
+    // 첫 번째 변환
+    fs.writeFileSync(workerPath, "self.onmessage = () => { self.postMessage('v1'); };");
+    const result1 = await transformWorkerPaths(source, filePath, outdir, {
+      format: "esm",
+      platform: "browser",
+      logLevel: "silent",
+    });
+    const hash1 = result1.match(/test\.worker-([a-f0-9]+)\.js/)?.[1];
+
+    // 워커 내용 변경 후 두 번째 변환
+    fs.writeFileSync(workerPath, "self.onmessage = () => { self.postMessage('v2-changed'); };");
+    const result2 = await transformWorkerPaths(source, filePath, outdir, {
+      format: "esm",
+      platform: "browser",
+      logLevel: "silent",
+    });
+    const hash2 = result2.match(/test\.worker-([a-f0-9]+)\.js/)?.[1];
+
+    expect(hash1).toBeDefined();
+    expect(hash2).toBeDefined();
+    expect(hash1).not.toBe(hash2);
+  });
+});