@firebreak/vitals 1.0.0

package/dist/checks/postgres.cjs

@@ -0,0 +1,89 @@
+"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/checks/postgres.ts
+var postgres_exports = {};
+__export(postgres_exports, {
+  pgClientCheck: () => pgClientCheck,
+  pgPoolCheck: () => pgPoolCheck
+});
+module.exports = __toCommonJS(postgres_exports);
+var import_node_perf_hooks = require("perf_hooks");
+
+// src/types.ts
+var Status = {
+  HEALTHY: 2,
+  DEGRADED: 1,
+  OUTAGE: 0
+};
+
+// src/checks/postgres.ts
+function pgClientCheck(connectionString, options) {
+  return async () => {
+    const start = import_node_perf_hooks.performance.now();
+    const { Client } = await import("pg");
+    const client = new Client({ connectionString, ...options });
+    try {
+      await client.connect();
+      await client.query("SELECT 1");
+      const latencyMs = Math.round(import_node_perf_hooks.performance.now() - start);
+      return { status: Status.HEALTHY, latencyMs, message: "" };
+    } catch (error) {
+      const latencyMs = Math.round(import_node_perf_hooks.performance.now() - start);
+      const message = error instanceof Error ? error.message : String(error);
+      return { status: Status.OUTAGE, latencyMs, message };
+    } finally {
+      client.end().catch(() => {
+      });
+    }
+  };
+}
+function pgPoolCheck(pool) {
+  return async () => {
+    const start = import_node_perf_hooks.performance.now();
+    let client;
+    try {
+      client = await pool.connect();
+      await client.query("SELECT 1");
+      const latencyMs = Math.round(import_node_perf_hooks.performance.now() - start);
+      return { status: Status.HEALTHY, latencyMs, message: "" };
+    } catch (error) {
+      const latencyMs = Math.round(import_node_perf_hooks.performance.now() - start);
+      const message = error instanceof Error ? error.message : String(error);
+      return { status: Status.OUTAGE, latencyMs, message };
+    } finally {
+      client?.release();
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pgClientCheck,
+  pgPoolCheck
+});

package/dist/checks/postgres.d.cts

@@ -0,0 +1,15 @@
+import { A as AsyncCheckFn } from '../core-9-MXAO0I.cjs';
+import { Pool } from 'pg';
+
+/**
+ * Creates a healthcheck function that opens a fresh pg Client connection,
+ * runs `SELECT 1`, and closes the connection.
+ */
+declare function pgClientCheck(connectionString: string, options?: Record<string, unknown>): AsyncCheckFn;
+/**
+ * Creates a healthcheck function that borrows a client from an existing pg Pool,
+ * runs `SELECT 1`, and releases the client back to the pool.
+ */
+declare function pgPoolCheck(pool: Pool): AsyncCheckFn;
+
+export { AsyncCheckFn, pgClientCheck, pgPoolCheck };

package/dist/checks/postgres.d.ts

@@ -0,0 +1,15 @@
+import { A as AsyncCheckFn } from '../core-9-MXAO0I.js';
+import { Pool } from 'pg';
+
+/**
+ * Creates a healthcheck function that opens a fresh pg Client connection,
+ * runs `SELECT 1`, and closes the connection.
+ */
+declare function pgClientCheck(connectionString: string, options?: Record<string, unknown>): AsyncCheckFn;
+/**
+ * Creates a healthcheck function that borrows a client from an existing pg Pool,
+ * runs `SELECT 1`, and releases the client back to the pool.
+ */
+declare function pgPoolCheck(pool: Pool): AsyncCheckFn;
+
+export { AsyncCheckFn, pgClientCheck, pgPoolCheck };

package/dist/checks/postgres.mjs

@@ -0,0 +1,53 @@
+// src/checks/postgres.ts
+import { performance } from "perf_hooks";
+
+// src/types.ts
+var Status = {
+  HEALTHY: 2,
+  DEGRADED: 1,
+  OUTAGE: 0
+};
+
+// src/checks/postgres.ts
+function pgClientCheck(connectionString, options) {
+  return async () => {
+    const start = performance.now();
+    const { Client } = await import("pg");
+    const client = new Client({ connectionString, ...options });
+    try {
+      await client.connect();
+      await client.query("SELECT 1");
+      const latencyMs = Math.round(performance.now() - start);
+      return { status: Status.HEALTHY, latencyMs, message: "" };
+    } catch (error) {
+      const latencyMs = Math.round(performance.now() - start);
+      const message = error instanceof Error ? error.message : String(error);
+      return { status: Status.OUTAGE, latencyMs, message };
+    } finally {
+      client.end().catch(() => {
+      });
+    }
+  };
+}
+function pgPoolCheck(pool) {
+  return async () => {
+    const start = performance.now();
+    let client;
+    try {
+      client = await pool.connect();
+      await client.query("SELECT 1");
+      const latencyMs = Math.round(performance.now() - start);
+      return { status: Status.HEALTHY, latencyMs, message: "" };
+    } catch (error) {
+      const latencyMs = Math.round(performance.now() - start);
+      const message = error instanceof Error ? error.message : String(error);
+      return { status: Status.OUTAGE, latencyMs, message };
+    } finally {
+      client?.release();
+    }
+  };
+}
+export {
+  pgClientCheck,
+  pgPoolCheck
+};

package/dist/checks/redis.cjs

@@ -0,0 +1,95 @@
+"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/checks/redis.ts
+var redis_exports = {};
+__export(redis_exports, {
+  ioredisCheck: () => ioredisCheck,
+  ioredisClientCheck: () => ioredisClientCheck
+});
+module.exports = __toCommonJS(redis_exports);
+var import_node_perf_hooks = require("perf_hooks");
+
+// src/types.ts
+var Status = {
+  HEALTHY: 2,
+  DEGRADED: 1,
+  OUTAGE: 0
+};
+
+// src/checks/redis.ts
+function ioredisCheck(url, options) {
+  return async () => {
+    const start = import_node_perf_hooks.performance.now();
+    const { default: RedisClient } = await import("ioredis");
+    const client = new RedisClient(url, {
+      lazyConnect: true,
+      retryStrategy: () => null,
+      enableOfflineQueue: false,
+      ...options
+    });
+    try {
+      await client.connect();
+      const result = await client.ping();
+      if (result !== "PONG") {
+        throw new Error(`PING returned ${result}`);
+      }
+      const latencyMs = Math.round(import_node_perf_hooks.performance.now() - start);
+      return { status: Status.HEALTHY, latencyMs, message: "" };
+    } catch (error) {
+      const latencyMs = Math.round(import_node_perf_hooks.performance.now() - start);
+      const message = error instanceof Error ? error.message : String(error);
+      return { status: Status.OUTAGE, latencyMs, message };
+    } finally {
+      client.disconnect();
+    }
+  };
+}
+function ioredisClientCheck(client) {
+  return async () => {
+    const start = import_node_perf_hooks.performance.now();
+    try {
+      const result = await client.ping();
+      if (result !== "PONG") {
+        throw new Error(`PING returned ${result}`);
+      }
+      const latencyMs = Math.round(import_node_perf_hooks.performance.now() - start);
+      return { status: Status.HEALTHY, latencyMs, message: "" };
+    } catch (error) {
+      const latencyMs = Math.round(import_node_perf_hooks.performance.now() - start);
+      const message = error instanceof Error ? error.message : String(error);
+      return { status: Status.OUTAGE, latencyMs, message };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ioredisCheck,
+  ioredisClientCheck
+});

package/dist/checks/redis.d.cts

@@ -0,0 +1,15 @@
+import { A as AsyncCheckFn } from '../core-9-MXAO0I.cjs';
+import Redis from 'ioredis';
+
+/**
+ * Creates a healthcheck function that opens a fresh ioredis connection,
+ * sends PING, validates the PONG response, and disconnects.
+ */
+declare function ioredisCheck(url: string, options?: Record<string, unknown>): AsyncCheckFn;
+/**
+ * Creates a healthcheck function that pings an existing (shared) ioredis client.
+ * Does NOT disconnect the client.
+ */
+declare function ioredisClientCheck(client: Redis): AsyncCheckFn;
+
+export { AsyncCheckFn, ioredisCheck, ioredisClientCheck };

package/dist/checks/redis.d.ts

@@ -0,0 +1,15 @@
+import { A as AsyncCheckFn } from '../core-9-MXAO0I.js';
+import Redis from 'ioredis';
+
+/**
+ * Creates a healthcheck function that opens a fresh ioredis connection,
+ * sends PING, validates the PONG response, and disconnects.
+ */
+declare function ioredisCheck(url: string, options?: Record<string, unknown>): AsyncCheckFn;
+/**
+ * Creates a healthcheck function that pings an existing (shared) ioredis client.
+ * Does NOT disconnect the client.
+ */
+declare function ioredisClientCheck(client: Redis): AsyncCheckFn;
+
+export { AsyncCheckFn, ioredisCheck, ioredisClientCheck };

package/dist/checks/redis.mjs

@@ -0,0 +1,59 @@
+// src/checks/redis.ts
+import { performance } from "perf_hooks";
+
+// src/types.ts
+var Status = {
+  HEALTHY: 2,
+  DEGRADED: 1,
+  OUTAGE: 0
+};
+
+// src/checks/redis.ts
+function ioredisCheck(url, options) {
+  return async () => {
+    const start = performance.now();
+    const { default: RedisClient } = await import("ioredis");
+    const client = new RedisClient(url, {
+      lazyConnect: true,
+      retryStrategy: () => null,
+      enableOfflineQueue: false,
+      ...options
+    });
+    try {
+      await client.connect();
+      const result = await client.ping();
+      if (result !== "PONG") {
+        throw new Error(`PING returned ${result}`);
+      }
+      const latencyMs = Math.round(performance.now() - start);
+      return { status: Status.HEALTHY, latencyMs, message: "" };
+    } catch (error) {
+      const latencyMs = Math.round(performance.now() - start);
+      const message = error instanceof Error ? error.message : String(error);
+      return { status: Status.OUTAGE, latencyMs, message };
+    } finally {
+      client.disconnect();
+    }
+  };
+}
+function ioredisClientCheck(client) {
+  return async () => {
+    const start = performance.now();
+    try {
+      const result = await client.ping();
+      if (result !== "PONG") {
+        throw new Error(`PING returned ${result}`);
+      }
+      const latencyMs = Math.round(performance.now() - start);
+      return { status: Status.HEALTHY, latencyMs, message: "" };
+    } catch (error) {
+      const latencyMs = Math.round(performance.now() - start);
+      const message = error instanceof Error ? error.message : String(error);
+      return { status: Status.OUTAGE, latencyMs, message };
+    }
+  };
+}
+export {
+  ioredisCheck,
+  ioredisClientCheck
+};

package/dist/core-9-MXAO0I.d.cts

@@ -0,0 +1,55 @@
+declare const Status: {
+    readonly HEALTHY: 2;
+    readonly DEGRADED: 1;
+    readonly OUTAGE: 0;
+};
+type StatusValue = (typeof Status)[keyof typeof Status];
+type StatusLabel = 'healthy' | 'degraded' | 'outage';
+declare function statusToLabel(status: StatusValue): StatusLabel;
+declare function statusFromString(value: string): StatusValue;
+interface CheckResult {
+    readonly status: StatusValue;
+    readonly latencyMs: number;
+    readonly message: string;
+}
+interface HealthcheckResponse {
+    readonly status: StatusValue;
+    readonly timestamp: string;
+    readonly checks: Readonly<Record<string, CheckResult>>;
+}
+interface HealthcheckResponseJson {
+    status: StatusLabel;
+    timestamp: string;
+    checks: Record<string, {
+        status: StatusLabel;
+        latencyMs: number;
+        message: string;
+    }>;
+}
+declare function toJson(response: HealthcheckResponse): HealthcheckResponseJson;
+declare function httpStatusCode(status: StatusValue): 200 | 503;
+
+type AsyncCheckFn = () => Promise<CheckResult>;
+type SyncCheckFn = () => CheckResult;
+interface RegistryOptions {
+    defaultTimeout?: number;
+}
+declare class HealthcheckRegistry {
+    private readonly checks;
+    private readonly defaultTimeout;
+    constructor(options?: RegistryOptions);
+    add(name: string, fn: AsyncCheckFn, options?: {
+        timeout?: number;
+    }): void;
+    check(name: string, fn: AsyncCheckFn, options?: {
+        timeout?: number;
+    }): AsyncCheckFn;
+    check(name: string, options?: {
+        timeout?: number;
+    }): (fn: AsyncCheckFn) => AsyncCheckFn;
+    run(): Promise<HealthcheckResponse>;
+    private runSingle;
+}
+declare function syncCheck(fn: SyncCheckFn): AsyncCheckFn;
+
+export { type AsyncCheckFn as A, type CheckResult as C, HealthcheckRegistry as H, Status as S, type HealthcheckResponse as a, type HealthcheckResponseJson as b, type StatusLabel as c, type StatusValue as d, type SyncCheckFn as e, statusToLabel as f, syncCheck as g, httpStatusCode as h, statusFromString as s, toJson as t };

package/dist/core-9-MXAO0I.d.ts

@@ -0,0 +1,55 @@
+declare const Status: {
+    readonly HEALTHY: 2;
+    readonly DEGRADED: 1;
+    readonly OUTAGE: 0;
+};
+type StatusValue = (typeof Status)[keyof typeof Status];
+type StatusLabel = 'healthy' | 'degraded' | 'outage';
+declare function statusToLabel(status: StatusValue): StatusLabel;
+declare function statusFromString(value: string): StatusValue;
+interface CheckResult {
+    readonly status: StatusValue;
+    readonly latencyMs: number;
+    readonly message: string;
+}
+interface HealthcheckResponse {
+    readonly status: StatusValue;
+    readonly timestamp: string;
+    readonly checks: Readonly<Record<string, CheckResult>>;
+}
+interface HealthcheckResponseJson {
+    status: StatusLabel;
+    timestamp: string;
+    checks: Record<string, {
+        status: StatusLabel;
+        latencyMs: number;
+        message: string;
+    }>;
+}
+declare function toJson(response: HealthcheckResponse): HealthcheckResponseJson;
+declare function httpStatusCode(status: StatusValue): 200 | 503;
+
+type AsyncCheckFn = () => Promise<CheckResult>;
+type SyncCheckFn = () => CheckResult;
+interface RegistryOptions {
+    defaultTimeout?: number;
+}
+declare class HealthcheckRegistry {
+    private readonly checks;
+    private readonly defaultTimeout;
+    constructor(options?: RegistryOptions);
+    add(name: string, fn: AsyncCheckFn, options?: {
+        timeout?: number;
+    }): void;
+    check(name: string, fn: AsyncCheckFn, options?: {
+        timeout?: number;
+    }): AsyncCheckFn;
+    check(name: string, options?: {
+        timeout?: number;
+    }): (fn: AsyncCheckFn) => AsyncCheckFn;
+    run(): Promise<HealthcheckResponse>;
+    private runSingle;
+}
+declare function syncCheck(fn: SyncCheckFn): AsyncCheckFn;
+
+export { type AsyncCheckFn as A, type CheckResult as C, HealthcheckRegistry as H, Status as S, type HealthcheckResponse as a, type HealthcheckResponseJson as b, type StatusLabel as c, type StatusValue as d, type SyncCheckFn as e, statusToLabel as f, syncCheck as g, httpStatusCode as h, statusFromString as s, toJson as t };

package/dist/index.cjs

@@ -0,0 +1,200 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  HealthcheckRegistry: () => HealthcheckRegistry,
+  Status: () => Status,
+  extractToken: () => extractToken,
+  httpStatusCode: () => httpStatusCode,
+  statusFromString: () => statusFromString,
+  statusToLabel: () => statusToLabel,
+  syncCheck: () => syncCheck,
+  toJson: () => toJson,
+  verifyToken: () => verifyToken
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/types.ts
+var Status = {
+  HEALTHY: 2,
+  DEGRADED: 1,
+  OUTAGE: 0
+};
+function statusToLabel(status) {
+  const labels = {
+    [Status.HEALTHY]: "healthy",
+    [Status.DEGRADED]: "degraded",
+    [Status.OUTAGE]: "outage"
+  };
+  return labels[status];
+}
+function statusFromString(value) {
+  const mapping = {
+    healthy: Status.HEALTHY,
+    ok: Status.HEALTHY,
+    degraded: Status.DEGRADED,
+    outage: Status.OUTAGE,
+    error: Status.OUTAGE
+  };
+  return mapping[value.toLowerCase()] ?? Status.OUTAGE;
+}
+function toJson(response) {
+  return {
+    status: statusToLabel(response.status),
+    timestamp: response.timestamp,
+    checks: Object.fromEntries(
+      Object.entries(response.checks).map(([name, result]) => [
+        name,
+        { status: statusToLabel(result.status), latencyMs: result.latencyMs, message: result.message }
+      ])
+    )
+  };
+}
+function httpStatusCode(status) {
+  return status === Status.HEALTHY ? 200 : 503;
+}
+
+// src/core.ts
+var import_node_perf_hooks = require("perf_hooks");
+var HealthcheckRegistry = class {
+  checks = [];
+  defaultTimeout;
+  constructor(options) {
+    this.defaultTimeout = options?.defaultTimeout ?? 5e3;
+  }
+  add(name, fn, options) {
+    if (this.checks.some((c) => c.name === name)) {
+      throw new Error(`Check "${name}" is already registered`);
+    }
+    this.checks.push({
+      name,
+      fn,
+      timeout: options?.timeout ?? this.defaultTimeout
+    });
+  }
+  check(name, fnOrOptions, options) {
+    if (typeof fnOrOptions === "function") {
+      const fn = fnOrOptions;
+      this.add(name, fn, options);
+      return fn;
+    }
+    const opts = fnOrOptions;
+    return (fn) => {
+      this.add(name, fn, opts);
+      return fn;
+    };
+  }
+  async run() {
+    if (this.checks.length === 0) {
+      return {
+        status: Status.HEALTHY,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        checks: {}
+      };
+    }
+    const results = await Promise.allSettled(
+      this.checks.map((entry) => this.runSingle(entry.name, entry.fn, entry.timeout))
+    );
+    const checksRecord = {};
+    const statuses = [];
+    for (let i = 0; i < this.checks.length; i++) {
+      const result = results[i];
+      const name = this.checks[i].name;
+      if (result.status === "fulfilled") {
+        checksRecord[name] = result.value;
+        statuses.push(result.value.status);
+      } else {
+        checksRecord[name] = {
+          status: Status.OUTAGE,
+          latencyMs: 0,
+          message: String(result.reason)
+        };
+        statuses.push(Status.OUTAGE);
+      }
+    }
+    const overallStatus = Math.min(...statuses);
+    return {
+      status: overallStatus,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      checks: checksRecord
+    };
+  }
+  async runSingle(name, fn, timeoutMs) {
+    const start = import_node_perf_hooks.performance.now();
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const result = await Promise.race([
+        fn(),
+        new Promise((_, reject) => {
+          controller.signal.addEventListener("abort", () => {
+            reject(new Error(`Check "${name}" timed out after ${timeoutMs}ms`));
+          });
+        })
+      ]);
+      const latencyMs = Math.round(import_node_perf_hooks.performance.now() - start);
+      return { status: result.status, latencyMs, message: result.message };
+    } catch (error) {
+      const latencyMs = Math.round(import_node_perf_hooks.performance.now() - start);
+      const message = error instanceof Error ? error.message : String(error);
+      return { status: Status.OUTAGE, latencyMs, message };
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+};
+function syncCheck(fn) {
+  return async () => fn();
+}
+
+// src/auth.ts
+var import_node_crypto = require("crypto");
+function verifyToken(provided, expected) {
+  if (!provided || !expected) return false;
+  const providedHash = (0, import_node_crypto.createHash)("sha256").update(provided).digest();
+  const expectedHash = (0, import_node_crypto.createHash)("sha256").update(expected).digest();
+  return (0, import_node_crypto.timingSafeEqual)(providedHash, expectedHash);
+}
+function extractToken(options) {
+  const { queryParams, authorizationHeader, queryParamName = "token" } = options;
+  if (queryParams) {
+    const value = queryParams[queryParamName];
+    const str = Array.isArray(value) ? value[0] : value;
+    if (str) return str;
+  }
+  if (authorizationHeader?.startsWith("Bearer ")) {
+    const token = authorizationHeader.slice("Bearer ".length);
+    if (token) return token;
+  }
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HealthcheckRegistry,
+  Status,
+  extractToken,
+  httpStatusCode,
+  statusFromString,
+  statusToLabel,
+  syncCheck,
+  toJson,
+  verifyToken
+});

package/dist/index.d.cts

@@ -0,0 +1,10 @@
+export { A as AsyncCheckFn, C as CheckResult, H as HealthcheckRegistry, a as HealthcheckResponse, b as HealthcheckResponseJson, S as Status, c as StatusLabel, d as StatusValue, e as SyncCheckFn, h as httpStatusCode, s as statusFromString, f as statusToLabel, g as syncCheck, t as toJson } from './core-9-MXAO0I.cjs';
+
+declare function verifyToken(provided: string, expected: string): boolean;
+declare function extractToken(options: {
+    queryParams?: Record<string, string | string[] | undefined>;
+    authorizationHeader?: string | null;
+    queryParamName?: string;
+}): string | null;
+
+export { extractToken, verifyToken };

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { A as AsyncCheckFn, C as CheckResult, H as HealthcheckRegistry, a as HealthcheckResponse, b as HealthcheckResponseJson, S as Status, c as StatusLabel, d as StatusValue, e as SyncCheckFn, h as httpStatusCode, s as statusFromString, f as statusToLabel, g as syncCheck, t as toJson } from './core-9-MXAO0I.js';
+
+declare function verifyToken(provided: string, expected: string): boolean;
+declare function extractToken(options: {
+    queryParams?: Record<string, string | string[] | undefined>;
+    authorizationHeader?: string | null;
+    queryParamName?: string;
+}): string | null;
+
+export { extractToken, verifyToken };

package/dist/index.mjs

@@ -0,0 +1,165 @@
+// src/types.ts
+var Status = {
+  HEALTHY: 2,
+  DEGRADED: 1,
+  OUTAGE: 0
+};
+function statusToLabel(status) {
+  const labels = {
+    [Status.HEALTHY]: "healthy",
+    [Status.DEGRADED]: "degraded",
+    [Status.OUTAGE]: "outage"
+  };
+  return labels[status];
+}
+function statusFromString(value) {
+  const mapping = {
+    healthy: Status.HEALTHY,
+    ok: Status.HEALTHY,
+    degraded: Status.DEGRADED,
+    outage: Status.OUTAGE,
+    error: Status.OUTAGE
+  };
+  return mapping[value.toLowerCase()] ?? Status.OUTAGE;
+}
+function toJson(response) {
+  return {
+    status: statusToLabel(response.status),
+    timestamp: response.timestamp,
+    checks: Object.fromEntries(
+      Object.entries(response.checks).map(([name, result]) => [
+        name,
+        { status: statusToLabel(result.status), latencyMs: result.latencyMs, message: result.message }
+      ])
+    )
+  };
+}
+function httpStatusCode(status) {
+  return status === Status.HEALTHY ? 200 : 503;
+}
+
+// src/core.ts
+import { performance } from "perf_hooks";
+var HealthcheckRegistry = class {
+  checks = [];
+  defaultTimeout;
+  constructor(options) {
+    this.defaultTimeout = options?.defaultTimeout ?? 5e3;
+  }
+  add(name, fn, options) {
+    if (this.checks.some((c) => c.name === name)) {
+      throw new Error(`Check "${name}" is already registered`);
+    }
+    this.checks.push({
+      name,
+      fn,
+      timeout: options?.timeout ?? this.defaultTimeout
+    });
+  }
+  check(name, fnOrOptions, options) {
+    if (typeof fnOrOptions === "function") {
+      const fn = fnOrOptions;
+      this.add(name, fn, options);
+      return fn;
+    }
+    const opts = fnOrOptions;
+    return (fn) => {
+      this.add(name, fn, opts);
+      return fn;
+    };
+  }
+  async run() {
+    if (this.checks.length === 0) {
+      return {
+        status: Status.HEALTHY,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        checks: {}
+      };
+    }
+    const results = await Promise.allSettled(
+      this.checks.map((entry) => this.runSingle(entry.name, entry.fn, entry.timeout))
+    );
+    const checksRecord = {};
+    const statuses = [];
+    for (let i = 0; i < this.checks.length; i++) {
+      const result = results[i];
+      const name = this.checks[i].name;
+      if (result.status === "fulfilled") {
+        checksRecord[name] = result.value;
+        statuses.push(result.value.status);
+      } else {
+        checksRecord[name] = {
+          status: Status.OUTAGE,
+          latencyMs: 0,
+          message: String(result.reason)
+        };
+        statuses.push(Status.OUTAGE);
+      }
+    }
+    const overallStatus = Math.min(...statuses);
+    return {
+      status: overallStatus,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      checks: checksRecord
+    };
+  }
+  async runSingle(name, fn, timeoutMs) {
+    const start = performance.now();
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const result = await Promise.race([
+        fn(),
+        new Promise((_, reject) => {
+          controller.signal.addEventListener("abort", () => {
+            reject(new Error(`Check "${name}" timed out after ${timeoutMs}ms`));
+          });
+        })
+      ]);
+      const latencyMs = Math.round(performance.now() - start);
+      return { status: result.status, latencyMs, message: result.message };
+    } catch (error) {
+      const latencyMs = Math.round(performance.now() - start);
+      const message = error instanceof Error ? error.message : String(error);
+      return { status: Status.OUTAGE, latencyMs, message };
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+};
+function syncCheck(fn) {
+  return async () => fn();
+}
+
+// src/auth.ts
+import { createHash, timingSafeEqual } from "crypto";
+function verifyToken(provided, expected) {
+  if (!provided || !expected) return false;
+  const providedHash = createHash("sha256").update(provided).digest();
+  const expectedHash = createHash("sha256").update(expected).digest();
+  return timingSafeEqual(providedHash, expectedHash);
+}
+function extractToken(options) {
+  const { queryParams, authorizationHeader, queryParamName = "token" } = options;
+  if (queryParams) {
+    const value = queryParams[queryParamName];
+    const str = Array.isArray(value) ? value[0] : value;
+    if (str) return str;
+  }
+  if (authorizationHeader?.startsWith("Bearer ")) {
+    const token = authorizationHeader.slice("Bearer ".length);
+    if (token) return token;
+  }
+  return null;
+}
+export {
+  HealthcheckRegistry,
+  Status,
+  extractToken,
+  httpStatusCode,
+  statusFromString,
+  statusToLabel,
+  syncCheck,
+  toJson,
+  verifyToken
+};

package/dist/integrations/express.cjs

@@ -0,0 +1,105 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/integrations/express.ts
+var express_exports = {};
+__export(express_exports, {
+  createHealthcheckMiddleware: () => createHealthcheckMiddleware
+});
+module.exports = __toCommonJS(express_exports);
+
+// src/auth.ts
+var import_node_crypto = require("crypto");
+function verifyToken(provided, expected) {
+  if (!provided || !expected) return false;
+  const providedHash = (0, import_node_crypto.createHash)("sha256").update(provided).digest();
+  const expectedHash = (0, import_node_crypto.createHash)("sha256").update(expected).digest();
+  return (0, import_node_crypto.timingSafeEqual)(providedHash, expectedHash);
+}
+function extractToken(options) {
+  const { queryParams, authorizationHeader, queryParamName = "token" } = options;
+  if (queryParams) {
+    const value = queryParams[queryParamName];
+    const str = Array.isArray(value) ? value[0] : value;
+    if (str) return str;
+  }
+  if (authorizationHeader?.startsWith("Bearer ")) {
+    const token = authorizationHeader.slice("Bearer ".length);
+    if (token) return token;
+  }
+  return null;
+}
+
+// src/types.ts
+var Status = {
+  HEALTHY: 2,
+  DEGRADED: 1,
+  OUTAGE: 0
+};
+function statusToLabel(status) {
+  const labels = {
+    [Status.HEALTHY]: "healthy",
+    [Status.DEGRADED]: "degraded",
+    [Status.OUTAGE]: "outage"
+  };
+  return labels[status];
+}
+function toJson(response) {
+  return {
+    status: statusToLabel(response.status),
+    timestamp: response.timestamp,
+    checks: Object.fromEntries(
+      Object.entries(response.checks).map(([name, result]) => [
+        name,
+        { status: statusToLabel(result.status), latencyMs: result.latencyMs, message: result.message }
+      ])
+    )
+  };
+}
+function httpStatusCode(status) {
+  return status === Status.HEALTHY ? 200 : 503;
+}
+
+// src/integrations/express.ts
+function createHealthcheckMiddleware(options) {
+  const { registry, token = null, queryParamName = "token" } = options;
+  return async (req, res) => {
+    try {
+      if (token !== null) {
+        const provided = extractToken({
+          queryParams: req.query,
+          authorizationHeader: req.headers.authorization ?? null,
+          queryParamName
+        });
+        if (provided === null || !verifyToken(provided, token)) {
+          res.status(403).json({ error: "Forbidden" });
+          return;
+        }
+      }
+      const response = await registry.run();
+      res.status(httpStatusCode(response.status)).json(toJson(response));
+    } catch {
+      res.status(500).json({ error: "Internal Server Error" });
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createHealthcheckMiddleware
+});

package/dist/integrations/express.d.cts

@@ -0,0 +1,11 @@
+import { RequestHandler } from 'express';
+import { H as HealthcheckRegistry } from '../core-9-MXAO0I.cjs';
+
+interface HealthcheckMiddlewareOptions {
+    registry: HealthcheckRegistry;
+    token?: string | null;
+    queryParamName?: string;
+}
+declare function createHealthcheckMiddleware(options: HealthcheckMiddlewareOptions): RequestHandler;
+
+export { type HealthcheckMiddlewareOptions, createHealthcheckMiddleware };

package/dist/integrations/express.d.ts

@@ -0,0 +1,11 @@
+import { RequestHandler } from 'express';
+import { H as HealthcheckRegistry } from '../core-9-MXAO0I.js';
+
+interface HealthcheckMiddlewareOptions {
+    registry: HealthcheckRegistry;
+    token?: string | null;
+    queryParamName?: string;
+}
+declare function createHealthcheckMiddleware(options: HealthcheckMiddlewareOptions): RequestHandler;
+
+export { type HealthcheckMiddlewareOptions, createHealthcheckMiddleware };

package/dist/integrations/express.mjs

@@ -0,0 +1,78 @@
+// src/auth.ts
+import { createHash, timingSafeEqual } from "crypto";
+function verifyToken(provided, expected) {
+  if (!provided || !expected) return false;
+  const providedHash = createHash("sha256").update(provided).digest();
+  const expectedHash = createHash("sha256").update(expected).digest();
+  return timingSafeEqual(providedHash, expectedHash);
+}
+function extractToken(options) {
+  const { queryParams, authorizationHeader, queryParamName = "token" } = options;
+  if (queryParams) {
+    const value = queryParams[queryParamName];
+    const str = Array.isArray(value) ? value[0] : value;
+    if (str) return str;
+  }
+  if (authorizationHeader?.startsWith("Bearer ")) {
+    const token = authorizationHeader.slice("Bearer ".length);
+    if (token) return token;
+  }
+  return null;
+}
+
+// src/types.ts
+var Status = {
+  HEALTHY: 2,
+  DEGRADED: 1,
+  OUTAGE: 0
+};
+function statusToLabel(status) {
+  const labels = {
+    [Status.HEALTHY]: "healthy",
+    [Status.DEGRADED]: "degraded",
+    [Status.OUTAGE]: "outage"
+  };
+  return labels[status];
+}
+function toJson(response) {
+  return {
+    status: statusToLabel(response.status),
+    timestamp: response.timestamp,
+    checks: Object.fromEntries(
+      Object.entries(response.checks).map(([name, result]) => [
+        name,
+        { status: statusToLabel(result.status), latencyMs: result.latencyMs, message: result.message }
+      ])
+    )
+  };
+}
+function httpStatusCode(status) {
+  return status === Status.HEALTHY ? 200 : 503;
+}
+
+// src/integrations/express.ts
+function createHealthcheckMiddleware(options) {
+  const { registry, token = null, queryParamName = "token" } = options;
+  return async (req, res) => {
+    try {
+      if (token !== null) {
+        const provided = extractToken({
+          queryParams: req.query,
+          authorizationHeader: req.headers.authorization ?? null,
+          queryParamName
+        });
+        if (provided === null || !verifyToken(provided, token)) {
+          res.status(403).json({ error: "Forbidden" });
+          return;
+        }
+      }
+      const response = await registry.run();
+      res.status(httpStatusCode(response.status)).json(toJson(response));
+    } catch {
+      res.status(500).json({ error: "Internal Server Error" });
+    }
+  };
+}
+export {
+  createHealthcheckMiddleware
+};

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@firebreak/vitals",
+  "version": "1.0.0",
+  "description": "Deep healthcheck endpoints following the HEALTHCHECK_SPEC format",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./checks/postgres": {
+      "import": {
+        "types": "./dist/checks/postgres.d.ts",
+        "default": "./dist/checks/postgres.mjs"
+      },
+      "require": {
+        "types": "./dist/checks/postgres.d.cts",
+        "default": "./dist/checks/postgres.cjs"
+      }
+    },
+    "./checks/redis": {
+      "import": {
+        "types": "./dist/checks/redis.d.ts",
+        "default": "./dist/checks/redis.mjs"
+      },
+      "require": {
+        "types": "./dist/checks/redis.d.cts",
+        "default": "./dist/checks/redis.cjs"
+      }
+    },
+    "./express": {
+      "import": {
+        "types": "./dist/integrations/express.d.ts",
+        "default": "./dist/integrations/express.mjs"
+      },
+      "require": {
+        "types": "./dist/integrations/express.d.cts",
+        "default": "./dist/integrations/express.cjs"
+      }
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "pg": ">=8.0.0",
+    "ioredis": ">=5.0.0",
+    "express": ">=4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "pg": {
+      "optional": true
+    },
+    "ioredis": {
+      "optional": true
+    },
+    "express": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.5.0",
+    "vitest": "^2.0.0",
+    "@types/node": "^22.0.0",
+    "@types/express": "^5.0.0",
+    "@types/pg": "^8.0.0",
+    "ioredis": "^5.0.0",
+    "express": "^4.21.0",
+    "pg": "^8.13.0",
+    "supertest": "^7.0.0",
+    "@types/supertest": "^6.0.0"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "license": "UNLICENSED"
+}