mega-framework 0.1.0

package/src/lib/mega-cron.js

@@ -0,0 +1,169 @@
+// @ts-check
+/**
+ * MegaCron — cron 표현식 파서 / 다음·이전 발생 시각 계산 (ADR-118).
+ *
+ * 검증된 공개 라이브러리 `croner`(v10) 를 우리 컨벤션으로 얇게 래핑한다(ADR-029: "내부 구현은 검증된
+ * 공개 npm 라이브러리를 래핑한다" — MegaRetry=p-retry, MegaCircuitBreaker=opossum 선례와 동일 원칙).
+ * cron 필드 파싱·범위 검증·timezone(IANA)·DST·다음 발생 시각 계산을 직접 짜면 추론 최소화 원칙 위반이
+ * 되기 쉽다(특히 timezone/DST 경계). croner 는 이를 **0 의존성**으로 검증된 형태로 제공한다.
+ *
+ * # cron 표현식이란 (중학생용 설명)
+ *   "매일 새벽 3시", "5분마다" 같은 **반복 시각**을 짧은 문자열로 적는 표준 표기다. 예:
+ *     - `0 3 * * *`     → 매일 03:00 (분 시 일 월 요일)
+ *     - `* /5 * * * *`  → 5분마다 (공백 없이 `*<슬래시>5`)
+ *     - `0 0 * * 1`     → 매주 월요일 00:00
+ *   croner 는 6필드(맨 앞에 초)도 지원한다: `* /5 * * * * *` = 5초마다.
+ *
+ * # 본 모듈은 "계산"만 — 스케줄 실행은 {@link module:lib/mega-schedule}
+ *   MegaCron 은 표현식을 검증하고 다음/이전 발생 시각을 **계산**하는 순수 정적 유틸이다(타이머 미가동 —
+ *   fn 없이 `new Cron(expr)` 를 만들면 croner 는 아무 타이머도 걸지 않는다, 실측 확인). 실제 시각에
+ *   맞춰 작업을 **실행**하는 스케줄러는 `MegaScheduler`(분산 중복방지 포함)가 담당한다.
+ *
+ * # 잘못된 표현식은 즉시 throw
+ *   `validate`/`next`/`prev` 는 표현식이 틀리면 croner 의 파싱 에러를 **명확한 메시지로 감싸 throw**
+ *   한다(삼키지 않음). throw 없이 boolean 만 원하면 {@link MegaCron.isValid}.
+ *
+ * @module lib/mega-cron
+ * @see https://croner.56k.guru/ (croner 공식 문서)
+ * @see ADR-118, ADR-029 (공개 라이브러리 래핑 원칙)
+ */
+import { Cron } from 'croner'
+
+/**
+ * cron 계산 옵션. timezone 은 발생 시각 계산에 영향을 준다(예: `0 3 * * *` 를 `Asia/Seoul` 로 보면
+ * 한국 새벽 3시 = UTC 18:00).
+ *
+ * @typedef {Object} MegaCronOptions
+ * @property {string} [timezone] - IANA 타임존(예: `'Asia/Seoul'`, `'Europe/Stockholm'`). 미지정 시
+ *   호스트 로컬 타임존. 잘못된 타임존은 throw.
+ */
+
+/**
+ * 표현식 문자열을 사전 검증한다. 비문자열/빈 문자열은 croner 에 넘기기 전에 더 친절한 에러로 막는다.
+ * @param {unknown} expr
+ * @returns {string}
+ */
+function assertExprString(expr) {
+  if (typeof expr !== 'string' || expr.trim() === '') {
+    throw new TypeError(
+      `MegaCron: cron expression must be a non-empty string (got: ${expr === '' ? "''" : typeof expr}).`,
+    )
+  }
+  return expr
+}
+
+/**
+ * 검증·계산용 croner 인스턴스를 만들고 `compute(cron)` 을 실행한다. **fn 을 넘기지 않으므로 타이머가
+ * 걸리지 않는다**(순수 계산용). 표현식 오류는 croner 생성자에서, **타임존 오류는 croner 가 계산 시점에야**
+ * throw 하므로(생성자는 통과), 생성과 계산을 한 try/catch 로 묶어 모두 명확한 메시지로 재포장한다
+ * (wrap-rethrow — 원본은 `.cause`).
+ *
+ * @template T
+ * @param {string} expr @param {MegaCronOptions|undefined} opts @param {(cron: Cron) => T} compute @returns {T}
+ */
+function withCron(expr, opts, compute) {
+  try {
+    // 2번째 인자는 옵션 객체(fn 아님) → 스케줄 미등록.
+    const cron = new Cron(expr, { timezone: opts?.timezone })
+    return compute(cron)
+  } catch (e) {
+    const reason = e instanceof Error ? e.message : String(e)
+    const tz = opts?.timezone ? ` (timezone='${opts.timezone}')` : ''
+    throw new Error(`MegaCron: invalid cron expression "${expr}"${tz}: ${reason}`, { cause: e })
+  }
+}
+
+/**
+ * cron 표현식 정적 유틸. 모든 메서드는 상태가 없다(인스턴스화 불필요).
+ *
+ * @example
+ * MegaCron.isValid('0 3 * * *')                 // true
+ * MegaCron.validate('nope')                     // throws Error
+ * MegaCron.next('0 3 * * *', new Date(), { timezone: 'Asia/Seoul' })  // 다음 새벽 3시(KST)
+ */
+export class MegaCron {
+  /**
+   * 표현식을 파싱 검증한다. 유효하면 아무것도 반환하지 않고, 무효면 throw 한다(삼키지 않음).
+   * @param {string} expr - cron 표현식.
+   * @param {MegaCronOptions} [opts] - timezone 등(타임존도 함께 검증).
+   * @returns {void}
+   * @throws {TypeError} expr 이 비문자열/빈 문자열일 때.
+   * @throws {Error} 표현식/타임존 파싱 실패 시(원본은 `.cause`).
+   */
+  static validate(expr, opts) {
+    // nextRun() 을 1회 호출해 표현식 + 타임존을 모두 검증한다(타임존은 계산 시점에야 throw 됨).
+    withCron(assertExprString(expr), opts, (cron) => cron.nextRun())
+  }
+
+  /**
+   * 표현식 유효 여부를 throw 없이 boolean 으로 돌려준다. 사용자 입력 검증 UI 등에 쓴다.
+   * @param {string} expr - cron 표현식.
+   * @param {MegaCronOptions} [opts] - timezone 등.
+   * @returns {boolean} 유효하면 true.
+   */
+  static isValid(expr, opts) {
+    try {
+      MegaCron.validate(expr, opts)
+      return true
+    } catch {
+      // isValid 의 계약 자체가 "throw 없이 true/false" — 여기서 에러를 흡수하는 것이 정상 동작이다.
+      // (예외: 무시가 아니라 boolean 으로 변환해 반환하는 것이 본 메서드의 목적.)
+      return false
+    }
+  }
+
+  /**
+   * `from`(기본=현재) **이후** 첫 발생 시각을 계산한다.
+   * @param {string} expr - cron 표현식.
+   * @param {Date} [from] - 기준 시각(이 시각 이후의 다음 발생). 미지정 시 현재.
+   * @param {MegaCronOptions} [opts] - timezone 등.
+   * @returns {Date} 다음 발생 시각.
+   * @throws {Error} 표현식 무효 시, 또는 이후 발생이 없을 때(예: 일회성 과거 시각).
+   */
+  static next(expr, from, opts) {
+    const run = withCron(assertExprString(expr), opts, (cron) => cron.nextRun(from ?? undefined))
+    if (run === null) {
+      throw new Error(
+        `MegaCron: no upcoming run for "${expr}"${from ? ` after ${from.toISOString()}` : ''}.`,
+      )
+    }
+    return run
+  }
+
+  /**
+   * `from`(기본=현재) 이후 **n개**의 발생 시각을 계산한다. 모니터링/미리보기용.
+   * @param {string} expr - cron 표현식.
+   * @param {number} n - 개수(양의 정수).
+   * @param {Date} [from] - 기준 시각. 미지정 시 현재.
+   * @param {MegaCronOptions} [opts] - timezone 등.
+   * @returns {Date[]} 발생 시각 배열(시간 오름차순). 더 없으면 길이가 n 보다 짧을 수 있다.
+   * @throws {TypeError} n 이 양의 정수가 아닐 때.
+   * @throws {Error} 표현식 무효 시.
+   */
+  static nextRuns(expr, n, from, opts) {
+    if (!Number.isInteger(n) || n <= 0) {
+      throw new TypeError(`MegaCron.nextRuns: n must be a positive integer (got: ${n}).`)
+    }
+    return withCron(assertExprString(expr), opts, (cron) => cron.nextRuns(n, from ?? undefined))
+  }
+
+  /**
+   * `from`(기본=현재) **이전** 가장 가까운 발생 시각을 계산한다(역산). croner `previousRuns(1, ref)` 위임.
+   * @param {string} expr - cron 표현식.
+   * @param {Date} [from] - 기준 시각(이 시각 이전의 가장 최근 발생). 미지정 시 현재.
+   * @param {MegaCronOptions} [opts] - timezone 등.
+   * @returns {Date} 이전 발생 시각.
+   * @throws {Error} 표현식 무효 시, 또는 이전 발생이 없을 때.
+   */
+  static prev(expr, from, opts) {
+    const runs = withCron(assertExprString(expr), opts, (cron) =>
+      cron.previousRuns(1, from ?? undefined),
+    )
+    if (runs.length === 0) {
+      throw new Error(
+        `MegaCron: no previous run for "${expr}"${from ? ` before ${from.toISOString()}` : ''}.`,
+      )
+    }
+    return runs[0]
+  }
+}

