@fluojs/terminus 1.0.0-beta.1

package/dist/indicators/disk.js

@@ -0,0 +1,73 @@
+import { statfs } from 'node:fs/promises';
+import { createDownResult, createUpResult, resolveIndicatorKey, throwHealthCheckError } from './utils.js';
+
+/** Options for checking free disk bytes and free-ratio thresholds. */
+
+const DEFAULT_DISK_FREE_RATIO_THRESHOLD = 0.1;
+function toNumber(value) {
+  return typeof value === 'bigint' ? Number(value) : value;
+}
+
+/**
+ * Create a disk-space health indicator.
+ *
+ * @param options Optional filesystem path and free-space thresholds.
+ * @returns A health indicator backed by `statfs()`.
+ */
+export function createDiskHealthIndicator(options = {}) {
+  return new DiskHealthIndicator(options);
+}
+
+/**
+ * Create a provider that registers a `DiskHealthIndicator` instance.
+ *
+ * @param options Optional filesystem path and free-space thresholds.
+ * @returns A value provider that exposes `DiskHealthIndicator` from the DI container.
+ */
+export function createDiskHealthIndicatorProvider(options = {}) {
+  return {
+    provide: DiskHealthIndicator,
+    useValue: new DiskHealthIndicator(options)
+  };
+}
+
+/** Health indicator that inspects free space for one filesystem path. */
+export class DiskHealthIndicator {
+  key;
+  constructor(options = {}) {
+    this.options = options;
+    this.key = options.key;
+  }
+  async check(key) {
+    const indicatorKey = resolveIndicatorKey('disk', this.options.key ?? key);
+    const path = this.options.path ?? '.';
+    const minFreeRatio = this.options.minFreeRatio ?? DEFAULT_DISK_FREE_RATIO_THRESHOLD;
+    try {
+      const stats = await statfs(path);
+      const blockSize = toNumber(stats.bsize);
+      const blocks = toNumber(stats.blocks);
+      const availableBlocks = toNumber(stats.bavail);
+      const freeBytes = availableBlocks * blockSize;
+      const totalBytes = blocks * blockSize;
+      const freeRatio = totalBytes > 0 ? freeBytes / totalBytes : 1;
+      const details = {
+        freeBytes,
+        freeRatio,
+        path,
+        totalBytes
+      };
+      if (this.options.minFreeBytes !== undefined && freeBytes < this.options.minFreeBytes) {
+        throwHealthCheckError('Disk health check failed.', createDownResult(indicatorKey, 'Disk free bytes dropped below the configured threshold.', details));
+      }
+      if (freeRatio < minFreeRatio) {
+        throwHealthCheckError('Disk health check failed.', createDownResult(indicatorKey, 'Disk free ratio dropped below the configured threshold.', details));
+      }
+      return createUpResult(indicatorKey, details);
+    } catch (error) {
+      if (error instanceof Error && error.name === 'HealthCheckError') {
+        throw error;
+      }
+      throwHealthCheckError('Disk health check failed.', createDownResult(indicatorKey, error instanceof Error ? error.message : 'Disk health check failed.'));
+    }
+  }
+}

package/dist/indicators/drizzle.d.ts

