@simplysm/core-node 13.0.69 → 13.0.71

package/src/utils/fs.ts

@@ -5,19 +5,19 @@ import { glob as globRaw, type GlobOptions, globSync as globRawSync } from "glob
 import { jsonParse, jsonStringify, SdError } from "@simplysm/core-common";
 import "@simplysm/core-common";
 
-//#region 존재 확인
+//#region Existence Check
 
 /**
- * 파일 또는 디렉토리 존재 확인 (동기).
- * @param targetPath - 확인할 경로
+ * Checks if a file or directory exists (synchronous).
+ * @param targetPath - Path to check
  */
 export function fsExistsSync(targetPath: string): boolean {
   return fs.existsSync(targetPath);
 }
 
 /**
- * 파일 또는 디렉토리 존재 확인 (비동기).
- * @param targetPath - 확인할 경로
+ * Checks if a file or directory exists (asynchronous).
+ * @param targetPath - Path to check
  */
 export async function fsExists(targetPath: string): Promise<boolean> {
   try {
@@ -30,11 +30,11 @@ export async function fsExists(targetPath: string): Promise<boolean> {
 
 //#endregion
 
-//#region 디렉토리 생성
+//#region Create Directory
 
 /**
- * 디렉토리 생성 (recursive).
- * @param targetPath - 생성할 디렉토리 경로
+ * Creates a directory (recursive).
+ * @param targetPath - Directory path to create
  */
 export function fsMkdirSync(targetPath: string): void {
   try {
@@ -45,8 +45,8 @@ export function fsMkdirSync(targetPath: string): void {
 }
 
 /**
- * 디렉토리 생성 (recursive, 비동기).
- * @param targetPath - 생성할 디렉토리 경로
+ * Creates a directory (recursive, asynchronous).
+ * @param targetPath - Directory path to create
  */
 export async function fsMkdir(targetPath: string): Promise<void> {
   try {
@@ -58,12 +58,12 @@ export async function fsMkdir(targetPath: string): Promise<void> {
 
 //#endregion
 
-//#region 삭제
+//#region Delete
 
 /**
- * 파일 또는 디렉토리 삭제.
- * @param targetPath - 삭제할 경로
- * @remarks 동기 버전은 재시도 없이 즉시 실패함. 파일 잠금 등 일시적 오류 가능성이 있는 경우 fsRm 사용을 권장함.
+ * Deletes a file or directory.
+ * @param targetPath - Path to delete
+ * @remarks The synchronous version fails immediately without retries. Use fsRm for cases with potential transient errors like file locks.
  */
 export function fsRmSync(targetPath: string): void {
   try {
@@ -74,9 +74,9 @@ export function fsRmSync(targetPath: string): void {
 }
 
 /**
- * 파일 또는 디렉토리 삭제 (비동기).
- * @param targetPath - 삭제할 경로
- * @remarks 비동기 버전은 파일 잠금 등의 일시적 오류에 대해 최대 6회(500ms 간격) 재시도함.
+ * Deletes a file or directory (asynchronous).
+ * @param targetPath - Path to delete
+ * @remarks The asynchronous version retries up to 6 times (500ms interval) for transient errors like file locks.
  */
 export async function fsRm(targetPath: string): Promise<void> {
   try {
@@ -93,21 +93,21 @@ export async function fsRm(targetPath: string): Promise<void> {
 
 //#endregion
 
-//#region 복사
+//#region Copy
 
 /**
- * 파일 또는 디렉토리 복사.
+ * Copies a file or directory.
  *
- * sourcePath가 존재하지 않으면 아무 작업도 수행하지 않고 반환한다.
+ * If sourcePath does not exist, no action is performed and the function returns.
  *
- * @param sourcePath 복사할 원본 경로
- * @param targetPath 복사 대상 경로
- * @param filter 복사 여부를 결정하는 필터 함수.
- *               각 파일/디렉토리의 **절대 경로**가 전달되며,
- *               true를 반환하면 복사, false면 제외.
- *               **주의**: 최상위 sourcePath는 필터 대상이 아니며,
- *               모든 하위 항목(자식, 손자 등)에 재귀적으로 filter 함수가 적용된다.
- *               디렉토리에 false를 반환하면 해당 디렉토리와 모든 하위 항목이 건너뛰어짐.
+ * @param sourcePath Path of the source to copy
+ * @param targetPath Destination path for the copy
+ * @param filter A filter function that determines whether to copy.
+ *               The **absolute path** of each file/directory is passed.
+ *               Returns true to copy, false to exclude.
+ *               **Note**: The top-level sourcePath is not subject to filtering;
+ *               the filter function is applied recursively to all children (direct and indirect).
+ *               Returning false for a directory skips that directory and all its contents.
  */
 export function fsCopySync(
   sourcePath: string,
@@ -151,18 +151,18 @@ export function fsCopySync(
 }
 
 /**
- * 파일 또는 디렉토리 복사 (비동기).
+ * Copies a file or directory (asynchronous).
  *
- * sourcePath가 존재하지 않으면 아무 작업도 수행하지 않고 반환한다.
+ * If sourcePath does not exist, no action is performed and the function returns.
  *
- * @param sourcePath 복사할 원본 경로
- * @param targetPath 복사 대상 경로
- * @param filter 복사 여부를 결정하는 필터 함수.
- *               각 파일/디렉토리의 **절대 경로**가 전달되며,
- *               true를 반환하면 복사, false면 제외.
- *               **주의**: 최상위 sourcePath는 필터 대상이 아니며,
- *               모든 하위 항목(자식, 손자 등)에 재귀적으로 filter 함수가 적용된다.
- *               디렉토리에 false를 반환하면 해당 디렉토리와 모든 하위 항목이 건너뛰어짐.
+ * @param sourcePath Path of the source to copy
+ * @param targetPath Destination path for the copy
+ * @param filter A filter function that determines whether to copy.
+ *               The **absolute path** of each file/directory is passed.
+ *               Returns true to copy, false to exclude.
+ *               **Note**: The top-level sourcePath is not subject to filtering;
+ *               the filter function is applied recursively to all children (direct and indirect).
+ *               Returning false for a directory skips that directory and all its contents.
  */
 export async function fsCopy(
   sourcePath: string,
@@ -207,11 +207,11 @@ export async function fsCopy(
 
 //#endregion
 
-//#region 파일 읽기
+//#region Read File
 
 /**
- * 파일 읽기 (UTF-8 문자열).
- * @param targetPath - 읽을 파일 경로
+ * Reads a file as a UTF-8 string.
+ * @param targetPath - Path of the file to read
  */
 export function fsReadSync(targetPath: string): string {
   try {
@@ -222,8 +222,8 @@ export function fsReadSync(targetPath: string): string {
 }
 
 /**
- * 파일 읽기 (UTF-8 문자열, 비동기).
- * @param targetPath - 읽을 파일 경로
+ * Reads a file as a UTF-8 string (asynchronous).
+ * @param targetPath - Path of the file to read
  */
 export async function fsRead(targetPath: string): Promise<string> {
   try {
@@ -234,8 +234,8 @@ export async function fsRead(targetPath: string): Promise<string> {
 }
 
 /**
- * 파일 읽기 (Buffer).
- * @param targetPath - 읽을 파일 경로
+ * Reads a file as a Buffer.
+ * @param targetPath - Path of the file to read
  */
 export function fsReadBufferSync(targetPath: string): Buffer {
   try {
@@ -246,8 +246,8 @@ export function fsReadBufferSync(targetPath: string): Buffer {
 }
 
 /**
- * 파일 읽기 (Buffer, 비동기).
- * @param targetPath - 읽을 파일 경로
+ * Reads a file as a Buffer (asynchronous).
+ * @param targetPath - Path of the file to read
  */
 export async function fsReadBuffer(targetPath: string): Promise<Buffer> {
   try {
@@ -258,8 +258,8 @@ export async function fsReadBuffer(targetPath: string): Promise<Buffer> {
 }
 
 /**
- * JSON 파일 읽기 (JsonConvert 사용).
- * @param targetPath - 읽을 JSON 파일 경로
+ * Reads a JSON file (using JsonConvert).
+ * @param targetPath - Path of the JSON file to read
  */
 export function fsReadJsonSync<TData = unknown>(targetPath: string): TData {
   const contents = fsReadSync(targetPath);
@@ -272,8 +272,8 @@ export function fsReadJsonSync<TData = unknown>(targetPath: string): TData {
 }
 
 /**
- * JSON 파일 읽기 (JsonConvert 사용, 비동기).
- * @param targetPath - 읽을 JSON 파일 경로
+ * Reads a JSON file (using JsonConvert, asynchronous).
+ * @param targetPath - Path of the JSON file to read
  */
 export async function fsReadJson<TData = unknown>(targetPath: string): Promise<TData> {
   const contents = await fsRead(targetPath);
@@ -287,12 +287,12 @@ export async function fsReadJson<TData = unknown>(targetPath: string): Promise<T
 
 //#endregion
 
-//#region 파일 쓰기
+//#region Write File
 
 /**
- * 파일 쓰기 (부모 디렉토리 자동 생성).
- * @param targetPath - 쓸 파일 경로
- * @param data - 쓸 데이터 (문자열 또는 바이너리)
+ * Writes data to a file (auto-creates parent directories).
+ * @param targetPath - Path of the file to write
+ * @param data - Data to write (string or binary)
  */
 export function fsWriteSync(targetPath: string, data: string | Uint8Array): void {
   fsMkdirSync(path.dirname(targetPath));
@@ -305,9 +305,9 @@ export function fsWriteSync(targetPath: string, data: string | Uint8Array): void
 }
 
 /**
- * 파일 쓰기 (부모 디렉토리 자동 생성, 비동기).
- * @param targetPath - 쓸 파일 경로
- * @param data - 쓸 데이터 (문자열 또는 바이너리)
+ * Writes data to a file (auto-creates parent directories, asynchronous).
+ * @param targetPath - Path of the file to write
+ * @param data - Data to write (string or binary)
  */
 export async function fsWrite(targetPath: string, data: string | Uint8Array): Promise<void> {
   await fsMkdir(path.dirname(targetPath));
@@ -320,10 +320,10 @@ export async function fsWrite(targetPath: string, data: string | Uint8Array): Pr
 }
 
 /**
- * JSON 파일 쓰기 (JsonConvert 사용).
- * @param targetPath - 쓸 JSON 파일 경로
- * @param data - 쓸 데이터
- * @param options - JSON 직렬화 옵션
+ * Writes data to a JSON file (using JsonConvert).
+ * @param targetPath - Path of the JSON file to write
+ * @param data - Data to write
+ * @param options - JSON serialization options
  */
 export function fsWriteJsonSync(
   targetPath: string,
@@ -338,10 +338,10 @@ export function fsWriteJsonSync(
 }
 
 /**
- * JSON 파일 쓰기 (JsonConvert 사용, 비동기).
- * @param targetPath - 쓸 JSON 파일 경로
- * @param data - 쓸 데이터
- * @param options - JSON 직렬화 옵션
+ * Writes data to a JSON file (using JsonConvert, asynchronous).
+ * @param targetPath - Path of the JSON file to write
+ * @param data - Data to write
+ * @param options - JSON serialization options
  */
 export async function fsWriteJson(
   targetPath: string,
@@ -357,11 +357,11 @@ export async function fsWriteJson(
 
 //#endregion
 
-//#region 디렉토리 읽기
+//#region Read Directory
 
 /**
- * 디렉토리 내용 읽기.
- * @param targetPath - 읽을 디렉토리 경로
+ * Reads the contents of a directory.
+ * @param targetPath - Path of the directory to read
  */
 export function fsReaddirSync(targetPath: string): string[] {
   try {
@@ -372,8 +372,8 @@ export function fsReaddirSync(targetPath: string): string[] {
 }
 
 /**
- * 디렉토리 내용 읽기 (비동기).
- * @param targetPath - 읽을 디렉토리 경로
+ * Reads the contents of a directory (asynchronous).
+ * @param targetPath - Path of the directory to read
  */
 export async function fsReaddir(targetPath: string): Promise<string[]> {
   try {
@@ -385,11 +385,11 @@ export async function fsReaddir(targetPath: string): Promise<string[]> {
 
 //#endregion
 
-//#region 파일 정보
+//#region File Information
 
 /**
- * 파일/디렉토리 정보 (심볼릭 링크 따라감).
- * @param targetPath - 정보를 조회할 경로
+ * Gets file/directory information (follows symbolic links).
+ * @param targetPath - Path to query information for
  */
 export function fsStatSync(targetPath: string): fs.Stats {
   try {
@@ -400,8 +400,8 @@ export function fsStatSync(targetPath: string): fs.Stats {
 }
 
 /**
- * 파일/디렉토리 정보 (심볼릭 링크 따라감, 비동기).
- * @param targetPath - 정보를 조회할 경로
+ * Gets file/directory information (follows symbolic links, asynchronous).
+ * @param targetPath - Path to query information for
  */
 export async function fsStat(targetPath: string): Promise<fs.Stats> {
   try {
@@ -412,8 +412,8 @@ export async function fsStat(targetPath: string): Promise<fs.Stats> {
 }
 
 /**
- * 파일/디렉토리 정보 (심볼릭 링크 따라가지 않음).
- * @param targetPath - 정보를 조회할 경로
+ * Gets file/directory information (does not follow symbolic links).
+ * @param targetPath - Path to query information for
  */
 export function fsLstatSync(targetPath: string): fs.Stats {
   try {
@@ -424,8 +424,8 @@ export function fsLstatSync(targetPath: string): fs.Stats {
 }
 
 /**
- * 파일/디렉토리 정보 (심볼릭 링크 따라가지 않음, 비동기).
- * @param targetPath - 정보를 조회할 경로
+ * Gets file/directory information (does not follow symbolic links, asynchronous).
+ * @param targetPath - Path to query information for
  */
 export async function fsLstat(targetPath: string): Promise<fs.Stats> {
   try {
@@ -437,13 +437,13 @@ export async function fsLstat(targetPath: string): Promise<fs.Stats> {
 
 //#endregion
 
-//#region 글로브
+//#region Glob
 
 /**
- * 글로브 패턴으로 파일 검색.
- * @param pattern - 글로브 패턴 (예: "**\/*.ts")
- * @param options - glob 옵션
- * @returns 매칭된 파일들의 절대 경로 배열
+ * Searches for files using a glob pattern.
+ * @param pattern - Glob pattern (e.g., "**\/*.ts")
+ * @param options - glob options
+ * @returns Array of absolute paths for matched files
  */
 export function fsGlobSync(pattern: string, options?: GlobOptions): string[] {
   return globRawSync(pattern.replace(/\\/g, "/"), options ?? {}).map((item) =>
@@ -452,10 +452,10 @@ export function fsGlobSync(pattern: string, options?: GlobOptions): string[] {
 }
 
 /**
- * 글로브 패턴으로 파일 검색 (비동기).
- * @param pattern - 글로브 패턴 (예: "**\/*.ts")
- * @param options - glob 옵션
- * @returns 매칭된 파일들의 절대 경로 배열
+ * Searches for files using a glob pattern (asynchronous).
+ * @param pattern - Glob pattern (e.g., "**\/*.ts")
+ * @param options - glob options
+ * @returns Array of absolute paths for matched files
  */
 export async function fsGlob(pattern: string, options?: GlobOptions): Promise<string[]> {
   return (await globRaw(pattern.replace(/\\/g, "/"), options ?? {})).map((item) =>
@@ -465,11 +465,11 @@ export async function fsGlob(pattern: string, options?: GlobOptions): Promise<st
 
 //#endregion
 
-//#region 유틸리티
+//#region Utilities
 
 /**
- * 지정 디렉토리 하위의 빈 디렉토리를 재귀적으로 탐색하여 삭제.
- * 하위 디렉토리가 모두 삭제되어 빈 디렉토리가 된 경우, 해당 디렉토리도 삭제 대상이 됨.
+ * Recursively searches and deletes empty directories under a specified directory.
+ * If all child directories are deleted and a parent becomes empty, it will also be deleted.
  */
 export async function fsClearEmptyDirectory(dirPath: string): Promise<void> {
   if (!(await fsExists(dirPath))) return;
@@ -486,23 +486,23 @@ export async function fsClearEmptyDirectory(dirPath: string): Promise<void> {
     }
   }
 
-  // 파일이 있었다면 삭제 불가
+  // If there are files, cannot delete
   if (hasFiles) return;
 
-  // 파일이 없었던 경우에만 재확인 (하위 디렉토리가 삭제되었을 수 있음)
+  // Only re-check if there were no files (child directories may have been deleted)
   if ((await fsReaddir(dirPath)).length === 0) {
     await fsRm(dirPath);
   }
 }
 
 /**
- * 시작 경로부터 루트 방향으로 상위 디렉토리를 순회하며 glob 패턴 검색.
- * 각 디렉토리에서 childGlob 패턴에 매칭되는 모든 파일 경로를 수집.
- * @param childGlob - 각 디렉토리에서 검색할 glob 패턴
- * @param fromPath - 검색 시작 경로
- * @param rootPath - 검색 종료 경로 (미지정 시 파일시스템 루트까지).
- *                   **주의**: fromPath가 rootPath의 자식 경로여야 함.
- *                   그렇지 않으면 파일시스템 루트까지 검색함.
+ * Searches for files matching a glob pattern by traversing parent directories from a start path towards the root.
+ * Collects all file paths matching the childGlob pattern in each directory.
+ * @param childGlob - Glob pattern to search for in each directory
+ * @param fromPath - Path to start searching from
+ * @param rootPath - Path to stop searching at (if not specified, searches to filesystem root).
+ *                   **Note**: fromPath must be a child path of rootPath.
+ *                   Otherwise, searches to the filesystem root.
  */
 export function fsFindAllParentChildPathsSync(
   childGlob: string,
@@ -528,13 +528,13 @@ export function fsFindAllParentChildPathsSync(
 }
 
 /**
- * 시작 경로부터 루트 방향으로 상위 디렉토리를 순회하며 glob 패턴 검색 (비동기).
- * 각 디렉토리에서 childGlob 패턴에 매칭되는 모든 파일 경로를 수집.
- * @param childGlob - 각 디렉토리에서 검색할 glob 패턴
- * @param fromPath - 검색 시작 경로
- * @param rootPath - 검색 종료 경로 (미지정 시 파일시스템 루트까지).
- *                   **주의**: fromPath가 rootPath의 자식 경로여야 함.
- *                   그렇지 않으면 파일시스템 루트까지 검색함.
+ * Searches for files matching a glob pattern by traversing parent directories from a start path towards the root (asynchronous).
+ * Collects all file paths matching the childGlob pattern in each directory.
+ * @param childGlob - Glob pattern to search for in each directory
+ * @param fromPath - Path to start searching from
+ * @param rootPath - Path to stop searching at (if not specified, searches to filesystem root).
+ *                   **Note**: fromPath must be a child path of rootPath.
+ *                   Otherwise, searches to the filesystem root.
  */
 export async function fsFindAllParentChildPaths(
   childGlob: string,

package/src/utils/path.ts

@@ -6,8 +6,8 @@ import { ArgumentError } from "@simplysm/core-common";
 const NORM = Symbol("NormPath");
 
 /**
- * 정규화된 경로를 나타내는 브랜드 타입.
- * pathNorm()을 통해서만 생성 가능.
+ * Brand type representing a normalized path.
+ * Can only be created through pathNorm().
  */
 export type NormPath = string & {
   [NORM]: never;
@@ -15,10 +15,10 @@ export type NormPath = string & {
 
 //#endregion
 
-//#region 함수
+//#region Functions
 
 /**
- * POSIX 스타일 경로로 변환 (백슬래시 → 슬래시).
+ * Converts to POSIX-style path (backslash → forward slash).
  *
  * @example
  * pathPosix("C:\\Users\\test"); // "C:/Users/test"
@@ -30,13 +30,13 @@ export function pathPosix(...args: string[]): string {
 }
 
 /**
- * 파일 경로의 디렉토리를 변경.
+ * Changes the directory of a file path.
  *
  * @example
  * pathChangeFileDirectory("/a/b/c.txt", "/a", "/x");
  * // → "/x/b/c.txt"
  *
- * @throws 파일이 fromDirectory 안에 없으면 에러
+ * @throws Error if the file is not inside fromDirectory
  */
 export function pathChangeFileDirectory(
   filePath: string,
@@ -48,7 +48,7 @@ export function pathChangeFileDirectory(
   }
 
   if (!pathIsChildPath(filePath, fromDirectory)) {
-    throw new ArgumentError(`'${filePath}'가 ${fromDirectory} 안에 없습니다.`, {
+    throw new ArgumentError(`'${filePath}' is not inside ${fromDirectory}.`, {
       filePath,
       fromDirectory,
     });
@@ -58,7 +58,7 @@ export function pathChangeFileDirectory(
 }
 
 /**
- * 확장자를 제거한 파일명(basename)을 반환.
+ * Returns the filename (basename) without extension.
  *
  * @example
  * pathBasenameWithoutExt("file.txt"); // "file"
@@ -69,27 +69,27 @@ export function pathBasenameWithoutExt(filePath: string): string {
 }
 
 /**
- * childPath가 parentPath의 자식 경로인지 확인.
- * 같은 경로는 false 반환.
+ * Checks if childPath is a child path of parentPath.
+ * Returns false if the paths are the same.
  *
- * 경로는 내부적으로 `pathNorm()`으로 정규화된 후 비교되며,
- * 플랫폼별 경로 구분자(Windows: `\`, Unix: `/`)를 사용한다.
+ * Paths are internally normalized using `pathNorm()` and compared using
+ * platform-specific path separators (Windows: `\`, Unix: `/`).
  *
  * @example
  * pathIsChildPath("/a/b/c", "/a/b"); // true
  * pathIsChildPath("/a/b", "/a/b/c"); // false
- * pathIsChildPath("/a/b", "/a/b"); // false (같은 경로)
+ * pathIsChildPath("/a/b", "/a/b"); // false (same path)
  */
 export function pathIsChildPath(childPath: string, parentPath: string): boolean {
   const normalizedChild = pathNorm(childPath);
   const normalizedParent = pathNorm(parentPath);
 
-  // 같은 경로면 false
+  // Same path returns false
   if (normalizedChild === normalizedParent) {
     return false;
   }
 
-  // 부모 경로 + 구분자로 시작하는지 확인
+  // Check if it starts with parent path + separator
   const parentWithSep = normalizedParent.endsWith(path.sep)
     ? normalizedParent
     : normalizedParent + path.sep;
@@ -98,27 +98,27 @@ export function pathIsChildPath(childPath: string, parentPath: string): boolean
 }
 
 /**
- * 경로를 정규화하여 NormPath로 반환.
- * 절대 경로로 변환되며, 플랫폼별 구분자로 정규화됨.
+ * Normalizes the path and returns it as NormPath.
+ * Converts to absolute path and normalizes using platform-specific separators.
  *
  * @example
  * pathNorm("/some/path"); // NormPath
- * pathNorm("relative", "path"); // NormPath (절대 경로로 변환)
+ * pathNorm("relative", "path"); // NormPath (converted to absolute path)
  */
 export function pathNorm(...paths: string[]): NormPath {
   return path.resolve(...paths) as NormPath;
 }
 
 /**
- * 타겟 경로 목록을 기준으로 파일을 필터링.
- * 파일이 타겟 경로와 같거나 타겟의 자식 경로일 때 포함.
+ * Filters files based on a list of target paths.
+ * Includes files that match or are children of a target path.
  *
- * @param files - 필터링할 파일 경로 목록.
- *                **주의**: cwd 하위의 절대 경로여야 함.
- *                cwd 외부 경로는 상대 경로(../ 형태)로 변환되어 처리됨.
- * @param targets - 타겟 경로 목록 (cwd 기준 상대 경로, POSIX 스타일 권장)
- * @param cwd - 현재 작업 디렉토리 (절대 경로)
- * @returns targets가 빈 배열이면 files 그대로, 아니면 타겟 경로 하위 파일만
+ * @param files - File paths to filter.
+ *                **Note**: Must be absolute paths under cwd.
+ *                Paths outside cwd are converted to relative paths (../) for processing.
+ * @param targets - Target paths (relative to cwd, POSIX style recommended)
+ * @param cwd - Current working directory (absolute path)
+ * @returns If targets is empty, returns files as-is; otherwise returns only files under target paths
  *
  * @example
  * const files = ["/proj/src/a.ts", "/proj/src/b.ts", "/proj/tests/c.ts"];

package/src/worker/create-worker.ts

@@ -2,18 +2,18 @@ import { parentPort } from "worker_threads";
 import { SdError, transferableDecode, transferableEncode } from "@simplysm/core-common";
 import type { WorkerRequest, WorkerResponse } from "./types";
 
-//#region createSdWorker
+//#region createWorker
 
 /**
- * 워커 스레드에서 사용할 워커 팩토리.
+ * Worker factory for use in worker threads.
  *
  * @example
- * // 이벤트 없는 워커
+ * // Worker without events
  * export default createWorker({
  *   add: (a: number, b: number) => a + b,
  * });
  *
- * // 이벤트 있는 워커
+ * // Worker with events
  * interface MyEvents { progress: number; }
  * const methods = {
  *   calc: (x: number) => { sender.send("progress", 50); return x * 2; },
@@ -32,13 +32,13 @@ export function createWorker<
   __events: TEvents;
 } {
   if (parentPort === null) {
-    throw new SdError("이 스크립트는 워커 스레드에서 실행되어야 합니다 (parentPort 필요).");
+    throw new SdError("This script must be executed in a worker thread (parentPort required).");
   }
 
   const port = parentPort;
 
-  // Worker 스레드의 stdout은 메인 스레드로 자동 전달되지 않음
-  // stdout.write를 가로채서 메시지 프로토콜을 통해 메인 스레드로 전달
+  // Worker thread's stdout is not automatically forwarded to the main thread
+  // Intercept stdout.write and forward it to the main thread via message protocol
   process.stdout.write = (
     chunk: string | Uint8Array,
     encodingOrCallback?: BufferEncoding | ((err?: Error) => void),
@@ -60,7 +60,7 @@ export function createWorker<
   port.on("message", async (serializedRequest: unknown) => {
     const decoded = transferableDecode(serializedRequest);
 
-    // 요청 구조 검증
+    // Validate request structure
     if (
       decoded == null ||
       typeof decoded !== "object" ||
@@ -77,7 +77,7 @@ export function createWorker<
       const errorResponse: WorkerResponse = {
         type: "error",
         request: { id: "unknown", method: "unknown", params: [] },
-        body: new SdError(`형식이 잘못된 워커 요청: ${decodedStr}`),
+        body: new SdError(`Invalid worker request format: ${decodedStr}`),
       };
       const serialized = transferableEncode(errorResponse);
       port.postMessage(serialized.result, serialized.transferList);
@@ -91,7 +91,7 @@ export function createWorker<
       const response: WorkerResponse = {
         request,
         type: "error",
-        body: new SdError(`알 수 없는 메서드: ${request.method}`),
+        body: new SdError(`Unknown method: ${request.method}`),
       };
 
       const serialized = transferableEncode(response);