@simplysm/core-node 13.0.0-beta.7 → 13.0.1

package/src/worker/create-worker.ts

@@ -0,0 +1,141 @@
+import { parentPort } from "worker_threads";
+import { SdError, transferableDecode, transferableEncode } from "@simplysm/core-common";
+import type { WorkerRequest, WorkerResponse } from "./types";
+
+//#region createSdWorker
+
+/**
+ * 워커 스레드에서 사용할 워커 팩토리.
+ *
+ * @example
+ * // 이벤트 없는 워커
+ * export default createWorker({
+ *   add: (a: number, b: number) => a + b,
+ * });
+ *
+ * // 이벤트 있는 워커
+ * interface MyEvents { progress: number; }
+ * const methods = {
+ *   calc: (x: number) => { sender.send("progress", 50); return x * 2; },
+ * };
+ * const sender = createWorker<typeof methods, MyEvents>(methods);
+ * export default sender;
+ */
+export function createWorker<
+  TMethods extends Record<string, (...args: any[]) => unknown>,
+  TEvents extends Record<string, unknown> = Record<string, never>,
+>(
+  methods: TMethods,
+): {
+  send<K extends keyof TEvents & string>(event: K, data?: TEvents[K]): void;
+  __methods: TMethods;
+  __events: TEvents;
+} {
+  if (parentPort === null) {
+    throw new SdError("이 스크립트는 워커 스레드에서 실행되어야 합니다 (parentPort 필요).");
+  }
+
+  const port = parentPort;
+
+  // Worker 스레드의 stdout은 메인 스레드로 자동 전달되지 않음
+  // stdout.write를 가로채서 메시지 프로토콜을 통해 메인 스레드로 전달
+  process.stdout.write = (
+    chunk: string | Uint8Array,
+    encodingOrCallback?: BufferEncoding | ((err?: Error) => void),
+    callback?: (err?: Error) => void,
+  ): boolean => {
+    const body = typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk);
+    const response: WorkerResponse = { type: "log", body };
+    const serialized = transferableEncode(response);
+    port.postMessage(serialized.result, serialized.transferList);
+
+    const cb = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
+    if (cb) {
+      queueMicrotask(() => cb());
+    }
+
+    return true;
+  };
+
+  port.on("message", async (serializedRequest: unknown) => {
+    const decoded = transferableDecode(serializedRequest);
+
+    // 요청 구조 검증
+    if (
+      decoded == null ||
+      typeof decoded !== "object" ||
+      !("id" in decoded) ||
+      !("method" in decoded) ||
+      !("params" in decoded)
+    ) {
+      let decodedStr: string;
+      try {
+        decodedStr = JSON.stringify(decoded);
+      } catch {
+        decodedStr = String(decoded);
+      }
+      const errorResponse: WorkerResponse = {
+        type: "error",
+        request: { id: "unknown", method: "unknown", params: [] },
+        body: new SdError(`형식이 잘못된 워커 요청: ${decodedStr}`),
+      };
+      const serialized = transferableEncode(errorResponse);
+      port.postMessage(serialized.result, serialized.transferList);
+      return;
+    }
+    const request = decoded as WorkerRequest;
+
+    const methodFn = methods[request.method] as ((...args: unknown[]) => unknown) | undefined;
+
+    if (methodFn == null) {
+      const response: WorkerResponse = {
+        request,
+        type: "error",
+        body: new SdError(`알 수 없는 메서드: ${request.method}`),
+      };
+
+      const serialized = transferableEncode(response);
+      port.postMessage(serialized.result, serialized.transferList);
+      return;
+    }
+
+    try {
+      const result = await methodFn(...request.params);
+
+      const response: WorkerResponse = {
+        request,
+        type: "return",
+        body: result,
+      };
+
+      const serialized = transferableEncode(response);
+      port.postMessage(serialized.result, serialized.transferList);
+    } catch (err) {
+      const response: WorkerResponse = {
+        request,
+        type: "error",
+        body: err instanceof Error ? err : new Error(String(err)),
+      };
+
+      const serialized = transferableEncode(response);
+      port.postMessage(serialized.result, serialized.transferList);
+    }
+  });
+
+  return {
+    __methods: methods,
+    __events: {} as TEvents,
+    send<K extends keyof TEvents & string>(event: K, data?: TEvents[K]) {
+      const response: WorkerResponse = {
+        type: "event",
+        event,
+        body: data,
+      };
+
+      const serialized = transferableEncode(response);
+      port.postMessage(serialized.result, serialized.transferList);
+    },
+  };
+}
+
+//#endregion