@@ -0,0 +1,36 @@
+import type { Provider } from '@fluojs/di';
+import type { HealthIndicator, HealthIndicatorResult } from '../types.js';
+interface DrizzleExecuteLike {
+    execute?: (query: unknown) => Promise<unknown>;
+}
+/** Options for probing Drizzle-backed database connectivity. */
+export interface DrizzleHealthIndicatorOptions {
+    database?: DrizzleExecuteLike;
+    key?: string;
+    ping?: () => Promise<unknown> | unknown;
+    query?: unknown;
+    timeoutMs?: number;
+}
+/**
+ * Create a Drizzle health indicator.
+ *
+ * @param options Optional database handle, ping callback, timeout, query, and key override.
+ * @returns A health indicator that executes a lightweight Drizzle query.
+ */
+export declare function createDrizzleHealthIndicator(options?: DrizzleHealthIndicatorOptions): HealthIndicator;
+/**
+ * Create a provider that resolves a Drizzle database handle from DI and wraps it as an indicator.
+ *
+ * @param options Optional timeout, query override, key override, or custom ping callback.
+ * @returns A factory provider that exposes `DrizzleHealthIndicator` from the DI container.
+ */
+export declare function createDrizzleHealthIndicatorProvider(options?: Omit<DrizzleHealthIndicatorOptions, 'database'>): Provider;
+/** Health indicator that probes Drizzle connectivity with an execute-capable handle. */
+export declare class DrizzleHealthIndicator implements HealthIndicator {
+    private readonly options;
+    readonly key: string | undefined;
+    constructor(options?: DrizzleHealthIndicatorOptions);
+    check(key: string): Promise<HealthIndicatorResult>;
+}
+export {};
+//# sourceMappingURL=drizzle.d.ts.map

package/dist/indicators/drizzle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drizzle.d.ts","sourceRoot":"","sources":["../../src/indicators/drizzle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAG3C,OAAO,KAAK,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAI1E,UAAU,kBAAkB;IAC1B,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CAChD;AAED,gEAAgE;AAChE,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,EAAE,kBAAkB,CAAC;IAC9B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;IACxC,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAsBD;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,GAAE,6BAAkC,GAAG,eAAe,CAEzG;AAED;;;;;GAKG;AACH,wBAAgB,oCAAoC,CAAC,OAAO,GAAE,IAAI,CAAC,6BAA6B,EAAE,UAAU,CAAM,GAAG,QAAQ,CAM5H;AAED,wFAAwF;AACxF,qBAAa,sBAAuB,YAAW,eAAe;IAGhD,OAAO,CAAC,QAAQ,CAAC,OAAO;IAFpC,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;gBAEJ,OAAO,GAAE,6BAAkC;IAIlE,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC;CAczD"}

package/dist/indicators/drizzle.js

@@ -0,0 +1,64 @@
+import { createDownResult, createUpResult, resolveIndicatorKey, throwHealthCheckError, withIndicatorTimeout } from './utils.js';
+const DRIZZLE_DATABASE = Symbol.for('fluo.drizzle.database');
+
+/** Options for probing Drizzle-backed database connectivity. */
+
+const DEFAULT_DRIZZLE_TIMEOUT_MS = 2_000;
+const DEFAULT_DRIZZLE_QUERY = 'select 1';
+async function runDrizzlePing(options) {
+  if (options.ping) {
+    await options.ping();
+    return;
+  }
+  const database = options.database;
+  if (!database || typeof database.execute !== 'function') {
+    throw new Error('Drizzle indicator requires an execute-capable database handle or a ping callback.');
+  }
+  await database.execute(options.query ?? DEFAULT_DRIZZLE_QUERY);
+}
+
+/**
+ * Create a Drizzle health indicator.
+ *
+ * @param options Optional database handle, ping callback, timeout, query, and key override.
+ * @returns A health indicator that executes a lightweight Drizzle query.
+ */
+export function createDrizzleHealthIndicator(options = {}) {
+  return new DrizzleHealthIndicator(options);
+}
+
+/**
+ * Create a provider that resolves a Drizzle database handle from DI and wraps it as an indicator.
+ *
+ * @param options Optional timeout, query override, key override, or custom ping callback.
+ * @returns A factory provider that exposes `DrizzleHealthIndicator` from the DI container.
+ */
+export function createDrizzleHealthIndicatorProvider(options = {}) {
+  return {
+    inject: [DRIZZLE_DATABASE],
+    provide: DrizzleHealthIndicator,
+    useFactory: database => new DrizzleHealthIndicator({
+      ...options,
+      database: database
+    })
+  };
+}
+
+/** Health indicator that probes Drizzle connectivity with an execute-capable handle. */
+export class DrizzleHealthIndicator {
+  key;
+  constructor(options = {}) {
+    this.options = options;
+    this.key = options.key;
+  }
+  async check(key) {
+    const indicatorKey = resolveIndicatorKey('drizzle', this.options.key ?? key);
+    const timeoutMs = this.options.timeoutMs ?? DEFAULT_DRIZZLE_TIMEOUT_MS;
+    try {
+      await withIndicatorTimeout(runDrizzlePing(this.options), timeoutMs, indicatorKey);
+      return createUpResult(indicatorKey);
+    } catch (error) {
+      throwHealthCheckError('Drizzle health check failed.', createDownResult(indicatorKey, error instanceof Error ? error.message : 'Drizzle health check failed.'));
+    }
+  }
+}

