@rscc/common-core 0.1.2

package/dist/index.js

@@ -0,0 +1,804 @@
+// src/types.ts
+function isValidationErrorData(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const errors = value.errors;
+  if (!Array.isArray(errors)) return false;
+  return errors.every(
+    (e) => typeof e === "object" && e !== null && typeof e.field === "string" && typeof e.reason === "string"
+  );
+}
+var ResultCode = {
+  SUCCESS: "200",
+  BAD_REQUEST: "400",
+  UNAUTHORIZED: "401",
+  FORBIDDEN: "403",
+  NOT_FOUND: "404",
+  METHOD_NOT_ALLOWED: "405",
+  CONFLICT: "409",
+  UNSUPPORTED_MEDIA_TYPE: "415",
+  TOO_MANY_REQUESTS: "429",
+  INTERNAL_SERVER_ERROR: "500"
+};
+
+// src/retry.ts
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
+function isRetryableStatus(status) {
+  return RETRYABLE_STATUS.has(status);
+}
+var DELTA_SECONDS_PATTERN = /^[0-9]{1,10}$/;
+var HTTP_DATE_PATTERN = /^[A-Za-z]{3}, ([0-9]{2}) [A-Za-z]{3} [0-9]{4} [0-9]{2}:[0-9]{2}:[0-9]{2} GMT$/;
+function parseRetryAfterMs(value, nowMs = Date.now()) {
+  if (value == null) return null;
+  const trimmed = value.trim();
+  if (DELTA_SECONDS_PATTERN.test(trimmed)) return Number(trimmed) * 1e3;
+  const httpDate = HTTP_DATE_PATTERN.exec(trimmed);
+  if (httpDate) {
+    const target = Date.parse(trimmed);
+    if (Number.isNaN(target)) return null;
+    if (new Date(target).getUTCDate() !== Number(httpDate[1])) return null;
+    return Math.max(0, target - nowMs);
+  }
+  return null;
+}
+function backoffDelay(attempt, minDelayMs, maxDelayMs, factor, jitter) {
+  const cap = Math.min(maxDelayMs, minDelayMs * Math.pow(factor, attempt));
+  return jitter ? Math.random() * cap : cap;
+}
+function abortError(signal) {
+  return signal.reason instanceof Error ? signal.reason : new Error("\uC791\uC5C5\uC774 \uCDE8\uC18C\uB418\uC5C8\uC2B5\uB2C8\uB2E4.");
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(abortError(signal));
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(abortError(signal));
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function retry(fn, options = {}) {
+  const {
+    retries = 3,
+    minDelayMs = 200,
+    maxDelayMs = 5e3,
+    factor = 2,
+    jitter = true,
+    maxElapsedMs = 0,
+    shouldRetry = () => true,
+    overrideDelay,
+    onRetry,
+    signal
+  } = options;
+  const start = Date.now();
+  let attempt = 0;
+  for (; ; ) {
+    if (signal?.aborted) throw abortError(signal);
+    try {
+      return await fn(attempt);
+    } catch (error) {
+      if (signal?.aborted) throw abortError(signal);
+      if (attempt >= retries || !shouldRetry(error, attempt)) throw error;
+      let delay = backoffDelay(attempt, minDelayMs, maxDelayMs, factor, jitter);
+      if (overrideDelay) {
+        const adjusted = overrideDelay(error, attempt, delay);
+        if (Number.isFinite(adjusted)) delay = Math.max(0, adjusted);
+      }
+      if (maxElapsedMs > 0 && Date.now() - start + delay > maxElapsedMs) throw error;
+      onRetry?.(error, attempt, delay);
+      await sleep(delay, signal);
+      attempt++;
+    }
+  }
+}
+
+// src/apiClient.ts
+var ApiError = class extends Error {
+  constructor(args) {
+    super(args.message);
+    this.name = "ApiError";
+    this.code = args.code;
+    this.status = args.status;
+    this.traceId = args.traceId;
+    this.data = args.data;
+    this.retryAfterMs = args.retryAfterMs ?? null;
+    this.rawText = args.rawText;
+  }
+};
+var DEFAULT_RETRY_METHODS = ["GET", "HEAD", "OPTIONS", "PUT", "DELETE"];
+var MAX_RAW_TEXT_LENGTH = 2048;
+function joinUrl(baseUrl, path) {
+  if (path === "") return baseUrl;
+  if (path.startsWith("?") || path.startsWith("#")) return baseUrl.replace(/\/+$/, "") + path;
+  return baseUrl.replace(/\/+$/, "") + "/" + path.replace(/^\/+/, "");
+}
+function defaultShouldRetry(error) {
+  if (error instanceof ApiError) return isRetryableStatus(error.status);
+  return error instanceof TypeError;
+}
+function generateTraceId() {
+  const c = globalThis.crypto;
+  if (c && typeof c.randomUUID === "function") return c.randomUUID().slice(0, 8);
+  return Math.random().toString(16).slice(2, 10).padEnd(8, "0");
+}
+function isCommonResponse(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  return typeof v.success === "boolean" && typeof v.code === "string" && typeof v.message === "string";
+}
+function createApiClient(config) {
+  const traceIdHeader = config.traceIdHeader ?? "X-Trace-Id";
+  let hookWarned = false;
+  const safeHook = (fn) => {
+    try {
+      fn();
+    } catch (error) {
+      if (!hookWarned) {
+        hookWarned = true;
+        console.warn("[apiClient] \uAD00\uCE21 \uD6C5 \uC608\uC678 \u2014 \uBB34\uC2DC\uB429\uB2C8\uB2E4.", error);
+      }
+    }
+  };
+  const nowMs = () => globalThis.performance?.now() ?? Date.now();
+  async function requestWithMeta(path, init = {}) {
+    const sentTraceId = generateTraceId();
+    const method = (init.method ?? "GET").toUpperCase();
+    const attemptOnce = async () => {
+      const headers = new Headers(init.headers);
+      headers.set(traceIdHeader, sentTraceId);
+      const isFormData = typeof FormData !== "undefined" && init.body instanceof FormData;
+      if (!headers.has("Content-Type") && !isFormData) {
+        headers.set("Content-Type", "application/json");
+      }
+      if (config.getToken && !headers.has("Authorization")) {
+        const token = config.getToken();
+        if (token) headers.set("Authorization", `Bearer ${token}`);
+      }
+      const fetchFn = config.fetchImpl ?? globalThis.fetch;
+      const response = await fetchFn(joinUrl(config.baseUrl, path), { ...init, headers });
+      const traceId = response.headers.get(traceIdHeader) ?? sentTraceId;
+      let raw = null;
+      try {
+        const source = typeof response.clone === "function" ? response.clone() : response;
+        raw = await source.text();
+      } catch {
+        if (config.strictJson && response.ok) {
+          throw new ApiError({
+            code: "INVALID_JSON",
+            message: "\uC751\uB2F5 \uBCF8\uBB38\uC744 \uC77D\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.",
+            status: response.status,
+            traceId,
+            retryAfterMs: parseRetryAfterMs(response.headers.get("Retry-After"))
+          });
+        }
+        raw = null;
+      }
+      let json = null;
+      if (raw !== null) {
+        if (raw.trim() === "") {
+          json = null;
+        } else {
+          try {
+            json = JSON.parse(raw);
+          } catch {
+            if (config.strictJson && response.ok) {
+              throw new ApiError({
+                code: "INVALID_JSON",
+                message: "\uC751\uB2F5 \uBCF8\uBB38\uC774 \uC720\uD6A8\uD55C JSON \uC774 \uC544\uB2D9\uB2C8\uB2E4.",
+                status: response.status,
+                traceId,
+                retryAfterMs: parseRetryAfterMs(response.headers.get("Retry-After")),
+                rawText: raw.slice(0, MAX_RAW_TEXT_LENGTH)
+              });
+            }
+            json = null;
+          }
+        }
+      }
+      const fail = (code, message, data) => {
+        const error = new ApiError({
+          code,
+          message,
+          status: response.status,
+          traceId,
+          data,
+          retryAfterMs: parseRetryAfterMs(response.headers.get("Retry-After"))
+        });
+        if (response.status === 401) config.onUnauthorized?.(error);
+        throw error;
+      };
+      if (isCommonResponse(json)) {
+        if (!response.ok || !json.success) fail(json.code, json.message, json.data);
+        return { data: json.data ?? void 0, traceId, status: response.status, response };
+      }
+      if (!response.ok) {
+        const j = json;
+        const message = typeof j?.message === "string" && j.message || typeof j?.error === "string" && j.error || `API \uC624\uB958: ${response.status} ${response.statusText}`;
+        fail(String(response.status), message);
+      }
+      return { data: json, traceId, status: response.status, response };
+    };
+    const execute = () => {
+      const retryConfig = config.retry;
+      if (!retryConfig) return attemptOnce();
+      if (!(retryConfig.methods ?? DEFAULT_RETRY_METHODS).includes(method)) return attemptOnce();
+      const isOneShotBody = typeof ReadableStream !== "undefined" && init.body instanceof ReadableStream || typeof FormData !== "undefined" && init.body instanceof FormData;
+      if (isOneShotBody) return attemptOnce();
+      const { shouldRetry = defaultShouldRetry, methods: _methods, ...retryOptions } = retryConfig;
+      return retry(attemptOnce, {
+        ...retryOptions,
+        shouldRetry,
+        // Retry-After 를 계산된 대기의 하한으로 적용 (배치1 overrideDelay 훅 시맨틱 —
+        // maxDelayMs 상한 미재적용, 폭주 방어는 maxElapsedMs 예산 담당).
+        overrideDelay: (error, _attempt, delayMs) => error instanceof ApiError && error.retryAfterMs != null ? Math.max(delayMs, error.retryAfterMs) : delayMs,
+        signal: init.signal ?? void 0
+      });
+    };
+    if (!config.onRequest && !config.onResponse && !config.onError) return execute();
+    const startedAt = nowMs();
+    safeHook(() => config.onRequest?.({ method, path, traceId: sentTraceId }));
+    try {
+      const result = await execute();
+      safeHook(
+        () => config.onResponse?.({
+          method,
+          path,
+          traceId: result.traceId,
+          status: result.status,
+          durationMs: nowMs() - startedAt
+        })
+      );
+      return result;
+    } catch (error) {
+      safeHook(
+        () => config.onError?.({
+          method,
+          path,
+          // ApiError 면 에코 traceId, 네트워크 오류 등 비-ApiError 는 발신 값.
+          traceId: error instanceof ApiError ? error.traceId : sentTraceId,
+          status: error instanceof ApiError ? error.status : void 0,
+          durationMs: nowMs() - startedAt,
+          error
+        })
+      );
+      throw error;
+    }
+  }
+  async function request(path, init) {
+    const result = await requestWithMeta(path, init);
+    return result.data;
+  }
+  return { request, requestWithMeta };
+}
+
+// src/sse.ts
+function parseSseFrame(frame) {
+  const dataLine = frame.split("\n").find((l) => l.startsWith("data:"))?.replace(/^data:\s*/, "");
+  if (dataLine === void 0 || dataLine === "") return { type: "skip" };
+  if (dataLine === "[DONE]") return { type: "done" };
+  try {
+    const obj = JSON.parse(dataLine);
+    if (typeof obj.conversationId === "number") {
+      return { type: "conversationId", id: obj.conversationId };
+    }
+    if (Array.isArray(obj.sources)) {
+      return { type: "sources", sources: obj.sources };
+    }
+    if (typeof obj.delta === "string") return { type: "delta", delta: obj.delta };
+    if (typeof obj.error === "string") return { type: "error", message: obj.error };
+  } catch {
+  }
+  return { type: "skip" };
+}
+async function readSseStream(response, callbacks) {
+  if (!response.body) {
+    throw new Error("SSE \uC751\uB2F5\uC5D0 body \uC2A4\uD2B8\uB9BC\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.");
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let errored = false;
+  const dispatch = (frame) => {
+    const ev = parseSseFrame(frame);
+    switch (ev.type) {
+      case "conversationId":
+        callbacks.onConversationId?.(ev.id);
+        break;
+      case "sources":
+        callbacks.onSources?.(ev.sources);
+        break;
+      case "delta":
+        if (!errored) callbacks.onDelta?.(ev.delta);
+        break;
+      case "error":
+        errored = true;
+        callbacks.onError?.(ev.message);
+        break;
+      case "done":
+        callbacks.onDone?.();
+        return true;
+      case "skip":
+        break;
+    }
+    return false;
+  };
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let sepIdx;
+      while ((sepIdx = buffer.indexOf("\n\n")) !== -1) {
+        const frame = buffer.slice(0, sepIdx);
+        buffer = buffer.slice(sepIdx + 2);
+        if (dispatch(frame)) {
+          await reader.cancel().catch(() => void 0);
+          return;
+        }
+      }
+    }
+    buffer += decoder.decode();
+    if (buffer.trim() !== "") dispatch(buffer);
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+// src/jwt.ts
+function decodeJwtPayload(token) {
+  try {
+    const seg = token.split(".")[1];
+    if (!seg) return null;
+    let b64 = seg.replace(/-/g, "+").replace(/_/g, "/");
+    const rem = b64.length % 4;
+    if (rem === 1) return null;
+    if (rem > 0) b64 += "=".repeat(4 - rem);
+    const bin = atob(b64);
+    const bytes = Uint8Array.from(bin, (c) => c.charCodeAt(0));
+    const parsed = JSON.parse(new TextDecoder().decode(bytes));
+    return typeof parsed === "object" && parsed !== null ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function getTokenExpiry(token) {
+  const payload = decodeJwtPayload(token);
+  const exp = payload?.exp;
+  return typeof exp === "number" ? exp * 1e3 : null;
+}
+function isTokenExpired(token, nowMs = Date.now()) {
+  const expiresAt = getTokenExpiry(token);
+  return expiresAt === null || expiresAt < nowMs;
+}
+
+// src/masking.ts
+var JAVA_BLANK_PATTERN = /^[\t-\r\u001C-\u001F \u1680\u2000-\u2006\u2008-\u200A\u2028\u2029\u205F\u3000]*$/;
+function maskSecret(secret) {
+  if (secret == null || JAVA_BLANK_PATTERN.test(secret)) return secret;
+  if (secret.length <= 8) return "*".repeat(secret.length);
+  return secret.slice(0, 4) + "\u2022\u2022\u2022\u2022" + secret.slice(-4);
+}
+function maskName(name) {
+  if (name == null || JAVA_BLANK_PATTERN.test(name)) return name;
+  const length = name.length;
+  if (length <= 1) return name;
+  if (length === 2) return name[0] + "*";
+  return name[0] + "*".repeat(length - 2) + name[length - 1];
+}
+function maskPhone(phone) {
+  if (phone == null || JAVA_BLANK_PATTERN.test(phone)) return phone;
+  return phone.replace(/(\d{2,3})-?(\d{3,4})-?(\d{4})/g, "$1-****-$3");
+}
+function maskEmail(email) {
+  if (email == null || JAVA_BLANK_PATTERN.test(email) || !email.includes("@")) return email;
+  const [id = "", domain = ""] = email.split("@");
+  if (id.length <= 2) return id.slice(0, 1) + "*@" + domain;
+  return id.slice(0, 2) + "*".repeat(id.length - 2) + "@" + domain;
+}
+function maskCardNumber(cardNumber) {
+  if (cardNumber == null || JAVA_BLANK_PATTERN.test(cardNumber)) return cardNumber;
+  return cardNumber.replace(/(\d{4})-?(\d{4})-?(\d{4})-?(\d{4})/g, "$1-****-****-$4");
+}
+
+// src/datetime.ts
+var pad = (n) => String(n).padStart(2, "0");
+function toWireDateTime(date) {
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}T${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+}
+function toWireDate(date) {
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+}
+function parseWireDateTime(value) {
+  const stripped = stripZone(value.trim());
+  const m = stripped.match(
+    /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2}))?(?:\.(\d+))?$/
+  );
+  if (!m) throw new Error(`\uC62C\uBC14\uB978 datetime \uD615\uC2DD\uC774 \uC544\uB2D9\uB2C8\uB2E4: ${value}`);
+  const [, y, mo, day, h, mi, s = "0", frac = "0"] = m;
+  const ms = Number((frac + "000").slice(0, 3));
+  const date = new Date(Number(y), Number(mo) - 1, Number(day), Number(h), Number(mi), Number(s), ms);
+  if (date.getFullYear() !== Number(y) || date.getMonth() !== Number(mo) - 1 || date.getDate() !== Number(day) || date.getHours() !== Number(h) || date.getMinutes() !== Number(mi) || date.getSeconds() !== Number(s)) {
+    throw new Error(`\uC720\uD6A8\uD558\uC9C0 \uC54A\uC740 datetime \uAC12\uC785\uB2C8\uB2E4: ${value}`);
+  }
+  return date;
+}
+function stripZone(value) {
+  if (value.endsWith("Z") || value.endsWith("z")) return value.slice(0, -1);
+  const tIndex = value.indexOf("T");
+  if (tIndex === -1) return value;
+  const timePart = value.slice(tIndex);
+  const offset = timePart.match(/[+-]\d{2}:?\d{2}$/);
+  if (offset && offset.index !== void 0) {
+    return value.slice(0, tIndex) + timePart.slice(0, offset.index);
+  }
+  return value;
+}
+
+// src/chosung.ts
+var CHO = String.fromCharCode(
+  12593,
+  12594,
+  12596,
+  12599,
+  12600,
+  12601,
+  12609,
+  12610,
+  12611,
+  12613,
+  12614,
+  12615,
+  12616,
+  12617,
+  12618,
+  12619,
+  12620,
+  12621,
+  12622
+);
+var HANGUL_BASE = 44032;
+var HANGUL_END = 55203;
+var CHO_DIV = 21 * 28;
+var COMPAT_CONS_START = 12593;
+var COMPAT_CONS_END = 12622;
+var COMPAT_VOWEL_START = 12623;
+var COMPAT_VOWEL_END = 12643;
+function toChosung(s) {
+  if (!s) return "";
+  let out = "";
+  for (const ch of s) {
+    if (ch === " " || ch === "	") continue;
+    const c = ch.codePointAt(0);
+    if (c >= COMPAT_VOWEL_START && c <= COMPAT_VOWEL_END) continue;
+    if (c >= HANGUL_BASE && c <= HANGUL_END) {
+      out += CHO[Math.floor((c - HANGUL_BASE) / CHO_DIV)];
+    } else if (c >= COMPAT_CONS_START && c <= COMPAT_CONS_END) {
+      out += ch;
+    } else {
+      out += ch.toLowerCase();
+    }
+  }
+  return out;
+}
+function isChosungQuery(s) {
+  if (!s) return false;
+  for (const ch of s) {
+    const c = ch.codePointAt(0);
+    if (c >= COMPAT_CONS_START && c <= COMPAT_CONS_END) return true;
+  }
+  return false;
+}
+
+// src/cache.ts
+function createTtlCache(options) {
+  const { ttlMs, maxEntries, now = Date.now } = options;
+  if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
+    throw new RangeError("ttlMs \uB294 0 \uBCF4\uB2E4 \uCEE4\uC57C \uD569\uB2C8\uB2E4.");
+  }
+  if (!Number.isInteger(maxEntries) || maxEntries <= 0) {
+    throw new RangeError("maxEntries \uB294 0 \uBCF4\uB2E4 \uCEE4\uC57C \uD569\uB2C8\uB2E4.");
+  }
+  const store = /* @__PURE__ */ new Map();
+  const inflight = /* @__PURE__ */ new Map();
+  let nextSeq = 0;
+  const isExpired = (entry) => now() - entry.createdAt >= ttlMs;
+  function set(key, value) {
+    if (value === null || value === void 0) {
+      throw new TypeError("null/undefined \uB294 \uCE90\uC2DC\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.");
+    }
+    store.set(key, { value, createdAt: now(), seq: nextSeq++ });
+    if (store.size <= maxEntries) return;
+    for (const [k, e] of store) {
+      if (isExpired(e)) store.delete(k);
+    }
+    while (store.size > maxEntries) {
+      let oldestKey;
+      let oldestSeq = Number.POSITIVE_INFINITY;
+      for (const [k, e] of store) {
+        if (e.seq < oldestSeq) {
+          oldestSeq = e.seq;
+          oldestKey = k;
+        }
+      }
+      store.delete(oldestKey);
+    }
+  }
+  function peek(key) {
+    const entry = store.get(key);
+    if (!entry) return void 0;
+    if (isExpired(entry)) {
+      store.delete(key);
+      return void 0;
+    }
+    return entry.value;
+  }
+  function get(key, loader) {
+    const entry = store.get(key);
+    if (entry) {
+      if (!isExpired(entry)) return Promise.resolve(entry.value);
+      store.delete(key);
+    }
+    const pending = inflight.get(key);
+    if (pending) return pending;
+    let loaded;
+    try {
+      loaded = loader(key);
+    } catch (error) {
+      return Promise.reject(error);
+    }
+    const promise = (async () => {
+      try {
+        const value = await loaded;
+        if (value !== null && value !== void 0) set(key, value);
+        return value;
+      } finally {
+        inflight.delete(key);
+      }
+    })();
+    inflight.set(key, promise);
+    return promise;
+  }
+  return {
+    get,
+    peek,
+    set,
+    delete: (key) => store.delete(key),
+    clear: () => store.clear(),
+    size: () => store.size
+  };
+}
+
+// src/circuitBreaker.ts
+function createCircuitBreaker(options) {
+  const { failureThreshold, openDurationMs, now = Date.now } = options;
+  if (!Number.isInteger(failureThreshold) || failureThreshold <= 0) {
+    throw new RangeError("failureThreshold \uB294 0 \uBCF4\uB2E4 \uCEE4\uC57C \uD569\uB2C8\uB2E4.");
+  }
+  if (!Number.isFinite(openDurationMs) || openDurationMs <= 0) {
+    throw new RangeError("openDurationMs \uB294 0 \uBCF4\uB2E4 \uCEE4\uC57C \uD569\uB2C8\uB2E4.");
+  }
+  let state = "CLOSED";
+  let consecutiveFailures = 0;
+  let openedAtMs = 0;
+  let probeInFlight = false;
+  let inFlightGrants = 0;
+  function allowRequest() {
+    if (state === "CLOSED") {
+      inFlightGrants++;
+      return true;
+    }
+    if (state === "OPEN") {
+      if (now() - openedAtMs >= openDurationMs) {
+        if (inFlightGrants > 0) {
+          return false;
+        }
+        state = "HALF_OPEN";
+        probeInFlight = true;
+        return true;
+      }
+      return false;
+    }
+    if (probeInFlight) return false;
+    probeInFlight = true;
+    return true;
+  }
+  function onSuccess() {
+    if (state === "CLOSED") {
+      inFlightGrants = Math.max(0, inFlightGrants - 1);
+      consecutiveFailures = 0;
+      return;
+    }
+    if (state === "HALF_OPEN") {
+      state = "CLOSED";
+      consecutiveFailures = 0;
+      probeInFlight = false;
+      return;
+    }
+    inFlightGrants = Math.max(0, inFlightGrants - 1);
+  }
+  function onFailure() {
+    if (state === "CLOSED") {
+      inFlightGrants = Math.max(0, inFlightGrants - 1);
+      consecutiveFailures++;
+      if (consecutiveFailures >= failureThreshold) {
+        state = "OPEN";
+        openedAtMs = now();
+      }
+      return;
+    }
+    if (state === "HALF_OPEN") {
+      state = "OPEN";
+      openedAtMs = now();
+      probeInFlight = false;
+      return;
+    }
+    inFlightGrants = Math.max(0, inFlightGrants - 1);
+  }
+  return {
+    allowRequest,
+    onSuccess,
+    onFailure,
+    state: () => state
+  };
+}
+
+// src/tokenBucket.ts
+function createTokenBucket(options) {
+  const { capacity, refillPerSecond, now = Date.now } = options;
+  if (!Number.isInteger(capacity) || capacity <= 0) {
+    throw new RangeError("capacity \uB294 0 \uBCF4\uB2E4 \uCEE4\uC57C \uD569\uB2C8\uB2E4.");
+  }
+  if (!Number.isFinite(refillPerSecond) || refillPerSecond <= 0) {
+    throw new RangeError("refillPerSecond \uB294 0 \uBCF4\uB2E4 \uCEE4\uC57C \uD569\uB2C8\uB2E4.");
+  }
+  let tokens = capacity;
+  let lastMs = now();
+  function tryAcquire(n = 1) {
+    if (!Number.isInteger(n) || n <= 0) {
+      throw new RangeError("n \uC740 0 \uBCF4\uB2E4 \uCEE4\uC57C \uD569\uB2C8\uB2E4: " + n);
+    }
+    if (n > capacity) return false;
+    const nowMs = now();
+    const elapsedMs = Math.max(0, nowMs - lastMs);
+    if (elapsedMs > 0) {
+      tokens = Math.min(capacity, tokens + elapsedMs / 1e3 * refillPerSecond);
+      lastMs = nowMs;
+    }
+    if (tokens >= n) {
+      tokens -= n;
+      return true;
+    }
+    return false;
+  }
+  return { tryAcquire };
+}
+
+// src/bulkhead.ts
+var BulkheadFullError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BulkheadFullError";
+  }
+};
+function createBulkhead(options) {
+  const { maxConcurrent, maxQueue = 0 } = options;
+  if (!Number.isInteger(maxConcurrent) || maxConcurrent <= 0) {
+    throw new RangeError("maxConcurrent \uB294 0 \uBCF4\uB2E4 \uCEE4\uC57C \uD569\uB2C8\uB2E4.");
+  }
+  if (!Number.isInteger(maxQueue) || maxQueue < 0) {
+    throw new RangeError("maxQueue \uB294 0 \uC774\uC0C1\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4.");
+  }
+  let active = 0;
+  const waiters = [];
+  function release() {
+    const next = waiters.shift();
+    if (next) {
+      next();
+    } else {
+      active--;
+    }
+  }
+  async function execute(fn) {
+    if (active < maxConcurrent) {
+      active++;
+    } else if (waiters.length < maxQueue) {
+      await new Promise((resolve) => waiters.push(resolve));
+    } else {
+      throw new BulkheadFullError(
+        `Bulkhead \uB9CC\uC11D \u2014 \uC2E4\uD589 ${maxConcurrent} + \uB300\uAE30 ${maxQueue} \uC2AC\uB86F \uCD08\uACFC`
+      );
+    }
+    try {
+      return await fn();
+    } finally {
+      release();
+    }
+  }
+  return {
+    execute,
+    activeCount: () => active,
+    queuedCount: () => waiters.length
+  };
+}
+
+// src/logSanitize.ts
+var CONTROL_CHARS_PATTERN = /[\u0000-\u001f\u007f]/g;
+function sanitizeLogValue(value, maxLength) {
+  if (maxLength !== void 0 && (!Number.isInteger(maxLength) || maxLength < 4)) {
+    throw new RangeError("maxLength \uB294 4 \uC774\uC0C1\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4: " + maxLength);
+  }
+  const sanitized = value.replace(CONTROL_CHARS_PATTERN, " ");
+  if (maxLength === void 0 || sanitized.length <= maxLength) return sanitized;
+  return sanitized.slice(0, maxLength - 3) + "...";
+}
+
+// src/bizno.ts
+var SEPARATOR_PATTERN = /[-\t ]/g;
+var BUSINESS_DIGITS_PATTERN = /^[0-9]{10}$/;
+var CORPORATE_DIGITS_PATTERN = /^[0-9]{13}$/;
+var BUSINESS_WEIGHTS = [1, 3, 7, 1, 3, 7, 1, 3, 5];
+var digitAt = (digits, i) => digits.charCodeAt(i) - 48;
+function normalizeBusinessNumber(value) {
+  if (value == null) return value;
+  return value.replace(SEPARATOR_PATTERN, "");
+}
+function isValidBusinessNumber(value) {
+  if (value == null) return false;
+  const digits = normalizeBusinessNumber(value);
+  if (!BUSINESS_DIGITS_PATTERN.test(digits)) return false;
+  let sum = 0;
+  for (const [i, weight] of BUSINESS_WEIGHTS.entries()) sum += digitAt(digits, i) * weight;
+  sum += Math.floor(digitAt(digits, 8) * 5 / 10);
+  const check = (10 - sum % 10) % 10;
+  return check === digitAt(digits, 9);
+}
+function isValidCorporateNumber(value) {
+  if (value == null) return false;
+  const digits = normalizeBusinessNumber(value);
+  if (!CORPORATE_DIGITS_PATTERN.test(digits)) return false;
+  let sum = 0;
+  for (let i = 0; i < 12; i++) sum += digitAt(digits, i) * (i % 2 === 0 ? 1 : 2);
+  const check = (10 - sum % 10) % 10;
+  return check === digitAt(digits, 12);
+}
+export {
+  ApiError,
+  BulkheadFullError,
+  ResultCode,
+  createApiClient,
+  createBulkhead,
+  createCircuitBreaker,
+  createTokenBucket,
+  createTtlCache,
+  decodeJwtPayload,
+  getTokenExpiry,
+  isChosungQuery,
+  isRetryableStatus,
+  isTokenExpired,
+  isValidBusinessNumber,
+  isValidCorporateNumber,
+  isValidationErrorData,
+  maskCardNumber,
+  maskEmail,
+  maskName,
+  maskPhone,
+  maskSecret,
+  normalizeBusinessNumber,
+  parseRetryAfterMs,
+  parseSseFrame,
+  parseWireDateTime,
+  readSseStream,
+  retry,
+  sanitizeLogValue,
+  stripZone,
+  toChosung,
+  toWireDate,
+  toWireDateTime
+};