package/src/worker/types.ts

@@ -0,0 +1,86 @@
+//#region Types
+
+/**
+ * `createWorker()`가 반환하는 워커 모듈의 타입 구조.
+ * `Worker.create<typeof import("./worker")>()`에서 타입 추론에 사용된다.
+ *
+ * @see createWorker - 워커 모듈 생성
+ * @see Worker.create - 워커 프록시 생성
+ */
+export interface WorkerModule {
+  default: {
+    __methods: Record<string, (...args: any[]) => unknown>;
+    __events: Record<string, unknown>;
+  };
+}
+
+/**
+ * 메서드 타입의 반환값을 Promise로 래핑하는 매핑 타입.
+ * 워커 메서드는 postMessage 기반으로 동작하여 항상 비동기이므로,
+ * 동기 메서드 타입도 `Promise<Awaited<R>>`로 변환한다.
+ */
+export type PromisifyMethods<T> = {
+  [K in keyof T]: T[K] extends (...args: infer P) => infer R ? (...args: P) => Promise<Awaited<R>> : never;
+};
+
+/**
+ * SdWorker.create()가 반환하는 Proxy 타입.
+ * Promisified 메서드들 + on() + terminate() 제공.
+ */
+export type WorkerProxy<TModule extends WorkerModule> = PromisifyMethods<TModule["default"]["__methods"]> & {
+  /**
+   * 워커 이벤트 리스너 등록.
+   */
+  on<K extends keyof TModule["default"]["__events"] & string>(
+    event: K,
+    listener: (data: TModule["default"]["__events"][K]) => void,
+  ): void;
+
+  /**
+   * 워커 이벤트 리스너 제거.
+   */
+  off<K extends keyof TModule["default"]["__events"] & string>(
+    event: K,
+    listener: (data: TModule["default"]["__events"][K]) => void,
+  ): void;
+
+  /**
+   * 워커 종료.
+   */
+  terminate(): Promise<void>;
+};
+
+/**
+ * Worker 내부 요청 메시지.
+ */
+export interface WorkerRequest {
+  id: string;
+  method: string;
+  params: unknown[];
+}
+
+/**
+ * Worker 내부 응답 메시지.
+ */
+export type WorkerResponse =
+  | {
+      request: WorkerRequest;
+      type: "return";
+      body?: unknown;
+    }
+  | {
+      request: WorkerRequest;
+      type: "error";
+      body: Error;
+    }
+  | {
+      type: "event";
+      event: string;
+      body?: unknown;
+    }
+  | {
+      type: "log";
+      body: string;
+    };
+
+//#endregion

package/src/worker/worker.ts