package/dist/indicators/http.d.ts

@@ -0,0 +1,33 @@
+import type { Provider } from '@fluojs/di';
+import type { HealthIndicator, HealthIndicatorResult } from '../types.js';
+/** Options for probing one upstream HTTP dependency. */
+export interface HttpHealthIndicatorOptions {
+    expectedStatus?: number | readonly number[] | ((status: number) => boolean);
+    headers?: Record<string, string>;
+    key?: string;
+    method?: string;
+    timeoutMs?: number;
+    url: string;
+}
+/**
+ * Create an HTTP-backed health indicator.
+ *
+ * @param options HTTP probe settings such as URL, method, headers, and accepted status codes.
+ * @returns A health indicator that fetches the configured endpoint on each check.
+ */
+export declare function createHttpHealthIndicator(options: HttpHealthIndicatorOptions): HealthIndicator;
+/**
+ * Create a provider that registers an `HttpHealthIndicator` instance.
+ *
+ * @param options HTTP probe settings such as URL, method, headers, and accepted status codes.
+ * @returns A value provider that exposes `HttpHealthIndicator` from the DI container.
+ */
+export declare function createHttpHealthIndicatorProvider(options: HttpHealthIndicatorOptions): Provider;
+/** Health indicator that probes an upstream HTTP endpoint with `fetch()`. */
+export declare class HttpHealthIndicator implements HealthIndicator {
+    private readonly options;
+    readonly key: string | undefined;
+    constructor(options: HttpHealthIndicatorOptions);
+    check(key: string): Promise<HealthIndicatorResult>;
+}
+//# sourceMappingURL=http.d.ts.map

package/dist/indicators/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../src/indicators/http.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAI3C,OAAO,KAAK,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAE1E,wDAAwD;AACxD,MAAM,WAAW,0BAA0B;IACzC,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,GAAG,CAAC,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC;IAC5E,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;CACb;AAoBD;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,0BAA0B,GAAG,eAAe,CAE9F;AAED;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAAC,OAAO,EAAE,0BAA0B,GAAG,QAAQ,CAK/F;AAED,6EAA6E;AAC7E,qBAAa,mBAAoB,YAAW,eAAe;IAG7C,OAAO,CAAC,QAAQ,CAAC,OAAO;IAFpC,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;gBAEJ,OAAO,EAAE,0BAA0B;IAI1D,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC;CA6CzD"}

package/dist/indicators/http.js

