@fluojs/terminus 1.0.0-beta.5 → 1.0.0-beta.6

package/README.ko.md

@@ -37,7 +37,8 @@ pnpm add @fluojs/terminus
 
 ```typescript
 import { Module } from '@fluojs/core';
-import { HttpHealthIndicator, MemoryHealthIndicator, TerminusModule } from '@fluojs/terminus';
+import { HttpHealthIndicator, TerminusModule } from '@fluojs/terminus';
+import { MemoryHealthIndicator } from '@fluojs/terminus/node';
 
 @Module({
   imports: [
@@ -61,8 +62,8 @@ class AppModule {}
 - `PrismaHealthIndicator` / `DrizzleHealthIndicator`
 - `RedisHealthIndicator` (`@fluojs/terminus/redis`에서 제공)
 - `HttpHealthIndicator`
-- `MemoryHealthIndicator`
-- `DiskHealthIndicator`
+- `MemoryHealthIndicator` (호환성을 위해 root에서도 export되며 `@fluojs/terminus/node`에서도 제공)
+- `DiskHealthIndicator` (호환성을 위해 root에서도 export되며 `@fluojs/terminus/node`에서도 제공)
 
 ### DI 기반 인디케이터
 
@@ -90,6 +91,8 @@ TerminusModule.forRoot({
 });
 ```
 
+Drizzle의 경우 `createDrizzleHealthIndicatorProvider()`는 `@fluojs/drizzle`이 노출하는 lifecycle-aware `DrizzleDatabase` wrapper를 우선 사용합니다. Drizzle이 종료 중이거나 중지되었거나 `DrizzleDatabase.createPlatformStatusSnapshot()` 기준으로 준비되지 않은 상태이면 SQL probe를 실행하기 전에 해당 indicator를 `down`으로 보고합니다. legacy raw `DRIZZLE_DATABASE` handle만 등록된 경우에는 기존 lightweight SQL probe 동작을 유지합니다.
+
 ### 실행 가드레일
 
 커스텀 인디케이터가 멈추거나 느린 하위 서비스에 의존할 수 있다면 `execution.indicatorTimeoutMs`를 사용하세요. probe가 설정된 시간을 넘기면 Terminus는 무기한 대기하지 않고 해당 인디케이터를 `down`으로 표시합니다.