@@ -0,0 +1,209 @@
+import { EventEmitter, transferableDecode, transferableEncode, Uuid } from "@simplysm/core-common";
+import consola from "consola";
+import path from "path";
+import { fileURLToPath } from "url";
+import type { WorkerOptions as WorkerRawOptions } from "worker_threads";
+import { Worker as WorkerRaw } from "worker_threads";
+import type { WorkerModule, WorkerProxy, WorkerRequest, WorkerResponse } from "./types";
+
+const logger = consola.withTag("sd-worker");
+
+//#region WorkerInternal
+
+/**
+ * Worker 내부 구현 클래스.
+ * Proxy를 통해 외부에 노출됨.
+ *
+ * 개발 환경(.ts)에서는 tsx를 통해 TypeScript 워커 파일을 실행하고,
+ * 프로덕션 환경(.js)에서는 직접 Worker를 생성한다.
+ */
+class WorkerInternal extends EventEmitter<Record<string, unknown>> {
+  private readonly _worker: WorkerRaw;
+  private _isTerminated = false;
+  private readonly _pendingRequests = new Map<
+    string,
+    { method: string; resolve: (value: unknown) => void; reject: (err: Error) => void }
+  >();
+
+  constructor(filePath: string, opt?: Omit<WorkerRawOptions, "stdout" | "stderr">) {
+    super();
+
+    const ext = path.extname(import.meta.filename);
+
+    // 타입 가드를 통한 env 객체 추출
+    const envObj = opt?.env != null && typeof opt.env === "object" ? opt.env : {};
+
+    // 개발 환경 (.ts 파일)인 경우 tsx를 통해 실행
+    // worker-dev-proxy.js: tsx로 TypeScript 워커 파일을 동적으로 로드하는 프록시
+    if (ext === ".ts") {
+      // file:// URL인 경우 절대 경로로 변환 (worker-dev-proxy.js에서 다시 pathToFileURL 적용)
+      const workerPath = filePath.startsWith("file://") ? fileURLToPath(filePath) : filePath;
+      this._worker = new WorkerRaw(path.resolve(import.meta.dirname, "../../lib/worker-dev-proxy.js"), {
+        stdout: true,
+        stderr: true,
+        ...opt,
+        env: {
+          ...process.env,
+          ...envObj,
+        },
+        argv: [workerPath, ...(opt?.argv ?? [])],
+      });
+    } else {
+      // 프로덕션 환경 (.js 파일)
+      // file:// URL인 경우 변환, 이미 절대 경로인 경우 그대로 사용
+      const workerPath = filePath.startsWith("file://") ? fileURLToPath(filePath) : filePath;
+      this._worker = new WorkerRaw(workerPath, {
+        stdout: true,
+        stderr: true,
+        ...opt,
+        env: {
+          ...process.env,
+          ...envObj,
+        },
+      });
+    }
+
+    // 워커의 stdout/stderr를 메인에 출력
+    this._worker.stdout.pipe(process.stdout);
+    this._worker.stderr.pipe(process.stderr);
+
+    this._worker.on("exit", (code) => {
+      if (!this._isTerminated && code !== 0) {
+        logger.error(`워커가 오류와 함께 닫힘 (code: ${code})`);
+        // 비정상 종료 시 대기 중인 모든 요청 reject
+        this._rejectAllPending(new Error(`워커가 비정상 종료됨 (code: ${code})`));
+      }
+    });
+
+    this._worker.on("error", (err) => {
+      logger.error("워커 오류:", err);
+      // 워커 에러 시 대기 중인 모든 요청 reject
+      this._rejectAllPending(err);
+    });
+
+    this._worker.on("message", (serializedResponse: unknown) => {
+      const decoded = transferableDecode(serializedResponse);
+
+      // 응답 구조 검증
+      if (decoded == null || typeof decoded !== "object" || !("type" in decoded)) {
+        logger.warn("워커에서 잘못된 형식의 응답:", decoded);
+        return;
+      }
+      const response = decoded as WorkerResponse;
+
+      if (response.type === "event") {
+        this.emit(response.event, response.body);
+      } else if (response.type === "log") {
+        process.stdout.write(response.body);
+      } else if (response.type === "return") {
+        const pending = this._pendingRequests.get(response.request.id);
+        if (pending) {
+          this._pendingRequests.delete(response.request.id);
+          pending.resolve(response.body);
+        }
+      } else {
+        // response.type === "error"
+        const pending = this._pendingRequests.get(response.request.id);
+        if (pending) {
+          this._pendingRequests.delete(response.request.id);
+          pending.reject(response.body);
+        }
+      }
+    });
+  }
+
+  /**
+   * 대기 중인 모든 요청을 reject합니다.
+   */
+  private _rejectAllPending(err: Error): void {
+    for (const [_id, { method, reject }] of this._pendingRequests) {
+      reject(new Error(`${err.message} (method: ${method})`));
+    }
+    this._pendingRequests.clear();
+  }
+
+  /**
+   * 워커 메서드 호출.
+   */
+  call(method: string, params: unknown[]): Promise<unknown> {
+    return new Promise((resolve, reject) => {
+      const request: WorkerRequest = {
+        id: Uuid.new().toString(),
+        method,
+        params,
+      };
+
+      this._pendingRequests.set(request.id, { method, resolve, reject });
+
+      const serialized = transferableEncode(request);
+      this._worker.postMessage(serialized.result, serialized.transferList);
+    });
+  }
+
+  /**
+   * 워커 종료.
+   */
+  async terminate(): Promise<void> {
+    this._isTerminated = true;
+    this._rejectAllPending(new Error("워커가 종료됨"));
+    await this._worker.terminate();
+  }
+}
+
+//#endregion
+
+//#region Worker
+
+/**
+ * 타입 안전한 Worker 래퍼.
+ *
+ * @example
+ * // worker.ts
+ * export default createWorker({
+ *   add: (a: number, b: number) => a + b,
+ * });
+ *
+ * // main.ts
+ * const worker = Worker.create<typeof import("./worker")>("./worker.ts");
+ * const result = await worker.add(10, 20);  // 30
+ * await worker.terminate();
+ */
+export const Worker = {
+  /**
+   * 타입 안전한 Worker Proxy 생성.
+   *
+   * @param filePath - 워커 파일 경로 (file:// URL 또는 절대 경로)
+   * @param opt - Worker 옵션
+   * @returns Proxy 객체 (메서드 직접 호출, on(), terminate() 지원)
+   */
+  create<TModule extends WorkerModule>(
+    filePath: string,
+    opt?: Omit<WorkerRawOptions, "stdout" | "stderr">,
+  ): WorkerProxy<TModule> {
+    const internal = new WorkerInternal(filePath, opt);
+
+    return new Proxy({} as WorkerProxy<TModule>, {
+      get(_target, prop: string) {
+        // 예약된 메서드: on, off, terminate
+        if (prop === "on") {
+          return (event: string, listener: (data: unknown) => void) => {
+            internal.on(event, listener);
+          };
+        }
+        if (prop === "off") {
+          return (event: string, listener: (data: unknown) => void) => {
+            internal.off(event, listener);
+          };
+        }
+        if (prop === "terminate") {
+          return () => internal.terminate();
+        }
+
+        // 그 외는 워커 메서드로 처리
+        return (...args: unknown[]) => internal.call(prop, args);
+      },
+    });
+  },
+};
+
+//#endregion

