@checkstack/healthcheck-jenkins-backend 0.2.13 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @checkstack/healthcheck-jenkins-backend
 
+## 0.3.0
+
+### Minor Changes
+
+- 3dd1914: Migrate health check strategies to VersionedAggregated with \_type discriminator
+
+  All 13 health check strategies now use `VersionedAggregated` for their `aggregatedResult` property, enabling automatic bucket merging with 100% mathematical fidelity.
+
+  **Key changes:**
+
+  - **`_type` discriminator**: All aggregated state objects now include a required `_type` field (`"average"`, `"rate"`, `"counter"`, `"minmax"`) for reliable type detection
+  - The `HealthCheckStrategy` interface now requires `aggregatedResult` to be a `VersionedAggregated<AggregatedResultShape>`
+  - Strategy/collector `mergeResult` methods return state objects with `_type` (e.g., `{ _type: "average", _sum, _count, avg }`)
+  - `mergeAggregatedBucketResults`, `combineBuckets`, and `reaggregateBuckets` now require `registry` and `strategyId` parameters
+  - `HealthCheckService` constructor now requires both `registry` and `collectorRegistry` parameters
+  - Frontend `extractComputedValue` now uses `_type` discriminator for robust type detection
+
+  **Breaking Change**: State objects now require `_type`. Merge functions automatically add `_type` to output. The bucket merging functions and `HealthCheckService` now require additional required parameters.
+
+### Patch Changes
+
+- Updated dependencies [3dd1914]
+  - @checkstack/backend-api@0.7.0
+
 ## 0.2.13
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@checkstack/healthcheck-jenkins-backend",
-  "version": "0.2.13",
+  "version": "0.3.0",
   "type": "module",
   "main": "src/index.ts",
   "scripts": {

package/src/collectors/build-history.test.ts

@@ -101,7 +101,7 @@ describe("BuildHistoryCollector", () => {
     let aggregated = collector.mergeResult(undefined, runs[0]);
       aggregated = collector.mergeResult(aggregated, runs[1]);
 
-    expect(aggregated.avgSuccessRate).toBe(70);
-    expect(aggregated.avgBuildDuration).toBe(70000);
+    expect(aggregated.avgSuccessRate.avg).toBe(70);
+    expect(aggregated.avgBuildDuration.avg).toBe(70000);
   });
 });

package/src/collectors/build-history.ts

@@ -5,8 +5,9 @@ import {
   type CollectorResult,
   type CollectorStrategy,
   mergeAverage,
-  averageStateSchema,
-  type AverageState,
+  VersionedAggregated,
+  aggregatedAverage,
+  type InferAggregatedResult,
 } from "@checkstack/backend-api";
 import { healthResultNumber } from "@checkstack/healthcheck-common";
 import { pluginMetadata } from "../plugin-metadata";