@@ -114,9 +117,11 @@ TerminusModule.forRoot({
 - 응답 본문은 `status`, `contributors`, `info`, `error`, `details`를 포함한 구조화된 JSON 객체입니다.
 - 하나의 인디케이터가 여러 keyed entry를 반환할 수도 있으며, 이 경우 `/health`는 모든 entry를 `details`와 `contributors.up` / `contributors.down` 요약에 그대로 반영합니다.
 - 지원하지 않는 status, 빈 결과, 객체가 아닌 인디케이터 결과는 조용히 버려지지 않고 `down` 진단으로 보고됩니다.
+- Blank indicator result key는 healthy entry로 기여하지 않고 `down` 진단으로 보고됩니다.
 - 같은 실행에서 이미 보고된 key를 다른 인디케이터가 다시 사용하면, Terminus는 먼저 기록된 entry를 유지하고 데이터를 조용히 덮어쓰는 대신 결정적인 `*-duplicate-key-error` contributor를 추가합니다.
 - 플랫폼 health/readiness 실패는 `/health` 응답에서 결정적인 `fluo-platform-health`, `fluo-platform-readiness` contributor로 노출됩니다.
 - Runtime diagnostics가 있으면 `/health` response에 platform health/readiness detail을 담은 `platform` block이 포함될 수 있습니다.
+- DI provider로 생성한 Drizzle indicator는 SQL probe보다 먼저 Drizzle lifecycle readiness/health state를 반영하므로, underlying driver가 raw ping을 아직 받을 수 있어도 종료 중이거나 중지된 통합은 `/health`와 `/ready`를 unavailable로 표시합니다.
 
 ## 공개 API 개요
 
@@ -144,6 +149,11 @@ TerminusModule.forRoot({
 - `RedisHealthIndicator`, `createRedisHealthIndicator()`, `createRedisHealthIndicatorProvider()`
   - Redis 전용 인디케이터 헬퍼는 선택적 Redis 피어가 설치되지 않은 환경에서도 루트 패키지 import가 안전하도록 전용 subpath에서 export됩니다.
 
+### `@fluojs/terminus/node`
+
+- `MemoryHealthIndicator`, `DiskHealthIndicator`, `createMemoryHealthIndicator()`, `createDiskHealthIndicator()`
+  - Node 전용 indicator helper는 호환성을 위해 root에서도 계속 export되며 이 전용 subpath에서도 export됩니다. Disk check의 filesystem access는 lazy-load되므로 root package import 시점에는 Node filesystem module을 load하지 않습니다.
+
 
 ### `HealthCheckError`
 

package/README.md

@@ -35,7 +35,8 @@ Import `TerminusModule.forRoot()` to register health indicators.
 
 ```typescript
 import { Module } from '@fluojs/core';
-import { HttpHealthIndicator, MemoryHealthIndicator, TerminusModule } from '@fluojs/terminus';
+import { HttpHealthIndicator, TerminusModule } from '@fluojs/terminus';
+import { MemoryHealthIndicator } from '@fluojs/terminus/node';
 
 @Module({
   imports: [
@@ -59,8 +60,8 @@ The package provides several indicators out of the box:
 - `PrismaHealthIndicator` / `DrizzleHealthIndicator`
 - `RedisHealthIndicator` (from `@fluojs/terminus/redis`)
 - `HttpHealthIndicator`
-- `MemoryHealthIndicator`
-- `DiskHealthIndicator`
+- `MemoryHealthIndicator` (root-exported for compatibility and also available from `@fluojs/terminus/node`)
+- `DiskHealthIndicator` (root-exported for compatibility and also available from `@fluojs/terminus/node`)
 
 ### DI-Backed Indicators
 
@@ -88,6 +89,8 @@ TerminusModule.forRoot({
 });
 ```
 
+For Drizzle, `createDrizzleHealthIndicatorProvider()` prefers the lifecycle-aware `DrizzleDatabase` wrapper exported by `@fluojs/drizzle`. The indicator reports `down` before probing SQL whenever Drizzle is shutting down, stopped, or otherwise not ready according to `DrizzleDatabase.createPlatformStatusSnapshot()`. If only the legacy raw `DRIZZLE_DATABASE` handle is registered, the provider keeps the previous lightweight SQL probe behavior.
+
 ### Execution Guardrails
 
 Use `execution.indicatorTimeoutMs` when custom indicators might hang or depend on slow downstreams. When a probe exceeds the configured timeout, Terminus marks that indicator as `down` instead of waiting forever.
@@ -114,9 +117,11 @@ When an indicator fails, it throws a `HealthCheckError`. The `TerminusHealthServ
 - The response body contains a structured JSON object with `status`, `contributors`, `info`, `error`, and `details`.
 - Indicators may emit multiple keyed entries in a single check result; `/health` preserves every keyed entry in `details` and in the `contributors.up` / `contributors.down` summaries.
 - Unsupported, empty, or non-object indicator results are reported as `down` diagnostics instead of being silently discarded.
+- Blank indicator result keys are reported as `down` diagnostics instead of contributing healthy entries.
 - If an indicator reuses a key that was already reported earlier in the same run, Terminus keeps the first entry and adds a deterministic `*-duplicate-key-error` contributor instead of silently overwriting data.
 - Platform health/readiness failures are surfaced as deterministic `fluo-platform-health` and `fluo-platform-readiness` contributors in `/health` responses.
 - `/health` responses may include a `platform` block with platform health/readiness details when runtime diagnostics are available.
+- Drizzle indicators created through the DI provider map Drizzle lifecycle readiness/health state before SQL probing, so shutdown or stopped integrations mark `/health` and `/ready` as unavailable even if the underlying driver still accepts a raw ping.
 
 ## Public API Overview
 
@@ -144,6 +149,11 @@ When an indicator fails, it throws a `HealthCheckError`. The `TerminusHealthServ
 - `RedisHealthIndicator`, `createRedisHealthIndicator()`, `createRedisHealthIndicatorProvider()`
   - Redis-specific indicator helpers are exported from the dedicated subpath so the root package stays import-safe without the optional Redis peer installed.
 
+### `@fluojs/terminus/node`
+
+- `MemoryHealthIndicator`, `DiskHealthIndicator`, `createMemoryHealthIndicator()`, `createDiskHealthIndicator()`
+  - Node-specific indicator helpers remain root-exported for compatibility and are also exported from this dedicated subpath. Filesystem access for disk checks is lazy-loaded so importing the root package does not load Node filesystem modules at module initialization time.
+
 
 ### `HealthCheckError`
 

package/dist/health-check.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"health-check.d.ts","sourceRoot":"","sources":["../src/health-check.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,2BAA2B,EAC3B,iBAAiB,EACjB,eAAe,EAGhB,MAAM,YAAY,CAAC;AAsOpB;;;;;;GAMG;AACH,wBAAsB,cAAc,CAClC,UAAU,EAAE,SAAS,eAAe,EAAE,EACtC,gBAAgB,GAAE,2BAAgC,GACjD,OAAO,CAAC,iBAAiB,CAAC,CAoB5B;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,iBAAiB,EAAE,OAAO,SAAyB,GAAG,iBAAiB,CAMhH;AAED,0FAA0F;AAC1F,qBAAa,qBAAqB;IAE9B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,gBAAgB;gBADhB,UAAU,EAAE,SAAS,eAAe,EAAE,EACtC,gBAAgB,GAAE,2BAAgC;IAGrE;;;;OAIG;IACG,KAAK,IAAI,OAAO,CAAC,iBAAiB,CAAC;IAIzC;;;;OAIG;IACG,SAAS,IAAI,OAAO,CAAC,OAAO,CAAC;CAGpC"}
+{"version":3,"file":"health-check.d.ts","sourceRoot":"","sources":["../src/health-check.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,2BAA2B,EAC3B,iBAAiB,EACjB,eAAe,EAGhB,MAAM,YAAY,CAAC;AAyQpB;;;;;;GAMG;AACH,wBAAsB,cAAc,CAClC,UAAU,EAAE,SAAS,eAAe,EAAE,EACtC,gBAAgB,GAAE,2BAAgC,GACjD,OAAO,CAAC,iBAAiB,CAAC,CAoB5B;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,iBAAiB,EAAE,OAAO,SAAyB,GAAG,iBAAiB,CAMhH;AAED,0FAA0F;AAC1F,qBAAa,qBAAqB;IAE9B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,gBAAgB;gBADhB,UAAU,EAAE,SAAS,eAAe,EAAE,EACtC,gBAAgB,GAAE,2BAAgC;IAGrE;;;;OAIG;IACG,KAAK,IAAI,OAAO,CAAC,iBAAiB,CAAC;IAIzC;;;;OAIG;IACG,SAAS,IAAI,OAAO,CAAC,OAAO,CAAC;CAGpC"}

package/dist/health-check.js

@@ -40,6 +40,25 @@ function hasIndicatorStatus(value) {
 function createUnsupportedEntryMessage(entryKey) {
   return entryKey.trim().length > 0 ? `Indicator returned an unsupported status value for result key "${entryKey}".` : 'Indicator returned an unsupported status value for an empty result key.';
 }
+function createBlankKeyFailureKey(indicatorKey, seenKeys) {
+  const baseKey = `${indicatorKey}-blank-key-error`;
+  if (!seenKeys.has(baseKey)) {
+    return baseKey;
+  }
+  let suffix = 2;
+  let candidate = `${baseKey}-${String(suffix)}`;
+  while (seenKeys.has(candidate)) {
+    suffix += 1;
+    candidate = `${baseKey}-${String(suffix)}`;
+  }
+  return candidate;
+}
+function createBlankKeyFailure(indicatorKey, seenKeys) {
+  return [createBlankKeyFailureKey(indicatorKey, seenKeys), {
+    message: 'Indicator returned a blank result key.',
+    status: 'down'
+  }];
+}
 function normalizeIndicatorResult(key, result) {
   if (typeof result !== 'object' || result === null || Array.isArray(result)) {
     return [[key, {
@@ -58,7 +77,13 @@ function normalizeIndicatorResult(key, result) {
     }]];
   }
   for (const [entryKey, entryValue] of entries) {
-    const normalizedKey = hasIndicatorStatus(entryValue) || entryKey.trim().length > 0 ? entryKey : key;
+    if (entryKey.trim().length === 0) {
+      const blankKeyFailure = createBlankKeyFailure(key, seenKeys);
+      seenKeys.add(blankKeyFailure[0]);
+      normalizedEntries.push(blankKeyFailure);
+      continue;
+    }
+    const normalizedKey = entryKey;
     if (seenKeys.has(normalizedKey)) {
       duplicateKeys.push(normalizedKey);
       continue;

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

@@ -1 +1 @@
-{"version":3,"file":"disk.d.ts","sourceRoot":"","sources":["../../src/indicators/disk.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAG3C,OAAO,KAAK,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAE1E,sEAAsE;AACtE,MAAM,WAAW,0BAA0B;IACzC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAQD;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,GAAE,0BAA+B,GAAG,eAAe,CAEnG;AAED;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAAC,OAAO,GAAE,0BAA+B,GAAG,QAAQ,CAKpG;AAED,yEAAyE;AACzE,qBAAa,mBAAoB,YAAW,eAAe;IAG7C,OAAO,CAAC,QAAQ,CAAC,OAAO;IAFpC,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;gBAEJ,OAAO,GAAE,0BAA+B;IAI/D,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC;CAsCzD"}
+{"version":3,"file":"disk.d.ts","sourceRoot":"","sources":["../../src/indicators/disk.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAG3C,OAAO,KAAK,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAE1E,sEAAsE;AACtE,MAAM,WAAW,0BAA0B;IACzC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAcD;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,GAAE,0BAA+B,GAAG,eAAe,CAEnG;AAED;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAAC,OAAO,GAAE,0BAA+B,GAAG,QAAQ,CAKpG;AAED,yEAAyE;AACzE,qBAAa,mBAAoB,YAAW,eAAe;IAG7C,OAAO,CAAC,QAAQ,CAAC,OAAO;IAFpC,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;gBAEJ,OAAO,GAAE,0BAA+B;IAI/D,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC;CAsCzD"}

package/dist/indicators/disk.js

@@ -1,4 +1,3 @@
-import { statfs } from 'node:fs/promises';
 import { createDownResult, createUpResult, resolveIndicatorKey, throwHealthCheckError } from './utils.js';
 
 /** Options for checking free disk bytes and free-ratio thresholds. */
@@ -7,6 +6,12 @@ const DEFAULT_DISK_FREE_RATIO_THRESHOLD = 0.1;
 function toNumber(value) {
   return typeof value === 'bigint' ? Number(value) : value;
 }
+async function statFilesystem(path) {
+  const {
+    statfs
+  } = await import('node:fs/promises');
+  return statfs(path);
+}
 
 /**
  * Create a disk-space health indicator.
@@ -43,7 +48,7 @@ export class DiskHealthIndicator {
     const path = this.options.path ?? '.';
     const minFreeRatio = this.options.minFreeRatio ?? DEFAULT_DISK_FREE_RATIO_THRESHOLD;
     try {
-      const stats = await statfs(path);
+      const stats = await statFilesystem(path);
       const blockSize = toNumber(stats.bsize);
       const blocks = toNumber(stats.blocks);
       const availableBlocks = toNumber(stats.bavail);

package/dist/indicators/drizzle.d.ts

@@ -1,11 +1,27 @@
-import type { Provider } from '@fluojs/di';
+import { type Provider } from '@fluojs/di';
 import type { HealthIndicator, HealthIndicatorResult } from '../types.js';
 interface DrizzleExecuteLike {
     execute?: (query: unknown) => Promise<unknown>;
 }
+interface DrizzleLifecycleSnapshotLike {
+    details?: Record<string, unknown>;
+    health: {
+        reason?: string;
+        status: 'healthy' | 'degraded' | 'unhealthy';
+    };
+    readiness: {
+        reason?: string;
+        status: 'ready' | 'not-ready';
+    };
+}
+interface DrizzleHandleProviderLike {
+    createPlatformStatusSnapshot?: () => DrizzleLifecycleSnapshotLike;
+    current?: () => DrizzleExecuteLike | unknown;
+}
 /** Options for probing Drizzle-backed database connectivity. */
 export interface DrizzleHealthIndicatorOptions {
     database?: DrizzleExecuteLike;
+    handleProvider?: DrizzleHandleProviderLike;
     key?: string;
     ping?: () => Promise<unknown> | unknown;
     query?: unknown;
@@ -14,8 +30,8 @@ export interface DrizzleHealthIndicatorOptions {
 /**
  * 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.
+ * @param options Optional lifecycle-aware handle provider, database handle, ping callback, timeout, query, and key override.
+ * @returns A health indicator that checks Drizzle lifecycle state before executing a lightweight query.
  */
 export declare function createDrizzleHealthIndicator(options?: DrizzleHealthIndicatorOptions): HealthIndicator;
 /**
@@ -24,8 +40,8 @@ export declare function createDrizzleHealthIndicator(options?: DrizzleHealthIndi
  * @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 function createDrizzleHealthIndicatorProvider(options?: Omit<DrizzleHealthIndicatorOptions, 'database' | 'handleProvider'>): Provider;
+/** Health indicator that maps Drizzle lifecycle state and probes connectivity with an execute-capable handle. */
 export declare class DrizzleHealthIndicator implements HealthIndicator {
     private readonly options;
     readonly key: string | undefined;

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

@@ -1 +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"}
+{"version":3,"file":"drizzle.d.ts","sourceRoot":"","sources":["../../src/indicators/drizzle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAGrD,OAAO,KAAK,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAK1E,UAAU,kBAAkB;IAC1B,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CAChD;AAED,UAAU,4BAA4B;IACpC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,MAAM,EAAE;QACN,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,SAAS,GAAG,UAAU,GAAG,WAAW,CAAC;KAC9C,CAAC;IACF,SAAS,EAAE;QACT,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,OAAO,GAAG,WAAW,CAAC;KAC/B,CAAC;CACH;AAED,UAAU,yBAAyB;IACjC,4BAA4B,CAAC,EAAE,MAAM,4BAA4B,CAAC;IAClE,OAAO,CAAC,EAAE,MAAM,kBAAkB,GAAG,OAAO,CAAC;CAC9C;AAED,gEAAgE;AAChE,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,EAAE,kBAAkB,CAAC;IAC9B,cAAc,CAAC,EAAE,yBAAyB,CAAC;IAC3C,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;AA8DD;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,GAAE,6BAAkC,GAAG,eAAe,CAEzG;AAED;;;;;GAKG;AACH,wBAAgB,oCAAoC,CAAC,OAAO,GAAE,IAAI,CAAC,6BAA6B,EAAE,UAAU,GAAG,gBAAgB,CAAM,GAAG,QAAQ,CAgB/I;AAED,iHAAiH;AACjH,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;CAiCzD"}

package/dist/indicators/drizzle.js

@@ -1,5 +1,7 @@
+import { optional } from '@fluojs/di';
 import { createDownResult, createUpResult, resolveIndicatorKey, throwHealthCheckError, withIndicatorTimeout } from './utils.js';
 const DRIZZLE_DATABASE = Symbol.for('fluo.drizzle.database');
+const DRIZZLE_HANDLE_PROVIDER = Symbol.for('fluo.drizzle.handle-provider');
 
 /** Options for probing Drizzle-backed database connectivity. */
 
@@ -10,18 +12,43 @@ async function runDrizzlePing(options) {
     await options.ping();
     return;
   }
-  const database = options.database;
+  const database = options.database ?? resolveCurrentDatabase(options.handleProvider);
   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);
 }
+function resolveCurrentDatabase(handleProvider) {
+  if (!handleProvider || typeof handleProvider.current !== 'function') {
+    return undefined;
+  }
+  return handleProvider.current();
+}
+function createDrizzleLifecycleDownResult(indicatorKey, snapshot) {
+  const healthStatus = snapshot.health.status;
+  const readinessStatus = snapshot.readiness.status;
+  if (healthStatus === 'healthy' && readinessStatus === 'ready') {
+    return undefined;
+  }
+  const message = snapshot.readiness.reason ?? snapshot.health.reason ?? `Drizzle lifecycle reported health=${healthStatus} readiness=${readinessStatus}.`;
+  return createDownResult(indicatorKey, message, {
+    details: snapshot.details,
+    healthStatus,
+    readinessStatus
+  });
+}
+function createDrizzleLifecycleSnapshot(handleProvider) {
+  if (!handleProvider || typeof handleProvider.createPlatformStatusSnapshot !== 'function') {
+    return undefined;
+  }
+  return handleProvider.createPlatformStatusSnapshot();
+}
 
 /**
  * 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.
+ * @param options Optional lifecycle-aware handle provider, database handle, ping callback, timeout, query, and key override.
+ * @returns A health indicator that checks Drizzle lifecycle state before executing a lightweight query.
  */
 export function createDrizzleHealthIndicator(options = {}) {
   return new DrizzleHealthIndicator(options);
@@ -35,16 +62,20 @@ export function createDrizzleHealthIndicator(options = {}) {
  */
 export function createDrizzleHealthIndicatorProvider(options = {}) {
   return {
-    inject: [DRIZZLE_DATABASE],
+    inject: [optional(DRIZZLE_HANDLE_PROVIDER), optional(DRIZZLE_DATABASE)],
     provide: DrizzleHealthIndicator,
-    useFactory: database => new DrizzleHealthIndicator({
-      ...options,
-      database: database
-    })
+    useFactory: (handleProvider, database) => {
+      const resolvedHandleProvider = typeof handleProvider === 'object' && handleProvider !== null ? handleProvider : undefined;
+      return new DrizzleHealthIndicator({
+        ...options,
+        database: database,
+        handleProvider: resolvedHandleProvider
+      });
+    }
   };
 }
 
-/** Health indicator that probes Drizzle connectivity with an execute-capable handle. */
+/** Health indicator that maps Drizzle lifecycle state and probes connectivity with an execute-capable handle. */
 export class DrizzleHealthIndicator {
   key;
   constructor(options = {}) {
@@ -55,9 +86,21 @@ export class DrizzleHealthIndicator {
     const indicatorKey = resolveIndicatorKey('drizzle', this.options.key ?? key);
     const timeoutMs = this.options.timeoutMs ?? DEFAULT_DRIZZLE_TIMEOUT_MS;
     try {
+      const snapshot = createDrizzleLifecycleSnapshot(this.options.handleProvider);
+      const lifecycleDownResult = snapshot ? createDrizzleLifecycleDownResult(indicatorKey, snapshot) : undefined;
+      if (lifecycleDownResult) {
+        throwHealthCheckError('Drizzle health check failed.', lifecycleDownResult);
+      }
       await withIndicatorTimeout(runDrizzlePing(this.options), timeoutMs, indicatorKey);
-      return createUpResult(indicatorKey);
+      return createUpResult(indicatorKey, snapshot ? {
+        details: snapshot.details,
+        healthStatus: snapshot.health.status,
+        readinessStatus: snapshot.readiness.status
+      } : {});
     } catch (error) {
+      if (error instanceof Error && error.name === 'HealthCheckError') {
+        throw error;
+      }
       throwHealthCheckError('Drizzle health check failed.', createDownResult(indicatorKey, error instanceof Error ? error.message : 'Drizzle health check failed.'));
     }
   }

package/dist/module.d.ts

@@ -7,6 +7,8 @@ export declare class TerminusModule {
      *
      * @example
      * ```ts
+     * import { MemoryHealthIndicator } from '@fluojs/terminus/node';
+     *
      * TerminusModule.forRoot({
      *   indicators: [new MemoryHealthIndicator({ key: 'memory' })],
      * });

package/dist/module.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../src/module.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,UAAU,EAGhB,MAAM,iBAAiB,CAAC;AAKzB,OAAO,KAAK,EAA4D,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAuRlH,uFAAuF;AACvF,qBAAa,cAAc;IACzB;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,OAAO,CAAC,OAAO,GAAE,qBAA0B,GAAG,UAAU;CAGhE"}
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../src/module.ts"],"names":[],"mappings":"AAGA,OAAO,EAGL,KAAK,UAAU,EAIhB,MAAM,iBAAiB,CAAC;AAIzB,OAAO,KAAK,EAA4D,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAyQlH,uFAAuF;AACvF,qBAAa,cAAc;IACzB;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,OAAO,CAAC,OAAO,GAAE,qBAA0B,GAAG,UAAU;CAGhE"}

package/dist/module.js

@@ -1,5 +1,4 @@
-import { createHealthModule, defineModule } from '@fluojs/runtime';
-import { PLATFORM_SHELL, RUNTIME_CONTAINER } from '@fluojs/runtime/internal';
+import { defineModule, HealthModule, PLATFORM_SHELL } from '@fluojs/runtime';
 import { TerminusHealthService } from './health-check.js';
 import { TERMINUS_HEALTH_INDICATORS, TERMINUS_INDICATOR_PROVIDER_TOKENS } from './tokens.js';
 const TERMINUS_OPTIONS = Symbol.for('fluo.terminus.options');
@@ -37,18 +36,16 @@ function createTerminusProviders(options = {}) {
     provide: TERMINUS_INDICATOR_PROVIDER_TOKENS,
     useValue: indicatorProviderTokens
   }, {
-    inject: [TERMINUS_OPTIONS, TERMINUS_INDICATOR_PROVIDER_TOKENS, RUNTIME_CONTAINER],
+    inject: [TERMINUS_OPTIONS, ...indicatorProviderTokens],
     provide: TERMINUS_HEALTH_INDICATORS,
-    useFactory: async (resolvedOptions, registeredTokens, runtimeContainer) => {
+    useFactory: (resolvedOptions, ...resolvedProviderIndicators) => {
       const resolvedIndicators = [];
       if (typeof resolvedOptions === 'object' && resolvedOptions !== null && 'indicators' in resolvedOptions) {
         const indicators = resolvedOptions.indicators;
         resolvedIndicators.push(...copyIndicators(indicators));
       }
-      if (runtimeContainer && typeof runtimeContainer === 'object' && runtimeContainer !== null && 'resolve' in runtimeContainer && typeof runtimeContainer.resolve === 'function' && Array.isArray(registeredTokens)) {
-        for (const token of registeredTokens) {
-          resolvedIndicators.push(await runtimeContainer.resolve(token));
-        }
+      for (const providerIndicator of resolvedProviderIndicators) {
+        resolvedIndicators.push(providerIndicator);
       }
       return resolvedIndicators;
     }
@@ -143,7 +140,7 @@ function withPlatformDiagnostics(report, health, readiness) {
 }
 function createTerminusRuntimeModule(options = {}) {
   const readinessChecks = [...(options.readinessChecks ?? [])];
-  const healthModule = createHealthModule({
+  const healthModule = HealthModule.forRoot({
     healthCheck: async ctx => {
       const healthService = await ctx.container.resolve(TerminusHealthService);
       const platformShell = await ctx.container.resolve(PLATFORM_SHELL);
@@ -171,14 +168,14 @@ function createTerminusRuntimeModule(options = {}) {
       path: options.path,
       readinessChecks
     }), {
-      inject: [TerminusHealthService, RUNTIME_CONTAINER],
+      inject: [TerminusHealthService],
       provide: TERMINUS_READINESS_REGISTRAR,
-      useFactory: (...deps) => {
-        const [healthService, runtimeContainer] = deps;
+      useFactory: resolvedHealthService => {
+        const healthService = resolvedHealthService;
         return {
           onApplicationBootstrap() {
-            healthModule.addReadinessCheck(async () => {
-              const platformShell = await runtimeContainer.resolve(PLATFORM_SHELL);
+            healthModule.addReadinessCheck(async ctx => {
+              const platformShell = await ctx.container.resolve(PLATFORM_SHELL);
               const [indicatorHealthy, readiness] = await Promise.all([healthService.isHealthy(), platformShell.ready()]);
               return indicatorHealthy && readiness.status === 'ready';
             });
@@ -196,6 +193,8 @@ export class TerminusModule {
    *
    * @example
    * ```ts
+   * import { MemoryHealthIndicator } from '@fluojs/terminus/node';
+   *
    * TerminusModule.forRoot({
    *   indicators: [new MemoryHealthIndicator({ key: 'memory' })],
    * });

package/dist/node.d.ts

@@ -0,0 +1,3 @@
+export * from './indicators/disk.js';
+export * from './indicators/memory.js';
+//# sourceMappingURL=node.d.ts.map

package/dist/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../src/node.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC"}

package/dist/node.js

@@ -0,0 +1,2 @@
+export * from './indicators/disk.js';
+export * from './indicators/memory.js';

package/package.json

@@ -9,7 +9,7 @@
     "liveness",
     "health-check"
   ],
-  "version": "1.0.0-beta.5",
+  "version": "1.0.0-beta.6",
   "private": false,
   "license": "MIT",
   "repository": {
@@ -29,6 +29,10 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "import": "./dist/node.js"
+    },
     "./redis": {
       "types": "./dist/redis.d.ts",
       "import": "./dist/redis.js"
@@ -40,15 +44,15 @@
     "dist"
   ],
   "dependencies": {
-    "@fluojs/core": "^1.0.0-beta.4",
-    "@fluojs/di": "^1.0.0-beta.6",
+    "@fluojs/runtime": "^1.0.0-beta.12",
     "@fluojs/http": "^1.0.0-beta.10",
-    "@fluojs/runtime": "^1.0.0-beta.11"
+    "@fluojs/core": "^1.0.0-beta.5",
+    "@fluojs/di": "^1.0.0-beta.7"
   },
   "peerDependencies": {
-    "@fluojs/prisma": "^1.0.0-beta.4",
-    "@fluojs/redis": "^1.0.0-beta.3",
-    "@fluojs/drizzle": "^1.0.0-beta.3"
+    "@fluojs/prisma": "^1.0.0-beta.5",
+    "@fluojs/drizzle": "^1.0.0-beta.4",
+    "@fluojs/redis": "^1.0.0-beta.4"
   },
   "peerDependenciesMeta": {
     "@fluojs/drizzle": {