{"version":3,"sources":["../../src/registry.ts","../../src/services/gateways/systemStatusGateway.service.ts","../../src/services/dependencies/cache/redisHealthChecker.service.ts","../../src/utils/logger.ts","../../src/utils/requireEnv.ts","../../src/utils/constants.ts","../../src/services/dependencies/database/postgresqlHealthChecker.service.ts","../../src/services/dependencies/event-broker/rabbitmqHealthChecker.service.ts","../../src/utils/awsSignature.ts","../../src/services/dependencies/warehouse/utils/defaultConstants.ts","../../src/services/dependencies/warehouse/utils/constants.ts","../../src/services/dependencies/warehouse/services/warehouseHealthChecker.service.ts","../../src/utils/checkersMap.ts","../../src/utils/withTimeout.ts","../../src/services/healthCheck.service.ts","../../src/services/runtimeHealth.service.ts","../../src/utils/runtimeHealth.constants.ts","../../src/utils/runtimeHealth.utils.ts","../../src/middleware/runtimeHealth/runtimeHealth.middleware.ts","../../src/interfaces/middleware.interface.ts","../../src/middleware/runtimeHealth/runtimeHealth.express.ts","../../src/middleware/runtimeHealth/runtimeHealth.fastify.ts","../../src/middleware/runtimeHealth/index.ts"],"names":["registered","Set","registerHealthCheck","dependency","deps","Array","isArray","forEach","d","add","getRegisteredHealthChecks","from","clearRegistry","clear","FetchService","SystemStatusGateway","getHealthReport","body","endpoint","data","post","privateDomain","useApiKey","createClient","createLogger","format","transports","combine","timestamp","printf","colorize","logFormat","level","message","baseLogger","Console","formatMessage","context","detail","Error","stack","JSON","stringify","String","logger","info","msg","warn","error","debug","requireEnv","varName","value","process","env","DEFAULT_HEALTH_CHECK_TIMEOUT","OK","FAILED","DEFAULT_HEALTH_STATUS","DEFAULT_SERVICE_NAME_HEADER","HTTP_METHOD_OPTIONS","HTTP_STATUS_TOO_MANY_REQUESTS","RUNTIME_HEALTH_ERROR_REASON","SYSTEM_STATUS_GATEWAY_CONTEXT","DEFAULT_AWS_REGION","AWS_REGION","AWS_DEFAULT_REGION","getNumberFromEnv","envVarName","fallbackValue","rawValue","undefined","parsed","parseInt","Number","isNaN","getBooleanFromEnv","trim","toLowerCase","VOID","QRVEY_PRODUCT_TYPE_ULTRA","isUltraLicense","QRVEY_PRODUCT_TYPE","createRedisClient","redisUrl","url","socket","connectTimeout","connectAndPing","client","connect","ping","closeConnection","quit","RedisHealthChecker","check","NODE_ENV","Client","PG_ENV_VAR","connectAndQuery","query","end","PostgreSQLHealthChecker","connectionString","getRabbitCredentials","user","pass","getRabbitHttpHost","raw","URL","basePath","pathname","replace","protocol","host","buildRabbitHttpConfig","basicAuth","Buffer","toString","authHeader","baseDomain","res","fetch","headers","Authorization","ok","statusText","listConsumers","get","getConsumersSet","map","c","consumer_tag","queue","name","validateQueues","queues","consumerTag","consumersSet","missingQueues","filter","has","length","join","handleConsumersCheck","param","metadata","shouldLoadConsumers","returnConsumersSet","hostName","performCheck","omitPing","status","RabbitMQHealthChecker","fromNodeProviderChain","SignatureV4","Sha256","HttpRequest","signAWSRequest","method","region","service","parsedUrl","request","hostname","port","path","search","credentialsProvider","credentials","signer","sha256","signedRequest","sign","DEFAULT_ES_HEALTH_CPU_USAGE_PERCENT","DEFAULT_ES_HEALTH_JVM_HEAP_PERCENT","DEFAULT_ES_HEALTH_DISK_USAGE_PERCENT","DEFAULT_ES_HEALTH_CIRCUIT_BREAKER_PERCENT","DEFAULT_ES_HEALTH_SEARCH_QUEUE_THRESHOLD","envNumber","fallback","isFinite","DEFAULT_HEALTH_THRESHOLDS","CPU_USAGE_PERCENT","ES_HEALTH_CPU_USAGE_PERCENT","JVM_HEAP_PERCENT","ES_HEALTH_JVM_HEAP_PERCENT","DISK_USAGE_PERCENT","ES_HEALTH_DISK_USAGE_PERCENT","CIRCUIT_BREAKER_PERCENT","ES_HEALTH_CIRCUIT_BREAKER_PERCENT","SEARCH_QUEUE_THRESHOLD","ES_HEALTH_SEARCH_QUEUE_THRESHOLD","CLUSTER_HEALTH_ENDPOINT","NODES_STATS_ENDPOINT","CLUSTER_STATS_ENDPOINT","shouldUseBasicAuth","hasAuthUser","ELASTICSEARCH_AUTH_USER","hasAuthPassword","ELASTICSEARCH_AUTH_PASSWORD","Boolean","getElasticsearchConfig","params","connection","timeout","ELASTICSEARCH_TIMEOUT","authType","username","password","ssl","rejectUnauthorized","useBasicAuth","ELASTICSEARCH_HOST","baseConfig","ELASTICSEARCH_PORT","useAWSAuth","getThresholds","cpuUsagePercent","thresholds","jvmHeapPercent","diskUsagePercent","circuitBreakerPercent","searchQueueThreshold","buildElasticsearchUrl","config","includes","buildRequestHeaders","auth","btoa","fetchElasticsearchData","startsWith","fullUrl","originalTlsReject","NODE_TLS_REJECT_UNAUTHORIZED","response","checkCircuitBreakerPercent","breakers","threshold","breakerTypes","some","type","breaker","breakerObj","estimatedSize","estimated_size_in_bytes","estimated_size","limitSize","limit_size_in_bytes","limit_size","limit","percent","buildEmptyNodeMetrics","circuitBreakersException","threadPoolRejections","searchQueuedRequests","jvmHeapUsagePercent","totalDiskBytes","usedDiskBytes","totalHeapMaxBytes","totalHeapUsedBytes","buildNodeMetrics","cpuSum","jvmHeapSum","diskSum","nodeCount","evaluateNodesMetrics","nodeStats","skipRules","node","os","cpu","jvm","mem","heap_used_percent","heap_max_in_bytes","heap_used_in_bytes","thread_pool","fs","total","used","total_in_bytes","available_in_bytes","bothCriticalChecksDisabled","skipCircuitBreakerCheck","skipThreadPoolCheck","bothConditionsFound","threadPool","rejected","write","bulk","getClusterStats","healthData","nodesStatsData","clusterStatsData","Promise","all","Object","values","nodes","nodeMetrics","clusterName","cluster_name","number_of_nodes","successful","number_of_data_nodes","failed","activePrimaryShards","active_primary_shards","activeShards","active_shards","relocatingShards","relocating_shards","initializingShards","initializing_shards","unassignedShards","unassigned_shards","indicesCount","indices","count","throwError","errorMessage","determineHealthStatus","stats","skipSearchQueueCheck","skipCpuCheck","skipJvmHeapCheck","skipDiskCheck","skipClusterStatusCheck","isClusterUnhealthy","customClusterStatusCheck","handleClusterStatsCheck","clusterStats","returnClusterStats","checkTimestamp","Date","toISOString","ruleError","clusterStatus","cpuUsage","jvmHeapUsage","diskUsage","result","WarehouseHealthChecker","warehouseParams","checkersMap","cache","CacheHealthChecker","database","DatabaseHealthChecker","eventBroker","EventBrokerHealthChecker","warehouse","withTimeout","healthCheckFn","ms","resolve","reject","timeoutId","setTimeout","then","clearTimeout","catch","withTimeoutAndTiming","healthCheckPromise","start","now","durationMs","HealthCheckService","dependencies","selectedDependencies","resolveDependencies","force","tryFetchRemoteHealthReport","results","runDependencyChecks","buildDetails","skip","dep","allSettled","checker","depParams","dependencyParam","mergedParam","err","otherParams","HOSTNAME","details","hasFailure","i","isVoid","reason","v8","monitorEventLoopDelay","RUNTIME_HEALTH_CACHE_SOURCE","computed","cached","in_flight","DEFAULT_RUNTIME_HEALTH_WINDOW_MS","DEFAULT_RUNTIME_HEALTH_THRESHOLDS","cpuPercent","heapPercent","eventLoopDelayMs","DEFAULT_RUNTIME_HEALTH_ENABLED_METRICS","DEFAULT_RUNTIME_HEALTH_LOG_GET","DEFAULT_RUNTIME_HEALTH_CACHE_TTL_MS","wait","bytesToMb","bytes","toFixed","RuntimeHealthService","getMetrics","options","windowMs","enabledMetrics","getEnabledMetrics","getCpuPercent","getEventLoopDelay","heapLimitMb","heapStats","getHeapStatistics","heap_size_limit","memoryUsage","heapUsed","metrics","failedMetrics","evaluateThresholds","runtimeStatus","getStatus","RuntimeHealth","push","directThresholds","startUsage","startTime","hrtime","bigint","endUsage","elapsedMicros","cpuCount","Math","max","cpus","cpuMicros","system","histogram","resolution","enable","disable","mean","handleRuntimeHealth","req","resolvedOptions","resolveStartOptions","isRequestTargeted","getRuntimeHealthStatusWithCache","runtimeOptions","cacheTtlMs","cacheLog","sendJson","source","createRuntimeHealthMiddlewareCacheState","serviceNames","serviceName","getHeaderValue","serviceNameHeader","isRuntimeHealthMiddlewareStartOptions","headerName","isCacheValid","withCacheInfo","cachedStatus","ttlMs","ageMs","cachedAtMs","cachedAt","toISOStringOrUndefined","inFlight","finally","cacheInfo","toMiddlewareRequest","toUpperCase","originalUrl","next","shouldContinue","statusCode","json","reply","done","code","send","RuntimeHealthMiddleware","express","fastify","fastifyStart"],"mappings":"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","sourcesContent":["import { Dependency } from './types';\n\nconst registered: Set<Dependency> = new Set();\n\nexport function registerHealthCheck(\n    dependency: Dependency | Dependency[],\n): void {\n    const deps = Array.isArray(dependency) ? dependency : [dependency];\n    deps.forEach((d) => registered.add(d));\n}\n\nexport function getRegisteredHealthChecks(): Dependency[] {\n    return Array.from(registered);\n}\n\nexport function clearRegistry(): void {\n    registered.clear();\n}\n","import { FetchService } from '@qrvey/fetch';\nimport { HealthCheckResult } from '../../types';\nimport { SystemStatusGatewayPayload } from '../../interfaces/';\n\nexport class SystemStatusGateway {\n    static async getHealthReport(\n        body: SystemStatusGatewayPayload,\n    ): Promise<HealthCheckResult> {\n        const endpoint = `/api/system/v1/status`;\n        const data = await FetchService.post(endpoint, body, {\n            privateDomain: true,\n            useApiKey: true,\n        });\n\n        return data as unknown as Promise<HealthCheckResult>;\n    }\n}\n","import { IHealthChecker } from '../../../interfaces/healthChecker.interface';\nimport { Dependency } from '../../../types';\nimport { createClient, RedisClientType } from 'redis';\nimport { requireEnv } from '../../../utils/requireEnv';\nimport logger from '../../../utils/logger';\nimport { DEFAULT_HEALTH_CHECK_TIMEOUT } from '../../../utils/constants';\n\nfunction createRedisClient(): RedisClientType {\n    const redisUrl = requireEnv('REDIS_URL');\n    return createClient({\n        url: redisUrl,\n        socket: {\n            connectTimeout: DEFAULT_HEALTH_CHECK_TIMEOUT,\n        },\n    });\n}\n\nasync function connectAndPing(client: RedisClientType): Promise<void> {\n    await client.connect();\n    await client.ping();\n}\n\nasync function closeConnection(client: RedisClientType): Promise<void> {\n    try {\n        await client.quit();\n    } catch (error) {\n        logger.warn(\n            '[RedisHealthChecker] Failed to close Redis connection',\n            error,\n        );\n    }\n}\n\nexport const RedisHealthChecker: IHealthChecker = {\n    dependency: 'cache' as Dependency,\n\n    async check() {\n        const client = createRedisClient();\n\n        try {\n            await connectAndPing(client);\n\n            if (process.env.NODE_ENV === 'test') {\n                logger.info('[RedisHealthCheck] check executed successfully');\n            }\n        } catch (error) {\n            logger.error('[RedisHealthChecker] Connection failed', error);\n            throw error;\n        } finally {\n            await closeConnection(client);\n        }\n    },\n};\n","import {\n    createLogger,\n    format,\n    transports,\n    Logger as WinstonLogger,\n} from 'winston';\n\nconst { combine, timestamp, printf, colorize } = format;\n\nconst logFormat = printf(({ level, message, timestamp }) => {\n    return `${timestamp} [${level}]: ${message}`;\n});\n\nconst baseLogger: WinstonLogger = createLogger({\n    level: 'info',\n    format: combine(\n        timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),\n        colorize(),\n        logFormat,\n    ),\n    transports: [new transports.Console()],\n});\n\nfunction formatMessage(context: string, data?: unknown): string {\n    if (!data) return context;\n\n    let detail = '';\n    if (data instanceof Error) {\n        detail = data.stack || data.message;\n    } else if (typeof data === 'object') {\n        try {\n            detail = JSON.stringify(data);\n        } catch {\n            detail = '[Unserializable object]';\n        }\n    } else {\n        detail = String(data);\n    }\n\n    return `${context} ${detail}`;\n}\n\nconst logger = {\n    info: (msg: string, data?: unknown) =>\n        baseLogger.info(formatMessage(msg, data)),\n    warn: (msg: string, data?: unknown) =>\n        baseLogger.warn(formatMessage(msg, data)),\n    error: (msg: string, data?: unknown) =>\n        baseLogger.error(formatMessage(msg, data)),\n    debug: (msg: string, data?: unknown) =>\n        baseLogger.debug(formatMessage(msg, data)),\n};\n\nexport default logger;\n","import logger from '../utils/logger';\n\nexport function requireEnv(varName: string): string {\n    const value = process.env[varName];\n    if (!value) {\n        logger.error(`[HealthCheck] Missing env variable: ${varName}`);\n        throw new Error(\n            `[HealthCheck] Missing required environment variable: ${varName}`,\n        );\n    }\n    return value;\n}\n","import { HealthStatus } from '../types';\n\nexport const DEFAULT_HEALTH_CHECK_TIMEOUT = 5_000;\n\nexport const OK: HealthStatus = 'OK';\nexport const FAILED: HealthStatus = 'FAILED';\nexport const DEFAULT_HEALTH_STATUS = OK;\n\nexport const DEFAULT_SERVICE_NAME_HEADER = 'q-service-name';\n\nexport const HTTP_METHOD_OPTIONS = 'OPTIONS';\nexport const HTTP_STATUS_TOO_MANY_REQUESTS = 429;\nexport const RUNTIME_HEALTH_ERROR_REASON = 'runtime_health_error';\n\nexport const SYSTEM_STATUS_GATEWAY_CONTEXT = 'system_status_gateway';\nexport const DEFAULT_AWS_REGION =\n    process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || 'us-east-1';\n\nexport function getNumberFromEnv(\n    envVarName: string,\n    fallbackValue: number,\n): number {\n    const rawValue = process.env[envVarName];\n    if (rawValue === undefined) return fallbackValue;\n\n    const parsed = parseInt(rawValue, 10);\n    return Number.isNaN(parsed) || parsed < 0 ? fallbackValue : parsed;\n}\n\nexport function getBooleanFromEnv(\n    envVarName: string,\n    fallbackValue: boolean,\n): boolean {\n    const rawValue = process.env[envVarName];\n    if (rawValue === undefined) return fallbackValue;\n\n    return rawValue.trim().toLowerCase() !== 'false';\n}\n\nexport const VOID: HealthStatus = 'VOID';\n\nexport const QRVEY_PRODUCT_TYPE_ULTRA = 'A3';\n\nexport function isUltraLicense(): boolean {\n    return process.env.QRVEY_PRODUCT_TYPE === QRVEY_PRODUCT_TYPE_ULTRA;\n}\n","import { IHealthChecker } from '../../../interfaces/healthChecker.interface';\nimport { Dependency } from '../../../types';\nimport { requireEnv } from '../../../utils/requireEnv';\nimport { Client } from 'pg';\nimport logger from '../../../utils/logger';\n\nconst PG_ENV_VAR = 'MULTIPLATFORM_PG_CONNECTION_STRING';\n\nasync function connectAndQuery(client: Client): Promise<void> {\n    await client.connect();\n    await client.query('SELECT 1');\n}\n\nasync function closeConnection(client: Client): Promise<void> {\n    try {\n        await client.end();\n    } catch (error) {\n        logger.warn(\n            '[PostgreSQLHealthChecker] Failed to close connection',\n            error,\n        );\n    }\n}\n\nexport const PostgreSQLHealthChecker: IHealthChecker = {\n    dependency: 'database' as Dependency,\n\n    async check() {\n        const connectionString = requireEnv(PG_ENV_VAR);\n        const client = new Client({ connectionString });\n\n        try {\n            await connectAndQuery(client);\n\n            if (process.env.NODE_ENV === 'test') {\n                logger.info(\n                    '[PostgreSQLHealthChecker] check executed successfully',\n                );\n            }\n        } catch (error) {\n            logger.error(\n                '[PostgreSQLHealthChecker] Failed to connect or query',\n                error,\n            );\n            throw error;\n        } finally {\n            await closeConnection(client);\n        }\n    },\n};\n","import { IHealthChecker } from '../../../interfaces/healthChecker.interface';\nimport { Dependency, EventBrokerHealthCheckerResult } from '../../../types';\nimport { requireEnv } from '../../../utils/requireEnv';\nimport logger from '../../../utils/logger';\nimport { IEventBrokerParams } from '../../../interfaces';\nimport { FetchService } from '@qrvey/fetch';\nimport { OK } from '../../../utils/constants';\n\nfunction getRabbitCredentials() {\n    const user = requireEnv('RABBITMQ_USER');\n    const pass = requireEnv('RABBITMQ_PASSWORD');\n    return { user, pass };\n}\n\nexport function getRabbitHttpHost(): string {\n    const raw = requireEnv('RABBITMQ_HTTP_HOST');\n    const url = new URL(raw);\n    const basePath = url.pathname.replace(/\\/$/, '');\n    return `${url.protocol}//${url.host}${basePath}`;\n}\n\nfunction buildRabbitHttpConfig() {\n    const { user, pass } = getRabbitCredentials();\n    const basicAuth = Buffer.from(`${user}:${pass}`).toString('base64');\n    const authHeader = `Basic ${basicAuth}`;\n\n    return {\n        baseDomain: getRabbitHttpHost(),\n        authHeader,\n    };\n}\n\nasync function ping(): Promise<void> {\n    const { baseDomain, authHeader } = buildRabbitHttpConfig();\n    const res = await fetch(`${baseDomain}/api/overview`, {\n        headers: { Authorization: authHeader },\n    });\n\n    if (!res.ok) {\n        throw new Error(\n            `[RabbitMQHealthChecker] Management API ping failed: ${res.statusText}`,\n        );\n    }\n}\n\nfunction listConsumers(): Promise<any> {\n    const { baseDomain, authHeader } = buildRabbitHttpConfig();\n    return FetchService.get('/api/consumers', {\n        baseDomain,\n        headers: { Authorization: authHeader },\n    });\n}\n\nasync function getConsumersSet(): Promise<Set<string>> {\n    return new Set(\n        (await listConsumers()).map(\n            (c: any) => `${c?.consumer_tag ?? ''}::${c?.queue?.name ?? ''}`,\n        ),\n    );\n}\n\nasync function validateQueues(\n    queues: string[],\n    consumerTag: string,\n    consumersSet: Set<string>,\n): Promise<void> {\n    const missingQueues = queues.filter(\n        (queue) => !consumersSet.has(`${consumerTag}::${queue}`),\n    );\n\n    if (missingQueues.length > 0) {\n        throw new Error(\n            `[RabbitMQHealthChecker] Missing subscriptions for queues: ${missingQueues.join(\n                ', ',\n            )} for consumerTag ${consumerTag}`,\n        );\n    }\n}\n\nasync function handleConsumersCheck(\n    param: IEventBrokerParams | undefined,\n    metadata: EventBrokerHealthCheckerResult['metadata'],\n): Promise<void> {\n    const shouldLoadConsumers =\n        param?.queues?.length || param?.returnConsumersSet;\n\n    if (!shouldLoadConsumers) return;\n\n    const consumersSet = param?.consumersSet ?? (await getConsumersSet());\n\n    if (param?.queues?.length) {\n        const consumerTag = param.hostName ?? requireEnv('HOSTNAME');\n        await validateQueues(param.queues, consumerTag, consumersSet);\n    }\n\n    if (param?.returnConsumersSet) {\n        metadata.consumersSet = consumersSet;\n    }\n}\n\nasync function performCheck(\n    param?: IEventBrokerParams,\n): Promise<EventBrokerHealthCheckerResult> {\n    const metadata: EventBrokerHealthCheckerResult['metadata'] = {};\n\n    if (!param?.omitPing) await ping();\n\n    await handleConsumersCheck(param, metadata);\n\n    if (process.env.NODE_ENV === 'test') {\n        logger.info('[RabbitMQHealthChecker] check executed successfully');\n    }\n\n    return { status: OK, metadata };\n}\n\nexport const RabbitMQHealthChecker: IHealthChecker<EventBrokerHealthCheckerResult> =\n    {\n        dependency: 'eventBroker' as Dependency,\n\n        async check(\n            param?: IEventBrokerParams,\n        ): Promise<EventBrokerHealthCheckerResult> {\n            try {\n                return await performCheck(param);\n            } catch (error) {\n                logger.error(\n                    '[RabbitMQHealthChecker] Health check failed',\n                    error,\n                );\n                throw error;\n            }\n        },\n    };\n","import { fromNodeProviderChain } from '@aws-sdk/credential-providers';\nimport { SignatureV4 } from '@smithy/signature-v4';\nimport { Sha256 } from '@aws-crypto/sha256-js';\nimport { HttpRequest } from '@smithy/protocol-http';\nimport { DEFAULT_AWS_REGION } from '../utils/constants';\n\nexport async function signAWSRequest(\n    url: string,\n    method: string = 'GET',\n    body?: string,\n    region: string = DEFAULT_AWS_REGION,\n    service: string = 'es',\n): Promise<Record<string, string>> {\n    try {\n        const parsedUrl = new URL(url);\n        const request = new HttpRequest({\n            method,\n            protocol: parsedUrl.protocol,\n            hostname: parsedUrl.hostname,\n            port: parsedUrl.port ? Number(parsedUrl.port) : undefined,\n            path: parsedUrl.pathname + parsedUrl.search,\n            headers: {\n                'Content-Type': 'application/json',\n                host: parsedUrl.hostname,\n            },\n            body,\n        });\n\n        // Get AWS credentials using fromNodeProviderChain\n        // This automatically checks:\n        // 1. Environment variables (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_SESSION_TOKEN)\n        // 2. ~/.aws/credentials file\n        // 3. IAM roles (EC2 instance profile, ECS task role, etc.)\n        // 4. AWS SSO\n        const credentialsProvider = fromNodeProviderChain();\n        const credentials = await credentialsProvider();\n\n        const signer = new SignatureV4({\n            credentials,\n            region,\n            service,\n            sha256: Sha256,\n        });\n        const signedRequest = await signer.sign(request);\n\n        return signedRequest.headers as Record<string, string>;\n    } catch (error) {\n        throw new Error(\n            `Failed to sign AWS request: ${\n                error instanceof Error ? error.message : 'Unknown error'\n            }`,\n        );\n    }\n}\n","const DEFAULT_ES_HEALTH_CPU_USAGE_PERCENT = 95;\nconst DEFAULT_ES_HEALTH_JVM_HEAP_PERCENT = 90;\nconst DEFAULT_ES_HEALTH_DISK_USAGE_PERCENT = 90;\nconst DEFAULT_ES_HEALTH_CIRCUIT_BREAKER_PERCENT = 80;\nconst DEFAULT_ES_HEALTH_SEARCH_QUEUE_THRESHOLD = 1;\n\nconst envNumber = (value: string | undefined, fallback: number): number => {\n    const parsed = Number(value);\n    return Number.isFinite(parsed) ? parsed : fallback;\n};\n\nexport const DEFAULT_HEALTH_THRESHOLDS = {\n    CPU_USAGE_PERCENT: envNumber(\n        process.env.ES_HEALTH_CPU_USAGE_PERCENT,\n        DEFAULT_ES_HEALTH_CPU_USAGE_PERCENT,\n    ),\n    JVM_HEAP_PERCENT: envNumber(\n        process.env.ES_HEALTH_JVM_HEAP_PERCENT,\n        DEFAULT_ES_HEALTH_JVM_HEAP_PERCENT,\n    ),\n    DISK_USAGE_PERCENT: envNumber(\n        process.env.ES_HEALTH_DISK_USAGE_PERCENT,\n        DEFAULT_ES_HEALTH_DISK_USAGE_PERCENT,\n    ),\n    CIRCUIT_BREAKER_PERCENT: envNumber(\n        process.env.ES_HEALTH_CIRCUIT_BREAKER_PERCENT,\n        DEFAULT_ES_HEALTH_CIRCUIT_BREAKER_PERCENT,\n    ),\n    SEARCH_QUEUE_THRESHOLD: envNumber(\n        process.env.ES_HEALTH_SEARCH_QUEUE_THRESHOLD,\n        DEFAULT_ES_HEALTH_SEARCH_QUEUE_THRESHOLD,\n    ),\n} as const;\n","export const CLUSTER_HEALTH_ENDPOINT = '/_cluster/health';\nexport const NODES_STATS_ENDPOINT = '/_nodes/stats';\nexport const CLUSTER_STATS_ENDPOINT = '/_cluster/stats';\n","import { IHealthChecker } from '../../../../interfaces/healthChecker.interface';\nimport { IWarehouseHealthCheckerParams } from '../../../../interfaces/warehouseHealthCheckerParams.interface';\nimport {\n    Dependency,\n    HealthStatus,\n    WarehouseHealthCheckerResult,\n    ElasticsearchClusterStats,\n    DependencyHealthCheckerParams,\n} from '../../../../types';\nimport logger from '../../../../utils/logger';\nimport { FAILED, VOID, isUltraLicense } from '../../../../utils/constants';\nimport { signAWSRequest } from '../../../../utils/awsSignature';\nimport {\n    IElasticsearchClusterStatsResponse,\n    IElasticsearchConnection,\n    IElasticsearchHealthResponse,\n    IElasticsearchNodesStatsResponse,\n    IElasticsearchNodeStats,\n} from '../interfaces';\nimport { DEFAULT_HEALTH_THRESHOLDS } from '../utils/defaultConstants';\nimport {\n    CLUSTER_HEALTH_ENDPOINT,\n    CLUSTER_STATS_ENDPOINT,\n    NODES_STATS_ENDPOINT,\n} from '../utils/constants';\nimport { FetchService } from '@qrvey/fetch';\n\nfunction shouldUseBasicAuth(): boolean {\n    const hasAuthUser = process.env.ELASTICSEARCH_AUTH_USER?.trim();\n    const hasAuthPassword = process.env.ELASTICSEARCH_AUTH_PASSWORD?.trim();\n    return Boolean(hasAuthUser && hasAuthPassword);\n}\n\nexport function getElasticsearchConfig(\n    params?: IWarehouseHealthCheckerParams,\n): IElasticsearchConnection {\n    if (params?.connection?.host) {\n        return {\n            host: params.connection.host,\n            port: params.connection.port,\n            timeout:\n                params.connection.timeout ||\n                parseInt(process.env.ELASTICSEARCH_TIMEOUT || '5000', 10),\n            authType: 'basic',\n            username: params.connection.username,\n            password: params.connection.password,\n            ssl: { rejectUnauthorized: false },\n        };\n    }\n\n    // ElasticView Logic: Basic Auth vs AWS\n    const useBasicAuth = shouldUseBasicAuth();\n    const host = process.env.ELASTICSEARCH_HOST ?? '';\n\n    const baseConfig = {\n        host,\n        port: parseInt(process.env.ELASTICSEARCH_PORT || '9200', 10),\n        timeout: parseInt(process.env.ELASTICSEARCH_TIMEOUT || '5000', 10),\n    };\n\n    if (useBasicAuth) {\n        return {\n            ...baseConfig,\n            authType: 'basic',\n            username: process.env.ELASTICSEARCH_AUTH_USER,\n            password: process.env.ELASTICSEARCH_AUTH_PASSWORD,\n            ssl: { rejectUnauthorized: false },\n        };\n    }\n\n    // AWS/IRSA (OpenSearch)\n    return {\n        ...baseConfig,\n        authType: 'aws',\n        useAWSAuth: true,\n    };\n}\n\nfunction getThresholds(params?: IWarehouseHealthCheckerParams) {\n    return {\n        cpuUsagePercent:\n            params?.thresholds?.cpuUsagePercent ??\n            DEFAULT_HEALTH_THRESHOLDS.CPU_USAGE_PERCENT,\n        jvmHeapPercent:\n            params?.thresholds?.jvmHeapPercent ??\n            DEFAULT_HEALTH_THRESHOLDS.JVM_HEAP_PERCENT,\n        diskUsagePercent:\n            params?.thresholds?.diskUsagePercent ??\n            DEFAULT_HEALTH_THRESHOLDS.DISK_USAGE_PERCENT,\n        circuitBreakerPercent:\n            params?.thresholds?.circuitBreakerPercent ??\n            DEFAULT_HEALTH_THRESHOLDS.CIRCUIT_BREAKER_PERCENT,\n        searchQueueThreshold:\n            params?.thresholds?.searchQueueThreshold ??\n            DEFAULT_HEALTH_THRESHOLDS.SEARCH_QUEUE_THRESHOLD,\n    };\n}\n\nfunction buildElasticsearchUrl(config: IElasticsearchConnection): string {\n    if (config.host.includes(':') || !config.port) {\n        return config.host;\n    }\n\n    return `${config.host}:${config.port}`;\n}\n\nfunction buildRequestHeaders(config: IElasticsearchConnection): HeadersInit {\n    const headers: HeadersInit = {\n        'Content-Type': 'application/json',\n    };\n\n    if (config.authType === 'basic' && config.username && config.password) {\n        const auth = btoa(`${config.username}:${config.password}`);\n        headers['Authorization'] = `Basic ${auth}`;\n    }\n\n    return headers;\n}\n\nasync function fetchElasticsearchData<T>(\n    config: IElasticsearchConnection,\n    endpoint: string,\n): Promise<T> {\n    const baseDomain = buildElasticsearchUrl(config);\n    let headers: Record<string, string>;\n    const useAWSAuth = config.authType === 'aws' || config.useAWSAuth === true;\n\n    if (useAWSAuth) {\n        const protocol = config.host.startsWith('https://') ? '' : 'https://';\n        const fullUrl = `${protocol}${baseDomain}${endpoint}`;\n        headers = await signAWSRequest(fullUrl);\n    } else {\n        headers = buildRequestHeaders(config) as Record<string, string>;\n    }\n\n    const originalTlsReject = process.env.NODE_TLS_REJECT_UNAUTHORIZED;\n    if (config.ssl?.rejectUnauthorized === false) {\n        process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';\n    }\n\n    try {\n        const response = await FetchService.get(endpoint, {\n            baseDomain,\n            headers,\n        });\n        return response as T;\n    } catch (error) {\n        logger.error(\n            `[WarehouseHealthChecker] Request failed to ${endpoint}`,\n            error,\n        );\n        throw error;\n    } finally {\n        // Restore original TLS setting\n        if (config.ssl?.rejectUnauthorized === false) {\n            if (originalTlsReject === undefined) {\n                delete process.env.NODE_TLS_REJECT_UNAUTHORIZED;\n            } else {\n                process.env.NODE_TLS_REJECT_UNAUTHORIZED = originalTlsReject;\n            }\n        }\n    }\n}\n\nfunction checkCircuitBreakerPercent(\n    breakers: IElasticsearchNodeStats['breakers'],\n    threshold: number = DEFAULT_HEALTH_THRESHOLDS.CIRCUIT_BREAKER_PERCENT,\n): boolean {\n    if (!breakers) return false;\n\n    const breakerTypes = [\n        'parent',\n        'request',\n        'fielddata',\n        'in_flight_requests',\n    ];\n\n    return breakerTypes.some((type) => {\n        const breaker = breakers?.[type as keyof typeof breakers];\n        if (!breaker || typeof breaker !== 'object') return false;\n\n        const breakerObj = breaker as Record<string, unknown>;\n        const estimatedSize =\n            (breakerObj.estimated_size_in_bytes as number) ||\n            (breakerObj.estimated_size as number) ||\n            0;\n        const limitSize =\n            (breakerObj.limit_size_in_bytes as number) ||\n            (breakerObj.limit_size as number) ||\n            (breakerObj.limit as number) ||\n            1;\n\n        const percent = (estimatedSize / limitSize) * 100;\n        return percent > threshold;\n    });\n}\n\nfunction buildEmptyNodeMetrics() {\n    return {\n        circuitBreakersException: false,\n        threadPoolRejections: false,\n        searchQueuedRequests: 0,\n        cpuUsagePercent: 0,\n        jvmHeapUsagePercent: 0,\n        diskUsagePercent: 0,\n        totalDiskBytes: 0,\n        usedDiskBytes: 0,\n        totalHeapMaxBytes: 0,\n        totalHeapUsedBytes: 0,\n    };\n}\n\nfunction buildNodeMetrics({\n    circuitBreakersException,\n    threadPoolRejections,\n    searchQueuedRequests,\n    cpuSum,\n    jvmHeapSum,\n    diskSum,\n    nodeCount,\n    totalDiskBytes,\n    usedDiskBytes,\n    totalHeapMaxBytes,\n    totalHeapUsedBytes,\n}: {\n    circuitBreakersException: boolean;\n    threadPoolRejections: boolean;\n    searchQueuedRequests: number;\n    cpuSum: number;\n    jvmHeapSum: number;\n    diskSum: number;\n    nodeCount: number;\n    totalDiskBytes: number;\n    usedDiskBytes: number;\n    totalHeapMaxBytes: number;\n    totalHeapUsedBytes: number;\n}) {\n    return {\n        circuitBreakersException,\n        threadPoolRejections,\n        searchQueuedRequests,\n        cpuUsagePercent: cpuSum / nodeCount,\n        jvmHeapUsagePercent: jvmHeapSum / nodeCount,\n        diskUsagePercent: diskSum / nodeCount,\n        totalDiskBytes,\n        usedDiskBytes,\n        totalHeapMaxBytes,\n        totalHeapUsedBytes,\n    };\n}\n\nfunction evaluateNodesMetrics(\n    nodeStats: IElasticsearchNodeStats[],\n    params?: IWarehouseHealthCheckerParams,\n) {\n    if (nodeStats.length === 0) {\n        return buildEmptyNodeMetrics();\n    }\n\n    const thresholds = getThresholds(params);\n    const skipRules = params?.skipRules || {};\n\n    let circuitBreakersException = false;\n    let threadPoolRejections = false;\n    let searchQueuedRequests = 0;\n    let cpuSum = 0;\n    let jvmHeapSum = 0;\n    let diskSum = 0;\n    let totalDiskBytes = 0;\n    let usedDiskBytes = 0;\n    let totalHeapMaxBytes = 0;\n    let totalHeapUsedBytes = 0;\n\n    for (const node of nodeStats) {\n        cpuSum += node.os?.cpu?.percent || 0;\n        jvmHeapSum += node.jvm?.mem?.heap_used_percent || 0;\n        totalHeapMaxBytes += node.jvm?.mem?.heap_max_in_bytes || 0;\n        totalHeapUsedBytes += node.jvm?.mem?.heap_used_in_bytes || 0;\n\n        searchQueuedRequests += node.thread_pool?.search?.queue || 0;\n\n        const fs = node.fs?.total;\n        if (fs) {\n            const used = fs.total_in_bytes - fs.available_in_bytes;\n            diskSum += (used / fs.total_in_bytes) * 100;\n            totalDiskBytes += fs.total_in_bytes;\n            usedDiskBytes += used;\n        }\n\n        const bothCriticalChecksDisabled =\n            skipRules.skipCircuitBreakerCheck && skipRules.skipThreadPoolCheck;\n\n        const bothConditionsFound =\n            circuitBreakersException && threadPoolRejections;\n\n        if (bothCriticalChecksDisabled || bothConditionsFound) {\n            continue;\n        }\n\n        if (!circuitBreakersException && !skipRules.skipCircuitBreakerCheck) {\n            circuitBreakersException = checkCircuitBreakerPercent(\n                node.breakers,\n                thresholds.circuitBreakerPercent,\n            );\n        }\n\n        if (!threadPoolRejections && !skipRules.skipThreadPoolCheck) {\n            const threadPool = node.thread_pool;\n            // rejected is cumulative since node start; require current queue pressure\n            // to avoid failing on historical spikes when the cluster is currently idle.\n            threadPoolRejections =\n                ((threadPool?.search?.rejected || 0) > 0 &&\n                    (threadPool?.search?.queue || 0) > 0) ||\n                ((threadPool?.write?.rejected || 0) > 0 &&\n                    (threadPool?.write?.queue || 0) > 0) ||\n                ((threadPool?.bulk?.rejected || 0) > 0 &&\n                    (threadPool?.bulk?.queue || 0) > 0);\n        }\n    }\n\n    const nodeCount = nodeStats.length;\n    return buildNodeMetrics({\n        circuitBreakersException,\n        threadPoolRejections,\n        searchQueuedRequests,\n        cpuSum,\n        jvmHeapSum,\n        diskSum,\n        nodeCount,\n        totalDiskBytes,\n        usedDiskBytes,\n        totalHeapMaxBytes,\n        totalHeapUsedBytes,\n    });\n}\n\nexport async function getClusterStats(\n    config: IElasticsearchConnection,\n    params?: IWarehouseHealthCheckerParams,\n): Promise<ElasticsearchClusterStats> {\n    try {\n        const [healthData, nodesStatsData, clusterStatsData] =\n            await Promise.all([\n                fetchElasticsearchData<IElasticsearchHealthResponse>(\n                    config,\n                    CLUSTER_HEALTH_ENDPOINT,\n                ),\n                fetchElasticsearchData<IElasticsearchNodesStatsResponse>(\n                    config,\n                    NODES_STATS_ENDPOINT,\n                ),\n                fetchElasticsearchData<IElasticsearchClusterStatsResponse>(\n                    config,\n                    CLUSTER_STATS_ENDPOINT,\n                ),\n            ]);\n\n        const nodeStats: IElasticsearchNodeStats[] = Object.values(\n            nodesStatsData.nodes || {},\n        );\n\n        const nodeMetrics = evaluateNodesMetrics(nodeStats, params);\n\n        return {\n            clusterName: healthData.cluster_name || 'unknown',\n            status: healthData.status || 'red',\n            nodes: {\n                total: healthData.number_of_nodes || 0,\n                successful: healthData.number_of_data_nodes || 0,\n                failed: 0,\n            },\n            cpuUsagePercent: nodeMetrics.cpuUsagePercent,\n            jvmHeapUsagePercent: nodeMetrics.jvmHeapUsagePercent,\n            diskUsagePercent: nodeMetrics.diskUsagePercent,\n            activePrimaryShards: healthData.active_primary_shards || 0,\n            activeShards: healthData.active_shards || 0,\n            relocatingShards: healthData.relocating_shards || 0,\n            initializingShards: healthData.initializing_shards || 0,\n            unassignedShards: healthData.unassigned_shards || 0,\n            circuitBreakersException: nodeMetrics.circuitBreakersException,\n            threadPoolRejections: nodeMetrics.threadPoolRejections,\n            searchQueuedRequests: nodeMetrics.searchQueuedRequests,\n            indicesCount: clusterStatsData?.indices?.count ?? undefined,\n            totalDiskBytes: nodeMetrics.totalDiskBytes,\n            usedDiskBytes: nodeMetrics.usedDiskBytes,\n            totalHeapMaxBytes: nodeMetrics.totalHeapMaxBytes,\n            totalHeapUsedBytes: nodeMetrics.totalHeapUsedBytes,\n        };\n    } catch (error) {\n        logger.error(\n            '[WarehouseHealthChecker] Error fetching cluster stats',\n            error,\n        );\n        throw error;\n    }\n}\n\nfunction throwError(errorMessage: string) {\n    const message = JSON.stringify(errorMessage, null, 2);\n    logger.error(message);\n    throw new Error(message);\n}\n\nfunction determineHealthStatus(\n    stats: ElasticsearchClusterStats,\n    params?: IWarehouseHealthCheckerParams,\n): HealthStatus {\n    const skipRules = params?.skipRules || {};\n    const thresholds = getThresholds(params);\n\n    if (!skipRules.skipCircuitBreakerCheck && stats.circuitBreakersException) {\n        throwError(\n            `Circuit breakers near limit (ratio > ${thresholds.circuitBreakerPercent}%) - cluster at risk`,\n        );\n    }\n\n    if (!skipRules.skipThreadPoolCheck && stats.threadPoolRejections) {\n        throwError('Thread pools rejecting requests - cluster saturated');\n    }\n\n    if (\n        !skipRules.skipSearchQueueCheck &&\n        stats.searchQueuedRequests >= thresholds.searchQueueThreshold\n    ) {\n        throwError(\n            `Search requests queuing up: ${stats.searchQueuedRequests} queued (threshold: ${thresholds.searchQueueThreshold}) - warehouse destabilizing`,\n        );\n    }\n\n    if (\n        !skipRules.skipCpuCheck &&\n        stats.cpuUsagePercent >= thresholds.cpuUsagePercent\n    ) {\n        throwError(\n            `High CPU usage: ${stats.cpuUsagePercent}% (threshold: ${thresholds.cpuUsagePercent}%)`,\n        );\n    }\n\n    if (\n        !skipRules.skipJvmHeapCheck &&\n        stats.jvmHeapUsagePercent >= thresholds.jvmHeapPercent\n    ) {\n        throwError(\n            `High JVM heap usage: ${stats.jvmHeapUsagePercent}% (threshold: ${thresholds.jvmHeapPercent}%)`,\n        );\n    }\n\n    if (\n        !skipRules.skipDiskCheck &&\n        stats.diskUsagePercent >= thresholds.diskUsagePercent\n    ) {\n        throwError(\n            `High disk usage: ${stats.diskUsagePercent}% (threshold: ${thresholds.diskUsagePercent}%)`,\n        );\n    }\n\n    if (!skipRules.skipClusterStatusCheck) {\n        const isClusterUnhealthy = params?.customClusterStatusCheck\n            ? !params.customClusterStatusCheck(stats.status)\n            : stats.status === 'red';\n\n        if (isClusterUnhealthy) {\n            throwError(`Cluster status is ${stats.status}`);\n        }\n    }\n\n    // if (!skipRules.skipUnassignedShardsCheck) {\n    //     const hasUnassignedShards = params?.customUnassignedShardsCheck\n    //         ? !params.customUnassignedShardsCheck(stats.unassignedShards)\n    //         : stats.unassignedShards > 0;\n\n    //     if (hasUnassignedShards) {\n    //         const message = `Unassigned shards: ${stats.unassignedShards}`;\n    //         logger.warn(message);\n    //         throw new Error(message);\n    //     }\n    // }\n\n    return 'OK';\n}\n\nasync function handleClusterStatsCheck(\n    params: IWarehouseHealthCheckerParams | undefined,\n    config: IElasticsearchConnection,\n    metadata: WarehouseHealthCheckerResult['metadata'],\n): Promise<ElasticsearchClusterStats> {\n    const clusterStats =\n        params?.clusterStats ?? (await getClusterStats(config, params));\n\n    if (params?.returnClusterStats) {\n        metadata.clusterStats = clusterStats;\n    }\n\n    return clusterStats;\n}\n\nexport async function performCheck(\n    params?: IWarehouseHealthCheckerParams,\n): Promise<WarehouseHealthCheckerResult> {\n    const checkTimestamp = new Date().toISOString();\n\n    try {\n        const config = getElasticsearchConfig(params);\n        const thresholds = getThresholds(params);\n\n        logger.info(\n            '[WarehouseHealthChecker] Starting health check',\n            JSON.stringify(\n                {\n                    host: config.host,\n                    port: config.port,\n                    thresholds,\n                    skipRules: params?.skipRules,\n                },\n                null,\n                2,\n            ),\n        );\n\n        const metadata: WarehouseHealthCheckerResult['metadata'] = {\n            checkTimestamp,\n        };\n\n        const clusterStats = await handleClusterStatsCheck(\n            params,\n            config,\n            metadata,\n        );\n\n        let status: HealthStatus;\n        try {\n            status = determineHealthStatus(clusterStats, params);\n        } catch (ruleError) {\n            const errorMessage =\n                ruleError instanceof Error\n                    ? ruleError.message\n                    : 'Unknown error';\n            logger.warn(\n                '[WarehouseHealthChecker] Check failed but returning cluster stats',\n                {\n                    error: errorMessage,\n                },\n            );\n            if (params?.returnClusterStats && !metadata.clusterStats) {\n                metadata.clusterStats = clusterStats;\n            }\n            metadata.errorMessage = errorMessage;\n            return { status: FAILED, metadata };\n        }\n\n        // eslint-disable-next-line max-len, object-curly-newline, object-property-newline\n        logger.info(\n            `[WarehouseHealthChecker] Health check completed ${JSON.stringify({\n                status,\n                clusterName: clusterStats.clusterName,\n                clusterStatus: clusterStats.status,\n                cpuUsage: clusterStats.cpuUsagePercent,\n                jvmHeapUsage: clusterStats.jvmHeapUsagePercent,\n                diskUsage: clusterStats.diskUsagePercent,\n                circuitBreakersException: clusterStats.circuitBreakersException,\n                threadPoolRejections: clusterStats.threadPoolRejections,\n                searchQueuedRequests: clusterStats.searchQueuedRequests,\n            })}`,\n        );\n\n        const result: WarehouseHealthCheckerResult = {\n            status,\n            metadata,\n        };\n\n        if (params?.returnClusterStats && !metadata.clusterStats) {\n            metadata.clusterStats = clusterStats;\n        }\n\n        return result;\n    } catch (error) {\n        const errorMessage =\n            error instanceof Error ? error.message : 'Unknown error';\n\n        logger.error('[WarehouseHealthChecker] Health check failed', {\n            error: errorMessage,\n            checkTimestamp,\n            params,\n            stack: error instanceof Error ? error.stack : undefined,\n        });\n\n        throw error;\n    }\n}\n\nexport const WarehouseHealthChecker: IHealthChecker<WarehouseHealthCheckerResult> =\n    {\n        dependency: 'warehouse' as Dependency,\n        async check(\n            params?: DependencyHealthCheckerParams,\n        ): Promise<WarehouseHealthCheckerResult> {\n            if (!isUltraLicense()) {\n                return {\n                    status: VOID,\n                    metadata: {\n                        checkTimestamp: new Date().toISOString(),\n                        errorMessage:\n                            'Warehouse is not part of the current product license infrastructure',\n                    },\n                };\n            }\n\n            const warehouseParams = params as\n                | IWarehouseHealthCheckerParams\n                | undefined;\n            try {\n                return await performCheck(warehouseParams);\n            } catch (error) {\n                logger.error(\n                    '[WarehouseHealthChecker] Health check failed',\n                    error,\n                );\n                throw error;\n            }\n        },\n    };\n","import { CacheHealthChecker } from '../services/dependencies/cache';\nimport { DatabaseHealthChecker } from '../services/dependencies/database';\nimport { EventBrokerHealthChecker } from '../services/dependencies/event-broker';\nimport { WarehouseHealthChecker } from '../services/dependencies/warehouse';\nimport { CheckerRegistry } from '../types';\n\nexport const checkersMap: CheckerRegistry = {\n    cache: CacheHealthChecker,\n    database: DatabaseHealthChecker,\n    eventBroker: EventBrokerHealthChecker,\n    warehouse: WarehouseHealthChecker,\n};\n","import { DEFAULT_HEALTH_CHECK_TIMEOUT } from './constants';\nimport logger from './logger';\nimport { HealthCheckExecutionResult } from '../types';\n\nexport function withTimeout<T>(\n    context: string,\n    healthCheckFn: Promise<T>,\n    ms: number = DEFAULT_HEALTH_CHECK_TIMEOUT,\n): Promise<T> {\n    return new Promise((resolve, reject) => {\n        const timeoutId = setTimeout(() => {\n            const message = `[${context}] HealthChecker timeout after ${ms}ms`;\n            logger.error(message);\n            reject(new Error(message));\n        }, ms);\n\n        healthCheckFn\n            .then((value) => {\n                clearTimeout(timeoutId);\n                resolve(value);\n            })\n            .catch((error) => {\n                clearTimeout(timeoutId);\n                reject(error);\n            });\n    });\n}\n\nexport async function withTimeoutAndTiming(\n    context: string,\n    healthCheckPromise: Promise<HealthCheckExecutionResult>,\n    ms: number = DEFAULT_HEALTH_CHECK_TIMEOUT,\n): Promise<{\n    durationMs: number;\n    status?: string;\n    metadata?: Record<string, unknown>;\n}> {\n    const start = Date.now();\n    const result = await withTimeout(context, healthCheckPromise, ms);\n    const durationMs = Date.now() - start;\n\n    const metadata =\n        result && typeof result === 'object' && 'metadata' in result\n            ? result.metadata\n            : undefined;\n\n    const status =\n        result && typeof result === 'object' && 'status' in result\n            ? (result.status as string)\n            : undefined;\n\n    return {\n        durationMs,\n        status,\n        metadata,\n    };\n}\n","import { getRegisteredHealthChecks } from '../registry';\nimport {\n    Dependency,\n    DependencyHealthCheckerParams,\n    HealthCheckerParams,\n    HealthCheckResult,\n    DependencyHealthDetail,\n} from '../types';\nimport { SystemStatusGatewayPayload } from '../interfaces';\n\nimport { SystemStatusGateway } from './gateways/systemStatusGateway.service';\nimport { checkersMap } from '../utils/checkersMap';\nimport {\n    OK,\n    FAILED,\n    VOID,\n    SYSTEM_STATUS_GATEWAY_CONTEXT,\n} from '../utils/constants';\nimport logger from '../utils/logger';\nimport { withTimeout, withTimeoutAndTiming } from '../utils/withTimeout';\n\nexport class HealthCheckService {\n    static async check(\n        dependencies: Dependency[],\n        params: HealthCheckerParams = {},\n    ): Promise<HealthCheckResult> {\n        const selectedDependencies = resolveDependencies(dependencies);\n        if (!params.force) {\n            const result = await tryFetchRemoteHealthReport(\n                selectedDependencies,\n                params,\n            );\n            if (result) return result;\n        }\n\n        const results = await runDependencyChecks(selectedDependencies, params);\n        return buildDetails(selectedDependencies, results);\n    }\n}\n\nfunction resolveDependencies(\n    dependencies?: Dependency[],\n    skip?: string[],\n): Dependency[] {\n    const all = dependencies ?? getRegisteredHealthChecks();\n    return skip ? all.filter((dep) => !skip.includes(dep)) : all;\n}\n\nasync function runDependencyChecks(\n    dependencies: Dependency[],\n    params: HealthCheckerParams = {},\n): Promise<\n    PromiseSettledResult<{\n        durationMs?: number;\n        metadata?: Record<string, unknown>;\n    }>[]\n> {\n    return Promise.allSettled(\n        dependencies.map(async (dep) => {\n            const checker = checkersMap[dep];\n            if (!checker) {\n                const msg = `[HealthCheckService] No checker found for dependency \"${dep}\"`;\n                logger.error(msg);\n                return Promise.reject(new Error(msg));\n            }\n\n            const depParams = params as Partial<\n                Record<Dependency, DependencyHealthCheckerParams>\n            >;\n            const dependencyParam = depParams[dep] ?? {};\n\n            const mergedParam: DependencyHealthCheckerParams = {\n                ...dependencyParam,\n                hostName: params.hostName,\n            };\n\n            try {\n                return await withTimeoutAndTiming(\n                    dep,\n                    checker.check(mergedParam),\n                );\n            } catch (err) {\n                logger.error(`[${dep}] HealthChecker threw an error`, err);\n                return Promise.reject(err);\n            }\n        }),\n    );\n}\n\nasync function tryFetchRemoteHealthReport(\n    dependencies: Dependency[],\n    params: HealthCheckerParams,\n): Promise<HealthCheckResult | null> {\n    try {\n        const { skip = [], force = false, hostName, ...otherParams } = params;\n\n        const body: SystemStatusGatewayPayload = {\n            dependencies,\n            service: hostName ?? (process.env.HOSTNAME || 'unknown'),\n            skip,\n            force,\n            params: otherParams,\n        };\n\n        const result = await withTimeout(\n            SYSTEM_STATUS_GATEWAY_CONTEXT,\n            SystemStatusGateway.getHealthReport(body),\n        );\n        return result;\n    } catch (err) {\n        const message =\n            err instanceof Error\n                ? err.message\n                : 'Unknown error during remote check';\n        logger.warn(\n            `[HealthCheckService] Remote health check fallback triggered: ${message}`,\n        );\n        return null;\n    }\n}\n\nexport function buildDetails(\n    dependencies: Dependency[],\n    results: PromiseSettledResult<{\n        durationMs?: number;\n        status?: string;\n        metadata?: Record<string, unknown>;\n    }>[],\n): HealthCheckResult {\n    const details = {} as Record<Dependency, DependencyHealthDetail>;\n    let hasFailure = false;\n\n    for (let i = 0; i < dependencies.length; i++) {\n        const dep = dependencies[i];\n        const result = results[i];\n\n        if (result.status === 'fulfilled') {\n            const isVoid = result.value.status === VOID;\n            details[dep] = {\n                status: isVoid ? VOID : OK,\n                durationMs: result.value.durationMs,\n                metadata: result.value.metadata ?? {},\n            };\n        } else {\n            details[dep] = {\n                status: FAILED,\n                durationMs: result.reason?.durationMs ?? 0,\n            };\n            hasFailure = true;\n        }\n    }\n\n    return {\n        status: hasFailure ? FAILED : OK,\n        details,\n    };\n}\n","import os from 'os';\nimport v8 from 'v8';\nimport { monitorEventLoopDelay } from 'perf_hooks';\n\nimport { FAILED, OK } from '../utils/constants';\nimport {\n    DEFAULT_RUNTIME_HEALTH_ENABLED_METRICS,\n    DEFAULT_RUNTIME_HEALTH_LOG_GET,\n    DEFAULT_RUNTIME_HEALTH_WINDOW_MS,\n    DEFAULT_RUNTIME_HEALTH_THRESHOLDS,\n} from '../utils/runtimeHealth.constants';\nimport { bytesToMb, wait } from '../utils/runtimeHealth.utils';\nimport logger from '../utils/logger';\nimport {\n    RuntimeHealthEnabledMetrics,\n    RuntimeHealthMetrics,\n    RuntimeHealthOptions,\n    RuntimeHealthResult,\n    RuntimeHealthStatus,\n    RuntimeHealthThresholds,\n} from '../types';\n\nexport class RuntimeHealthService {\n    static async getMetrics(\n        options: RuntimeHealthOptions = {},\n    ): Promise<RuntimeHealthMetrics> {\n        const windowMs = options.windowMs ?? DEFAULT_RUNTIME_HEALTH_WINDOW_MS;\n        const enabledMetrics = getEnabledMetrics();\n\n        const [cpuPercent, eventLoopDelayMs] = await Promise.all([\n            enabledMetrics.cpuPercent ? getCpuPercent(windowMs) : null,\n            enabledMetrics.eventLoopDelayMs\n                ? getEventLoopDelay(windowMs)\n                : null,\n        ]);\n\n        let heapPercent: number | null = null;\n        let heapLimitMb: number | null = null;\n        if (enabledMetrics.heapPercent) {\n            const heapStats = v8.getHeapStatistics();\n            heapLimitMb = bytesToMb(heapStats.heap_size_limit);\n            heapPercent =\n                heapStats.heap_size_limit > 0\n                    ? (process.memoryUsage().heapUsed /\n                          heapStats.heap_size_limit) *\n                      100\n                    : 0;\n        }\n\n        return {\n            cpuPercent,\n            heapPercent,\n            eventLoopDelayMs,\n            heapLimitMb,\n        };\n    }\n\n    static async get(\n        options: RuntimeHealthOptions = {},\n    ): Promise<RuntimeHealthStatus> {\n        const thresholds = getThresholds(options);\n        const enabledMetrics = getEnabledMetrics();\n        const metrics = await this.getMetrics(options);\n        const failedMetrics = evaluateThresholds(\n            metrics,\n            thresholds,\n            enabledMetrics,\n        );\n        const status = failedMetrics.length > 0 ? FAILED : OK;\n        const details: RuntimeHealthResult = {\n            status,\n            metrics,\n            enabledMetrics,\n            thresholds,\n            failedMetrics,\n        };\n\n        const runtimeStatus = {\n            status,\n            details,\n        };\n\n        if (DEFAULT_RUNTIME_HEALTH_LOG_GET) {\n            logger.info('[RuntimeHealthService.get]', runtimeStatus);\n        }\n        return runtimeStatus;\n    }\n\n    static async getStatus(\n        options: RuntimeHealthOptions = {},\n    ): Promise<RuntimeHealthStatus> {\n        return this.get(options);\n    }\n}\n\nexport const RuntimeHealth = RuntimeHealthService;\n\nexport function evaluateThresholds(\n    metrics: RuntimeHealthMetrics,\n    thresholds: RuntimeHealthThresholds,\n    enabledMetrics: RuntimeHealthEnabledMetrics = DEFAULT_RUNTIME_HEALTH_ENABLED_METRICS,\n): string[] {\n    const failedMetrics: string[] = [];\n\n    if (\n        enabledMetrics.cpuPercent &&\n        typeof metrics.cpuPercent === 'number' &&\n        metrics.cpuPercent >= thresholds.cpuPercent\n    ) {\n        failedMetrics.push('cpuPercent');\n    }\n\n    if (\n        enabledMetrics.heapPercent &&\n        typeof metrics.heapPercent === 'number' &&\n        metrics.heapPercent >= thresholds.heapPercent\n    ) {\n        failedMetrics.push('heapPercent');\n    }\n\n    if (\n        enabledMetrics.eventLoopDelayMs &&\n        typeof metrics.eventLoopDelayMs === 'number' &&\n        metrics.eventLoopDelayMs >= thresholds.eventLoopDelayMs\n    ) {\n        failedMetrics.push('eventLoopDelayMs');\n    }\n\n    return failedMetrics;\n}\n\nfunction getEnabledMetrics(): RuntimeHealthEnabledMetrics {\n    return { ...DEFAULT_RUNTIME_HEALTH_ENABLED_METRICS };\n}\n\nfunction getThresholds(\n    options?: RuntimeHealthOptions,\n): RuntimeHealthThresholds {\n    const directThresholds: Partial<RuntimeHealthThresholds> = {};\n    if (typeof options?.cpuPercent === 'number') {\n        directThresholds.cpuPercent = options.cpuPercent;\n    }\n    if (typeof options?.heapPercent === 'number') {\n        directThresholds.heapPercent = options.heapPercent;\n    }\n    if (typeof options?.eventLoopDelayMs === 'number') {\n        directThresholds.eventLoopDelayMs = options.eventLoopDelayMs;\n    }\n\n    return {\n        ...DEFAULT_RUNTIME_HEALTH_THRESHOLDS,\n        ...directThresholds,\n        ...options?.thresholds,\n    };\n}\n\nasync function getCpuPercent(windowMs: number): Promise<number> {\n    const startUsage = process.cpuUsage();\n    const startTime = process.hrtime.bigint();\n    await wait(windowMs);\n    const endUsage = process.cpuUsage(startUsage);\n    const elapsedMicros = Number(process.hrtime.bigint() - startTime) / 1_000;\n    const cpuCount = Math.max(os.cpus().length, 1);\n    const cpuMicros = endUsage.user + endUsage.system;\n\n    if (elapsedMicros <= 0) return 0;\n\n    return (cpuMicros / (elapsedMicros * cpuCount)) * 100;\n}\n\nasync function getEventLoopDelay(windowMs: number): Promise<number> {\n    const histogram = monitorEventLoopDelay({ resolution: 20 });\n    histogram.enable();\n    await wait(windowMs);\n    histogram.disable();\n    return histogram.mean / 1_000_000;\n}\n","import { RuntimeHealthEnabledMetrics, RuntimeHealthThresholds } from '../types';\nimport { getBooleanFromEnv, getNumberFromEnv } from './constants';\n\nexport const RUNTIME_HEALTH_CACHE_SOURCE = {\n    computed: 'computed',\n    cached: 'cached',\n    in_flight: 'in_flight',\n} as const;\n\nexport type RuntimeHealthCacheSource =\n    (typeof RUNTIME_HEALTH_CACHE_SOURCE)[keyof typeof RUNTIME_HEALTH_CACHE_SOURCE];\n\nexport const DEFAULT_RUNTIME_HEALTH_WINDOW_MS = getNumberFromEnv(\n    'RUNTIME_HEALTH_WINDOW_MS',\n    250,\n);\n\nexport const DEFAULT_RUNTIME_HEALTH_THRESHOLDS: RuntimeHealthThresholds = {\n    cpuPercent: getNumberFromEnv('RUNTIME_HEALTH_CPU_PERCENT', 90),\n    heapPercent: getNumberFromEnv('RUNTIME_HEALTH_HEAP_PERCENT', 90),\n    eventLoopDelayMs: getNumberFromEnv(\n        'RUNTIME_HEALTH_EVENT_LOOP_DELAY_MS',\n        200,\n    ),\n};\n\nexport const DEFAULT_RUNTIME_HEALTH_ENABLED_METRICS: RuntimeHealthEnabledMetrics =\n    {\n        cpuPercent: getBooleanFromEnv('RUNTIME_HEALTH_ENABLE_CPU', true),\n        heapPercent: getBooleanFromEnv('RUNTIME_HEALTH_ENABLE_HEAP', true),\n        eventLoopDelayMs: getBooleanFromEnv(\n            'RUNTIME_HEALTH_ENABLE_EVENT_LOOP_DELAY',\n            true,\n        ),\n    };\n\nexport const DEFAULT_RUNTIME_HEALTH_LOG_GET = getBooleanFromEnv(\n    'RUNTIME_HEALTH_LOG_GET',\n    false,\n);\n\nexport const DEFAULT_RUNTIME_HEALTH_CACHE_TTL_MS =\n    getNumberFromEnv('RUNTIME_HEALTH_CACHE_TTL_SECONDS', 3) * 1_000;\n","export function wait(ms: number): Promise<void> {\n    return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\nexport function bytesToMb(bytes: number): number {\n    return Number((bytes / (1024 * 1024)).toFixed(2));\n}\n","import {\n    RuntimeHealthCacheInfo,\n    RuntimeHealthMiddlewareCacheState,\n    RuntimeHealthMiddlewareStartInput,\n    RuntimeHealthMiddlewareStartOptions,\n    RuntimeHealthOptions,\n    RuntimeHealthStatus,\n    ResolvedMiddlewareOptions,\n} from '../../types';\nimport { RuntimeHealthService } from '../../services/runtimeHealth.service';\nimport {\n    DEFAULT_SERVICE_NAME_HEADER,\n    FAILED,\n    HTTP_METHOD_OPTIONS,\n    HTTP_STATUS_TOO_MANY_REQUESTS,\n    RUNTIME_HEALTH_ERROR_REASON,\n} from '../../utils/constants';\nimport {\n    DEFAULT_RUNTIME_HEALTH_CACHE_TTL_MS,\n    DEFAULT_RUNTIME_HEALTH_LOG_GET,\n} from '../../utils/runtimeHealth.constants';\nimport { RUNTIME_HEALTH_CACHE_SOURCE } from '../../utils/runtimeHealth.constants';\nimport logger from '../../utils/logger';\nimport { IMiddlewareRequest, IMiddlewareResponse } from '../../interfaces';\n\nexport const handleRuntimeHealth = async (\n    req: IMiddlewareRequest,\n    res: IMiddlewareResponse,\n    options?: RuntimeHealthMiddlewareStartInput,\n    cache?: RuntimeHealthMiddlewareCacheState,\n): Promise<boolean> => {\n    if (req.method === HTTP_METHOD_OPTIONS) {\n        return true;\n    }\n\n    const resolvedOptions = resolveStartOptions(options);\n    if (!isRequestTargeted(req, resolvedOptions)) {\n        return true;\n    }\n\n    try {\n        const result = await getRuntimeHealthStatusWithCache(\n            resolvedOptions.runtimeOptions,\n            resolvedOptions.cacheTtlMs,\n            cache,\n        );\n        if (result.status === FAILED) {\n            const cacheLog =\n                DEFAULT_RUNTIME_HEALTH_LOG_GET && result.details.cache\n                    ? { cache: result.details.cache }\n                    : {};\n            logger.warn(\n                '[RuntimeHealthMiddleware] RuntimeHealth is unhealthy',\n                {\n                    path: req.path,\n                    method: req.method,\n                    failedMetrics: result.details.failedMetrics,\n                    ...cacheLog,\n                },\n            );\n            res.sendJson(HTTP_STATUS_TOO_MANY_REQUESTS, result);\n            return false;\n        }\n        if (\n            DEFAULT_RUNTIME_HEALTH_LOG_GET &&\n            result.details.cache &&\n            result.details.cache.source !== RUNTIME_HEALTH_CACHE_SOURCE.computed\n        ) {\n            logger.info('[RuntimeHealthMiddleware] RuntimeHealth from cache', {\n                path: req.path,\n                method: req.method,\n                cache: result.details.cache,\n            });\n        }\n        return true;\n    } catch (err) {\n        logger.error('[RuntimeHealthMiddleware] RuntimeHealth check failed', {\n            error: err instanceof Error ? err.message : String(err),\n            path: req.path,\n            method: req.method,\n        });\n        res.sendJson(HTTP_STATUS_TOO_MANY_REQUESTS, {\n            status: FAILED,\n            details: { reason: RUNTIME_HEALTH_ERROR_REASON },\n        });\n        return false;\n    }\n};\n\nexport function createRuntimeHealthMiddlewareCacheState(): RuntimeHealthMiddlewareCacheState {\n    return {};\n}\n\nfunction isRequestTargeted(\n    req: IMiddlewareRequest,\n    resolvedOptions: ResolvedMiddlewareOptions,\n): boolean {\n    if (resolvedOptions.serviceNames.length === 0) {\n        return true;\n    }\n    const serviceName = getHeaderValue(\n        req.headers,\n        resolvedOptions.serviceNameHeader,\n    );\n    return !!serviceName && resolvedOptions.serviceNames.includes(serviceName);\n}\n\nfunction resolveStartOptions(\n    options?: RuntimeHealthMiddlewareStartInput,\n): ResolvedMiddlewareOptions {\n    if (!options) {\n        return {\n            runtimeOptions: undefined,\n            serviceNames: [],\n            serviceNameHeader: DEFAULT_SERVICE_NAME_HEADER,\n            cacheTtlMs: DEFAULT_RUNTIME_HEALTH_CACHE_TTL_MS,\n        };\n    }\n\n    if (isRuntimeHealthMiddlewareStartOptions(options)) {\n        return {\n            runtimeOptions: options.runtimeOptions,\n            serviceNames: options.serviceNames ?? [],\n            serviceNameHeader:\n                options.serviceNameHeader?.toLowerCase() ??\n                DEFAULT_SERVICE_NAME_HEADER,\n            cacheTtlMs:\n                options.cacheTtlMs ?? DEFAULT_RUNTIME_HEALTH_CACHE_TTL_MS,\n        };\n    }\n\n    return {\n        runtimeOptions: options,\n        serviceNames: [],\n        serviceNameHeader: DEFAULT_SERVICE_NAME_HEADER,\n        cacheTtlMs: DEFAULT_RUNTIME_HEALTH_CACHE_TTL_MS,\n    };\n}\n\nfunction isRuntimeHealthMiddlewareStartOptions(\n    options: RuntimeHealthMiddlewareStartInput,\n): options is RuntimeHealthMiddlewareStartOptions {\n    return (\n        'runtimeOptions' in options ||\n        'serviceNames' in options ||\n        'serviceNameHeader' in options ||\n        'cacheTtlMs' in options\n    );\n}\n\nfunction getHeaderValue(\n    headers: Record<string, string | string[] | undefined>,\n    headerName: string,\n): string | undefined {\n    const value = headers[headerName];\n    if (Array.isArray(value)) {\n        return value[0];\n    }\n    return typeof value === 'string' ? value : undefined;\n}\n\nasync function getRuntimeHealthStatusWithCache(\n    runtimeOptions: RuntimeHealthOptions | undefined,\n    cacheTtlMs: number,\n    cache: RuntimeHealthMiddlewareCacheState = {},\n): Promise<RuntimeHealthStatus> {\n    const now = Date.now();\n\n    if (isCacheValid(cache, now, cacheTtlMs)) {\n        return withCacheInfo(cache.cachedStatus!, {\n            source: RUNTIME_HEALTH_CACHE_SOURCE.cached,\n            ttlMs: cacheTtlMs,\n            ageMs: now - cache.cachedAtMs!,\n            cachedAt: toISOStringOrUndefined(cache.cachedAtMs),\n        });\n    }\n\n    if (cache.inFlight) {\n        const status = await cache.inFlight;\n        return withCacheInfo(status, {\n            source: RUNTIME_HEALTH_CACHE_SOURCE.in_flight,\n            ttlMs: cacheTtlMs,\n            ageMs: cache.cachedAtMs != null ? Date.now() - cache.cachedAtMs : 0,\n            cachedAt: toISOStringOrUndefined(cache.cachedAtMs),\n        });\n    }\n\n    cache.inFlight = RuntimeHealthService.get(runtimeOptions)\n        .then((status) => {\n            cache.cachedStatus = status;\n            cache.cachedAtMs = Date.now();\n            return status;\n        })\n        .finally(() => {\n            cache.inFlight = undefined;\n        });\n\n    const status = await cache.inFlight;\n    return withCacheInfo(status, {\n        source: RUNTIME_HEALTH_CACHE_SOURCE.computed,\n        ttlMs: cacheTtlMs,\n        ageMs: 0,\n        cachedAt: toISOStringOrUndefined(cache.cachedAtMs),\n    });\n}\n\nfunction isCacheValid(\n    cache: RuntimeHealthMiddlewareCacheState,\n    now: number,\n    cacheTtlMs: number,\n): cache is Required<\n    Pick<RuntimeHealthMiddlewareCacheState, 'cachedStatus' | 'cachedAtMs'>\n> {\n    return (\n        cache.cachedStatus != null &&\n        cache.cachedAtMs != null &&\n        now - cache.cachedAtMs < cacheTtlMs\n    );\n}\n\nfunction toISOStringOrUndefined(ms: number | undefined): string | undefined {\n    return ms != null ? new Date(ms).toISOString() : undefined;\n}\n\nfunction withCacheInfo(\n    status: RuntimeHealthStatus,\n    cacheInfo: RuntimeHealthCacheInfo,\n): RuntimeHealthStatus {\n    return {\n        ...status,\n        details: {\n            ...status.details,\n            cache: cacheInfo,\n        },\n    };\n}\n","export interface IFrameworkRequest {\n    method?: string;\n    path?: string;\n    originalUrl?: string;\n    url?: string;\n    headers?: Record<string, string | string[] | undefined>;\n}\n\nexport interface IMiddlewareRequest {\n    method: string;\n    path: string;\n    headers: Record<string, string | string[] | undefined>;\n}\n\nexport interface IMiddlewareResponse {\n    sendJson: (statusCode: number, body: unknown) => void;\n}\n\nexport const toMiddlewareRequest = (\n    req: IFrameworkRequest,\n): IMiddlewareRequest => ({\n    method: (req.method ?? 'GET').toUpperCase(),\n    path: req.path ?? req.originalUrl ?? req.url ?? '/',\n    headers: req.headers ?? {},\n});\n","import { RuntimeHealthMiddlewareStartInput } from '../../types';\nimport {\n    createRuntimeHealthMiddlewareCacheState,\n    handleRuntimeHealth,\n} from './runtimeHealth.middleware';\nimport { IFrameworkRequest, toMiddlewareRequest } from '../../interfaces';\n\nexport type ExpressNext = (err?: unknown) => void;\n\nexport type ExpressResponse = {\n    status: (code: number) => {\n        json: (body: unknown) => void;\n    };\n};\n\nexport const start = (options?: RuntimeHealthMiddlewareStartInput) => {\n    const cache = createRuntimeHealthMiddlewareCacheState();\n    return async (\n        req: IFrameworkRequest,\n        res: ExpressResponse,\n        next: ExpressNext,\n    ): Promise<void> => {\n        const shouldContinue = await handleRuntimeHealth(\n            toMiddlewareRequest(req),\n            {\n                sendJson: (statusCode, body) =>\n                    res.status(statusCode).json(body),\n            },\n            options,\n            cache,\n        );\n\n        if (shouldContinue) next();\n    };\n};\n","import { RuntimeHealthMiddlewareStartInput } from '../../types';\nimport {\n    createRuntimeHealthMiddlewareCacheState,\n    handleRuntimeHealth,\n} from './runtimeHealth.middleware';\nimport { IFrameworkRequest, toMiddlewareRequest } from '../../interfaces';\n\nexport type FastifyDone = (err?: Error) => void;\n\nexport type FastifyReply = {\n    code: (statusCode: number) => FastifyReply;\n    send: (body: unknown) => void;\n};\n\nexport const start = (options?: RuntimeHealthMiddlewareStartInput) => {\n    const cache = createRuntimeHealthMiddlewareCacheState();\n    return async (\n        req: IFrameworkRequest,\n        reply: FastifyReply,\n        done: FastifyDone,\n    ): Promise<void> => {\n        const shouldContinue = await handleRuntimeHealth(\n            toMiddlewareRequest(req),\n            {\n                sendJson: (statusCode, body) =>\n                    reply.code(statusCode).send(body),\n            },\n            options,\n            cache,\n        );\n\n        if (shouldContinue) done();\n    };\n};\n","import { start as expressStart } from './runtimeHealth.express';\nimport { start as fastifyStart } from './runtimeHealth.fastify';\n\nexport const RuntimeHealthMiddleware = {\n    express: { start: expressStart },\n    fastify: { start: fastifyStart },\n};\n"]}