@@ -89,32 +90,23 @@ const buildHistoryResultSchema = z.object({
 
 export type BuildHistoryResult = z.infer<typeof buildHistoryResultSchema>;
 
-const buildHistoryAggregatedDisplaySchema = z.object({
-  avgSuccessRate: healthResultNumber({
+// Aggregated result fields definition
+const buildHistoryAggregatedFields = {
+  avgSuccessRate: aggregatedAverage({
     "x-chart-type": "gauge",
     "x-chart-label": "Avg Success Rate",
     "x-chart-unit": "%",
   }),
-  avgBuildDuration: healthResultNumber({
+  avgBuildDuration: aggregatedAverage({
     "x-chart-type": "line",
     "x-chart-label": "Avg Build Duration",
     "x-chart-unit": "ms",
   }),
-});
-
-const buildHistoryAggregatedInternalSchema = z.object({
-  _successRate: averageStateSchema
-    .optional(),
-  _duration: averageStateSchema
-    .optional(),
-});
+};
 
-const buildHistoryAggregatedSchema = buildHistoryAggregatedDisplaySchema.merge(
-  buildHistoryAggregatedInternalSchema,
-);
-
-export type BuildHistoryAggregatedResult = z.infer<
-  typeof buildHistoryAggregatedSchema
+// Type inferred from field definitions
+export type BuildHistoryAggregatedResult = InferAggregatedResult<
+  typeof buildHistoryAggregatedFields
 >;
 
 // ============================================================================
@@ -140,9 +132,9 @@ export class BuildHistoryCollector implements CollectorStrategy<
 
   config = new Versioned({ version: 1, schema: buildHistoryConfigSchema });
   result = new Versioned({ version: 1, schema: buildHistoryResultSchema });
-  aggregatedResult = new Versioned({
+  aggregatedResult = new VersionedAggregated({
     version: 1,
-    schema: buildHistoryAggregatedSchema,
+    fields: buildHistoryAggregatedFields,
   });
 
   async execute({
@@ -270,21 +262,15 @@ export class BuildHistoryCollector implements CollectorStrategy<
   ): BuildHistoryAggregatedResult {
     const metadata = run.metadata;
 
-    const successRateState = mergeAverage(
-      existing?._successRate as AverageState | undefined,
-      metadata?.successRate,
-    );
-
-    const durationState = mergeAverage(
-      existing?._duration as AverageState | undefined,
-      metadata?.avgDurationMs,
-    );
-
     return {
-      avgSuccessRate: successRateState.avg,
-      avgBuildDuration: durationState.avg,
-      _successRate: successRateState,
-      _duration: durationState,
+      avgSuccessRate: mergeAverage(
+        existing?.avgSuccessRate,
+        metadata?.successRate,
+      ),
+      avgBuildDuration: mergeAverage(
+        existing?.avgBuildDuration,
+        metadata?.avgDurationMs,
+      ),
     };
   }
 }

package/src/collectors/job-status.test.ts

@@ -141,8 +141,8 @@ describe("JobStatusCollector", () => {
     aggregated = collector.mergeResult(aggregated, runs[1]);
     aggregated = collector.mergeResult(aggregated, runs[2]);
 
-    expect(aggregated.successRate).toBe(67); // 2/3
-    expect(aggregated.avgBuildDurationMs).toBe(60000); // (60000+80000+40000)/3
-    expect(aggregated.buildableRate).toBe(100);
+    expect(aggregated.successRate.rate).toBe(67); // 2/3
+    expect(aggregated.avgBuildDurationMs.avg).toBe(60000); // (60000+80000+40000)/3
+    expect(aggregated.buildableRate.rate).toBe(100);
   });
 });

package/src/collectors/job-status.ts

@@ -6,10 +6,10 @@ import {
   type CollectorStrategy,
   mergeAverage,
   mergeRate,
-  averageStateSchema,
-  rateStateSchema,
-  type AverageState,
-  type RateState,
+  VersionedAggregated,
+  aggregatedAverage,
+  aggregatedRate,
+  type InferAggregatedResult,
 } from "@checkstack/backend-api";
 import {
   healthResultNumber,
@@ -83,36 +83,28 @@ const jobStatusResultSchema = z.object({
 
 export type JobStatusResult = z.infer<typeof jobStatusResultSchema>;
 
-const jobStatusAggregatedDisplaySchema = z.object({
-  avgBuildDurationMs: healthResultNumber({
+// Aggregated result fields definition
+const jobStatusAggregatedFields = {
+  avgBuildDurationMs: aggregatedAverage({
     "x-chart-type": "line",
     "x-chart-label": "Avg Build Duration",
     "x-chart-unit": "ms",
   }),
-  successRate: healthResultNumber({
+  successRate: aggregatedRate({
     "x-chart-type": "gauge",
     "x-chart-label": "Success Rate",
     "x-chart-unit": "%",
   }),
-  buildableRate: healthResultNumber({
+  buildableRate: aggregatedRate({
     "x-chart-type": "gauge",
     "x-chart-label": "Enabled Rate",
     "x-chart-unit": "%",
   }),
-});
-
-const jobStatusAggregatedInternalSchema = z.object({
-  _duration: averageStateSchema.optional(),
-  _success: rateStateSchema.optional(),
-  _buildable: rateStateSchema.optional(),
-});
-
-const jobStatusAggregatedSchema = jobStatusAggregatedDisplaySchema.merge(
-  jobStatusAggregatedInternalSchema,
-);
+};
 
-export type JobStatusAggregatedResult = z.infer<
-  typeof jobStatusAggregatedSchema
+// Type inferred from field definitions
+export type JobStatusAggregatedResult = InferAggregatedResult<
+  typeof jobStatusAggregatedFields
 >;
 
 // ============================================================================
@@ -138,9 +130,9 @@ export class JobStatusCollector implements CollectorStrategy<
 
   config = new Versioned({ version: 1, schema: jobStatusConfigSchema });
   result = new Versioned({ version: 1, schema: jobStatusResultSchema });
-  aggregatedResult = new Versioned({
+  aggregatedResult = new VersionedAggregated({
     version: 1,
-    schema: jobStatusAggregatedSchema,
+    fields: jobStatusAggregatedFields,
   });
 
   async execute({
@@ -224,29 +216,16 @@ export class JobStatusCollector implements CollectorStrategy<
   ): JobStatusAggregatedResult {
     const metadata = run.metadata;
 
-    const durationState = mergeAverage(
-      existing?._duration as AverageState | undefined,
-      metadata?.lastBuildDurationMs,
-    );
-
-    // Success is when lastBuildResult === "SUCCESS"
-    const successState = mergeRate(
-      existing?._success as RateState | undefined,
-      metadata?.lastBuildResult === "SUCCESS",
-    );
-
-    const buildableState = mergeRate(
-      existing?._buildable as RateState | undefined,
-      metadata?.buildable,
-    );
-
     return {
-      avgBuildDurationMs: durationState.avg,
-      successRate: successState.rate,
-      buildableRate: buildableState.rate,
-      _duration: durationState,
-      _success: successState,
-      _buildable: buildableState,
+      avgBuildDurationMs: mergeAverage(
+        existing?.avgBuildDurationMs,
+        metadata?.lastBuildDurationMs,
+      ),
+      successRate: mergeRate(
+        existing?.successRate,
+        metadata?.lastBuildResult === "SUCCESS",
+      ),
+      buildableRate: mergeRate(existing?.buildableRate, metadata?.buildable),
     };
   }
 }

package/src/collectors/node-health.test.ts

@@ -143,8 +143,8 @@ describe("NodeHealthCollector", () => {
     let aggregated = collector.mergeResult(undefined, runs[0]);
       aggregated = collector.mergeResult(aggregated, runs[1]);
 
-    expect(aggregated.avgOnlineNodes).toBe(4);
-    expect(aggregated.avgUtilization).toBe(60);
-    expect(aggregated.minOnlineNodes).toBe(3);
+    expect(aggregated.avgOnlineNodes.avg).toBe(4);
+    expect(aggregated.avgUtilization.avg).toBe(60);
+    expect(aggregated.minOnlineNodes.min).toBe(3);
   });
 });

package/src/collectors/node-health.ts

@@ -6,10 +6,10 @@ import {
   type CollectorStrategy,
   mergeAverage,
   mergeMinMax,
-  averageStateSchema,
-  minMaxStateSchema,
-  type AverageState,
-  type MinMaxState,
+  VersionedAggregated,
+  aggregatedAverage,
+  aggregatedMinMax,
+  type InferAggregatedResult,
 } from "@checkstack/backend-api";
 import {
   healthResultBoolean,
@@ -83,34 +83,26 @@ const nodeHealthResultSchema = z.object({
 
 export type NodeHealthResult = z.infer<typeof nodeHealthResultSchema>;
 
-const nodeHealthAggregatedDisplaySchema = z.object({
-  avgOnlineNodes: healthResultNumber({
+// Aggregated result fields definition
+const nodeHealthAggregatedFields = {
+  avgOnlineNodes: aggregatedAverage({
     "x-chart-type": "line",
     "x-chart-label": "Avg Online Nodes",
   }),
-  avgUtilization: healthResultNumber({
+  avgUtilization: aggregatedAverage({
     "x-chart-type": "gauge",
     "x-chart-label": "Avg Utilization",
     "x-chart-unit": "%",
   }),
-  minOnlineNodes: healthResultNumber({
+  minOnlineNodes: aggregatedMinMax({
     "x-chart-type": "line",
     "x-chart-label": "Min Online Nodes",
   }),
-});
-
-const nodeHealthAggregatedInternalSchema = z.object({
-  _onlineNodes: averageStateSchema.optional(),
-  _utilization: averageStateSchema.optional(),
-  _minOnlineNodes: minMaxStateSchema.optional(),
-});
-
-const nodeHealthAggregatedSchema = nodeHealthAggregatedDisplaySchema.merge(
-  nodeHealthAggregatedInternalSchema,
-);
+};
 
-export type NodeHealthAggregatedResult = z.infer<
-  typeof nodeHealthAggregatedSchema
+// Type inferred from field definitions
+export type NodeHealthAggregatedResult = InferAggregatedResult<
+  typeof nodeHealthAggregatedFields
 >;
 
 // ============================================================================
@@ -136,9 +128,9 @@ export class NodeHealthCollector implements CollectorStrategy<
 
   config = new Versioned({ version: 1, schema: nodeHealthConfigSchema });
   result = new Versioned({ version: 1, schema: nodeHealthResultSchema });
-  aggregatedResult = new Versioned({
+  aggregatedResult = new VersionedAggregated({
     version: 1,
-    schema: nodeHealthAggregatedSchema,
+    fields: nodeHealthAggregatedFields,
   });
 
   async execute({
@@ -294,28 +286,19 @@ export class NodeHealthCollector implements CollectorStrategy<
   ): NodeHealthAggregatedResult {
     const metadata = run.metadata;
 
-    const onlineNodesState = mergeAverage(
-      existing?._onlineNodes as AverageState | undefined,
-      metadata?.onlineNodes,
-    );
-
-    const utilizationState = mergeAverage(
-      existing?._utilization as AverageState | undefined,
-      metadata?.executorUtilization,
-    );
-
-    const minOnlineNodesState = mergeMinMax(
-      existing?._minOnlineNodes as MinMaxState | undefined,
-      metadata?.onlineNodes,
-    );
-
     return {
-      avgOnlineNodes: onlineNodesState.avg,
-      avgUtilization: utilizationState.avg,
-      minOnlineNodes: minOnlineNodesState.min,
-      _onlineNodes: onlineNodesState,
-      _utilization: utilizationState,
-      _minOnlineNodes: minOnlineNodesState,
+      avgOnlineNodes: mergeAverage(
+        existing?.avgOnlineNodes,
+        metadata?.onlineNodes,
+      ),
+      avgUtilization: mergeAverage(
+        existing?.avgUtilization,
+        metadata?.executorUtilization,
+      ),
+      minOnlineNodes: mergeMinMax(
+        existing?.minOnlineNodes,
+        metadata?.onlineNodes,
+      ),
     };
   }
 }

package/src/collectors/queue-info.test.ts

@@ -107,8 +107,8 @@ describe("QueueInfoCollector", () => {
     let aggregated = collector.mergeResult(undefined, runs[0]);
       aggregated = collector.mergeResult(aggregated, runs[1]);
 
-    expect(aggregated.avgQueueLength).toBe(4);
-    expect(aggregated.maxQueueLength).toBe(5);
-    expect(aggregated.avgWaitTime).toBe(15000);
+    expect(aggregated.avgQueueLength.avg).toBe(4);
+    expect(aggregated.maxQueueLength.max).toBe(5);
+    expect(aggregated.avgWaitTime.avg).toBe(15000);
   });
 });

package/src/collectors/queue-info.ts

@@ -6,10 +6,10 @@ import {
   type CollectorStrategy,
   mergeAverage,
   mergeMinMax,
-  averageStateSchema,
-  minMaxStateSchema,
-  type AverageState,
-  type MinMaxState,
+  VersionedAggregated,
+  aggregatedAverage,
+  aggregatedMinMax,
+  type InferAggregatedResult,
 } from "@checkstack/backend-api";
 import { healthResultNumber } from "@checkstack/healthcheck-common";
 import { pluginMetadata } from "../plugin-metadata";
@@ -58,34 +58,26 @@ const queueInfoResultSchema = z.object({
 
 export type QueueInfoResult = z.infer<typeof queueInfoResultSchema>;
 
-const queueInfoAggregatedDisplaySchema = z.object({
-  avgQueueLength: healthResultNumber({
+// Aggregated result fields definition
+const queueInfoAggregatedFields = {
+  avgQueueLength: aggregatedAverage({
     "x-chart-type": "line",
     "x-chart-label": "Avg Queue Length",
   }),
-  maxQueueLength: healthResultNumber({
+  maxQueueLength: aggregatedMinMax({
     "x-chart-type": "line",
     "x-chart-label": "Max Queue Length",
   }),
-  avgWaitTime: healthResultNumber({
+  avgWaitTime: aggregatedAverage({
     "x-chart-type": "line",
     "x-chart-label": "Avg Wait Time",
     "x-chart-unit": "ms",
   }),
-});
-
-const queueInfoAggregatedInternalSchema = z.object({
-  _queueLength: averageStateSchema.optional(),
-  _maxQueueLength: minMaxStateSchema.optional(),
-  _waitTime: averageStateSchema.optional(),
-});
-
-const queueInfoAggregatedSchema = queueInfoAggregatedDisplaySchema.merge(
-  queueInfoAggregatedInternalSchema,
-);
+};
 
-export type QueueInfoAggregatedResult = z.infer<
-  typeof queueInfoAggregatedSchema
+// Type inferred from field definitions
+export type QueueInfoAggregatedResult = InferAggregatedResult<
+  typeof queueInfoAggregatedFields
 >;
 
 // ============================================================================
@@ -110,9 +102,9 @@ export class QueueInfoCollector implements CollectorStrategy<
 
   config = new Versioned({ version: 1, schema: queueInfoConfigSchema });
   result = new Versioned({ version: 1, schema: queueInfoResultSchema });
-  aggregatedResult = new Versioned({
+  aggregatedResult = new VersionedAggregated({
     version: 1,
-    schema: queueInfoAggregatedSchema,
+    fields: queueInfoAggregatedFields,
   });
 
   async execute({
@@ -206,28 +198,16 @@ export class QueueInfoCollector implements CollectorStrategy<
   ): QueueInfoAggregatedResult {
     const metadata = run.metadata;
 
-    const queueLengthState = mergeAverage(
-      existing?._queueLength as AverageState | undefined,
-      metadata?.queueLength,
-    );
-
-    const maxQueueLengthState = mergeMinMax(
-      existing?._maxQueueLength as MinMaxState | undefined,
-      metadata?.queueLength,
-    );
-
-    const waitTimeState = mergeAverage(
-      existing?._waitTime as AverageState | undefined,
-      metadata?.avgWaitingMs,
-    );
-
     return {
-      avgQueueLength: queueLengthState.avg,
-      maxQueueLength: maxQueueLengthState.max,
-      avgWaitTime: waitTimeState.avg,
-      _queueLength: queueLengthState,
-      _maxQueueLength: maxQueueLengthState,
-      _waitTime: waitTimeState,
+      avgQueueLength: mergeAverage(
+        existing?.avgQueueLength,
+        metadata?.queueLength,
+      ),
+      maxQueueLength: mergeMinMax(
+        existing?.maxQueueLength,
+        metadata?.queueLength,
+      ),
+      avgWaitTime: mergeAverage(existing?.avgWaitTime, metadata?.avgWaitingMs),
     };
   }
 }

package/src/collectors/server-info.test.ts

@@ -9,7 +9,7 @@ describe("ServerInfoCollector", () => {
   const collector = new ServerInfoCollector();
 
   const createMockClient = (
-    response: JenkinsResponse
+    response: JenkinsResponse,
   ): JenkinsTransportClient => ({
     exec: async () => response,
   });
@@ -83,9 +83,9 @@ describe("ServerInfoCollector", () => {
     ];
 
     let aggregated = collector.mergeResult(undefined, runs[0]);
-      aggregated = collector.mergeResult(aggregated, runs[1]);
+    aggregated = collector.mergeResult(aggregated, runs[1]);
 
-    expect(aggregated.avgExecutors).toBe(5);
-    expect(aggregated.avgTotalJobs).toBe(11);
+    expect(aggregated.avgExecutors.avg).toBe(5);
+    expect(aggregated.avgTotalJobs.avg).toBe(11);
   });
 });

package/src/collectors/server-info.ts

@@ -5,8 +5,9 @@ import {
   type CollectorResult,
   type CollectorStrategy,
   mergeAverage,
-  averageStateSchema,
-  type AverageState,
+  VersionedAggregated,
+  aggregatedAverage,
+  type InferAggregatedResult,
 } from "@checkstack/backend-api";
 import {
   healthResultNumber,
@@ -57,28 +58,21 @@ const serverInfoResultSchema = z.object({
 
 export type ServerInfoResult = z.infer<typeof serverInfoResultSchema>;
 
-const serverInfoAggregatedDisplaySchema = z.object({
-  avgExecutors: healthResultNumber({
+// Aggregated result fields definition
+const serverInfoAggregatedFields = {
+  avgExecutors: aggregatedAverage({
     "x-chart-type": "line",
     "x-chart-label": "Avg Executors",
   }),
-  avgTotalJobs: healthResultNumber({
+  avgTotalJobs: aggregatedAverage({
     "x-chart-type": "line",
     "x-chart-label": "Avg Jobs",
   }),
-});
-
-const serverInfoAggregatedInternalSchema = z.object({
-  _executors: averageStateSchema.optional(),
-  _jobs: averageStateSchema.optional(),
-});
+};
 
-const serverInfoAggregatedSchema = serverInfoAggregatedDisplaySchema.merge(
-  serverInfoAggregatedInternalSchema,
-);
-
-export type ServerInfoAggregatedResult = z.infer<
-  typeof serverInfoAggregatedSchema
+// Type inferred from field definitions
+export type ServerInfoAggregatedResult = InferAggregatedResult<
+  typeof serverInfoAggregatedFields
 >;
 
 // ============================================================================
@@ -103,9 +97,9 @@ export class ServerInfoCollector implements CollectorStrategy<
 
   config = new Versioned({ version: 1, schema: serverInfoConfigSchema });
   result = new Versioned({ version: 1, schema: serverInfoResultSchema });
-  aggregatedResult = new Versioned({
+  aggregatedResult = new VersionedAggregated({
     version: 1,
-    schema: serverInfoAggregatedSchema,
+    fields: serverInfoAggregatedFields,
   });
 
   async execute({
@@ -159,21 +153,12 @@ export class ServerInfoCollector implements CollectorStrategy<
   ): ServerInfoAggregatedResult {
     const metadata = run.metadata;
 
-    const executorsState = mergeAverage(
-      existing?._executors as AverageState | undefined,
-      metadata?.numExecutors,
-    );
-
-    const jobsState = mergeAverage(
-      existing?._jobs as AverageState | undefined,
-      metadata?.totalJobs,
-    );
-
     return {
-      avgExecutors: executorsState.avg,
-      avgTotalJobs: jobsState.avg,
-      _executors: executorsState,
-      _jobs: jobsState,
+      avgExecutors: mergeAverage(
+        existing?.avgExecutors,
+        metadata?.numExecutors,
+      ),
+      avgTotalJobs: mergeAverage(existing?.avgTotalJobs, metadata?.totalJobs),
     };
   }
 }

package/src/strategy.test.ts

@@ -184,9 +184,9 @@ describe("JenkinsHealthCheckStrategy", () => {
       aggregated = strategy.mergeResult(aggregated, runs[1]);
       aggregated = strategy.mergeResult(aggregated, runs[2]);
 
-      expect(aggregated.successRate).toBe(67); // 2/3
-      expect(aggregated.avgResponseTimeMs).toBe(175); // (150+200)/2
-      expect(aggregated.errorCount).toBe(1);
+      expect(aggregated.successRate.rate).toBe(67); // 2/3
+      expect(aggregated.avgResponseTimeMs.avg).toBe(175); // (150+200)/2
+      expect(aggregated.errorCount.count).toBe(1);
     });
 
     it("should handle single run", () => {
@@ -197,9 +197,9 @@ describe("JenkinsHealthCheckStrategy", () => {
       };
       const aggregated = strategy.mergeResult(undefined, run);
 
-      expect(aggregated.successRate).toBe(100);
-      expect(aggregated.avgResponseTimeMs).toBe(150);
-      expect(aggregated.errorCount).toBe(0);
+      expect(aggregated.successRate.rate).toBe(100);
+      expect(aggregated.avgResponseTimeMs.avg).toBe(150);
+      expect(aggregated.errorCount.count).toBe(0);
     });
   });
 });

package/src/strategy.ts

@@ -2,19 +2,18 @@ import {
   HealthCheckStrategy,
   HealthCheckRunForAggregation,
   Versioned,
+  VersionedAggregated,
+  aggregatedAverage,
+  aggregatedRate,
+  aggregatedCounter,
+  mergeAverage,
+  mergeRate,
+  mergeCounter,
   z,
   configString,
   configNumber,
   type ConnectedClient,
-  mergeAverage,
-  averageStateSchema,
-  mergeRate,
-  rateStateSchema,
-  mergeCounter,
-  counterStateSchema,
-  type AverageState,
-  type RateState,
-  type CounterState,
+  type InferAggregatedResult,
 } from "@checkstack/backend-api";
 import {
   healthResultNumber,
@@ -75,37 +74,27 @@ const jenkinsResultSchema = healthResultSchema({
 
 type JenkinsResult = z.infer<typeof jenkinsResultSchema>;
 
-/** Aggregated metadata for buckets */
-const jenkinsAggregatedDisplaySchema = healthResultSchema({
-  successRate: healthResultNumber({
+/** Aggregated field definitions for bucket merging */
+const jenkinsAggregatedFields = {
+  successRate: aggregatedRate({
     "x-chart-type": "gauge",
     "x-chart-label": "Success Rate",
     "x-chart-unit": "%",
   }),
-  avgResponseTimeMs: healthResultNumber({
+  avgResponseTimeMs: aggregatedAverage({
     "x-chart-type": "line",
     "x-chart-label": "Avg Response Time",
     "x-chart-unit": "ms",
   }),
-  errorCount: healthResultNumber({
+  errorCount: aggregatedCounter({
     "x-chart-type": "counter",
     "x-chart-label": "Errors",
   }),
-});
+};
 
-const jenkinsAggregatedInternalSchema = z.object({
-  _responseTime: averageStateSchema
-    .optional(),
-  _success: rateStateSchema
-    .optional(),
-  _errors: counterStateSchema.optional(),
-});
-
-const jenkinsAggregatedSchema = jenkinsAggregatedDisplaySchema.merge(
-  jenkinsAggregatedInternalSchema,
-);
-
-type JenkinsAggregatedResult = z.infer<typeof jenkinsAggregatedSchema>;
+type JenkinsAggregatedResult = InferAggregatedResult<
+  typeof jenkinsAggregatedFields
+>;
 
 // ============================================================================
 // STRATEGY
@@ -115,7 +104,7 @@ export class JenkinsHealthCheckStrategy implements HealthCheckStrategy<
   JenkinsConfig,
   JenkinsTransportClient,
   JenkinsResult,
-  JenkinsAggregatedResult
+  typeof jenkinsAggregatedFields
 > {
   id = "jenkins";
   displayName = "Jenkins Health Check";
@@ -131,9 +120,9 @@ export class JenkinsHealthCheckStrategy implements HealthCheckStrategy<
     schema: jenkinsResultSchema,
   });
 
-  aggregatedResult: Versioned<JenkinsAggregatedResult> = new Versioned({
+  aggregatedResult = new VersionedAggregated({
     version: 1,
-    schema: jenkinsAggregatedSchema,
+    fields: jenkinsAggregatedFields,
   });
 
   /**
@@ -224,28 +213,17 @@ export class JenkinsHealthCheckStrategy implements HealthCheckStrategy<
   ): JenkinsAggregatedResult {
     const metadata = run.metadata;
 
-    const responseTimeState = mergeAverage(
-      existing?._responseTime as AverageState | undefined,
+    const avgResponseTimeMs = mergeAverage(
+      existing?.avgResponseTimeMs,
       metadata?.responseTimeMs,
     );
 
-    const successState = mergeRate(
-      existing?._success as RateState | undefined,
-      metadata?.connected,
-    );
+    const isSuccess = metadata?.connected ?? false;
+    const successRate = mergeRate(existing?.successRate, isSuccess);
 
-    const errorState = mergeCounter(
-      existing?._errors as CounterState | undefined,
-      metadata?.error !== undefined,
-    );
+    const hasError = metadata?.error !== undefined;
+    const errorCount = mergeCounter(existing?.errorCount, hasError);
 
-    return {
-      successRate: successState.rate,
-      avgResponseTimeMs: responseTimeState.avg,
-      errorCount: errorState.count,
-      _responseTime: responseTimeState,
-      _success: successState,
-      _errors: errorState,
-    };
+    return { successRate, avgResponseTimeMs, errorCount };
   }
 }