@sebspark/health-check 1.0.1 → 1.0.3

package/dist/index.js

@@ -1,44 +1,5 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  DependencyMonitor: () => DependencyMonitor,
-  HealthMonitor: () => HealthMonitor,
-  TimeoutError: () => TimeoutError,
-  UnknownError: () => UnknownError
-});
-module.exports = __toCommonJS(index_exports);
-
 // src/dependency-monitor.ts
-var import_node_perf_hooks = require("perf_hooks");
+import { performance } from "perf_hooks";
 
 // src/types.ts
 var TimeoutError = class extends Error {
@@ -156,11 +117,11 @@ var DependencyMonitor = class {
    * - Error if `"error"`, `Error`, or timeout exceeded
    */
   async doSyncCheck() {
-    const start = import_node_perf_hooks.performance.now();
+    const start = performance.now();
     const { syncCall, timeoutLimitMs } = this.config;
     try {
       const response = await runAgainstTimeout(syncCall(), timeoutLimitMs);
-      const duration = import_node_perf_hooks.performance.now() - start;
+      const duration = performance.now() - start;
       this.handleDependencyResponse(response, duration);
     } catch (err) {
       this.handleDependencyError(err);
@@ -174,7 +135,7 @@ var DependencyMonitor = class {
    */
   async doAsyncCheck() {
     const { asyncCall, healthyLimitMs, timeoutLimitMs } = this.config;
-    const start = import_node_perf_hooks.performance.now();
+    const start = performance.now();
     let callActive = true;
     let healthTimeout;
     let serviceTimeout;
@@ -183,7 +144,7 @@ var DependencyMonitor = class {
       callActive = false;
       clearTimeout(healthTimeout);
       clearTimeout(serviceTimeout);
-      const duration = import_node_perf_hooks.performance.now() - start;
+      const duration = performance.now() - start;
       this.handleDependencyResponse(response, duration);
     });
     healthTimeout = setTimeout(() => {
@@ -284,25 +245,25 @@ var DependencyMonitor = class {
 };
 
 // src/health-monitor.ts
-var import_express = require("express");
+import { Router } from "express";
 
 // src/static-checks.ts
-var import_node_os = __toESM(require("os"));
+import os from "os";
 var ping = () => ({ status: "ok" });
 var liveness = () => {
-  const cpus = import_node_os.default.cpus();
-  const total = import_node_os.default.totalmem();
-  const free = import_node_os.default.freemem();
+  const cpus = os.cpus();
+  const total = os.totalmem();
+  const free = os.freemem();
   return {
     status: "ok",
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     system: {
-      hostname: import_node_os.default.hostname(),
-      platform: import_node_os.default.platform(),
-      release: import_node_os.default.release(),
-      arch: import_node_os.default.arch(),
-      uptime: import_node_os.default.uptime(),
-      loadavg: import_node_os.default.loadavg(),
+      hostname: os.hostname(),
+      platform: os.platform(),
+      release: os.release(),
+      arch: os.arch(),
+      uptime: os.uptime(),
+      loadavg: os.loadavg(),
       totalmem: total,
       freemem: free,
       memUsedRatio: total > 0 ? (total - free) / total : 0,
@@ -362,7 +323,7 @@ var HealthMonitor = class {
    * Internal: create the Express router with /health routes.
    */
   createRouter() {
-    const router = (0, import_express.Router)();
+    const router = Router();
     router.get("/health", async (_req, res, next) => {
       try {
         const health = await this.health();
@@ -564,10 +525,10 @@ var HealthMonitor = class {
     }
   }
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   DependencyMonitor,
   HealthMonitor,
   TimeoutError,
   UnknownError
-});
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/dependency-monitor.ts","../src/types.ts","../src/timing.ts","../src/health-monitor.ts","../src/static-checks.ts"],"sourcesContent":["import { performance } from 'node:perf_hooks'\nimport { runAgainstTimeout, singleFlight } from './timing'\nimport {\n  type CheckError,\n  type DependencyCheck,\n  type DependencyStatusValue,\n  type Freshness,\n  type Impact,\n  type Mode,\n  type Observed,\n  type StatusValue,\n  TimeoutError,\n  UnknownError,\n} from './types'\n\n/**\n * Base configuration shared by all dependency monitor modes.\n */\ntype BaseConfig = {\n  /**\n   * Importance of the dependency:\n   * - `'critical'` → service cannot run without it\n   * - `'non_critical'` → service is degraded but still functional if it fails\n   */\n  impact: Impact\n\n  /**\n   * Polling interval in milliseconds.\n   * - Required for polled and async modes\n   * - Must not be set for inline mode\n   */\n  pollRate?: number\n\n  /**\n   * Polling interval in milliseconds for failed calls.\n   * - Defaults to pollRate for polled and async modes\n   * - Must not be set for inline mode\n   */\n  retryRate?: number\n\n  /**\n   * Maximum response time in milliseconds considered healthy.\n   * - A call resolving within this time window **and** returning `\"ok\"` → status `\"ok\"`\n   * - A call resolving after this but **before** `timeoutLimitMs` → status `\"degraded\"`\n   */\n  healthyLimitMs: number\n\n  /**\n   * Absolute upper bound in milliseconds; beyond this a call is considered `\"error\"`.\n   * - Inline: the awaited call is raced with a timeout and rejected past this limit\n   * - Polled/Async: escalate `unknown` → `degraded` at `healthyLimitMs`, then `\"error\"` at `timeoutLimitMs`\n   * - Any late `\"ok\"` result after this limit is ignored\n   */\n  timeoutLimitMs: number\n}\n\n/**\n * Inline mode configuration (no polling).\n * `syncCall` runs **only** when {@link DependencyMonitor.check} is invoked.\n */\nexport type SyncInlineConfig = BaseConfig & {\n  /** Performs the check immediately when {@link DependencyMonitor.check} is called. */\n  syncCall: () => Promise<DependencyStatusValue | Error>\n  asyncCall?: never\n  pollRate?: undefined\n  retryRate?: undefined\n}\n\n/**\n * Polled mode configuration.\n * `syncCall` runs on an interval (`pollRate`) and results are cached.\n */\nexport type SyncPolledConfig = BaseConfig & {\n  /** Performs the check at each poll interval. */\n  syncCall: () => Promise<DependencyStatusValue | Error>\n  /** Polling interval in milliseconds. */\n  pollRate: number\n  asyncCall?: never\n}\n\n/**\n * Async mode configuration.\n * `asyncCall` starts a check and must report via the provided callback.\n */\nexport type AsyncConfig = BaseConfig & {\n  /**\n   * Starts an asynchronous check. Must call `reportResponse` once a result is available.\n   * The callback may be invoked with a `DependencyStatusValue` or an `Error`.\n   */\n  asyncCall: (\n    reportResponse: (\n      status: DependencyStatusValue | Error\n    ) => void | Promise<void>\n  ) => void | Promise<void>\n  /** Polling interval in milliseconds. */\n  pollRate: number\n  syncCall?: never\n}\n\n/**\n * Discriminated configuration for a dependency monitor.\n * - {@link SyncInlineConfig} → inline checks on demand\n * - {@link SyncPolledConfig} → synchronous checks on a fixed interval\n * - {@link AsyncConfig} → asynchronous checks that report back via callback\n */\nexport type DependencyMonitorConfig =\n  | SyncInlineConfig\n  | SyncPolledConfig\n  | AsyncConfig\n\n/**\n * Tracks the health of a single dependency in one of three modes:\n *\n * - **inline**: `syncCall` executed only when {@link check} is called\n * - **polled**: `syncCall` executed on `pollRate`; latest result cached\n * - **async**: `asyncCall` executed on `pollRate`, result returned via callback\n *\n * The monitor:\n * - classifies results using `healthyLimitMs` and `timeoutLimitMs`\n * - records freshness (`lastChecked`, `lastSuccess`)\n * - records observed latency (ms) when applicable\n *\n * Status interpretation:\n * - `\"ok\"` only if returned `\"ok\"` **and** latency ≤ `healthyLimitMs`\n * - `\"degraded\"` if returned `\"degraded\"` **or** latency > `healthyLimitMs` but ≤ `timeoutLimitMs`\n * - `\"error\"` if returned `\"error\"`, an `Error`, or exceeded `timeoutLimitMs`\n * - `\"unknown\"` is the initial state before first successful/failed result (polled/async)\n */\nexport class DependencyMonitor {\n  /** Immutable configuration for this monitor. */\n  private readonly config: DependencyMonitorConfig\n  /** Operational mode determined from the configuration. */\n  private readonly mode: Mode\n\n  /** Last computed status (starts as `\"unknown\"` until first result). */\n  private status: StatusValue\n  /** Optional error details from the last failure. */\n  private error?: CheckError\n  /** Last observed metrics (e.g., latency). */\n  private observed?: Observed\n  /** Freshness timestamps for last check/success. */\n  private freshness?: Freshness\n\n  /** Indicates whether this monitor has been disposed. */\n  private isDisposed = false\n  /** Internal timer handle for polling/retry. */\n  private timeout?: NodeJS.Timeout\n\n  /**\n   * Create a new {@link DependencyMonitor}.\n   * @param config Monitor configuration (inline, polled, or async).\n   */\n  constructor(config: DependencyMonitorConfig) {\n    this.config = config\n\n    this.mode = config.asyncCall\n      ? 'async'\n      : config.pollRate\n        ? 'polled'\n        : 'inline'\n\n    this.status = 'unknown'\n\n    // Deduplicate concurrent inline checks (single-flight).\n    if (this.mode === 'inline') {\n      this.check = singleFlight(this.check.bind(this))\n    }\n\n    // Kick off the first cycle for polled/async.\n    if (this.mode !== 'inline') {\n      this.doCheck()\n    }\n  }\n\n  /** Impact of this dependency (critical/non_critical). */\n  public get impact() {\n    return this.config.impact\n  }\n\n  /**\n   * Run one check cycle depending on the configured mode.\n   * - Inline: no-op here (runs in {@link check})\n   * - Polled/Async: invoked automatically and re-scheduled as needed\n   */\n  private async doCheck() {\n    if (this.timeout) {\n      clearTimeout(this.timeout)\n    }\n    if (this.isDisposed) {\n      return\n    }\n\n    if (this.config.syncCall) {\n      await this.doSyncCheck()\n    } else {\n      this.doAsyncCheck()\n    }\n  }\n\n  /**\n   * Execute a synchronous (inline/polled) check and update internal state.\n   * Classification:\n   * - OK if `\"ok\"` and latency ≤ `healthyLimitMs`\n   * - Degraded if `\"degraded\"` or latency between `(healthyLimitMs, timeoutLimitMs]`\n   * - Error if `\"error\"`, `Error`, or timeout exceeded\n   */\n  private async doSyncCheck() {\n    const start = performance.now()\n\n    const { syncCall, timeoutLimitMs } = this.config as SyncInlineConfig\n\n    try {\n      const response = await runAgainstTimeout(syncCall(), timeoutLimitMs)\n      const duration = performance.now() - start\n\n      this.handleDependencyResponse(response, duration)\n    } catch (err) {\n      this.handleDependencyError(err as Error)\n    }\n  }\n\n  /**\n   * Execute an asynchronous check (async mode).\n   * - Initializes timers to escalate `unknown` → `degraded` → `error`\n   *   if no callback result arrives within the thresholds.\n   * - On callback, clears timers and classifies the result with latency.\n   */\n  private async doAsyncCheck() {\n    const { asyncCall, healthyLimitMs, timeoutLimitMs } = this\n      .config as AsyncConfig\n\n    const start = performance.now()\n    let callActive = true\n    let healthTimeout: NodeJS.Timeout | undefined\n    let serviceTimeout: NodeJS.Timeout | undefined\n\n    asyncCall((response) => {\n      if (!callActive) return\n      callActive = false\n      clearTimeout(healthTimeout)\n      clearTimeout(serviceTimeout)\n\n      const duration = performance.now() - start\n      this.handleDependencyResponse(response, duration)\n    })\n\n    // Escalate to degraded after healthy limit if still waiting.\n    healthTimeout = setTimeout(() => {\n      if (callActive) this.status = 'degraded'\n    }, healthyLimitMs)\n\n    // Escalate to error after timeout limit if still waiting.\n    serviceTimeout = setTimeout(() => {\n      if (!callActive) return\n      callActive = false\n      clearTimeout(healthTimeout)\n      this.handleDependencyError(new TimeoutError())\n    }, timeoutLimitMs)\n  }\n\n  /**\n   * Normalize a successful dependency response into status + metadata.\n   * @param response Returned status value or Error from the dependency\n   * @param duration Measured latency in milliseconds\n   */\n  private handleDependencyResponse(\n    response: DependencyStatusValue | Error,\n    duration: number\n  ) {\n    if (response instanceof Error) {\n      return this.handleDependencyError(response)\n    }\n    if (response === 'error') {\n      return this.handleDependencyError(new UnknownError())\n    }\n\n    this.error = undefined\n    this.status =\n      response === 'ok' && duration <= this.config.healthyLimitMs\n        ? 'ok'\n        : 'degraded'\n\n    const end = new Date()\n    this.freshness = {\n      lastChecked: end.toISOString(),\n      lastSuccess: end.toISOString(),\n    }\n\n    this.observed = { latencyMs: duration }\n\n    // Schedule next poll if applicable.\n    if (this.config.pollRate && !this.isDisposed) {\n      const delay = this.config.pollRate\n      this.timeout = setTimeout(() => this.doCheck(), delay)\n    }\n  }\n\n  /**\n   * Normalize a failed dependency result into `\"error\"` and update metadata.\n   * @param error Error thrown/returned or synthesized (e.g., timeout)\n   */\n  private handleDependencyError(error: Error & { code?: string }) {\n    this.status = 'error'\n    this.observed = undefined\n    this.error = {\n      code: error.code || 'UNKNOWN',\n      message: error.message,\n    }\n\n    const end = new Date()\n    if (this.freshness) {\n      this.freshness.lastChecked = end.toISOString()\n    } else {\n      this.freshness = { lastChecked: end.toISOString(), lastSuccess: null }\n    }\n\n    // Schedule retry/poll if configured.\n    if ((this.config.retryRate || this.config.pollRate) && !this.isDisposed) {\n      const delay = this.config.retryRate || this.config.pollRate\n      this.timeout = setTimeout(() => this.doCheck(), delay)\n    }\n  }\n\n  /**\n   * Get a snapshot of the dependency’s current health.\n   * - Inline mode: executes the `syncCall` (single-flight guarded)\n   * - Polled/Async: returns the cached result\n   * @throws if the monitor has been disposed\n   */\n  public async check(): Promise<DependencyCheck> {\n    if (this.isDisposed) {\n      throw new Error('DependencyMonitor has been disposed')\n    }\n\n    if (this.mode === 'inline') {\n      await this.doCheck()\n    }\n\n    const result: DependencyCheck = {\n      status: this.status as StatusValue,\n      impact: this.config.impact,\n      mode: this.mode,\n      freshness: this.freshness as Freshness,\n      observed: this.observed,\n      error: this.error,\n    }\n\n    return result\n  }\n\n  /** Symbol-based disposer for use with `using`. */\n  public [Symbol.dispose]() {\n    this.dispose()\n  }\n\n  /**\n   * Dispose the monitor:\n   * - Clears any scheduled timers\n   * - Prevents further checks from running\n   */\n  public dispose() {\n    this.isDisposed = true\n    if (this.timeout) {\n      clearTimeout(this.timeout)\n    }\n  }\n}\n","export type DependencyStatusValue = 'ok' | 'degraded' | 'error'\nexport type StatusValue = DependencyStatusValue | 'unknown' | 'draining'\nexport type Impact = 'critical' | 'non_critical'\nexport type Mode = 'inline' | 'polled' | 'async'\n\nexport type Status = {\n  status: StatusValue\n}\n\nexport type System = {\n  hostname: string\n  platform: NodeJS.Platform\n  release: string\n  arch: string\n  uptime: number\n  loadavg: [number, number, number] // 1, 5, 15 min\n  totalmem: number\n  freemem: number\n  memUsedRatio: number // 0..1\n  cpus: {\n    count: number\n    model?: string\n    speedMHz?: number\n  }\n}\n\nexport type Process = {\n  pid: number\n  node: string\n  uptime: number\n  memory: NodeJS.MemoryUsage\n}\n\nexport type Liveness = Status & {\n  timestamp: string\n  system: System\n  process: Process\n}\n\nexport type Freshness = {\n  lastChecked: string\n  lastSuccess: string | null\n}\n\nexport type Observed = {\n  latencyMs: number | null\n  [k: string]: unknown\n}\n\nexport type CheckError = {\n  code: string\n  message: string\n}\n\nexport type DependencyCheck = Status & {\n  impact: Impact\n  mode: Mode\n  freshness: Freshness\n  observed?: Observed\n  details?: Record<string, unknown>\n  error?: CheckError | null\n  since?: string | null\n}\n\nexport type ReadinessSummary = {\n  critical: { ok: number; failing: number }\n  nonCritical: { ok: number; degraded: number; failing: number }\n  degradedReasons: string[]\n}\n\nexport type ReadinessPayload = Status & {\n  timestamp: string\n  service?: { name?: string; version?: string; instanceId?: string }\n  summary: ReadinessSummary\n  checks: Record<string, DependencyCheck>\n}\n\nexport type HealthSummary = Status &\n  Pick<ReadinessPayload, 'summary' | 'checks'> &\n  Pick<Liveness, 'system' | 'process'> & { timestamp: string }\n\nexport class TimeoutError extends Error {\n  constructor() {\n    super('timeout')\n    this.name = 'TimeoutError'\n  }\n}\n\nexport class UnknownError extends Error {\n  constructor() {\n    super('unknown')\n    this.name = 'UnknownError'\n  }\n}\n","import { TimeoutError } from './types'\n\nexport const wait = (ms: number) =>\n  new Promise<void>((resolve) => setTimeout(resolve, ms))\n\nexport const runTimeoutTimer = async (ms: number) => {\n  await wait(ms)\n  throw new TimeoutError()\n}\n\nexport const runAgainstTimeout = <T>(\n  promise: Promise<T>,\n  ms?: number | undefined\n): Promise<T> => {\n  if ((ms as number) > 0) {\n    return Promise.race([promise, runTimeoutTimer(ms as number)])\n  }\n\n  return promise\n}\n\n/**\n * Throttles an async function:\n *  - coalesces concurrent calls into a single in-flight Promise,\n *  - after it settles, reuses that settled Promise for `ms` ms,\n *  - then clears so the next call invokes `fn` again.\n *\n * Fully preserves the original function signature.\n */\nexport const throttle = <F extends (...args: unknown[]) => Promise<unknown>>(\n  fn: F,\n  ms: number\n) => {\n  type R = ReturnType<F> // a Promise<T>\n\n  let current: R | null = null\n  let clearHandle: NodeJS.Timeout | null = null\n\n  const wrapped = (...args: Parameters<F>): R => {\n    if (!current) {\n      current = fn(...args) as R\n\n      if (clearHandle) {\n        clearTimeout(clearHandle)\n        clearHandle = null\n      }\n\n      current.finally(() => {\n        if (ms > 0) {\n          clearHandle = setTimeout(() => {\n            current = null\n            clearHandle = null\n          }, ms)\n        } else {\n          current = null\n        }\n      })\n    }\n\n    return current\n  }\n\n  // Cast to F so the returned function has the *identical* callable type\n  return wrapped as unknown as F\n}\n\n/**\n * Wraps an async function so that concurrent invocations share the same in-flight Promise.\n * After the Promise settles (resolve or reject), the next call will invoke the function again.\n * Essentially just throttled with timeout 0\n */\nexport const singleFlight = <\n  F extends (...args: unknown[]) => Promise<unknown>,\n>(\n  fn: F\n) => throttle<F>(fn, 0)\n","import { Router } from 'express'\nimport type { ErrorRequestHandler } from 'express-serve-static-core'\nimport type {\n  DependencyMonitor,\n  DependencyMonitorConfig,\n} from './dependency-monitor'\nimport { liveness, ping } from './static-checks'\nimport { throttle } from './timing'\nimport type {\n  DependencyCheck,\n  HealthSummary,\n  Impact,\n  ReadinessPayload,\n  ReadinessSummary,\n} from './types'\n\nexport interface HealthMonitorConfig {\n  throttle: number\n}\n\n/**\n * HealthMonitor wires up standard health check endpoints for an Express app.\n *\n * It provides three endpoints under `/health`:\n * - /ping → lightweight always-OK response (`{ status: \"ok\" }`)\n * - /live → liveness probe (`{ status, uptime, timestamp }`)\n * - /ready → readiness probe with dependency checks (`{ status, checks }`)\n *\n * Dependencies can be added via {@link addDependency} with a {@link DependencyMonitorConfig}.\n * Each dependency is wrapped in a {@link DependencyMonitor} and tracked for readiness.\n *\n * ### Example\n *\n * ```ts\n * import express from 'express'\n * import { HealthMonitor } from './health-monitor'\n *\n * const app = express()\n * const monitor = new HealthMonitor()\n *\n * monitor.addDependency('db', {\n *   impact: 'critical',\n *   syncCall: async () => {\n *     await db.ping()\n *     return 'ok'\n *   }\n * })\n *\n * app.use(monitor.router)\n * app.listen(3000)\n * ```\n */\nexport class HealthMonitor {\n  private readonly _router: Router\n  private readonly dependencies: Map<string, DependencyMonitor>\n  // private isDisposed = false\n\n  /**\n   * Create a new HealthMonitor instance with its own router and dependency map.\n   */\n  constructor(config?: HealthMonitorConfig) {\n    this._router = this.createRouter()\n    this.dependencies = new Map()\n\n    const thr = config ? config.throttle : 10\n    if (thr > 0) {\n      this.ready = throttle(this.ready.bind(this), thr)\n    }\n  }\n\n  /**\n   * Register a named dependency to be checked as part of readiness.\n   *\n   * @param name - Identifier for the dependency (e.g. \"postgres\", \"redis\").\n   * @param dependency - DependencyMonitor\n   * @returns this for chaining\n   *\n   * @example\n   * ```ts\n   * monitor.addDependency('redis', new DependencyMonitor({\n   *   impact: 'critical',\n   *   pollRate: 5000,\n   *   syncCall: async () => redis.ping() ? 'ok' : 'error'\n   * }))\n   * ```\n   */\n  public addDependency(name: string, dependency: DependencyMonitor) {\n    this.dependencies.set(name, dependency)\n    return this\n  }\n\n  /**\n   * Internal: create the Express router with /health routes.\n   */\n  private createRouter() {\n    const router = Router()\n\n    // Health\n    router.get('/health', async (_req, res, next) => {\n      try {\n        const health = await this.health()\n        res.status(200).json(health)\n      } catch (err) {\n        next?.(err)\n      }\n    })\n\n    // Ping\n    router.get('/health/ping', (_req, res, next) => {\n      try {\n        res.status(200).json(this.ping())\n      } catch (err) {\n        next?.(err)\n      }\n    })\n\n    // Liveness\n    router.get('/health/live', (_req, res, next) => {\n      try {\n        res.status(200).json(this.live())\n      } catch (err) {\n        next?.(err)\n      }\n    })\n\n    // Readiness\n    router.get('/health/ready', async (_req, res, next) => {\n      try {\n        const readiness = await this.ready()\n        res.status(200).json(readiness)\n      } catch (err) {\n        next?.(err)\n      }\n    })\n\n    // Error handler\n    const errorHandler: ErrorRequestHandler = (err, _req, res, _next) => {\n      const message = err instanceof Error ? err.message : String(err)\n      res.status(500).json({\n        status: 'error',\n        error: { message },\n      })\n    }\n    router.use(errorHandler)\n\n    return router\n  }\n\n  /**\n   * Static ping check — always returns `{ status: \"ok\" }`.\n   */\n  public ping() {\n    return ping()\n  }\n\n  /**\n   * Liveness probe: reports uptime and current timestamp.\n   */\n  public live() {\n    return liveness()\n  }\n\n  /**\n   * Readiness probe: runs all registered dependencies in parallel\n   * and aggregates their results into an overall status.\n   *\n   * - Any **critical error** → `\"error\"`\n   * - Else any **critical degraded** or any non-critical degraded/error → `\"degraded\"`\n   * - Else → `\"ok\"`\n   *\n   * @returns Object with overall `status` and per-dependency `checks`\n   *\n   * @example\n   * ```json\n   * {\n   *   \"status\": \"ok\",\n   *   \"checks\": {\n   *     \"postgres\": {\n   *       \"status\": \"ok\",\n   *       \"impact\": \"critical\",\n   *       \"mode\": \"inline\",\n   *       \"freshness\": {\n   *         \"lastChecked\": \"2025-08-19T12:00:00Z\",\n   *         \"lastSuccess\": \"2025-08-19T12:00:00Z\"\n   *       },\n   *       \"observed\": { \"latencyMs\": 12 }\n   *     }\n   *   }\n   * }\n   * ```\n   */\n  public async ready(): Promise<ReadinessPayload> {\n    const entries = Array.from(this.dependencies.entries())\n\n    const settled = await Promise.allSettled(\n      entries.map(async ([name, monitor]) => {\n        const check = await monitor.check()\n        return [name, check] as const\n      })\n    )\n\n    const checks: Record<string, DependencyCheck> = {}\n\n    for (let i = 0; i < settled.length; i++) {\n      const s = settled[i]\n      const [name] = entries[i]\n\n      if (s.status === 'fulfilled') {\n        const [, check] = s.value\n        checks[name] = check\n      } else {\n        checks[name] = {\n          status: 'error',\n          impact: this.dependencies.get(name)?.impact as Impact,\n          mode: 'polled',\n          freshness: {\n            lastChecked: new Date().toISOString(),\n            lastSuccess: null,\n          },\n          observed: undefined,\n          error: {\n            code: 'CHECK_FAILED',\n            message: String(s.reason ?? 'unknown error'),\n          },\n        }\n      }\n    }\n\n    // ----- summary -------------------------------------------------------------\n    let criticalOk = 0\n    let criticalFailing = 0 // counts any non-ok critical (degraded OR error)\n\n    let nonCritOk = 0\n    let nonCritDegraded = 0\n    let nonCritFailing = 0 // non-critical with status === 'error'\n\n    const degradedReasons: string[] = []\n\n    for (const [name, c] of Object.entries(checks)) {\n      const isCritical = c.impact === 'critical'\n      if (c.status === 'ok') {\n        if (isCritical) criticalOk++\n        else nonCritOk++\n      } else if (c.status === 'degraded') {\n        if (isCritical)\n          criticalFailing++ // critical degraded counts as failing\n        else nonCritDegraded++\n        degradedReasons.push(`${name}:degraded`)\n      } else {\n        // 'error'\n        if (isCritical) criticalFailing++\n        else nonCritFailing++\n        degradedReasons.push(`${name}:${c.error?.code ?? 'error'}`)\n      }\n    }\n\n    const summary: ReadinessSummary = {\n      critical: { ok: criticalOk, failing: criticalFailing },\n      nonCritical: {\n        ok: nonCritOk,\n        degraded: nonCritDegraded,\n        failing: nonCritFailing,\n      },\n      degradedReasons,\n    }\n\n    // ----- overall status (same rules as before) -------------------------------\n    let status: import('./types').StatusValue = 'ok'\n    const values = Object.values(checks)\n    const anyCriticalError = values.some(\n      (c) => c.impact === 'critical' && c.status === 'error'\n    )\n    const anyDegradedOrError = values.some(\n      (c) => c.status === 'degraded' || c.status === 'error'\n    )\n    const anyCriticalDegraded = values.some(\n      (c) => c.impact === 'critical' && c.status === 'degraded'\n    )\n\n    if (anyCriticalError) status = 'error'\n    else if (anyCriticalDegraded || anyDegradedOrError) status = 'degraded'\n\n    // ----- payload -------------------------------------------------------------\n    const payload: ReadinessPayload = {\n      status,\n      timestamp: new Date().toISOString(),\n      // service: { name, version, instanceId } // (optional; if you add config later)\n      summary,\n      checks,\n    }\n\n    return payload\n  }\n\n  public async health() {\n    const { status, checks, summary } = await this.ready()\n    const { timestamp, system, process } = this.live()\n\n    return {\n      status,\n      timestamp,\n      system,\n      process,\n      checks,\n      summary,\n    } as HealthSummary\n  }\n\n  /**\n   * Accessor for the Express router that exposes /health endpoints.\n   */\n  public get router() {\n    return this._router\n  }\n\n  /**\n   * Symbol-based disposer for use with `using`.\n   */\n  public [Symbol.dispose]() {\n    this.dispose()\n  }\n\n  /**\n   * Dispose of the monitor:\n   * - marks as disposed\n   * - (future: could also stop all dependency monitors)\n   */\n  public dispose() {\n    // this.isDisposed = true\n    for (const dependency of this.dependencies.values()) {\n      dependency.dispose()\n    }\n  }\n}\n","import os from 'node:os'\nimport type { Liveness, Status } from './types'\n\nexport const ping = (): Status => ({ status: 'ok' })\nexport const liveness = (): Liveness => {\n  const cpus = os.cpus()\n  const total = os.totalmem()\n  const free = os.freemem()\n\n  return {\n    status: 'ok',\n    timestamp: new Date().toISOString(),\n    system: {\n      hostname: os.hostname(),\n      platform: os.platform(),\n      release: os.release(),\n      arch: os.arch(),\n      uptime: os.uptime(),\n      loadavg: os.loadavg() as [number, number, number],\n      totalmem: total,\n      freemem: free,\n      memUsedRatio: total > 0 ? (total - free) / total : 0,\n      cpus: {\n        count: cpus.length,\n        model: cpus[0]?.model,\n        speedMHz: cpus[0]?.speed,\n      },\n    },\n    process: {\n      pid: process.pid,\n      node: process.versions.node,\n      uptime: process.uptime(),\n      memory: process.memoryUsage(), // rss, heapTotal, heapUsed, external, arrayBuffers\n    },\n  }\n}\n"],"mappings":";AAAA,SAAS,mBAAmB;;;ACiFrB,IAAM,eAAN,cAA2B,MAAM;AAAA,EACtC,cAAc;AACZ,UAAM,SAAS;AACf,SAAK,OAAO;AAAA,EACd;AACF;AAEO,IAAM,eAAN,cAA2B,MAAM;AAAA,EACtC,cAAc;AACZ,UAAM,SAAS;AACf,SAAK,OAAO;AAAA,EACd;AACF;;;AC3FO,IAAM,OAAO,CAAC,OACnB,IAAI,QAAc,CAAC,YAAY,WAAW,SAAS,EAAE,CAAC;AAEjD,IAAM,kBAAkB,OAAO,OAAe;AACnD,QAAM,KAAK,EAAE;AACb,QAAM,IAAI,aAAa;AACzB;AAEO,IAAM,oBAAoB,CAC/B,SACA,OACe;AACf,MAAK,KAAgB,GAAG;AACtB,WAAO,QAAQ,KAAK,CAAC,SAAS,gBAAgB,EAAY,CAAC,CAAC;AAAA,EAC9D;AAEA,SAAO;AACT;AAUO,IAAM,WAAW,CACtB,IACA,OACG;AAGH,MAAI,UAAoB;AACxB,MAAI,cAAqC;AAEzC,QAAM,UAAU,IAAI,SAA2B;AAC7C,QAAI,CAAC,SAAS;AACZ,gBAAU,GAAG,GAAG,IAAI;AAEpB,UAAI,aAAa;AACf,qBAAa,WAAW;AACxB,sBAAc;AAAA,MAChB;AAEA,cAAQ,QAAQ,MAAM;AACpB,YAAI,KAAK,GAAG;AACV,wBAAc,WAAW,MAAM;AAC7B,sBAAU;AACV,0BAAc;AAAA,UAChB,GAAG,EAAE;AAAA,QACP,OAAO;AACL,oBAAU;AAAA,QACZ;AAAA,MACF,CAAC;AAAA,IACH;AAEA,WAAO;AAAA,EACT;AAGA,SAAO;AACT;AAOO,IAAM,eAAe,CAG1B,OACG,SAAY,IAAI,CAAC;;;AFqDf,IAAM,oBAAN,MAAwB;AAAA;AAAA,EAEZ;AAAA;AAAA,EAEA;AAAA;AAAA,EAGT;AAAA;AAAA,EAEA;AAAA;AAAA,EAEA;AAAA;AAAA,EAEA;AAAA;AAAA,EAGA,aAAa;AAAA;AAAA,EAEb;AAAA;AAAA;AAAA;AAAA;AAAA,EAMR,YAAY,QAAiC;AAC3C,SAAK,SAAS;AAEd,SAAK,OAAO,OAAO,YACf,UACA,OAAO,WACL,WACA;AAEN,SAAK,SAAS;AAGd,QAAI,KAAK,SAAS,UAAU;AAC1B,WAAK,QAAQ,aAAa,KAAK,MAAM,KAAK,IAAI,CAAC;AAAA,IACjD;AAGA,QAAI,KAAK,SAAS,UAAU;AAC1B,WAAK,QAAQ;AAAA,IACf;AAAA,EACF;AAAA;AAAA,EAGA,IAAW,SAAS;AAClB,WAAO,KAAK,OAAO;AAAA,EACrB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAc,UAAU;AACtB,QAAI,KAAK,SAAS;AAChB,mBAAa,KAAK,OAAO;AAAA,IAC3B;AACA,QAAI,KAAK,YAAY;AACnB;AAAA,IACF;AAEA,QAAI,KAAK,OAAO,UAAU;AACxB,YAAM,KAAK,YAAY;AAAA,IACzB,OAAO;AACL,WAAK,aAAa;AAAA,IACpB;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,MAAc,cAAc;AAC1B,UAAM,QAAQ,YAAY,IAAI;AAE9B,UAAM,EAAE,UAAU,eAAe,IAAI,KAAK;AAE1C,QAAI;AACF,YAAM,WAAW,MAAM,kBAAkB,SAAS,GAAG,cAAc;AACnE,YAAM,WAAW,YAAY,IAAI,IAAI;AAErC,WAAK,yBAAyB,UAAU,QAAQ;AAAA,IAClD,SAAS,KAAK;AACZ,WAAK,sBAAsB,GAAY;AAAA,IACzC;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAc,eAAe;AAC3B,UAAM,EAAE,WAAW,gBAAgB,eAAe,IAAI,KACnD;AAEH,UAAM,QAAQ,YAAY,IAAI;AAC9B,QAAI,aAAa;AACjB,QAAI;AACJ,QAAI;AAEJ,cAAU,CAAC,aAAa;AACtB,UAAI,CAAC,WAAY;AACjB,mBAAa;AACb,mBAAa,aAAa;AAC1B,mBAAa,cAAc;AAE3B,YAAM,WAAW,YAAY,IAAI,IAAI;AACrC,WAAK,yBAAyB,UAAU,QAAQ;AAAA,IAClD,CAAC;AAGD,oBAAgB,WAAW,MAAM;AAC/B,UAAI,WAAY,MAAK,SAAS;AAAA,IAChC,GAAG,cAAc;AAGjB,qBAAiB,WAAW,MAAM;AAChC,UAAI,CAAC,WAAY;AACjB,mBAAa;AACb,mBAAa,aAAa;AAC1B,WAAK,sBAAsB,IAAI,aAAa,CAAC;AAAA,IAC/C,GAAG,cAAc;AAAA,EACnB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOQ,yBACN,UACA,UACA;AACA,QAAI,oBAAoB,OAAO;AAC7B,aAAO,KAAK,sBAAsB,QAAQ;AAAA,IAC5C;AACA,QAAI,aAAa,SAAS;AACxB,aAAO,KAAK,sBAAsB,IAAI,aAAa,CAAC;AAAA,IACtD;AAEA,SAAK,QAAQ;AACb,SAAK,SACH,aAAa,QAAQ,YAAY,KAAK,OAAO,iBACzC,OACA;AAEN,UAAM,MAAM,oBAAI,KAAK;AACrB,SAAK,YAAY;AAAA,MACf,aAAa,IAAI,YAAY;AAAA,MAC7B,aAAa,IAAI,YAAY;AAAA,IAC/B;AAEA,SAAK,WAAW,EAAE,WAAW,SAAS;AAGtC,QAAI,KAAK,OAAO,YAAY,CAAC,KAAK,YAAY;AAC5C,YAAM,QAAQ,KAAK,OAAO;AAC1B,WAAK,UAAU,WAAW,MAAM,KAAK,QAAQ,GAAG,KAAK;AAAA,IACvD;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA,EAMQ,sBAAsB,OAAkC;AAC9D,SAAK,SAAS;AACd,SAAK,WAAW;AAChB,SAAK,QAAQ;AAAA,MACX,MAAM,MAAM,QAAQ;AAAA,MACpB,SAAS,MAAM;AAAA,IACjB;AAEA,UAAM,MAAM,oBAAI,KAAK;AACrB,QAAI,KAAK,WAAW;AAClB,WAAK,UAAU,cAAc,IAAI,YAAY;AAAA,IAC/C,OAAO;AACL,WAAK,YAAY,EAAE,aAAa,IAAI,YAAY,GAAG,aAAa,KAAK;AAAA,IACvE;AAGA,SAAK,KAAK,OAAO,aAAa,KAAK,OAAO,aAAa,CAAC,KAAK,YAAY;AACvE,YAAM,QAAQ,KAAK,OAAO,aAAa,KAAK,OAAO;AACnD,WAAK,UAAU,WAAW,MAAM,KAAK,QAAQ,GAAG,KAAK;AAAA,IACvD;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAa,QAAkC;AAC7C,QAAI,KAAK,YAAY;AACnB,YAAM,IAAI,MAAM,qCAAqC;AAAA,IACvD;AAEA,QAAI,KAAK,SAAS,UAAU;AAC1B,YAAM,KAAK,QAAQ;AAAA,IACrB;AAEA,UAAM,SAA0B;AAAA,MAC9B,QAAQ,KAAK;AAAA,MACb,QAAQ,KAAK,OAAO;AAAA,MACpB,MAAM,KAAK;AAAA,MACX,WAAW,KAAK;AAAA,MAChB,UAAU,KAAK;AAAA,MACf,OAAO,KAAK;AAAA,IACd;AAEA,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,CAAQ,OAAO,OAAO,IAAI;AACxB,SAAK,QAAQ;AAAA,EACf;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,UAAU;AACf,SAAK,aAAa;AAClB,QAAI,KAAK,SAAS;AAChB,mBAAa,KAAK,OAAO;AAAA,IAC3B;AAAA,EACF;AACF;;;AG9WA,SAAS,cAAc;;;ACAvB,OAAO,QAAQ;AAGR,IAAM,OAAO,OAAe,EAAE,QAAQ,KAAK;AAC3C,IAAM,WAAW,MAAgB;AACtC,QAAM,OAAO,GAAG,KAAK;AACrB,QAAM,QAAQ,GAAG,SAAS;AAC1B,QAAM,OAAO,GAAG,QAAQ;AAExB,SAAO;AAAA,IACL,QAAQ;AAAA,IACR,YAAW,oBAAI,KAAK,GAAE,YAAY;AAAA,IAClC,QAAQ;AAAA,MACN,UAAU,GAAG,SAAS;AAAA,MACtB,UAAU,GAAG,SAAS;AAAA,MACtB,SAAS,GAAG,QAAQ;AAAA,MACpB,MAAM,GAAG,KAAK;AAAA,MACd,QAAQ,GAAG,OAAO;AAAA,MAClB,SAAS,GAAG,QAAQ;AAAA,MACpB,UAAU;AAAA,MACV,SAAS;AAAA,MACT,cAAc,QAAQ,KAAK,QAAQ,QAAQ,QAAQ;AAAA,MACnD,MAAM;AAAA,QACJ,OAAO,KAAK;AAAA,QACZ,OAAO,KAAK,CAAC,GAAG;AAAA,QAChB,UAAU,KAAK,CAAC,GAAG;AAAA,MACrB;AAAA,IACF;AAAA,IACA,SAAS;AAAA,MACP,KAAK,QAAQ;AAAA,MACb,MAAM,QAAQ,SAAS;AAAA,MACvB,QAAQ,QAAQ,OAAO;AAAA,MACvB,QAAQ,QAAQ,YAAY;AAAA;AAAA,IAC9B;AAAA,EACF;AACF;;;ADiBO,IAAM,gBAAN,MAAoB;AAAA,EACR;AAAA,EACA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMjB,YAAY,QAA8B;AACxC,SAAK,UAAU,KAAK,aAAa;AACjC,SAAK,eAAe,oBAAI,IAAI;AAE5B,UAAM,MAAM,SAAS,OAAO,WAAW;AACvC,QAAI,MAAM,GAAG;AACX,WAAK,QAAQ,SAAS,KAAK,MAAM,KAAK,IAAI,GAAG,GAAG;AAAA,IAClD;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAkBO,cAAc,MAAc,YAA+B;AAChE,SAAK,aAAa,IAAI,MAAM,UAAU;AACtC,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKQ,eAAe;AACrB,UAAM,SAAS,OAAO;AAGtB,WAAO,IAAI,WAAW,OAAO,MAAM,KAAK,SAAS;AAC/C,UAAI;AACF,cAAM,SAAS,MAAM,KAAK,OAAO;AACjC,YAAI,OAAO,GAAG,EAAE,KAAK,MAAM;AAAA,MAC7B,SAAS,KAAK;AACZ,eAAO,GAAG;AAAA,MACZ;AAAA,IACF,CAAC;AAGD,WAAO,IAAI,gBAAgB,CAAC,MAAM,KAAK,SAAS;AAC9C,UAAI;AACF,YAAI,OAAO,GAAG,EAAE,KAAK,KAAK,KAAK,CAAC;AAAA,MAClC,SAAS,KAAK;AACZ,eAAO,GAAG;AAAA,MACZ;AAAA,IACF,CAAC;AAGD,WAAO,IAAI,gBAAgB,CAAC,MAAM,KAAK,SAAS;AAC9C,UAAI;AACF,YAAI,OAAO,GAAG,EAAE,KAAK,KAAK,KAAK,CAAC;AAAA,MAClC,SAAS,KAAK;AACZ,eAAO,GAAG;AAAA,MACZ;AAAA,IACF,CAAC;AAGD,WAAO,IAAI,iBAAiB,OAAO,MAAM,KAAK,SAAS;AACrD,UAAI;AACF,cAAM,YAAY,MAAM,KAAK,MAAM;AACnC,YAAI,OAAO,GAAG,EAAE,KAAK,SAAS;AAAA,MAChC,SAAS,KAAK;AACZ,eAAO,GAAG;AAAA,MACZ;AAAA,IACF,CAAC;AAGD,UAAM,eAAoC,CAAC,KAAK,MAAM,KAAK,UAAU;AACnE,YAAM,UAAU,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG;AAC/D,UAAI,OAAO,GAAG,EAAE,KAAK;AAAA,QACnB,QAAQ;AAAA,QACR,OAAO,EAAE,QAAQ;AAAA,MACnB,CAAC;AAAA,IACH;AACA,WAAO,IAAI,YAAY;AAEvB,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKO,OAAO;AACZ,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAKO,OAAO;AACZ,WAAO,SAAS;AAAA,EAClB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA+BA,MAAa,QAAmC;AAC9C,UAAM,UAAU,MAAM,KAAK,KAAK,aAAa,QAAQ,CAAC;AAEtD,UAAM,UAAU,MAAM,QAAQ;AAAA,MAC5B,QAAQ,IAAI,OAAO,CAAC,MAAM,OAAO,MAAM;AACrC,cAAM,QAAQ,MAAM,QAAQ,MAAM;AAClC,eAAO,CAAC,MAAM,KAAK;AAAA,MACrB,CAAC;AAAA,IACH;AAEA,UAAM,SAA0C,CAAC;AAEjD,aAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACvC,YAAM,IAAI,QAAQ,CAAC;AACnB,YAAM,CAAC,IAAI,IAAI,QAAQ,CAAC;AAExB,UAAI,EAAE,WAAW,aAAa;AAC5B,cAAM,CAAC,EAAE,KAAK,IAAI,EAAE;AACpB,eAAO,IAAI,IAAI;AAAA,MACjB,OAAO;AACL,eAAO,IAAI,IAAI;AAAA,UACb,QAAQ;AAAA,UACR,QAAQ,KAAK,aAAa,IAAI,IAAI,GAAG;AAAA,UACrC,MAAM;AAAA,UACN,WAAW;AAAA,YACT,cAAa,oBAAI,KAAK,GAAE,YAAY;AAAA,YACpC,aAAa;AAAA,UACf;AAAA,UACA,UAAU;AAAA,UACV,OAAO;AAAA,YACL,MAAM;AAAA,YACN,SAAS,OAAO,EAAE,UAAU,eAAe;AAAA,UAC7C;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAGA,QAAI,aAAa;AACjB,QAAI,kBAAkB;AAEtB,QAAI,YAAY;AAChB,QAAI,kBAAkB;AACtB,QAAI,iBAAiB;AAErB,UAAM,kBAA4B,CAAC;AAEnC,eAAW,CAAC,MAAM,CAAC,KAAK,OAAO,QAAQ,MAAM,GAAG;AAC9C,YAAM,aAAa,EAAE,WAAW;AAChC,UAAI,EAAE,WAAW,MAAM;AACrB,YAAI,WAAY;AAAA,YACX;AAAA,MACP,WAAW,EAAE,WAAW,YAAY;AAClC,YAAI;AACF;AAAA,YACG;AACL,wBAAgB,KAAK,GAAG,IAAI,WAAW;AAAA,MACzC,OAAO;AAEL,YAAI,WAAY;AAAA,YACX;AACL,wBAAgB,KAAK,GAAG,IAAI,IAAI,EAAE,OAAO,QAAQ,OAAO,EAAE;AAAA,MAC5D;AAAA,IACF;AAEA,UAAM,UAA4B;AAAA,MAChC,UAAU,EAAE,IAAI,YAAY,SAAS,gBAAgB;AAAA,MACrD,aAAa;AAAA,QACX,IAAI;AAAA,QACJ,UAAU;AAAA,QACV,SAAS;AAAA,MACX;AAAA,MACA;AAAA,IACF;AAGA,QAAI,SAAwC;AAC5C,UAAM,SAAS,OAAO,OAAO,MAAM;AACnC,UAAM,mBAAmB,OAAO;AAAA,MAC9B,CAAC,MAAM,EAAE,WAAW,cAAc,EAAE,WAAW;AAAA,IACjD;AACA,UAAM,qBAAqB,OAAO;AAAA,MAChC,CAAC,MAAM,EAAE,WAAW,cAAc,EAAE,WAAW;AAAA,IACjD;AACA,UAAM,sBAAsB,OAAO;AAAA,MACjC,CAAC,MAAM,EAAE,WAAW,cAAc,EAAE,WAAW;AAAA,IACjD;AAEA,QAAI,iBAAkB,UAAS;AAAA,aACtB,uBAAuB,mBAAoB,UAAS;AAG7D,UAAM,UAA4B;AAAA,MAChC;AAAA,MACA,YAAW,oBAAI,KAAK,GAAE,YAAY;AAAA;AAAA,MAElC;AAAA,MACA;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AAAA,EAEA,MAAa,SAAS;AACpB,UAAM,EAAE,QAAQ,QAAQ,QAAQ,IAAI,MAAM,KAAK,MAAM;AACrD,UAAM,EAAE,WAAW,QAAQ,SAAAA,SAAQ,IAAI,KAAK,KAAK;AAEjD,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA;AAAA,MACA,SAAAA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,IAAW,SAAS;AAClB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAKA,CAAQ,OAAO,OAAO,IAAI;AACxB,SAAK,QAAQ;AAAA,EACf;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,UAAU;AAEf,eAAW,cAAc,KAAK,aAAa,OAAO,GAAG;AACnD,iBAAW,QAAQ;AAAA,IACrB;AAAA,EACF;AACF;","names":["process"]}

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@sebspark/health-check",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "license": "Apache-2.0",
+  "type": "module",
   "main": "dist/index.js",
-  "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
   "files": [
     "dist"
   ],
   "scripts": {
-    "build": "tsup-node src/index.ts --format esm,cjs --target node22 --dts",
+    "build": "tsup src/index.ts --config ./tsup.config.ts",
     "dev": "tsc --watch --noEmit",
     "lint": "biome check .",
     "test": "vitest run --passWithNoTests --coverage",

package/dist/index.d.mts

@@ -1,378 +0,0 @@
-import { Router } from 'express';
-
-type DependencyStatusValue = 'ok' | 'degraded' | 'error';
-type StatusValue = DependencyStatusValue | 'unknown' | 'draining';
-type Impact = 'critical' | 'non_critical';
-type Mode = 'inline' | 'polled' | 'async';
-type Status = {
-    status: StatusValue;
-};
-type System = {
-    hostname: string;
-    platform: NodeJS.Platform;
-    release: string;
-    arch: string;
-    uptime: number;
-    loadavg: [number, number, number];
-    totalmem: number;
-    freemem: number;
-    memUsedRatio: number;
-    cpus: {
-        count: number;
-        model?: string;
-        speedMHz?: number;
-    };
-};
-type Process = {
-    pid: number;
-    node: string;
-    uptime: number;
-    memory: NodeJS.MemoryUsage;
-};
-type Liveness = Status & {
-    timestamp: string;
-    system: System;
-    process: Process;
-};
-type Freshness = {
-    lastChecked: string;
-    lastSuccess: string | null;
-};
-type Observed = {
-    latencyMs: number | null;
-    [k: string]: unknown;
-};
-type CheckError = {
-    code: string;
-    message: string;
-};
-type DependencyCheck = Status & {
-    impact: Impact;
-    mode: Mode;
-    freshness: Freshness;
-    observed?: Observed;
-    details?: Record<string, unknown>;
-    error?: CheckError | null;
-    since?: string | null;
-};
-type ReadinessSummary = {
-    critical: {
-        ok: number;
-        failing: number;
-    };
-    nonCritical: {
-        ok: number;
-        degraded: number;
-        failing: number;
-    };
-    degradedReasons: string[];
-};
-type ReadinessPayload = Status & {
-    timestamp: string;
-    service?: {
-        name?: string;
-        version?: string;
-        instanceId?: string;
-    };
-    summary: ReadinessSummary;
-    checks: Record<string, DependencyCheck>;
-};
-type HealthSummary = Status & Pick<ReadinessPayload, 'summary' | 'checks'> & Pick<Liveness, 'system' | 'process'> & {
-    timestamp: string;
-};
-declare class TimeoutError extends Error {
-    constructor();
-}
-declare class UnknownError extends Error {
-    constructor();
-}
-
-/**
- * Base configuration shared by all dependency monitor modes.
- */
-type BaseConfig = {
-    /**
-     * Importance of the dependency:
-     * - `'critical'` → service cannot run without it
-     * - `'non_critical'` → service is degraded but still functional if it fails
-     */
-    impact: Impact;
-    /**
-     * Polling interval in milliseconds.
-     * - Required for polled and async modes
-     * - Must not be set for inline mode
-     */
-    pollRate?: number;
-    /**
-     * Polling interval in milliseconds for failed calls.
-     * - Defaults to pollRate for polled and async modes
-     * - Must not be set for inline mode
-     */
-    retryRate?: number;
-    /**
-     * Maximum response time in milliseconds considered healthy.
-     * - A call resolving within this time window **and** returning `"ok"` → status `"ok"`
-     * - A call resolving after this but **before** `timeoutLimitMs` → status `"degraded"`
-     */
-    healthyLimitMs: number;
-    /**
-     * Absolute upper bound in milliseconds; beyond this a call is considered `"error"`.
-     * - Inline: the awaited call is raced with a timeout and rejected past this limit
-     * - Polled/Async: escalate `unknown` → `degraded` at `healthyLimitMs`, then `"error"` at `timeoutLimitMs`
-     * - Any late `"ok"` result after this limit is ignored
-     */
-    timeoutLimitMs: number;
-};
-/**
- * Inline mode configuration (no polling).
- * `syncCall` runs **only** when {@link DependencyMonitor.check} is invoked.
- */
-type SyncInlineConfig = BaseConfig & {
-    /** Performs the check immediately when {@link DependencyMonitor.check} is called. */
-    syncCall: () => Promise<DependencyStatusValue | Error>;
-    asyncCall?: never;
-    pollRate?: undefined;
-    retryRate?: undefined;
-};
-/**
- * Polled mode configuration.
- * `syncCall` runs on an interval (`pollRate`) and results are cached.
- */
-type SyncPolledConfig = BaseConfig & {
-    /** Performs the check at each poll interval. */
-    syncCall: () => Promise<DependencyStatusValue | Error>;
-    /** Polling interval in milliseconds. */
-    pollRate: number;
-    asyncCall?: never;
-};
-/**
- * Async mode configuration.
- * `asyncCall` starts a check and must report via the provided callback.
- */
-type AsyncConfig = BaseConfig & {
-    /**
-     * Starts an asynchronous check. Must call `reportResponse` once a result is available.
-     * The callback may be invoked with a `DependencyStatusValue` or an `Error`.
-     */
-    asyncCall: (reportResponse: (status: DependencyStatusValue | Error) => void | Promise<void>) => void | Promise<void>;
-    /** Polling interval in milliseconds. */
-    pollRate: number;
-    syncCall?: never;
-};
-/**
- * Discriminated configuration for a dependency monitor.
- * - {@link SyncInlineConfig} → inline checks on demand
- * - {@link SyncPolledConfig} → synchronous checks on a fixed interval
- * - {@link AsyncConfig} → asynchronous checks that report back via callback
- */
-type DependencyMonitorConfig = SyncInlineConfig | SyncPolledConfig | AsyncConfig;
-/**
- * Tracks the health of a single dependency in one of three modes:
- *
- * - **inline**: `syncCall` executed only when {@link check} is called
- * - **polled**: `syncCall` executed on `pollRate`; latest result cached
- * - **async**: `asyncCall` executed on `pollRate`, result returned via callback
- *
- * The monitor:
- * - classifies results using `healthyLimitMs` and `timeoutLimitMs`
- * - records freshness (`lastChecked`, `lastSuccess`)
- * - records observed latency (ms) when applicable
- *
- * Status interpretation:
- * - `"ok"` only if returned `"ok"` **and** latency ≤ `healthyLimitMs`
- * - `"degraded"` if returned `"degraded"` **or** latency > `healthyLimitMs` but ≤ `timeoutLimitMs`
- * - `"error"` if returned `"error"`, an `Error`, or exceeded `timeoutLimitMs`
- * - `"unknown"` is the initial state before first successful/failed result (polled/async)
- */
-declare class DependencyMonitor {
-    /** Immutable configuration for this monitor. */
-    private readonly config;
-    /** Operational mode determined from the configuration. */
-    private readonly mode;
-    /** Last computed status (starts as `"unknown"` until first result). */
-    private status;
-    /** Optional error details from the last failure. */
-    private error?;
-    /** Last observed metrics (e.g., latency). */
-    private observed?;
-    /** Freshness timestamps for last check/success. */
-    private freshness?;
-    /** Indicates whether this monitor has been disposed. */
-    private isDisposed;
-    /** Internal timer handle for polling/retry. */
-    private timeout?;
-    /**
-     * Create a new {@link DependencyMonitor}.
-     * @param config Monitor configuration (inline, polled, or async).
-     */
-    constructor(config: DependencyMonitorConfig);
-    /** Impact of this dependency (critical/non_critical). */
-    get impact(): Impact;
-    /**
-     * Run one check cycle depending on the configured mode.
-     * - Inline: no-op here (runs in {@link check})
-     * - Polled/Async: invoked automatically and re-scheduled as needed
-     */
-    private doCheck;
-    /**
-     * Execute a synchronous (inline/polled) check and update internal state.
-     * Classification:
-     * - OK if `"ok"` and latency ≤ `healthyLimitMs`
-     * - Degraded if `"degraded"` or latency between `(healthyLimitMs, timeoutLimitMs]`
-     * - Error if `"error"`, `Error`, or timeout exceeded
-     */
-    private doSyncCheck;
-    /**
-     * Execute an asynchronous check (async mode).
-     * - Initializes timers to escalate `unknown` → `degraded` → `error`
-     *   if no callback result arrives within the thresholds.
-     * - On callback, clears timers and classifies the result with latency.
-     */
-    private doAsyncCheck;
-    /**
-     * Normalize a successful dependency response into status + metadata.
-     * @param response Returned status value or Error from the dependency
-     * @param duration Measured latency in milliseconds
-     */
-    private handleDependencyResponse;
-    /**
-     * Normalize a failed dependency result into `"error"` and update metadata.
-     * @param error Error thrown/returned or synthesized (e.g., timeout)
-     */
-    private handleDependencyError;
-    /**
-     * Get a snapshot of the dependency’s current health.
-     * - Inline mode: executes the `syncCall` (single-flight guarded)
-     * - Polled/Async: returns the cached result
-     * @throws if the monitor has been disposed
-     */
-    check(): Promise<DependencyCheck>;
-    /** Symbol-based disposer for use with `using`. */
-    [Symbol.dispose](): void;
-    /**
-     * Dispose the monitor:
-     * - Clears any scheduled timers
-     * - Prevents further checks from running
-     */
-    dispose(): void;
-}
-
-interface HealthMonitorConfig {
-    throttle: number;
-}
-/**
- * HealthMonitor wires up standard health check endpoints for an Express app.
- *
- * It provides three endpoints under `/health`:
- * - /ping → lightweight always-OK response (`{ status: "ok" }`)
- * - /live → liveness probe (`{ status, uptime, timestamp }`)
- * - /ready → readiness probe with dependency checks (`{ status, checks }`)
- *
- * Dependencies can be added via {@link addDependency} with a {@link DependencyMonitorConfig}.
- * Each dependency is wrapped in a {@link DependencyMonitor} and tracked for readiness.
- *
- * ### Example
- *
- * ```ts
- * import express from 'express'
- * import { HealthMonitor } from './health-monitor'
- *
- * const app = express()
- * const monitor = new HealthMonitor()
- *
- * monitor.addDependency('db', {
- *   impact: 'critical',
- *   syncCall: async () => {
- *     await db.ping()
- *     return 'ok'
- *   }
- * })
- *
- * app.use(monitor.router)
- * app.listen(3000)
- * ```
- */
-declare class HealthMonitor {
-    private readonly _router;
-    private readonly dependencies;
-    /**
-     * Create a new HealthMonitor instance with its own router and dependency map.
-     */
-    constructor(config?: HealthMonitorConfig);
-    /**
-     * Register a named dependency to be checked as part of readiness.
-     *
-     * @param name - Identifier for the dependency (e.g. "postgres", "redis").
-     * @param dependency - DependencyMonitor
-     * @returns this for chaining
-     *
-     * @example
-     * ```ts
-     * monitor.addDependency('redis', new DependencyMonitor({
-     *   impact: 'critical',
-     *   pollRate: 5000,
-     *   syncCall: async () => redis.ping() ? 'ok' : 'error'
-     * }))
-     * ```
-     */
-    addDependency(name: string, dependency: DependencyMonitor): this;
-    /**
-     * Internal: create the Express router with /health routes.
-     */
-    private createRouter;
-    /**
-     * Static ping check — always returns `{ status: "ok" }`.
-     */
-    ping(): Status;
-    /**
-     * Liveness probe: reports uptime and current timestamp.
-     */
-    live(): Liveness;
-    /**
-     * Readiness probe: runs all registered dependencies in parallel
-     * and aggregates their results into an overall status.
-     *
-     * - Any **critical error** → `"error"`
-     * - Else any **critical degraded** or any non-critical degraded/error → `"degraded"`
-     * - Else → `"ok"`
-     *
-     * @returns Object with overall `status` and per-dependency `checks`
-     *
-     * @example
-     * ```json
-     * {
-     *   "status": "ok",
-     *   "checks": {
-     *     "postgres": {
-     *       "status": "ok",
-     *       "impact": "critical",
-     *       "mode": "inline",
-     *       "freshness": {
-     *         "lastChecked": "2025-08-19T12:00:00Z",
-     *         "lastSuccess": "2025-08-19T12:00:00Z"
-     *       },
-     *       "observed": { "latencyMs": 12 }
-     *     }
-     *   }
-     * }
-     * ```
-     */
-    ready(): Promise<ReadinessPayload>;
-    health(): Promise<HealthSummary>;
-    /**
-     * Accessor for the Express router that exposes /health endpoints.
-     */
-    get router(): Router;
-    /**
-     * Symbol-based disposer for use with `using`.
-     */
-    [Symbol.dispose](): void;
-    /**
-     * Dispose of the monitor:
-     * - marks as disposed
-     * - (future: could also stop all dependency monitors)
-     */
-    dispose(): void;
-}
-
-export { type AsyncConfig, type CheckError, type DependencyCheck, DependencyMonitor, type DependencyMonitorConfig, type DependencyStatusValue, type Freshness, HealthMonitor, type HealthMonitorConfig, type HealthSummary, type Impact, type Liveness, type Mode, type Observed, type Process, type ReadinessPayload, type ReadinessSummary, type Status, type StatusValue, type SyncInlineConfig, type SyncPolledConfig, type System, TimeoutError, UnknownError };

package/dist/index.mjs

@@ -1,533 +0,0 @@
-// src/dependency-monitor.ts
-import { performance } from "perf_hooks";
-
-// src/types.ts
-var TimeoutError = class extends Error {
-  constructor() {
-    super("timeout");
-    this.name = "TimeoutError";
-  }
-};
-var UnknownError = class extends Error {
-  constructor() {
-    super("unknown");
-    this.name = "UnknownError";
-  }
-};
-
-// src/timing.ts
-var wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-var runTimeoutTimer = async (ms) => {
-  await wait(ms);
-  throw new TimeoutError();
-};
-var runAgainstTimeout = (promise, ms) => {
-  if (ms > 0) {
-    return Promise.race([promise, runTimeoutTimer(ms)]);
-  }
-  return promise;
-};
-var throttle = (fn, ms) => {
-  let current = null;
-  let clearHandle = null;
-  const wrapped = (...args) => {
-    if (!current) {
-      current = fn(...args);
-      if (clearHandle) {
-        clearTimeout(clearHandle);
-        clearHandle = null;
-      }
-      current.finally(() => {
-        if (ms > 0) {
-          clearHandle = setTimeout(() => {
-            current = null;
-            clearHandle = null;
-          }, ms);
-        } else {
-          current = null;
-        }
-      });
-    }
-    return current;
-  };
-  return wrapped;
-};
-var singleFlight = (fn) => throttle(fn, 0);
-
-// src/dependency-monitor.ts
-var DependencyMonitor = class {
-  /** Immutable configuration for this monitor. */
-  config;
-  /** Operational mode determined from the configuration. */
-  mode;
-  /** Last computed status (starts as `"unknown"` until first result). */
-  status;
-  /** Optional error details from the last failure. */
-  error;
-  /** Last observed metrics (e.g., latency). */
-  observed;
-  /** Freshness timestamps for last check/success. */
-  freshness;
-  /** Indicates whether this monitor has been disposed. */
-  isDisposed = false;
-  /** Internal timer handle for polling/retry. */
-  timeout;
-  /**
-   * Create a new {@link DependencyMonitor}.
-   * @param config Monitor configuration (inline, polled, or async).
-   */
-  constructor(config) {
-    this.config = config;
-    this.mode = config.asyncCall ? "async" : config.pollRate ? "polled" : "inline";
-    this.status = "unknown";
-    if (this.mode === "inline") {
-      this.check = singleFlight(this.check.bind(this));
-    }
-    if (this.mode !== "inline") {
-      this.doCheck();
-    }
-  }
-  /** Impact of this dependency (critical/non_critical). */
-  get impact() {
-    return this.config.impact;
-  }
-  /**
-   * Run one check cycle depending on the configured mode.
-   * - Inline: no-op here (runs in {@link check})
-   * - Polled/Async: invoked automatically and re-scheduled as needed
-   */
-  async doCheck() {
-    if (this.timeout) {
-      clearTimeout(this.timeout);
-    }
-    if (this.isDisposed) {
-      return;
-    }
-    if (this.config.syncCall) {
-      await this.doSyncCheck();
-    } else {
-      this.doAsyncCheck();
-    }
-  }
-  /**
-   * Execute a synchronous (inline/polled) check and update internal state.
-   * Classification:
-   * - OK if `"ok"` and latency ≤ `healthyLimitMs`
-   * - Degraded if `"degraded"` or latency between `(healthyLimitMs, timeoutLimitMs]`
-   * - Error if `"error"`, `Error`, or timeout exceeded
-   */
-  async doSyncCheck() {
-    const start = performance.now();
-    const { syncCall, timeoutLimitMs } = this.config;
-    try {
-      const response = await runAgainstTimeout(syncCall(), timeoutLimitMs);
-      const duration = performance.now() - start;
-      this.handleDependencyResponse(response, duration);
-    } catch (err) {
-      this.handleDependencyError(err);
-    }
-  }
-  /**
-   * Execute an asynchronous check (async mode).
-   * - Initializes timers to escalate `unknown` → `degraded` → `error`
-   *   if no callback result arrives within the thresholds.
-   * - On callback, clears timers and classifies the result with latency.
-   */
-  async doAsyncCheck() {
-    const { asyncCall, healthyLimitMs, timeoutLimitMs } = this.config;
-    const start = performance.now();
-    let callActive = true;
-    let healthTimeout;
-    let serviceTimeout;
-    asyncCall((response) => {
-      if (!callActive) return;
-      callActive = false;
-      clearTimeout(healthTimeout);
-      clearTimeout(serviceTimeout);
-      const duration = performance.now() - start;
-      this.handleDependencyResponse(response, duration);
-    });
-    healthTimeout = setTimeout(() => {
-      if (callActive) this.status = "degraded";
-    }, healthyLimitMs);
-    serviceTimeout = setTimeout(() => {
-      if (!callActive) return;
-      callActive = false;
-      clearTimeout(healthTimeout);
-      this.handleDependencyError(new TimeoutError());
-    }, timeoutLimitMs);
-  }
-  /**
-   * Normalize a successful dependency response into status + metadata.
-   * @param response Returned status value or Error from the dependency
-   * @param duration Measured latency in milliseconds
-   */
-  handleDependencyResponse(response, duration) {
-    if (response instanceof Error) {
-      return this.handleDependencyError(response);
-    }
-    if (response === "error") {
-      return this.handleDependencyError(new UnknownError());
-    }
-    this.error = void 0;
-    this.status = response === "ok" && duration <= this.config.healthyLimitMs ? "ok" : "degraded";
-    const end = /* @__PURE__ */ new Date();
-    this.freshness = {
-      lastChecked: end.toISOString(),
-      lastSuccess: end.toISOString()
-    };
-    this.observed = { latencyMs: duration };
-    if (this.config.pollRate && !this.isDisposed) {
-      const delay = this.config.pollRate;
-      this.timeout = setTimeout(() => this.doCheck(), delay);
-    }
-  }
-  /**
-   * Normalize a failed dependency result into `"error"` and update metadata.
-   * @param error Error thrown/returned or synthesized (e.g., timeout)
-   */
-  handleDependencyError(error) {
-    this.status = "error";
-    this.observed = void 0;
-    this.error = {
-      code: error.code || "UNKNOWN",
-      message: error.message
-    };
-    const end = /* @__PURE__ */ new Date();
-    if (this.freshness) {
-      this.freshness.lastChecked = end.toISOString();
-    } else {
-      this.freshness = { lastChecked: end.toISOString(), lastSuccess: null };
-    }
-    if ((this.config.retryRate || this.config.pollRate) && !this.isDisposed) {
-      const delay = this.config.retryRate || this.config.pollRate;
-      this.timeout = setTimeout(() => this.doCheck(), delay);
-    }
-  }
-  /**
-   * Get a snapshot of the dependency’s current health.
-   * - Inline mode: executes the `syncCall` (single-flight guarded)
-   * - Polled/Async: returns the cached result
-   * @throws if the monitor has been disposed
-   */
-  async check() {
-    if (this.isDisposed) {
-      throw new Error("DependencyMonitor has been disposed");
-    }
-    if (this.mode === "inline") {
-      await this.doCheck();
-    }
-    const result = {
-      status: this.status,
-      impact: this.config.impact,
-      mode: this.mode,
-      freshness: this.freshness,
-      observed: this.observed,
-      error: this.error
-    };
-    return result;
-  }
-  /** Symbol-based disposer for use with `using`. */
-  [Symbol.dispose]() {
-    this.dispose();
-  }
-  /**
-   * Dispose the monitor:
-   * - Clears any scheduled timers
-   * - Prevents further checks from running
-   */
-  dispose() {
-    this.isDisposed = true;
-    if (this.timeout) {
-      clearTimeout(this.timeout);
-    }
-  }
-};
-
-// src/health-monitor.ts
-import { Router } from "express";
-
-// src/static-checks.ts
-import os from "os";
-var ping = () => ({ status: "ok" });
-var liveness = () => {
-  const cpus = os.cpus();
-  const total = os.totalmem();
-  const free = os.freemem();
-  return {
-    status: "ok",
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    system: {
-      hostname: os.hostname(),
-      platform: os.platform(),
-      release: os.release(),
-      arch: os.arch(),
-      uptime: os.uptime(),
-      loadavg: os.loadavg(),
-      totalmem: total,
-      freemem: free,
-      memUsedRatio: total > 0 ? (total - free) / total : 0,
-      cpus: {
-        count: cpus.length,
-        model: cpus[0]?.model,
-        speedMHz: cpus[0]?.speed
-      }
-    },
-    process: {
-      pid: process.pid,
-      node: process.versions.node,
-      uptime: process.uptime(),
-      memory: process.memoryUsage()
-      // rss, heapTotal, heapUsed, external, arrayBuffers
-    }
-  };
-};
-
-// src/health-monitor.ts
-var HealthMonitor = class {
-  _router;
-  dependencies;
-  // private isDisposed = false
-  /**
-   * Create a new HealthMonitor instance with its own router and dependency map.
-   */
-  constructor(config) {
-    this._router = this.createRouter();
-    this.dependencies = /* @__PURE__ */ new Map();
-    const thr = config ? config.throttle : 10;
-    if (thr > 0) {
-      this.ready = throttle(this.ready.bind(this), thr);
-    }
-  }
-  /**
-   * Register a named dependency to be checked as part of readiness.
-   *
-   * @param name - Identifier for the dependency (e.g. "postgres", "redis").
-   * @param dependency - DependencyMonitor
-   * @returns this for chaining
-   *
-   * @example
-   * ```ts
-   * monitor.addDependency('redis', new DependencyMonitor({
-   *   impact: 'critical',
-   *   pollRate: 5000,
-   *   syncCall: async () => redis.ping() ? 'ok' : 'error'
-   * }))
-   * ```
-   */
-  addDependency(name, dependency) {
-    this.dependencies.set(name, dependency);
-    return this;
-  }
-  /**
-   * Internal: create the Express router with /health routes.
-   */
-  createRouter() {
-    const router = Router();
-    router.get("/health", async (_req, res, next) => {
-      try {
-        const health = await this.health();
-        res.status(200).json(health);
-      } catch (err) {
-        next?.(err);
-      }
-    });
-    router.get("/health/ping", (_req, res, next) => {
-      try {
-        res.status(200).json(this.ping());
-      } catch (err) {
-        next?.(err);
-      }
-    });
-    router.get("/health/live", (_req, res, next) => {
-      try {
-        res.status(200).json(this.live());
-      } catch (err) {
-        next?.(err);
-      }
-    });
-    router.get("/health/ready", async (_req, res, next) => {
-      try {
-        const readiness = await this.ready();
-        res.status(200).json(readiness);
-      } catch (err) {
-        next?.(err);
-      }
-    });
-    const errorHandler = (err, _req, res, _next) => {
-      const message = err instanceof Error ? err.message : String(err);
-      res.status(500).json({
-        status: "error",
-        error: { message }
-      });
-    };
-    router.use(errorHandler);
-    return router;
-  }
-  /**
-   * Static ping check — always returns `{ status: "ok" }`.
-   */
-  ping() {
-    return ping();
-  }
-  /**
-   * Liveness probe: reports uptime and current timestamp.
-   */
-  live() {
-    return liveness();
-  }
-  /**
-   * Readiness probe: runs all registered dependencies in parallel
-   * and aggregates their results into an overall status.
-   *
-   * - Any **critical error** → `"error"`
-   * - Else any **critical degraded** or any non-critical degraded/error → `"degraded"`
-   * - Else → `"ok"`
-   *
-   * @returns Object with overall `status` and per-dependency `checks`
-   *
-   * @example
-   * ```json
-   * {
-   *   "status": "ok",
-   *   "checks": {
-   *     "postgres": {
-   *       "status": "ok",
-   *       "impact": "critical",
-   *       "mode": "inline",
-   *       "freshness": {
-   *         "lastChecked": "2025-08-19T12:00:00Z",
-   *         "lastSuccess": "2025-08-19T12:00:00Z"
-   *       },
-   *       "observed": { "latencyMs": 12 }
-   *     }
-   *   }
-   * }
-   * ```
-   */
-  async ready() {
-    const entries = Array.from(this.dependencies.entries());
-    const settled = await Promise.allSettled(
-      entries.map(async ([name, monitor]) => {
-        const check = await monitor.check();
-        return [name, check];
-      })
-    );
-    const checks = {};
-    for (let i = 0; i < settled.length; i++) {
-      const s = settled[i];
-      const [name] = entries[i];
-      if (s.status === "fulfilled") {
-        const [, check] = s.value;
-        checks[name] = check;
-      } else {
-        checks[name] = {
-          status: "error",
-          impact: this.dependencies.get(name)?.impact,
-          mode: "polled",
-          freshness: {
-            lastChecked: (/* @__PURE__ */ new Date()).toISOString(),
-            lastSuccess: null
-          },
-          observed: void 0,
-          error: {
-            code: "CHECK_FAILED",
-            message: String(s.reason ?? "unknown error")
-          }
-        };
-      }
-    }
-    let criticalOk = 0;
-    let criticalFailing = 0;
-    let nonCritOk = 0;
-    let nonCritDegraded = 0;
-    let nonCritFailing = 0;
-    const degradedReasons = [];
-    for (const [name, c] of Object.entries(checks)) {
-      const isCritical = c.impact === "critical";
-      if (c.status === "ok") {
-        if (isCritical) criticalOk++;
-        else nonCritOk++;
-      } else if (c.status === "degraded") {
-        if (isCritical)
-          criticalFailing++;
-        else nonCritDegraded++;
-        degradedReasons.push(`${name}:degraded`);
-      } else {
-        if (isCritical) criticalFailing++;
-        else nonCritFailing++;
-        degradedReasons.push(`${name}:${c.error?.code ?? "error"}`);
-      }
-    }
-    const summary = {
-      critical: { ok: criticalOk, failing: criticalFailing },
-      nonCritical: {
-        ok: nonCritOk,
-        degraded: nonCritDegraded,
-        failing: nonCritFailing
-      },
-      degradedReasons
-    };
-    let status = "ok";
-    const values = Object.values(checks);
-    const anyCriticalError = values.some(
-      (c) => c.impact === "critical" && c.status === "error"
-    );
-    const anyDegradedOrError = values.some(
-      (c) => c.status === "degraded" || c.status === "error"
-    );
-    const anyCriticalDegraded = values.some(
-      (c) => c.impact === "critical" && c.status === "degraded"
-    );
-    if (anyCriticalError) status = "error";
-    else if (anyCriticalDegraded || anyDegradedOrError) status = "degraded";
-    const payload = {
-      status,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      // service: { name, version, instanceId } // (optional; if you add config later)
-      summary,
-      checks
-    };
-    return payload;
-  }
-  async health() {
-    const { status, checks, summary } = await this.ready();
-    const { timestamp, system, process: process2 } = this.live();
-    return {
-      status,
-      timestamp,
-      system,
-      process: process2,
-      checks,
-      summary
-    };
-  }
-  /**
-   * Accessor for the Express router that exposes /health endpoints.
-   */
-  get router() {
-    return this._router;
-  }
-  /**
-   * Symbol-based disposer for use with `using`.
-   */
-  [Symbol.dispose]() {
-    this.dispose();
-  }
-  /**
-   * Dispose of the monitor:
-   * - marks as disposed
-   * - (future: could also stop all dependency monitors)
-   */
-  dispose() {
-    for (const dependency of this.dependencies.values()) {
-      dependency.dispose();
-    }
-  }
-};
-export {
-  DependencyMonitor,
-  HealthMonitor,
-  TimeoutError,
-  UnknownError
-};