package/dist/core-common/src/common.types.d.ts

@@ -1,74 +0,0 @@
-import { DateTime } from "./types/date-time";
-import { DateOnly } from "./types/date-only";
-import { Time } from "./types/time";
-import { Uuid } from "./types/uuid";
-/**
- * Buffer 대신 사용하는 바이너리 타입
- */
-export type Bytes = Uint8Array;
-/**
- * Primitive 타입 매핑
- * orm-common과 공유
- */
-export type PrimitiveTypeMap = {
-    string: string;
-    number: number;
-    boolean: boolean;
-    DateTime: DateTime;
-    DateOnly: DateOnly;
-    Time: Time;
-    Uuid: Uuid;
-    Bytes: Bytes;
-};
-/**
- * Primitive 타입 문자열 키
- */
-export type PrimitiveTypeStr = keyof PrimitiveTypeMap;
-/**
- * Primitive 타입 유니온
- */
-export type PrimitiveType = PrimitiveTypeMap[PrimitiveTypeStr] | undefined;
-/**
- * 깊은 Partial 타입
- *
- * 객체의 모든 속성을 재귀적으로 선택적(optional)으로 만듭니다.
- * Primitive 타입(string, number, boolean 등)은 그대로 유지하고,
- * 객체/배열 타입만 재귀적으로 Partial을 적용합니다.
- *
- * @example
- * ```typescript
- * interface User {
- *   name: string;
- *   profile: {
- *     age: number;
- *     address: { city: string };
- *   };
- * }
- *
- * // 모든 깊이의 속성이 선택적이 됨
- * const partial: DeepPartial<User> = {
- *   profile: { address: {} }
- * };
- * ```
- */
-export type DeepPartial<T> = Partial<{
-    [K in keyof T]: T[K] extends PrimitiveType ? T[K] : DeepPartial<T[K]>;
-}>;
-/**
- * 생성자 타입
- *
- * 클래스 생성자를 타입으로 표현할 때 사용합니다.
- * 주로 의존성 주입, 팩토리 패턴, instanceof 체크 등에서 활용됩니다.
- *
- * @example
- * function create<T>(ctor: Type<T>): T {
- *   return new ctor();
- * }
- *
- * class MyClass { name = "test"; }
- * const instance = create(MyClass); // MyClass 인스턴스
- */
-export interface Type<T> extends Function {
-    new (...args: unknown[]): T;
-}
-//# sourceMappingURL=common.types.d.ts.map

package/dist/core-common/src/common.types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"common.types.d.ts","sourceRoot":"","sources":["../../../../core-common/src/common.types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AACpC,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAIpC;;GAEG;AACH,MAAM,MAAM,KAAK,GAAG,UAAU,CAAC;AAM/B;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,QAAQ,CAAC;IACnB,QAAQ,EAAE,QAAQ,CAAC;IACnB,IAAI,EAAE,IAAI,CAAC;IACX,IAAI,EAAE,IAAI,CAAC;IACX,KAAK,EAAE,KAAK,CAAC;CACd,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,gBAAgB,CAAC;AAEtD;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,gBAAgB,CAAC,gBAAgB,CAAC,GAAG,SAAS,CAAC;AAM3E;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,OAAO,CAAC;KAClC,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,aAAa,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CACtE,CAAC,CAAC;AAEH;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,IAAI,CAAC,CAAC,CAAE,SAAQ,QAAQ;IACvC,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC;CAC7B"}