@@ -0,0 +1,87 @@
+import { createDownResult, createUpResult, resolveIndicatorKey, throwHealthCheckError } from './utils.js';
+import { HealthCheckError } from '../errors.js';
+
+/** Options for probing one upstream HTTP dependency. */
+
+const DEFAULT_HTTP_TIMEOUT_MS = 2_000;
+function isExpectedStatus(status, expected) {
+  if (typeof expected === 'function') {
+    return expected(status);
+  }
+  if (Array.isArray(expected)) {
+    return expected.includes(status);
+  }
+  if (typeof expected === 'number') {
+    return status === expected;
+  }
+  return status >= 200 && status < 300;
+}
+
+/**
+ * Create an HTTP-backed health indicator.
+ *
+ * @param options HTTP probe settings such as URL, method, headers, and accepted status codes.
+ * @returns A health indicator that fetches the configured endpoint on each check.
+ */
+export function createHttpHealthIndicator(options) {
+  return new HttpHealthIndicator(options);
+}
+
+/**
+ * Create a provider that registers an `HttpHealthIndicator` instance.
+ *
+ * @param options HTTP probe settings such as URL, method, headers, and accepted status codes.
+ * @returns A value provider that exposes `HttpHealthIndicator` from the DI container.
+ */
+export function createHttpHealthIndicatorProvider(options) {
+  return {
+    provide: HttpHealthIndicator,
+    useValue: new HttpHealthIndicator(options)
+  };
+}
+
+/** Health indicator that probes an upstream HTTP endpoint with `fetch()`. */
+export class HttpHealthIndicator {
+  key;
+  constructor(options) {
+    this.options = options;
+    this.key = options.key;
+  }
+  async check(key) {
+    const indicatorKey = resolveIndicatorKey('http', this.options.key ?? key);
+    const timeoutMs = this.options.timeoutMs ?? DEFAULT_HTTP_TIMEOUT_MS;
+    const method = this.options.method ?? 'GET';
+    const abortController = new AbortController();
+    const startedAt = Date.now();
+    const timeout = setTimeout(() => {
+      abortController.abort(new Error(`HTTP health check timed out after ${String(timeoutMs)}ms.`));
+    }, timeoutMs);
+    try {
+      const response = await fetch(this.options.url, {
+        headers: this.options.headers,
+        method,
+        signal: abortController.signal
+      });
+      const responseTimeMs = Date.now() - startedAt;
+      if (!isExpectedStatus(response.status, this.options.expectedStatus)) {
+        throwHealthCheckError('HTTP health check failed.', createDownResult(indicatorKey, `Unexpected status code ${String(response.status)} from ${this.options.url}.`, {
+          responseTimeMs,
+          statusCode: response.status,
+          url: this.options.url
+        }));
+      }
+      return createUpResult(indicatorKey, {
+        responseTimeMs,
+        statusCode: response.status,
+        url: this.options.url
+      });
+    } catch (error) {
+      if (error instanceof HealthCheckError) {
+        throw error;
+      }
+      throwHealthCheckError('HTTP health check failed.', createDownResult(indicatorKey, error instanceof Error ? error.message : `HTTP health check failed for ${this.options.url}.`));
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+}

package/dist/indicators/index.d.ts

@@ -0,0 +1,6 @@
+export * from './disk.js';
+export * from './drizzle.js';
+export * from './http.js';
+export * from './memory.js';
+export * from './prisma.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/indicators/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/indicators/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC"}

package/dist/indicators/index.js

@@ -0,0 +1,5 @@
+export * from './disk.js';
+export * from './drizzle.js';
+export * from './http.js';
+export * from './memory.js';
+export * from './prisma.js';

package/dist/indicators/memory.d.ts

@@ -0,0 +1,31 @@
+import type { Provider } from '@fluojs/di';
+import type { HealthIndicator, HealthIndicatorResult } from '../types.js';
+/** Options for checking process heap and RSS thresholds. */
+export interface MemoryHealthIndicatorOptions {
+    heapUsedThresholdBytes?: number;
+    heapUsedThresholdRatio?: number;
+    key?: string;
+    rssThresholdBytes?: number;
+}
+/**
+ * Create a process-memory health indicator.
+ *
+ * @param options Optional heap and RSS thresholds plus an indicator key override.
+ * @returns A health indicator backed by `process.memoryUsage()`.
+ */
+export declare function createMemoryHealthIndicator(options?: MemoryHealthIndicatorOptions): HealthIndicator;
+/**
+ * Create a provider that registers a `MemoryHealthIndicator` instance.
+ *
+ * @param options Optional heap and RSS thresholds plus an indicator key override.
+ * @returns A value provider that exposes `MemoryHealthIndicator` from the DI container.
+ */
+export declare function createMemoryHealthIndicatorProvider(options?: MemoryHealthIndicatorOptions): Provider;
+/** Health indicator that checks local process heap and RSS usage. */
+export declare class MemoryHealthIndicator implements HealthIndicator {
+    private readonly options;
+    readonly key: string | undefined;
+    constructor(options?: MemoryHealthIndicatorOptions);
+    check(key: string): Promise<HealthIndicatorResult>;
+}
+//# sourceMappingURL=memory.d.ts.map

package/dist/indicators/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../src/indicators/memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAG3C,OAAO,KAAK,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAE1E,4DAA4D;AAC5D,MAAM,WAAW,4BAA4B;IAC3C,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAYD;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,GAAE,4BAAiC,GAAG,eAAe,CAEvG;AAED;;;;;GAKG;AACH,wBAAgB,mCAAmC,CAAC,OAAO,GAAE,4BAAiC,GAAG,QAAQ,CAKxG;AAED,qEAAqE;AACrE,qBAAa,qBAAsB,YAAW,eAAe;IAG/C,OAAO,CAAC,QAAQ,CAAC,OAAO;IAFpC,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;gBAEJ,OAAO,GAAE,4BAAiC;IAIjE,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC;CAiCzD"}

package/dist/indicators/memory.js

@@ -0,0 +1,68 @@
+import { createDownResult, createUpResult, resolveIndicatorKey, throwHealthCheckError } from './utils.js';
+
+/** Options for checking process heap and RSS thresholds. */
+
+const DEFAULT_HEAP_RATIO_THRESHOLD = 0.95;
+function exceedsRatioThreshold(used, total, threshold) {
+  if (total <= 0) {
+    return false;
+  }
+  return used / total >= threshold;
+}
+
+/**
+ * Create a process-memory health indicator.
+ *
+ * @param options Optional heap and RSS thresholds plus an indicator key override.
+ * @returns A health indicator backed by `process.memoryUsage()`.
+ */
+export function createMemoryHealthIndicator(options = {}) {
+  return new MemoryHealthIndicator(options);
+}
+
+/**
+ * Create a provider that registers a `MemoryHealthIndicator` instance.
+ *
+ * @param options Optional heap and RSS thresholds plus an indicator key override.
+ * @returns A value provider that exposes `MemoryHealthIndicator` from the DI container.
+ */
+export function createMemoryHealthIndicatorProvider(options = {}) {
+  return {
+    provide: MemoryHealthIndicator,
+    useValue: new MemoryHealthIndicator(options)
+  };
+}
+
+/** Health indicator that checks local process heap and RSS usage. */
+export class MemoryHealthIndicator {
+  key;
+  constructor(options = {}) {
+    this.options = options;
+    this.key = options.key;
+  }
+  async check(key) {
+    const indicatorKey = resolveIndicatorKey('memory', this.options.key ?? key);
+    const heapRatioThreshold = this.options.heapUsedThresholdRatio ?? DEFAULT_HEAP_RATIO_THRESHOLD;
+    const usage = process.memoryUsage();
+    const usageDetails = {
+      arrayBuffers: usage.arrayBuffers,
+      external: usage.external,
+      heapTotal: usage.heapTotal,
+      heapUsed: usage.heapUsed,
+      rss: usage.rss
+    };
+    if (this.options.heapUsedThresholdBytes !== undefined && usage.heapUsed >= this.options.heapUsedThresholdBytes) {
+      throwHealthCheckError('Memory health check failed.', createDownResult(indicatorKey, 'Heap usage exceeded the configured byte threshold.', usageDetails));
+    }
+    if (this.options.rssThresholdBytes !== undefined && usage.rss >= this.options.rssThresholdBytes) {
+      throwHealthCheckError('Memory health check failed.', createDownResult(indicatorKey, 'RSS usage exceeded the configured byte threshold.', usageDetails));
+    }
+    if (exceedsRatioThreshold(usage.heapUsed, usage.heapTotal, heapRatioThreshold)) {
+      throwHealthCheckError('Memory health check failed.', createDownResult(indicatorKey, 'Heap usage exceeded the configured ratio threshold.', {
+        ...usageDetails,
+        heapUsedRatio: usage.heapTotal > 0 ? usage.heapUsed / usage.heapTotal : 0
+      }));
+    }
+    return createUpResult(indicatorKey, usageDetails);
+  }
+}

package/dist/indicators/prisma.d.ts

@@ -0,0 +1,38 @@
+import type { Provider } from '@fluojs/di';
+import type { HealthIndicator, HealthIndicatorResult } from '../types.js';
+interface PrismaClientLike {
+    $executeRaw?: (...args: unknown[]) => Promise<unknown>;
+    $executeRawUnsafe?: (query: string) => Promise<unknown>;
+    $queryRaw?: (...args: unknown[]) => Promise<unknown>;
+    $queryRawUnsafe?: (query: string) => Promise<unknown>;
+}
+/** Options for probing Prisma-backed database connectivity. */
+export interface PrismaHealthIndicatorOptions {
+    client?: PrismaClientLike;
+    key?: string;
+    ping?: () => Promise<unknown> | unknown;
+    timeoutMs?: number;
+}
+/**
+ * Create a Prisma health indicator.
+ *
+ * @param options Optional Prisma client, ping callback, timeout, and key override.
+ * @returns A health indicator that executes a lightweight Prisma round trip.
+ */
+export declare function createPrismaHealthIndicator(options?: PrismaHealthIndicatorOptions): HealthIndicator;
+/**
+ * Create a provider that resolves a Prisma client from DI and wraps it as an indicator.
+ *
+ * @param options Optional timeout, key override, or custom ping callback.
+ * @returns A factory provider that exposes `PrismaHealthIndicator` from the DI container.
+ */
+export declare function createPrismaHealthIndicatorProvider(options?: Omit<PrismaHealthIndicatorOptions, 'client'>): Provider;
+/** Health indicator that probes Prisma connectivity with a trivial query. */
+export declare class PrismaHealthIndicator implements HealthIndicator {
+    private readonly options;
+    readonly key: string | undefined;
+    constructor(options?: PrismaHealthIndicatorOptions);
+    check(key: string): Promise<HealthIndicatorResult>;
+}
+export {};
+//# sourceMappingURL=prisma.d.ts.map

package/dist/indicators/prisma.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prisma.d.ts","sourceRoot":"","sources":["../../src/indicators/prisma.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAG3C,OAAO,KAAK,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAI1E,UAAU,gBAAgB;IACxB,WAAW,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACvD,iBAAiB,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACxD,SAAS,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACrD,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CACvD;AAED,+DAA+D;AAC/D,MAAM,WAAW,4BAA4B;IAC3C,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;IACxC,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAuCD;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,GAAE,4BAAiC,GAAG,eAAe,CAEvG;AAED;;;;;GAKG;AACH,wBAAgB,mCAAmC,CAAC,OAAO,GAAE,IAAI,CAAC,4BAA4B,EAAE,QAAQ,CAAM,GAAG,QAAQ,CAMxH;AAED,6EAA6E;AAC7E,qBAAa,qBAAsB,YAAW,eAAe;IAG/C,OAAO,CAAC,QAAQ,CAAC,OAAO;IAFpC,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;gBAEJ,OAAO,GAAE,4BAAiC;IAIjE,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC;CAczD"}

package/dist/indicators/prisma.js

@@ -0,0 +1,79 @@
+import { createDownResult, createUpResult, resolveIndicatorKey, throwHealthCheckError, withIndicatorTimeout } from './utils.js';
+const PRISMA_CLIENT = Symbol.for('fluo.prisma.client');
+
+/** Options for probing Prisma-backed database connectivity. */
+
+const DEFAULT_PRISMA_TIMEOUT_MS = 2_000;
+async function runPrismaPing(options) {
+  if (options.ping) {
+    await options.ping();
+    return;
+  }
+  const client = options.client;
+  if (!client) {
+    throw new Error('Prisma indicator requires either a client or ping callback.');
+  }
+  if (typeof client.$queryRawUnsafe === 'function') {
+    await client.$queryRawUnsafe('SELECT 1');
+    return;
+  }
+  if (typeof client.$executeRawUnsafe === 'function') {
+    await client.$executeRawUnsafe('SELECT 1');
+    return;
+  }
+  if (typeof client.$queryRaw === 'function') {
+    await client.$queryRaw('SELECT 1');
+    return;
+  }
+  if (typeof client.$executeRaw === 'function') {
+    await client.$executeRaw('SELECT 1');
+    return;
+  }
+  throw new Error('Prisma indicator requires a client with query/execute capabilities or a ping callback.');
+}
+
+/**
+ * Create a Prisma health indicator.
+ *
+ * @param options Optional Prisma client, ping callback, timeout, and key override.
+ * @returns A health indicator that executes a lightweight Prisma round trip.
+ */
+export function createPrismaHealthIndicator(options = {}) {
+  return new PrismaHealthIndicator(options);
+}
+
+/**
+ * Create a provider that resolves a Prisma client from DI and wraps it as an indicator.
+ *
+ * @param options Optional timeout, key override, or custom ping callback.
+ * @returns A factory provider that exposes `PrismaHealthIndicator` from the DI container.
+ */
+export function createPrismaHealthIndicatorProvider(options = {}) {
+  return {
+    inject: [PRISMA_CLIENT],
+    provide: PrismaHealthIndicator,
+    useFactory: client => new PrismaHealthIndicator({
+      ...options,
+      client: client
+    })
+  };
+}
+
+/** Health indicator that probes Prisma connectivity with a trivial query. */
+export class PrismaHealthIndicator {
+  key;
+  constructor(options = {}) {
+    this.options = options;
+    this.key = options.key;
+  }
+  async check(key) {
+    const indicatorKey = resolveIndicatorKey('prisma', this.options.key ?? key);
+    const timeoutMs = this.options.timeoutMs ?? DEFAULT_PRISMA_TIMEOUT_MS;
+    try {
+      await withIndicatorTimeout(runPrismaPing(this.options), timeoutMs, indicatorKey);
+      return createUpResult(indicatorKey);
+    } catch (error) {
+      throwHealthCheckError('Prisma health check failed.', createDownResult(indicatorKey, error instanceof Error ? error.message : 'Prisma health check failed.'));
+    }
+  }
+}

package/dist/indicators/redis.d.ts

@@ -0,0 +1,36 @@
+import type { Provider } from '@fluojs/di';
+import type { HealthIndicator, HealthIndicatorResult } from '../types.js';
+interface RedisClientLike {
+    ping?: () => Promise<unknown>;
+}
+/** Options for probing Redis connectivity. */
+export interface RedisHealthIndicatorOptions {
+    client?: RedisClientLike;
+    clientName?: string;
+    key?: string;
+    ping?: () => Promise<unknown> | unknown;
+    timeoutMs?: number;
+}
+/**
+ * Create a Redis health indicator.
+ *
+ * @param options Optional Redis client, ping callback, timeout, and key override.
+ * @returns A health indicator that checks Redis with `PING` semantics.
+ */
+export declare function createRedisHealthIndicator(options?: RedisHealthIndicatorOptions): HealthIndicator;
+/**
+ * Create a provider that resolves a Redis client from DI and wraps it as an indicator.
+ *
+ * @param options Optional timeout, key override, or custom ping callback.
+ * @returns A factory provider that exposes `RedisHealthIndicator` from the DI container.
+ */
+export declare function createRedisHealthIndicatorProvider(options?: Omit<RedisHealthIndicatorOptions, 'client'>): Provider;
+/** Health indicator that checks Redis reachability with a ping-like operation. */
+export declare class RedisHealthIndicator implements HealthIndicator {
+    private readonly options;
+    readonly key: string | undefined;
+    constructor(options?: RedisHealthIndicatorOptions);
+    check(key: string): Promise<HealthIndicatorResult>;
+}
+export {};
+//# sourceMappingURL=redis.d.ts.map

package/dist/indicators/redis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis.d.ts","sourceRoot":"","sources":["../../src/indicators/redis.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAI3C,OAAO,KAAK,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAE1E,UAAU,eAAe;IACvB,IAAI,CAAC,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;CAC/B;AAED,8CAA8C;AAC9C,MAAM,WAAW,2BAA2B;IAC1C,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;IACxC,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAmBD;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,GAAE,2BAAgC,GAAG,eAAe,CAErG;AAED;;;;;GAKG;AACH,wBAAgB,kCAAkC,CAAC,OAAO,GAAE,IAAI,CAAC,2BAA2B,EAAE,QAAQ,CAAM,GAAG,QAAQ,CAQtH;AAED,kFAAkF;AAClF,qBAAa,oBAAqB,YAAW,eAAe;IAG9C,OAAO,CAAC,QAAQ,CAAC,OAAO;IAFpC,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;gBAEJ,OAAO,GAAE,2BAAgC;IAIhE,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC;CAczD"}

package/dist/indicators/redis.js

@@ -0,0 +1,64 @@
+import { getRedisClientToken } from '@fluojs/redis';
+import { createDownResult, createUpResult, resolveIndicatorKey, throwHealthCheckError, withIndicatorTimeout } from './utils.js';
+
+/** Options for probing Redis connectivity. */
+
+const DEFAULT_REDIS_TIMEOUT_MS = 2_000;
+async function runRedisPing(options) {
+  if (options.ping) {
+    await options.ping();
+    return;
+  }
+  const client = options.client;
+  if (!client || typeof client.ping !== 'function') {
+    throw new Error('Redis indicator requires a client with ping() or a ping callback.');
+  }
+  await client.ping();
+}
+
+/**
+ * Create a Redis health indicator.
+ *
+ * @param options Optional Redis client, ping callback, timeout, and key override.
+ * @returns A health indicator that checks Redis with `PING` semantics.
+ */
+export function createRedisHealthIndicator(options = {}) {
+  return new RedisHealthIndicator(options);
+}
+
+/**
+ * Create a provider that resolves a Redis client from DI and wraps it as an indicator.
+ *
+ * @param options Optional timeout, key override, or custom ping callback.
+ * @returns A factory provider that exposes `RedisHealthIndicator` from the DI container.
+ */
+export function createRedisHealthIndicatorProvider(options = {}) {
+  const indicatorProviderToken = Symbol('fluo.terminus.redis-health-indicator');
+  return {
+    inject: [getRedisClientToken(options.clientName)],
+    provide: indicatorProviderToken,
+    useFactory: client => new RedisHealthIndicator({
+      ...options,
+      client: client
+    })
+  };
+}
+
+/** Health indicator that checks Redis reachability with a ping-like operation. */
+export class RedisHealthIndicator {
+  key;
+  constructor(options = {}) {
+    this.options = options;
+    this.key = options.key;
+  }
+  async check(key) {
+    const indicatorKey = resolveIndicatorKey('redis', this.options.key ?? key);
+    const timeoutMs = this.options.timeoutMs ?? DEFAULT_REDIS_TIMEOUT_MS;
+    try {
+      await withIndicatorTimeout(runRedisPing(this.options), timeoutMs, indicatorKey);
+      return createUpResult(indicatorKey);
+    } catch (error) {
+      throwHealthCheckError('Redis health check failed.', createDownResult(indicatorKey, error instanceof Error ? error.message : 'Redis health check failed.'));
+    }
+  }
+}