@simplysm/sd-cli 14.0.45 → 14.0.47

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/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줄 추가)과 무관

package/tests/esbuild/esbuild-worker-plugin.spec.ts

@@ -8,7 +8,7 @@ import { fileURLToPath } from "url";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const fixturesDir = path.join(__dirname, "fixtures", "worker-plugin");
 
-const { transformWorkerPatterns, createWorkerBundlePlugin } = await import(
+const { transformWorkerPatterns, createWorkerBundlePlugin, findWorkerPatterns } = await import(
   "../../src/esbuild/esbuild-worker-plugin.js"
 );
 
@@ -28,6 +28,36 @@ function createMockBuild(overrides?: Partial<esbuild.BuildOptions>): esbuild.Plu
   } as unknown as esbuild.PluginBuild;
 }
 
+/**
+ * transformSync 호출을 추적할 수 있도록 esbuild 네임스페이스를 wrap한다.
+ * vi.spyOn이 ESM namespace frozen property에서 실패하므로 대안으로 사용한다.
+ */
+function createTrackedBuild(overrides?: Partial<esbuild.BuildOptions>): {
+  build: esbuild.PluginBuild;
+  transformSyncCalls: Array<Parameters<typeof esbuild.transformSync>>;
+} {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "worker-unit-"));
+  const transformSyncCalls: Array<Parameters<typeof esbuild.transformSync>> = [];
+  const trackedEsbuild = {
+    ...esbuild,
+    transformSync: (...args: Parameters<typeof esbuild.transformSync>) => {
+      transformSyncCalls.push(args);
+      return esbuild.transformSync(...args);
+    },
+  } as typeof esbuild;
+
+  const build = {
+    esbuild: trackedEsbuild,
+    initialOptions: {
+      outdir: tmpDir,
+      write: false,
+      ...overrides,
+    },
+  } as unknown as esbuild.PluginBuild;
+
+  return { build, transformSyncCalls };
+}
+
 describe("transformWorkerPatterns — 패턴 감지", () => {
   it("Worker 패턴이 없는 content에 대해 undefined를 반환한다", () => {
     const result = transformWorkerPatterns(
@@ -59,6 +89,27 @@ describe("transformWorkerPatterns — 패턴 감지", () => {
     expect(result).toBeUndefined();
   });
 
+  it("주석 내 Worker 패턴은 무시한다", () => {
+    const result = transformWorkerPatterns(
+      `// new Worker(new URL("./worker.js", import.meta.url))
+const x = 1;`,
+      "/test/entry.js",
+      createMockBuild(),
+    );
+
+    expect(result).toBeUndefined();
+  });
+
+  it("문자열 리터럴 내 Worker 패턴은 무시한다", () => {
+    const result = transformWorkerPatterns(
+      `const s = "new Worker(new URL(\\"./worker.js\\", import.meta.url))";`,
+      "/test/entry.js",
+      createMockBuild(),
+    );
+
+    expect(result).toBeUndefined();
+  });
+
   it("Worker + new URL + import.meta.url 패턴을 감지하여 치환한다", () => {
     const entryPath = path.join(fixturesDir, "entry.js");
 
@@ -295,3 +346,498 @@ describe("createWorkerBundlePlugin — 플러그인 구조", () => {
     expect(hasOnEnd).toBe(true);
   });
 });
+
+describe("findWorkerPatterns — AST 기반 패턴 탐지", () => {
+  it("Worker + new URL + import.meta.url 패턴을 탐지한다", () => {
+    const matches = findWorkerPatterns(
+      `const w = new Worker(new URL("./worker.js", import.meta.url));`,
+    );
+
+    expect(matches).toHaveLength(1);
+    expect(matches[0].type).toBe("browser");
+    expect(matches[0].urlPath).toBe("./worker.js");
+    expect(matches[0].workerType).toBe("Worker");
+    expect(matches[0].existingOpts).toBeUndefined();
+  });
+
+  it("SharedWorker 패턴을 탐지한다", () => {
+    const matches = findWorkerPatterns(
+      `const sw = new SharedWorker(new URL("./sw.js", import.meta.url));`,
+    );
+
+    expect(matches).toHaveLength(1);
+    expect(matches[0].workerType).toBe("SharedWorker");
+    expect(matches[0].urlPath).toBe("./sw.js");
+  });
+
+  it("옵션 객체가 있는 Worker 패턴을 탐지하고 원본 텍스트를 보존한다", () => {
+    const content = `const w = new Worker(new URL("./w.js", import.meta.url), { type: "module" });`;
+    const matches = findWorkerPatterns(content);
+
+    expect(matches).toHaveLength(1);
+    expect(matches[0].existingOpts).toBe('{ type: "module" }');
+  });
+
+  it("import.meta.resolve 상대 경로 패턴을 탐지한다", () => {
+    const matches = findWorkerPatterns(
+      `const p = import.meta.resolve("./node-worker.js");`,
+    );
+
+    expect(matches).toHaveLength(1);
+    expect(matches[0].type).toBe("node");
+    expect(matches[0].urlPath).toBe("./node-worker.js");
+  });
+
+  it("import.meta.resolve 절대 모듈 경로는 무시한다", () => {
+    const matches = findWorkerPatterns(
+      `const p = import.meta.resolve("some-package");`,
+    );
+
+    expect(matches).toHaveLength(0);
+  });
+
+  it("new URL 없는 Worker는 무시한다", () => {
+    const matches = findWorkerPatterns(
+      `const w = new Worker("./worker.js");`,
+    );
+
+    expect(matches).toHaveLength(0);
+  });
+
+  it("import.meta.url이 아닌 URL 생성은 무시한다", () => {
+    const matches = findWorkerPatterns(
+      `const w = new Worker(new URL("./w.js", location.href));`,
+    );
+
+    expect(matches).toHaveLength(0);
+  });
+
+  it("복수 패턴을 모두 탐지한다", () => {
+    const matches = findWorkerPatterns(
+      [
+        `const w1 = new Worker(new URL("./w1.js", import.meta.url));`,
+        `const w2 = new Worker(new URL("./w2.js", import.meta.url));`,
+      ].join("\n"),
+    );
+
+    expect(matches).toHaveLength(2);
+    expect(matches[0].urlPath).toBe("./w1.js");
+    expect(matches[1].urlPath).toBe("./w2.js");
+  });
+
+  it("start/end 위치가 정확하다", () => {
+    const content = `const w = new Worker(new URL("./w.js", import.meta.url));`;
+    const matches = findWorkerPatterns(content);
+
+    expect(matches).toHaveLength(1);
+    const matched = content.slice(matches[0].start, matches[0].end);
+    expect(matched).toBe(`new Worker(new URL("./w.js", import.meta.url))`);
+  });
+
+  it("주석 내 Worker 패턴은 무시한다", () => {
+    const matches = findWorkerPatterns(
+      `// new Worker(new URL("./w.js", import.meta.url))
+const x = 1;`,
+    );
+
+    expect(matches).toHaveLength(0);
+  });
+
+  it("문자열 리터럴 내 Worker 패턴은 무시한다", () => {
+    const matches = findWorkerPatterns(
+      `const s = "new Worker(new URL(\\"./w.js\\", import.meta.url))";`,
+    );
+
+    expect(matches).toHaveLength(0);
+  });
+
+  it("블록 주석 내 Worker 패턴은 무시한다", () => {
+    const matches = findWorkerPatterns(
+      `/* new Worker(new URL("./w.js", import.meta.url)) */
+const x = 1;`,
+    );
+
+    expect(matches).toHaveLength(0);
+  });
+
+  it("주석 내 import.meta.resolve는 무시한다", () => {
+    const matches = findWorkerPatterns(
+      `// import.meta.resolve("./w.js")
+const x = 1;`,
+    );
+
+    expect(matches).toHaveLength(0);
+  });
+
+  it("파싱 불가능한 코드는 빈 배열을 반환한다", () => {
+    const matches = findWorkerPatterns(
+      `this is not valid javascript }{][`,
+    );
+
+    expect(matches).toHaveLength(0);
+  });
+});
+
+describe("transformWorkerPatterns — TypeScript 파일 처리", () => {
+  it("import type이 포함된 .ts 파일에서 Worker 패턴을 탐지하여 치환한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.ts");
+    const result = transformWorkerPatterns(
+      `import type { T } from "pkg";
+const w = new Worker(new URL("./worker.js", import.meta.url));`,
+      entryPath,
+      createMockBuild(),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.contents).not.toContain("./worker.js");
+    expect(result!.contents).toMatch(/worker-[a-z0-9]+\.js/i);
+    expect(result!.errors).toHaveLength(0);
+  });
+
+  it("import type이 포함된 .ts 파일에서 import.meta.resolve 패턴을 탐지하여 치환한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.ts");
+    const result = transformWorkerPatterns(
+      `import type { T } from "pkg";
+const p = import.meta.resolve("./node-worker.js");`,
+      entryPath,
+      createMockBuild({ platform: "node" }),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.contents).not.toContain("./node-worker.js");
+    expect(result!.contents).toMatch(
+      /new URL\("worker-[a-z0-9]+\.js", import\.meta\.url\)\.href/i,
+    );
+    expect(result!.errors).toHaveLength(0);
+  });
+
+  it("타입 어노테이션이 있는 변수 선언(const w: Worker = ...)에서 Worker를 탐지한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.ts");
+    const result = transformWorkerPatterns(
+      `const w: Worker = new Worker(new URL("./worker.js", import.meta.url));`,
+      entryPath,
+      createMockBuild(),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.contents).toMatch(/worker-[a-z0-9]+\.js/i);
+  });
+
+  it(".mts 확장자의 TS 파일도 변환 후 처리한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.mts");
+    const result = transformWorkerPatterns(
+      `import type { T } from "pkg";
+const w = new Worker(new URL("./worker.js", import.meta.url));`,
+      entryPath,
+      createMockBuild(),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.contents).toMatch(/worker-[a-z0-9]+\.js/i);
+  });
+
+  it(".cts 확장자의 TS 파일도 변환 후 처리한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.cts");
+    const result = transformWorkerPatterns(
+      `import type { T } from "pkg";
+const w = new Worker(new URL("./worker.js", import.meta.url));`,
+      entryPath,
+      createMockBuild(),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.contents).toMatch(/worker-[a-z0-9]+\.js/i);
+  });
+
+  it("TS 파일의 주석 내 Worker 패턴은 무시한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.ts");
+    const result = transformWorkerPatterns(
+      `import type { T } from "pkg";
+// new Worker(new URL("./worker.js", import.meta.url))
+const x: number = 1;`,
+      entryPath,
+      createMockBuild(),
+    );
+
+    expect(result).toBeUndefined();
+  });
+
+  it("TS 파일의 문자열 리터럴 내 Worker 패턴은 무시한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.ts");
+    const result = transformWorkerPatterns(
+      `import type { T } from "pkg";
+const s: string = "new Worker(new URL(\\"./worker.js\\", import.meta.url))";`,
+      entryPath,
+      createMockBuild(),
+    );
+
+    expect(result).toBeUndefined();
+  });
+
+  it("사전 필터를 통과하지 못하는 TS 파일(Worker 키워드 없음)은 undefined를 반환한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.ts");
+    const result = transformWorkerPatterns(
+      `import type { T } from "pkg";
+const x: number = 1;`,
+      entryPath,
+      createMockBuild(),
+    );
+
+    expect(result).toBeUndefined();
+  });
+
+  it("TS 변환 실패(문법 오류) 시 errors에 에러를 포함하여 반환한다", () => {
+    const entryPath = path.join(fixturesDir, "entry.ts");
+    const result = transformWorkerPatterns(
+      `const w = new Worker(new URL("./worker.js", import.meta.url)); const x: =`,
+      entryPath,
+      createMockBuild(),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.errors.length).toBeGreaterThan(0);
+  });
+});
+
+describe("createWorkerBundlePlugin — TS 파일 onLoad 반환", () => {
+  it("TS 파일에서 Worker 감지 시 loader로 'js'를 반환한다", async () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "worker-onload-"));
+    const tsFile = path.join(tmpDir, "entry.ts");
+    fs.copyFileSync(
+      path.join(fixturesDir, "worker.js"),
+      path.join(tmpDir, "worker.js"),
+    );
+    fs.writeFileSync(
+      tsFile,
+      `import type { T } from "pkg";
+const w = new Worker(new URL("./worker.js", import.meta.url));`,
+    );
+
+    const plugin = createWorkerBundlePlugin();
+
+    let onLoadCallback: ((args: { path: string }) => Promise<any> | any) | null = null;
+    const mockBuild = {
+      esbuild,
+      initialOptions: { outdir: tmpDir, write: false },
+      onLoad: (_filter: unknown, cb: (args: { path: string }) => Promise<any> | any) => {
+        onLoadCallback = cb;
+      },
+      onEnd: () => { /* noop */ },
+    } as unknown as esbuild.PluginBuild;
+
+    await plugin.setup(mockBuild);
+    expect(onLoadCallback).not.toBeNull();
+
+    const result = await onLoadCallback!({ path: tsFile });
+    expect(result).toBeDefined();
+    expect(result.loader).toBe("js");
+    expect(result.contents).toMatch(/worker-[a-z0-9]+\.js/i);
+  });
+});
+
+describe("transformWorkerPatterns — skipTsTransform 옵션", () => {
+  it("skipTsTransform: true + .ts 경로 + JS content → transformSync 호출 없이 정상 치환", () => {
+    const entryPath = path.join(fixturesDir, "entry.ts");
+    const { build, transformSyncCalls } = createTrackedBuild();
+
+    // ngtsc emit 결과를 흉내: 파일 경로는 .ts이지만 content는 이미 JS
+    const result = transformWorkerPatterns(
+      `const w = new Worker(new URL("./worker.js", import.meta.url));`,
+      entryPath,
+      build,
+      { skipTsTransform: true },
+    );
+
+    expect(transformSyncCalls).toHaveLength(0);
+    expect(result).toBeDefined();
+    expect(result!.contents).toMatch(/worker-[a-z0-9]+\.js/i);
+    expect(result!.errors).toHaveLength(0);
+  });
+
+  it("skipTsTransform: true + .ts 경로 + 실제 TS 구문 → 계약 위반으로 undefined (조용한 누락)", () => {
+    const entryPath = path.join(fixturesDir, "entry.ts");
+    const { build, transformSyncCalls } = createTrackedBuild();
+
+    // 호출자가 계약을 위반하여 실제 TS 구문을 넘긴 경우:
+    // transformSync가 스킵되므로 acorn이 TS 구문 파싱 실패 → 빈 matches → undefined
+    const result = transformWorkerPatterns(
+      `import type { T } from "pkg";
+const w = new Worker(new URL("./worker.js", import.meta.url));`,
+      entryPath,
+      build,
+      { skipTsTransform: true },
+    );
+
+    expect(transformSyncCalls).toHaveLength(0);
+    expect(result).toBeUndefined();
+  });
+
+  it("옵션 생략 + .ts + import type + Worker → transformSync 호출 후 정상 감지 (후방 호환)", () => {
+    const entryPath = path.join(fixturesDir, "entry.ts");
+    const { build, transformSyncCalls } = createTrackedBuild();
+
+    const result = transformWorkerPatterns(
+      `import type { T } from "pkg";
+const w = new Worker(new URL("./worker.js", import.meta.url));`,
+      entryPath,
+      build,
+    );
+
+    expect(transformSyncCalls).toHaveLength(1);
+    expect(transformSyncCalls[0][1]).toMatchObject({ loader: "ts" });
+    expect(result).toBeDefined();
+    expect(result!.contents).toMatch(/worker-[a-z0-9]+\.js/i);
+  });
+
+  it("옵션 { skipTsTransform: false } → 기본 동작 (transformSync 호출)", () => {
+    const entryPath = path.join(fixturesDir, "entry.ts");
+    const { build, transformSyncCalls } = createTrackedBuild();
+
+    const result = transformWorkerPatterns(
+      `import type { T } from "pkg";
+const w = new Worker(new URL("./worker.js", import.meta.url));`,
+      entryPath,
+      build,
+      { skipTsTransform: false },
+    );
+
+    expect(transformSyncCalls).toHaveLength(1);
+    expect(result).toBeDefined();
+    expect(result!.contents).toMatch(/worker-[a-z0-9]+\.js/i);
+  });
+
+  it("빈 객체 {} → skipTsTransform undefined → 기본 동작 (transformSync 호출)", () => {
+    const entryPath = path.join(fixturesDir, "entry.ts");
+    const { build, transformSyncCalls } = createTrackedBuild();
+
+    const result = transformWorkerPatterns(
+      `import type { T } from "pkg";
+const w = new Worker(new URL("./worker.js", import.meta.url));`,
+      entryPath,
+      build,
+      {},
+    );
+
+    expect(transformSyncCalls).toHaveLength(1);
+    expect(result).toBeDefined();
+  });
+
+  it("skipTsTransform: true + .js 경로 → 동작 동일 (확장자 분기 진입 안 함)", () => {
+    const entryPath = path.join(fixturesDir, "entry.js");
+    const { build, transformSyncCalls } = createTrackedBuild();
+
+    const result = transformWorkerPatterns(
+      `const w = new Worker(new URL("./worker.js", import.meta.url));`,
+      entryPath,
+      build,
+      { skipTsTransform: true },
+    );
+
+    expect(transformSyncCalls).toHaveLength(0);
+    expect(result).toBeDefined();
+    expect(result!.contents).toMatch(/worker-[a-z0-9]+\.js/i);
+  });
+});
+
+describe("transformWorkerPatterns — 사전 필터 정규식 경계", () => {
+  it("타입 어노테이션만 등장한 Worker 키워드 → 사전 필터 차단", () => {
+    const { build, transformSyncCalls } = createTrackedBuild();
+
+    const result = transformWorkerPatterns(
+      `const x: Worker = 1 as any;`,
+      path.join(fixturesDir, "entry.ts"),
+      build,
+    );
+
+    expect(transformSyncCalls).toHaveLength(0);
+    expect(result).toBeUndefined();
+  });
+
+  it("interface 선언에만 등장한 Worker → 사전 필터 차단", () => {
+    const { build, transformSyncCalls } = createTrackedBuild();
+
+    const result = transformWorkerPatterns(
+      `interface WorkerLike { run(): void; }`,
+      path.join(fixturesDir, "entry.ts"),
+      build,
+    );
+
+    expect(transformSyncCalls).toHaveLength(0);
+    expect(result).toBeUndefined();
+  });
+
+  it("import type에만 등장한 Worker → 사전 필터 차단", () => {
+    const { build, transformSyncCalls } = createTrackedBuild();
+
+    const result = transformWorkerPatterns(
+      `import type { Worker } from "./types";`,
+      path.join(fixturesDir, "entry.ts"),
+      build,
+    );
+
+    expect(transformSyncCalls).toHaveLength(0);
+    expect(result).toBeUndefined();
+  });
+
+  it("new Worker 호출 → 사전 필터 통과, AST 감지", () => {
+    const entryPath = path.join(fixturesDir, "entry.js");
+    const result = transformWorkerPatterns(
+      `const w = new Worker(new URL("./worker.js", import.meta.url));`,
+      entryPath,
+      createMockBuild(),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.contents).toMatch(/worker-[a-z0-9]+\.js/i);
+  });
+
+  it("new SharedWorker 호출 → 사전 필터 통과, AST 감지", () => {
+    const entryPath = path.join(fixturesDir, "entry.js");
+    const result = transformWorkerPatterns(
+      `const sw = new SharedWorker(new URL("./shared-worker.js", import.meta.url));`,
+      entryPath,
+      createMockBuild(),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.contents).toMatch(/worker-[a-z0-9]+\.js/i);
+  });
+
+  it("import.meta.resolve 호출 → 사전 필터 통과, AST 감지", () => {
+    const entryPath = path.join(fixturesDir, "entry.js");
+    const result = transformWorkerPatterns(
+      `const p = import.meta.resolve("./node-worker.js");`,
+      entryPath,
+      createMockBuild({ platform: "node" }),
+    );
+
+    expect(result).toBeDefined();
+    expect(result!.contents).toMatch(
+      /new URL\("worker-[a-z0-9]+\.js", import\.meta\.url\)\.href/i,
+    );
+  });
+
+  it("new  Worker (연속 공백) → 사전 필터 통과", () => {
+    const entryPath = path.join(fixturesDir, "entry.js");
+    const result = transformWorkerPatterns(
+      `const w = new   Worker(new URL("./worker.js", import.meta.url));`,
+      entryPath,
+      createMockBuild(),
+    );
+
+    expect(result).toBeDefined();
+  });
+
+  it("WorkerSubClass 식별자 (단어 경계 위반) → 사전 필터 차단", () => {
+    const { build, transformSyncCalls } = createTrackedBuild();
+
+    const result = transformWorkerPatterns(
+      `class WorkerSubClass {}\nconst x = new WorkerSubClass();`,
+      path.join(fixturesDir, "entry.ts"),
+      build,
+    );
+
+    expect(transformSyncCalls).toHaveLength(0);
+    expect(result).toBeUndefined();
+  });
+});