package/dist/core-common/src/env.d.ts

@@ -1,6 +0,0 @@
-export declare const env: {
-    DEV: boolean;
-    VER?: string;
-    [key: string]: unknown;
-};
-//# sourceMappingURL=env.d.ts.map

package/dist/core-common/src/env.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../../../core-common/src/env.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,GAAG,EAAE;IAChB,GAAG,EAAE,OAAO,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CAKxB,CAAC"}

package/dist/core-common/src/errors/argument-error.d.ts

@@ -1,25 +0,0 @@
-import { SdError } from "./sd-error";
-/**
- * 인수 오류
- *
- * 잘못된 인수를 받았을 때 발생시키는 에러이다.
- * 인수 객체를 YAML 형식으로 메시지에 포함하여 디버깅을 용이하게 한다.
- *
- * @example
- * // 인수 객체만 전달
- * throw new ArgumentError({ userId: 123, name: null });
- * // 결과 메시지: "인수가 잘못되었습니다.\n\nuserId: 123\nname: null"
- *
- * @example
- * // 커스텀 메시지와 인수 객체 전달
- * throw new ArgumentError("유효하지 않은 사용자", { userId: 123 });
- * // 결과 메시지: "유효하지 않은 사용자\n\nuserId: 123"
- */
-export declare class ArgumentError extends SdError {
-    /** 기본 메시지("인수가 잘못되었습니다.")와 함께 인수 객체를 YAML 형식으로 출력 */
-    constructor(argObj: Record<string, unknown>);
-    /** 커스텀 메시지와 함께 인수 객체를 YAML 형식으로 출력 */
-    constructor(message: string, argObj: Record<string, unknown>);
-    constructor(arg1: Record<string, unknown> | string, arg2?: Record<string, unknown>);
-}
-//# sourceMappingURL=argument-error.d.ts.map

package/dist/core-common/src/errors/argument-error.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"argument-error.d.ts","sourceRoot":"","sources":["../../../../../core-common/src/errors/argument-error.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAErC;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,aAAc,SAAQ,OAAO;IACxC,qDAAqD;gBACzC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC3C,sCAAsC;gBAC1B,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;gBAChD,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAYnF"}

package/dist/core-common/src/errors/not-implemented-error.d.ts

@@ -1,29 +0,0 @@
-import { SdError } from "./sd-error";
-/**
- * 미구현 오류
- *
- * 아직 구현되지 않은 기능을 호출했을 때 발생시키는 에러이다.
- * 추상 메서드 스텁, 향후 구현 예정인 분기 등에 사용한다.
- *
- * @example
- * // 추상 메서드 구현 전
- * class BaseService {
- *   process(): void {
- *     throw new NotImplementedError("서브클래스에서 구현 필요");
- *   }
- * }
- *
- * @example
- * // 향후 구현 예정 분기
- * switch (type) {
- *   case "A": return handleA();
- *   case "B": throw new NotImplementedError(`타입 ${type} 처리`);
- * }
- */
-export declare class NotImplementedError extends SdError {
-    /**
-     * @param message 추가 설명 메시지
-     */
-    constructor(message?: string);
-}
-//# sourceMappingURL=not-implemented-error.d.ts.map

package/dist/core-common/src/errors/not-implemented-error.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"not-implemented-error.d.ts","sourceRoot":"","sources":["../../../../../core-common/src/errors/not-implemented-error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,mBAAoB,SAAQ,OAAO;IAC9C;;OAEG;gBACS,OAAO,CAAC,EAAE,MAAM;CAI7B"}

package/dist/core-common/src/errors/sd-error.d.ts