package/src/lib/mega-hash.js

@@ -0,0 +1,179 @@
+// @ts-check
+/**
+ * MegaHash — 비밀번호 해싱 유틸 (ADR-130 / ADR-050 개정).
+ *
+ * # 왜 해싱인가
+ *   비밀번호를 그대로 DB 에 저장하면 DB 가 털렸을 때 모든 비밀번호가 즉시 유출된다. 그래서 비밀번호는
+ *   **되돌릴 수 없게** 변환(해시)해 저장하고, 로그인 때는 입력값을 똑같이 변환해 저장된 값과 **비교**만
+ *   한다. 공격자가 해시를 손에 넣어도 원본 비밀번호를 알아내려면 무수히 많은 후보를 일일이 해시해
+ *   맞춰봐야 한다(brute force). 좋은 비밀번호 해시는 이 "맞춰보기" 를 **일부러 느리고 메모리를 많이
+ *   먹게**(memory-hard) 만들어 GPU·ASIC 공격을 비싸게 한다.
+ *
+ * # 알고리즘 = scrypt (zero-dep, node:crypto 빌트인)
+ *   ADR-050 은 본래 argon2id 를 정본으로 정했으나, argon2 npm 은 **네이티브 C++ 빌드 의존성**(node-gyp)
+ *   이라 프로젝트 zero-dep 정책과 충돌한다. 그래서 **scrypt** 채택 — Node 빌트인이라 신규
+ *   의존성 0 이고, OWASP 가 argon2id 다음으로 권장하는 memory-hard 함수다(ADR-130 이 ADR-050 supersede).
+ *
+ * # 파라미터(자체 판단 — ADR-130)
+ *   OWASP(2023) 는 scrypt 최소 `N=2^17, r=8, p=1`(≈128 MiB/해시)을 권장하나, 그 메모리를 **요청마다**
+ *   할당하면 동시 로그인 폭주 시 서버 자체가 OOM 위험(자기-DoS)에 노출된다. 따라서 디폴트는 한 단계 낮춘
+ *   **`N=2^15(32768), r=8, p=1`(≈32 MiB/해시)** — bcrypt 의 실효 강도를 크게 웃돌면서 서버 메모리도
+ *   안전한 균형점이다. 파라미터는 해시 문자열에 **임베드**되므로(아래 포맷) 나중에 N 을 올려도 기존 해시는
+ *   그대로 검증된다(점진적 업그레이드 가능). 더 강한 보호가 필요하면 {@link MegaHash.password.hash} 의
+ *   `opts` 로 호출부에서 올린다.
+ *
+ * # 해시 포맷 (self-describing, PHC 풍)
+ *   `$scrypt$N=<N>,r=<r>,p=<p>$<salt-base64url>$<hash-base64url>`
+ *   - 알고리즘·파라미터·salt 가 전부 문자열 안에 있어, `verify` 는 별도 정보 없이 검증 가능.
+ *   - salt 는 16바이트 random(해시마다 고유 — rainbow table 무력화), 출력 키는 32바이트.
+ *
+ * # verify 의 fail-closed 의미
+ *   `verify(plain, hash)` 는 **boolean** 을 반환한다(03-api-spec §765). 포맷이 깨졌거나 우리 `$scrypt$`
+ *   해시가 아니면 **false**(= 불일치)로 처리한다 — 이는 에러를 "묵는" 게 아니라 정의된 의미다(잘못된
+ *   저장 해시로 로그인을 **통과시키지 않는다** = fail-closed, 보안상 안전한 방향). 비교는 항상
+ *   `timingSafeEqual` 로 상수 시간(타이밍 공격 회피).
+ *
+ * @module lib/mega-hash
+ * @see https://cheatsheetseries.owasp.org/cheatsheets/Password_Storage_Cheat_Sheet.html (OWASP)
+ * @see https://nodejs.org/api/crypto.html#cryptoscryptpassword-salt-keylen-options (node:crypto scrypt)
+ */
+import { randomBytes, scrypt as scryptCb, timingSafeEqual } from 'node:crypto'
+import { MegaValidationError } from '../errors/http-errors.js'
+import { MegaConfigError } from '../errors/config-error.js'
+
+/**
+ * parseHash 가 허용하는 scrypt 파라미터 방어적 상한(L-1). 손상되거나 악의적으로 조작된 저장 해시가
+ * 거대한 N(예: 2^30)을 담고 있으면, verify 가 그 값으로 scrypt 를 돌리며 수 GB 를 할당해 서버가
+ * OOM(자기-DoS)에 빠질 수 있다. 정상 운영 범위를 한참 웃도는 값은 "검증 거부"로 끊는다.
+ *   - N <= 2^20 (≈1M, V 배열 메모리 ~1GB 한계)
+ *   - r <= 32, p <= 16
+ */
+const MAX_PARAMS = Object.freeze({ N: 2 ** 20, r: 32, p: 16 })
+
+/** scrypt 디폴트 파라미터(ADR-130 — 서버 메모리 안전 균형). 해시 문자열에 임베드돼 검증 시 복원된다. */
+const DEFAULTS = Object.freeze({ N: 32768, r: 8, p: 1, keylen: 32, saltBytes: 16 })
+
+/**
+ * scrypt 가 필요로 하는 메모리(maxmem) 산정 — 지배항은 V 배열 `128*N*r` 이고, p 는 V 배열이 아니라
+ * B 버퍼(`128*r*p`)에만 곱해진다(즉 `128*N*r` 가 아니라 `128*N*r*p` 로 오해하면 안 됨, I-2).
+ * V 배열 + 작업 버퍼 여유까지 덮도록 `128*N*r` 의 2배 + B 버퍼(`128*r*p`) + 1MiB 여유를 둔다(파라미터 무관하게 안전).
+ * @param {number} N @param {number} r @param {number} p @returns {number}
+ */
+function maxmemFor(N, r, p) {
+  return 128 * r * N * 2 + 128 * r * p + 1024 * 1024
+}
+
+/**
+ * scrypt 를 Promise 로 감싼다(이벤트 루프 블로킹 회피 — 동기 scryptSync 대신 비동기 콜백 사용).
+ * @param {string} plain @param {Buffer} salt @param {number} keylen
+ * @param {{ N: number, r: number, p: number }} params
+ * @returns {Promise<Buffer>}
+ */
+function scryptAsync(plain, salt, keylen, { N, r, p }) {
+  return new Promise((resolve, reject) => {
+    scryptCb(plain, salt, keylen, { N, r, p, maxmem: maxmemFor(N, r, p) }, (err, derived) => {
+      if (err) reject(err)
+      else resolve(derived)
+    })
+  })
+}
+
+/**
+ * scrypt 해시 문자열을 파싱한다. 우리 포맷이 아니거나 손상되면 `null`(verify 가 false 로 귀결).
+ * 단, 파라미터가 방어적 상한({@link MAX_PARAMS})을 넘으면 `MegaConfigError('hash.invalid_params')`
+ * 를 throw 한다(L-1) — verify 가 잡아서 false 로 처리(거대 N OOM 차단, 의미상 fail-closed 동일).
+ * @param {string} stored
+ * @returns {{ N: number, r: number, p: number, salt: Buffer, hash: Buffer } | null}
+ * @throws {MegaConfigError} `hash.invalid_params` - N/r/p 가 안전 상한 초과.
+ */
+function parseHash(stored) {
+  if (typeof stored !== 'string') return null
+  // `$scrypt$N=..,r=..,p=..$<salt>$<hash>` — 정확히 4개 세그먼트(빈 첫 토큰 제외).
+  const parts = stored.split('$')
+  if (parts.length !== 5 || parts[0] !== '' || parts[1] !== 'scrypt') return null
+  const m = /^N=(\d+),r=(\d+),p=(\d+)$/.exec(parts[2])
+  if (!m) return null
+  const N = Number(m[1])
+  const r = Number(m[2])
+  const p = Number(m[3])
+  // 파라미터가 양의 정수이고 N 이 2의 거듭제곱(scrypt 요구)인지 — 아니면 손상으로 간주.
+  if (!isPositiveInt(N) || !isPositiveInt(r) || !isPositiveInt(p) || (N & (N - 1)) !== 0) return null
+  // 방어적 상한 초과(L-1) — 거대 N 으로 scrypt 가 수 GB 를 할당해 서버를 OOM 시키는 자기-DoS 차단.
+  if (N > MAX_PARAMS.N || r > MAX_PARAMS.r || p > MAX_PARAMS.p) {
+    throw new MegaConfigError('hash.invalid_params', `parseHash: scrypt params exceed safe bounds (N=${N}<=${MAX_PARAMS.N}, r=${r}<=${MAX_PARAMS.r}, p=${p}<=${MAX_PARAMS.p}).`, {
+      details: { N, r, p, max: MAX_PARAMS },
+    })
+  }
+  try {
+    const salt = Buffer.from(parts[3], 'base64url')
+    const hash = Buffer.from(parts[4], 'base64url')
+    if (salt.length === 0 || hash.length === 0) return null
+    return { N, r, p, salt, hash }
+  } catch {
+    // base64url 디코딩 실패 = 손상된 해시 → null(verify false). 원본 비밀번호 leak 없음.
+    return null
+  }
+}
+
+/** @param {unknown} n @returns {boolean} 양의 정수인지(Boolean 컨벤션). */
+function isPositiveInt(n) {
+  return typeof n === 'number' && Number.isInteger(n) && n > 0
+}
+
+/**
+ * MegaHash — 비밀번호 해싱 진입점. 03-api-spec §765 의 `static password = { hash, verify }` 표면.
+ */
+export class MegaHash {
+  static password = {
+    /**
+     * 비밀번호를 scrypt 로 해시한다. 매 호출 새 random salt → 같은 비밀번호도 매번 다른 해시.
+     *
+     * @param {string} plain - 평문 비밀번호.
+     * @param {{ N?: number, r?: number, p?: number, keylen?: number, saltBytes?: number }} [opts]
+     *   - scrypt 파라미터 오버라이드(미지정 시 ADR-130 디폴트). 강한 보호가 필요할 때만 사용.
+     * @returns {Promise<string>} `$scrypt$N=..,r=..,p=..$<salt>$<hash>` 포맷 문자열.
+     * @throws {MegaValidationError} `hash.invalid_password` - plain 이 비-문자열/빈 문자열.
+     */
+    async hash(plain, opts = {}) {
+      if (typeof plain !== 'string' || plain.length === 0) {
+        // 빈/비문자열 비밀번호는 프로그래밍 오류 — silent 진행 대신 fail-fast.
+        throw new MegaValidationError('hash.invalid_password', 'MegaHash.password.hash: plain password must be a non-empty string.')
+      }
+      const N = opts.N ?? DEFAULTS.N
+      const r = opts.r ?? DEFAULTS.r
+      const p = opts.p ?? DEFAULTS.p
+      const keylen = opts.keylen ?? DEFAULTS.keylen
+      const saltBytes = opts.saltBytes ?? DEFAULTS.saltBytes
+      const salt = randomBytes(saltBytes)
+      const derived = await scryptAsync(plain, salt, keylen, { N, r, p })
+      return `$scrypt$N=${N},r=${r},p=${p}$${salt.toString('base64url')}$${derived.toString('base64url')}`
+    },
+
+    /**
+     * 평문이 저장된 해시와 일치하는지 검증한다(상수 시간 비교). 03-api-spec §765 — verify 는 검증 액션
+     * 자체라 `is*` 접두사 룰의 예외로 동사형 그대로 둔다.
+     *
+     * @param {string} plain - 평문 비밀번호.
+     * @param {string} stored - {@link MegaHash.password.hash} 가 만든 해시 문자열.
+     * @returns {Promise<boolean>} 일치하면 true. 포맷 손상/비-scrypt/불일치는 모두 false(fail-closed).
+     */
+    async verify(plain, stored) {
+      if (typeof plain !== 'string' || plain.length === 0) return false // 빈 입력은 어떤 해시와도 불일치.
+      let parsed
+      try {
+        parsed = parseHash(stored)
+      } catch (e) {
+        // 상한 초과 해시(L-1)는 검증 거부 = false(fail-closed). 묵시 무시 아니라 정의된 의미 —
+        // 거대 N scrypt 를 돌리지 않아 OOM 차단. 그 외 에러는 가리지 않고 그대로 전파.
+        if (e instanceof MegaConfigError) return false
+        throw e
+      }
+      if (parsed === null) return false // 우리 해시가 아니거나 손상 → 불일치(통과시키지 않음).
+      const { N, r, p, salt, hash } = parsed
+      const derived = await scryptAsync(plain, salt, hash.length, { N, r, p })
+      // 길이가 다르면 timingSafeEqual 이 throw — 먼저 길이 비교(불일치 = false).
+      if (derived.length !== hash.length) return false
+      return timingSafeEqual(derived, hash)
+    },
+  }
+}

package/src/lib/mega-health.js

@@ -0,0 +1,91 @@
+// @ts-check
+
+/**
+ * MegaHealth — 사용자 정의 헬스 체크 등록 + checkAll + isReady.
+ *
+ * 사용:
+ *   MegaHealth.register('db', async () => ({ ok: await db.ping() }))
+ *   MegaHealth.register('cache', async () => ({ ok: await redis.ping() }))
+ *
+ *   const snapshot = await MegaHealth.checkAll()   // { ok: boolean, checks: {...} }
+ *   const ready = await MegaHealth.isReady()       // boolean
+ *
+ * Fastify 통합:
+ *   /health (liveness)  — 항상 200 OK + uptime
+ *   /health/ready       — checkAll 결과 — 모두 ok 면 200, 아니면 503
+ *
+ * 셋 다 rate-limit·ASP·CSRF 면제.
+ */
+
+import { MegaShutdown } from './mega-shutdown.js'
+
+const checks = new Map()
+
+/**
+ * 헬스 체크 등록.
+ * @param {string} name
+ * @param {() => Promise<{ ok: boolean, [key: string]: any }> | { ok: boolean }} fn
+ */
+export function register(name, fn) {
+  if (typeof name !== 'string' || name.length === 0) {
+    throw new Error('MegaHealth.register: name is required (string)')
+  }
+  if (typeof fn !== 'function') {
+    throw new Error('MegaHealth.register: fn must be a function')
+  }
+  checks.set(name, fn)
+}
+
+/**
+ * 모든 체크 실행 (병렬). 하나라도 false 면 전체 ok=false.
+ * @returns {Promise<{ ok: boolean, checks: Record<string, { ok: boolean, error?: string, [key: string]: any }> }>}
+ */
+export async function checkAll() {
+  // shutdown 중이면 readiness false (LB 가 트래픽 회수)
+  if (MegaShutdown.isShuttingDown()) {
+    return { ok: false, checks: { _shutdown: { ok: false, reason: 'shutting_down' } } }
+  }
+
+  const entries = [...checks.entries()]
+  const results = await Promise.all(
+    entries.map(async ([name, fn]) => {
+      try {
+        const result = await fn()
+        return [name, result?.ok === true ? result : { ok: false, ...result }]
+      } catch (err) {
+        return [name, { ok: false, error: err?.message ?? String(err) }]
+      }
+    }),
+  )
+  /** @type {Record<string, any>} */
+  const summary = {}
+  let allOk = true
+  for (const [name, r] of results) {
+    summary[name] = r
+    if (!r.ok) allOk = false
+  }
+  return { ok: allOk, checks: summary }
+}
+
+/**
+ * @returns {Promise<boolean>}
+ */
+export async function isReady() {
+  const { ok } = await checkAll()
+  return ok
+}
+
+/**
+ * 디버그·테스트용.
+ * @returns {number}
+ */
+export function registeredCount() {
+  return checks.size
+}
+
+/**
+ * 테스트용 reset.
+ */
+export function _reset() {
+  checks.clear()
+}