@@ -1,27 +0,0 @@
-/**
- * 오류의 Tree 구조 구성이 가능한 오류 클래스
- * ES2024 cause 속성 활용
- *
- * @example
- * // 원인 에러를 감싸서 생성
- * try {
- *   await fetch(url);
- * } catch (err) {
- *   throw new SdError(err, "API 호출 실패", "사용자 로드 실패");
- * }
- * // 결과 메시지: "사용자 로드 실패 => API 호출 실패 => 원본 에러 메시지"
- *
- * @example
- * // 메시지만으로 생성
- * throw new SdError("잘못된 상태", "처리 불가");
- * // 결과 메시지: "처리 불가 => 잘못된 상태"
- */
-export declare class SdError extends Error {
-    cause?: Error;
-    /** 원인 에러를 감싸서 생성. 메시지는 역순으로 연결됨 (상위 메시지 => 하위 메시지 => 원인 메시지) */
-    constructor(cause: Error, ...messages: string[]);
-    /** 메시지만으로 생성. 메시지는 역순으로 연결됨 (상위 메시지 => 하위 메시지) */
-    constructor(...messages: string[]);
-    constructor(arg1?: unknown, ...messages: string[]);
-}
-//# sourceMappingURL=sd-error.d.ts.map

package/dist/core-common/src/errors/sd-error.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sd-error.d.ts","sourceRoot":"","sources":["../../../../../core-common/src/errors/sd-error.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,OAAQ,SAAQ,KAAK;IACvB,KAAK,CAAC,EAAE,KAAK,CAAC;IAEvB,gEAAgE;gBACpD,KAAK,EAAE,KAAK,EAAE,GAAG,QAAQ,EAAE,MAAM,EAAE;IAC/C,kDAAkD;gBACtC,GAAG,QAAQ,EAAE,MAAM,EAAE;gBACrB,IAAI,CAAC,EAAE,OAAO,EAAE,GAAG,QAAQ,EAAE,MAAM,EAAE;CA2BlD"}

package/dist/core-common/src/errors/timeout-error.d.ts

@@ -1,31 +0,0 @@
-import { SdError } from "./sd-error";
-/**
- * 타임아웃 오류
- *
- * 대기 시간이 초과되었을 때 발생하는 에러이다.
- * Wait.until() 등의 비동기 대기 함수에서 최대 시도 횟수를 초과하면 자동으로 발생한다.
- *
- * @example
- * // Wait.until에서 자동 발생
- * try {
- *   await Wait.until(() => isReady, 100, 50); // 100ms 간격, 최대 50회
- * } catch (err) {
- *   if (err instanceof TimeoutError) {
- *     console.log("시간 초과");
- *   }
- * }
- *
- * @example
- * // 직접 발생
- * if (elapsed > maxTime) {
- *   throw new TimeoutError(undefined, "API 응답 대기 초과");
- * }
- */
-export declare class TimeoutError extends SdError {
-    /**
-     * @param count 시도 횟수
-     * @param message 추가 메시지
-     */
-    constructor(count?: number, message?: string);
-}
-//# sourceMappingURL=timeout-error.d.ts.map

package/dist/core-common/src/errors/timeout-error.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"timeout-error.d.ts","sourceRoot":"","sources":["../../../../../core-common/src/errors/timeout-error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,YAAa,SAAQ,OAAO;IACvC;;;OAGG;gBACS,KAAK,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM;CAM7C"}

package/dist/core-common/src/extensions/arr-ext.d.ts

@@ -1,15 +0,0 @@
-/**
- * Array 확장 메서드
- *
- * @remarks 각 메서드의 TSDoc은 타입 정의 파일(arr-ext.types.ts) 참조
- */
-import "./map-ext";
-import type { ReadonlyArrayExt, MutableArrayExt } from "./arr-ext.types";
-declare global {
-    interface ReadonlyArray<T> extends ReadonlyArrayExt<T> {
-    }
-    interface Array<T> extends ReadonlyArrayExt<T>, MutableArrayExt<T> {
-    }
-}
-export type { ArrayDiffsResult, ArrayDiffs2Result, TreeArray, ComparableType } from "./arr-ext.types";
-//# sourceMappingURL=arr-ext.d.ts.map

package/dist/core-common/src/extensions/arr-ext.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"arr-ext.d.ts","sourceRoot":"","sources":["../../../../../core-common/src/extensions/arr-ext.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,WAAW,CAAC;AAUnB,OAAO,KAAK,EACV,gBAAgB,EAChB,eAAe,EAIhB,MAAM,iBAAiB,CAAC;AA2uBzB,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,aAAa,CAAC,CAAC,CAAE,SAAQ,gBAAgB,CAAC,CAAC,CAAC;KAAG;IACzD,UAAU,KAAK,CAAC,CAAC,CAAE,SAAQ,gBAAgB,CAAC,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC;KAAG;CACtE;AAID,YAAY,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC"}