@justair/justair-library 7.3.0-alpha.e85bbda → 7.3.0-alpha.f340581

package/README.md

@@ -97,6 +97,18 @@ The following parameters were added to `HEAVY_METALS` and are now included in `s
 | `MN` | Manganese |
 | `SE` | Selenium |
 
+### New met parameters in 7.3.0
+
+The following parameters were added to `PARAMETERS` and are now included in `parametersEnum`. Consuming services that display or filter parameters without a `type` filter (admin pickers, notification threshold UIs, reporting) will start showing them on install, even though no service writes them yet.
+
+| id | Name | Unit |
+|---|---|---|
+| `T_AMB` | Ambient Temperature | `°F` |
+| `RH_AMB` | Ambient Relative Humidity | `%` |
+| `DP_AMB` | Ambient Dew Point | `°F` |
+
+These are **not** interchangeable with the bare `T` / `RH` / `DP` ids, which are enclosure-internal readings used only by correction equations and fog detection. Never fall back from one kind to the other. See "Ambient vs internal met parameters" in `CLAUDE.md` before wiring these up. `INTERNAL_TO_AMBIENT_PARAMETERS` exports the pairing as data so consumers can filter on it instead of hardcoding the six ids.
+
 ### Object shape
 
 Each constant is an object with the following fields:

package/dist/constants/dataDownloads.d.ts

@@ -1,2 +1,2 @@
-export const DATA_DOWNLOAD_TYPES: string[];
+export const DATA_DOWNLOAD_TYPES: readonly string[];
 //# sourceMappingURL=dataDownloads.d.ts.map

package/dist/constants/dataDownloads.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dataDownloads.d.ts","sourceRoot":"","sources":["../../src/constants/dataDownloads.js"],"names":[],"mappings":"AAeA,2CAAqD"}
+{"version":3,"file":"dataDownloads.d.ts","sourceRoot":"","sources":["../../src/constants/dataDownloads.js"],"names":[],"mappings":"AAkBA,oDAAoE"}

package/dist/constants/pollutants.d.ts

@@ -279,7 +279,7 @@ export namespace PARAMETERS {
         let impacts_15: any;
         export { impacts_15 as impacts };
     }
-    namespace RH {
+    namespace DP_AMB {
         let id_16: string;
         export { id_16 as id };
         let label_16: string;
@@ -297,7 +297,7 @@ export namespace PARAMETERS {
         let impacts_16: any;
         export { impacts_16 as impacts };
     }
-    namespace T {
+    namespace RH {
         let id_17: string;
         export { id_17 as id };
         let label_17: string;
@@ -315,7 +315,7 @@ export namespace PARAMETERS {
         let impacts_17: any;
         export { impacts_17 as impacts };
     }
-    namespace WD {
+    namespace RH_AMB {
         let id_18: string;
         export { id_18 as id };
         let label_18: string;
@@ -333,7 +333,7 @@ export namespace PARAMETERS {
         let impacts_18: any;
         export { impacts_18 as impacts };
     }
-    namespace WS {
+    namespace T {
         let id_19: string;
         export { id_19 as id };
         let label_19: string;
@@ -351,7 +351,7 @@ export namespace PARAMETERS {
         let impacts_19: any;
         export { impacts_19 as impacts };
     }
-    namespace GS {
+    namespace T_AMB {
         let id_20: string;
         export { id_20 as id };
         let label_20: string;
@@ -369,7 +369,7 @@ export namespace PARAMETERS {
         let impacts_20: any;
         export { impacts_20 as impacts };
     }
-    namespace R {
+    namespace WD {
         let id_21: string;
         export { id_21 as id };
         let label_21: string;
@@ -387,7 +387,7 @@ export namespace PARAMETERS {
         let impacts_21: any;
         export { impacts_21 as impacts };
     }
-    namespace SR {
+    namespace WS {
         let id_22: string;
         export { id_22 as id };
         let label_22: string;
@@ -405,7 +405,7 @@ export namespace PARAMETERS {
         let impacts_22: any;
         export { impacts_22 as impacts };
     }
-    namespace P {
+    namespace GS {
         let id_23: string;
         export { id_23 as id };
         let label_23: string;
@@ -423,7 +423,7 @@ export namespace PARAMETERS {
         let impacts_23: any;
         export { impacts_23 as impacts };
     }
-    namespace PAR {
+    namespace R {
         let id_24: string;
         export { id_24 as id };
         let label_24: string;
@@ -441,7 +441,7 @@ export namespace PARAMETERS {
         let impacts_24: any;
         export { impacts_24 as impacts };
     }
-    namespace ARM {
+    namespace SR {
         let id_25: string;
         export { id_25 as id };
         let label_25: string;
@@ -459,7 +459,7 @@ export namespace PARAMETERS {
         let impacts_25: any;
         export { impacts_25 as impacts };
     }
-    namespace ARW {
+    namespace P {
         let id_26: string;
         export { id_26 as id };
         let label_26: string;
@@ -477,7 +477,7 @@ export namespace PARAMETERS {
         let impacts_26: any;
         export { impacts_26 as impacts };
     }
-    namespace ARD {
+    namespace PAR {
         let id_27: string;
         export { id_27 as id };
         let label_27: string;
@@ -495,7 +495,7 @@ export namespace PARAMETERS {
         let impacts_27: any;
         export { impacts_27 as impacts };
     }
-    namespace ARH {
+    namespace ARM {
         let id_28: string;
         export { id_28 as id };
         let label_28: string;
@@ -513,9 +513,7 @@ export namespace PARAMETERS {
         let impacts_28: any;
         export { impacts_28 as impacts };
     }
-}
-export namespace HEAVY_METALS {
-    export namespace AS {
+    namespace ARW {
         let id_29: string;
         export { id_29 as id };
         let label_29: string;
@@ -526,14 +524,14 @@ export namespace HEAVY_METALS {
         export { unit_29 as unit };
         let type_29: string;
         export { type_29 as type };
-        let rfc_29: number;
+        let rfc_29: any;
         export { rfc_29 as rfc };
-        let origin_29: string;
+        let origin_29: any;
         export { origin_29 as origin };
-        let impacts_29: string;
+        let impacts_29: any;
         export { impacts_29 as impacts };
     }
-    export namespace BA {
+    namespace ARD {
         let id_30: string;
         export { id_30 as id };
         let label_30: string;
@@ -546,12 +544,12 @@ export namespace HEAVY_METALS {
         export { type_30 as type };
         let rfc_30: any;
         export { rfc_30 as rfc };
-        let origin_30: string;
+        let origin_30: any;
         export { origin_30 as origin };
-        let impacts_30: string;
+        let impacts_30: any;
         export { impacts_30 as impacts };
     }
-    export namespace C6H6 {
+    namespace ARH {
         let id_31: string;
         export { id_31 as id };
         let label_31: string;
@@ -562,14 +560,21 @@ export namespace HEAVY_METALS {
         export { unit_31 as unit };
         let type_31: string;
         export { type_31 as type };
-        let rfc_31: number;
+        let rfc_31: any;
         export { rfc_31 as rfc };
-        let origin_31: string;
+        let origin_31: any;
         export { origin_31 as origin };
-        let impacts_31: string;
+        let impacts_31: any;
         export { impacts_31 as impacts };
     }
-    export namespace BE {
+}
+export const INTERNAL_TO_AMBIENT_PARAMETERS: Readonly<{
+    T: "T_AMB";
+    RH: "RH_AMB";
+    DP: "DP_AMB";
+}>;
+export namespace HEAVY_METALS {
+    export namespace AS {
         let id_32: string;
         export { id_32 as id };
         let label_32: string;
@@ -587,7 +592,7 @@ export namespace HEAVY_METALS {
         let impacts_32: string;
         export { impacts_32 as impacts };
     }
-    export namespace CD {
+    export namespace BA {
         let id_33: string;
         export { id_33 as id };
         let label_33: string;
@@ -598,14 +603,14 @@ export namespace HEAVY_METALS {
         export { unit_33 as unit };
         let type_33: string;
         export { type_33 as type };
-        let rfc_33: number;
+        let rfc_33: any;
         export { rfc_33 as rfc };
         let origin_33: string;
         export { origin_33 as origin };
         let impacts_33: string;
         export { impacts_33 as impacts };
     }
-    export namespace CR {
+    export namespace C6H6 {
         let id_34: string;
         export { id_34 as id };
         let label_34: string;
@@ -623,7 +628,7 @@ export namespace HEAVY_METALS {
         let impacts_34: string;
         export { impacts_34 as impacts };
     }
-    export namespace CO_1 {
+    export namespace BE {
         let id_35: string;
         export { id_35 as id };
         let label_35: string;
@@ -634,15 +639,14 @@ export namespace HEAVY_METALS {
         export { unit_35 as unit };
         let type_35: string;
         export { type_35 as type };
-        let rfc_35: any;
+        let rfc_35: number;
         export { rfc_35 as rfc };
         let origin_35: string;
         export { origin_35 as origin };
         let impacts_35: string;
         export { impacts_35 as impacts };
     }
-    export { CO_1 as CO };
-    export namespace CU {
+    export namespace CD {
         let id_36: string;
         export { id_36 as id };
         let label_36: string;
@@ -653,14 +657,14 @@ export namespace HEAVY_METALS {
         export { unit_36 as unit };
         let type_36: string;
         export { type_36 as type };
-        let rfc_36: any;
+        let rfc_36: number;
         export { rfc_36 as rfc };
         let origin_36: string;
         export { origin_36 as origin };
         let impacts_36: string;
         export { impacts_36 as impacts };
     }
-    export namespace FE {
+    export namespace CR {
         let id_37: string;
         export { id_37 as id };
         let label_37: string;
@@ -671,14 +675,14 @@ export namespace HEAVY_METALS {
         export { unit_37 as unit };
         let type_37: string;
         export { type_37 as type };
-        let rfc_37: any;
+        let rfc_37: number;
         export { rfc_37 as rfc };
         let origin_37: string;
         export { origin_37 as origin };
         let impacts_37: string;
         export { impacts_37 as impacts };
     }
-    export namespace PB {
+    export namespace CO_1 {
         let id_38: string;
         export { id_38 as id };
         let label_38: string;
@@ -689,14 +693,15 @@ export namespace HEAVY_METALS {
         export { unit_38 as unit };
         let type_38: string;
         export { type_38 as type };
-        let rfc_38: number;
+        let rfc_38: any;
         export { rfc_38 as rfc };
         let origin_38: string;
         export { origin_38 as origin };
         let impacts_38: string;
         export { impacts_38 as impacts };
     }
-    export namespace MN {
+    export { CO_1 as CO };
+    export namespace CU {
         let id_39: string;
         export { id_39 as id };
         let label_39: string;
@@ -707,14 +712,14 @@ export namespace HEAVY_METALS {
         export { unit_39 as unit };
         let type_39: string;
         export { type_39 as type };
-        let rfc_39: number;
+        let rfc_39: any;
         export { rfc_39 as rfc };
         let origin_39: string;
         export { origin_39 as origin };
         let impacts_39: string;
         export { impacts_39 as impacts };
     }
-    export namespace NI {
+    export namespace FE {
         let id_40: string;
         export { id_40 as id };
         let label_40: string;
@@ -732,7 +737,7 @@ export namespace HEAVY_METALS {
         let impacts_40: string;
         export { impacts_40 as impacts };
     }
-    export namespace SE {
+    export namespace PB {
         let id_41: string;
         export { id_41 as id };
         let label_41: string;
@@ -743,14 +748,14 @@ export namespace HEAVY_METALS {
         export { unit_41 as unit };
         let type_41: string;
         export { type_41 as type };
-        let rfc_41: any;
+        let rfc_41: number;
         export { rfc_41 as rfc };
         let origin_41: string;
         export { origin_41 as origin };
         let impacts_41: string;
         export { impacts_41 as impacts };
     }
-    export namespace ZN {
+    export namespace MN {
         let id_42: string;
         export { id_42 as id };
         let label_42: string;
@@ -761,12 +766,66 @@ export namespace HEAVY_METALS {
         export { unit_42 as unit };
         let type_42: string;
         export { type_42 as type };
-        let rfc_42: any;
+        let rfc_42: number;
         export { rfc_42 as rfc };
         let origin_42: string;
         export { origin_42 as origin };
         let impacts_42: string;
         export { impacts_42 as impacts };
     }
+    export namespace NI {
+        let id_43: string;
+        export { id_43 as id };
+        let label_43: string;
+        export { label_43 as label };
+        let name_43: string;
+        export { name_43 as name };
+        let unit_43: string;
+        export { unit_43 as unit };
+        let type_43: string;
+        export { type_43 as type };
+        let rfc_43: any;
+        export { rfc_43 as rfc };
+        let origin_43: string;
+        export { origin_43 as origin };
+        let impacts_43: string;
+        export { impacts_43 as impacts };
+    }
+    export namespace SE {
+        let id_44: string;
+        export { id_44 as id };
+        let label_44: string;
+        export { label_44 as label };
+        let name_44: string;
+        export { name_44 as name };
+        let unit_44: string;
+        export { unit_44 as unit };
+        let type_44: string;
+        export { type_44 as type };
+        let rfc_44: any;
+        export { rfc_44 as rfc };
+        let origin_44: string;
+        export { origin_44 as origin };
+        let impacts_44: string;
+        export { impacts_44 as impacts };
+    }
+    export namespace ZN {
+        let id_45: string;
+        export { id_45 as id };
+        let label_45: string;
+        export { label_45 as label };
+        let name_45: string;
+        export { name_45 as name };
+        let unit_45: string;
+        export { unit_45 as unit };
+        let type_45: string;
+        export { type_45 as type };
+        let rfc_45: any;
+        export { rfc_45 as rfc };
+        let origin_45: string;
+        export { origin_45 as origin };
+        let impacts_45: string;
+        export { impacts_45 as impacts };
+    }
 }
 //# sourceMappingURL=pollutants.d.ts.map

package/dist/constants/pollutants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pollutants.d.ts","sourceRoot":"","sources":["../../src/constants/pollutants.js"],"names":[],"mappings":""}
+{"version":3,"file":"pollutants.d.ts","sourceRoot":"","sources":["../../src/constants/pollutants.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+UA;;;;GAIG"}

package/dist/constants/timezones.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"timezones.d.ts","sourceRoot":"","sources":["../../src/constants/timezones.js"],"names":[],"mappings":"AAKA,kDAAmD"}
+{"version":3,"file":"timezones.d.ts","sourceRoot":"","sources":["../../src/constants/timezones.js"],"names":[],"mappings":"AAWA,kDAAmD"}

package/dist/index.d.ts

@@ -97,8 +97,11 @@ import { validateDateOrder as validateDataDownloadDateOrder } from "./utils/data
 import { validateMaxDateRange as validateDataDownloadMaxDateRange } from "./utils/dataDownloadValidation.js";
 import { validateDownloadEmail as validateDataDownloadEmail } from "./utils/dataDownloadValidation.js";
 import { normalizeDownloadEmail as normalizeDataDownloadEmail } from "./utils/dataDownloadValidation.js";
+import { validateDownloadTimezone as validateDataDownloadTimezone } from "./utils/dataDownloadValidation.js";
+import { normalizeDownloadTimezone as normalizeDataDownloadTimezone } from "./utils/dataDownloadValidation.js";
 import { PARAMETERS } from "./constants/pollutants.js";
 import { HEAVY_METALS } from "./constants/pollutants.js";
+import { INTERNAL_TO_AMBIENT_PARAMETERS } from "./constants/pollutants.js";
 import { ALERT_LEVEL_WEIGHTS } from "./constants/alertLevels.js";
 import { getAlertWeight } from "./constants/alertLevels.js";
 import { splitName } from "./utils/splitName.js";
@@ -111,5 +114,5 @@ import { validateQuietHours } from "./utils/quietHours.js";
 import { getZoneMinutes } from "./utils/quietHours.js";
 import { isInQuietWindow } from "./utils/quietHours.js";
 import { resolveQuietHours } from "./utils/quietHours.js";
-export { Database, adminSchema, Admin, configurationsSchema, Configurations, measurementsSchema, Measurements, monitorRequestsSchema, MonitorRequests, monitorsSchema, Monitors, organizationsSchema, Organizations, usersSchema, Users, COOKIE_CONSENT_CATEGORIES, COOKIE_CONSENT_VALUES, validateCookieConsent, eventsSchema, Events, lightMonitorSchema, LightMonitors, monitorSuppliersSchema, MonitorSuppliers, contextsSchema, Contexts, parametersSchema, Parameters, announcementSchema, Announcements, jobsSchema, Jobs, apiKeySchema, ApiKey, UsageMetrics, usageMetricsSchema, Audit, auditSchema, EventsAudit, eventsAuditSchema, MonitorAudit, monitorAuditSchema, parametersEnum, deploymentTypesEnum, AlertsAudit, Alerts, alertsSchema, alertsAuditSchema, Features, featuresSchema, dataCompletenessSchema, DataCompleteness, networkMetricsSchema, NetworkMetrics, rateOfChangeSchema, RateOfChange, changeStreamCheckpointsSchema, ChangeStreamCheckpoints, sitesSchema, Sites, sampleSitesSchema, SampleSites, sampleSiteAuditSchema, SampleSiteAudit, sampleParametersEnum, samplesSchema, Samples, samplesAuditSchema, SamplesAudit, sampleParameterReferenceConcentrations, passwordResetTokenSchema, PasswordResetToken, monitorEpisodesSchema, MonitorEpisode, userNotificationsSchema, UserNotification, AqiAlertNotification, DeviceOfflineNotification, WeeklyDigestNotification, AccountNotification, NOTIFICATION_KINDS, NOTIFICATION_CHANNELS, DELIVERY_STATUSES, DATA_DOWNLOAD_TYPES, dataDownloadSchema, DataDownloads, AqiDataDownload, SampleDataDownload, DATA_DOWNLOAD_MAX_RANGE_DAYS, DATA_DOWNLOAD_ERRORS, validateDataDownloadDateOrder, validateDataDownloadMaxDateRange, validateDataDownloadEmail, normalizeDataDownloadEmail, PARAMETERS, HEAVY_METALS, ALERT_LEVEL_WEIGHTS, getAlertWeight, splitName, DEFAULT_QUIET_HOURS, DEFAULT_TIMEZONE, QUIET_HOURS_ERRORS, isValidTimeString, isValidIANATimezone, validateQuietHours, getZoneMinutes, isInQuietWindow, resolveQuietHours };
+export { Database, adminSchema, Admin, configurationsSchema, Configurations, measurementsSchema, Measurements, monitorRequestsSchema, MonitorRequests, monitorsSchema, Monitors, organizationsSchema, Organizations, usersSchema, Users, COOKIE_CONSENT_CATEGORIES, COOKIE_CONSENT_VALUES, validateCookieConsent, eventsSchema, Events, lightMonitorSchema, LightMonitors, monitorSuppliersSchema, MonitorSuppliers, contextsSchema, Contexts, parametersSchema, Parameters, announcementSchema, Announcements, jobsSchema, Jobs, apiKeySchema, ApiKey, UsageMetrics, usageMetricsSchema, Audit, auditSchema, EventsAudit, eventsAuditSchema, MonitorAudit, monitorAuditSchema, parametersEnum, deploymentTypesEnum, AlertsAudit, Alerts, alertsSchema, alertsAuditSchema, Features, featuresSchema, dataCompletenessSchema, DataCompleteness, networkMetricsSchema, NetworkMetrics, rateOfChangeSchema, RateOfChange, changeStreamCheckpointsSchema, ChangeStreamCheckpoints, sitesSchema, Sites, sampleSitesSchema, SampleSites, sampleSiteAuditSchema, SampleSiteAudit, sampleParametersEnum, samplesSchema, Samples, samplesAuditSchema, SamplesAudit, sampleParameterReferenceConcentrations, passwordResetTokenSchema, PasswordResetToken, monitorEpisodesSchema, MonitorEpisode, userNotificationsSchema, UserNotification, AqiAlertNotification, DeviceOfflineNotification, WeeklyDigestNotification, AccountNotification, NOTIFICATION_KINDS, NOTIFICATION_CHANNELS, DELIVERY_STATUSES, DATA_DOWNLOAD_TYPES, dataDownloadSchema, DataDownloads, AqiDataDownload, SampleDataDownload, DATA_DOWNLOAD_MAX_RANGE_DAYS, DATA_DOWNLOAD_ERRORS, validateDataDownloadDateOrder, validateDataDownloadMaxDateRange, validateDataDownloadEmail, normalizeDataDownloadEmail, validateDataDownloadTimezone, normalizeDataDownloadTimezone, PARAMETERS, HEAVY_METALS, INTERNAL_TO_AMBIENT_PARAMETERS, ALERT_LEVEL_WEIGHTS, getAlertWeight, splitName, DEFAULT_QUIET_HOURS, DEFAULT_TIMEZONE, QUIET_HOURS_ERRORS, isValidTimeString, isValidIANATimezone, validateQuietHours, getZoneMinutes, isInQuietWindow, resolveQuietHours };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"AAkJA;;;iBAEC;yBAlFwB,oBAAoB;qBADxB,gBAAgB;4BAjEF,mBAAmB;sBAAnB,mBAAmB;qCAI/C,4BAA4B;+BAA5B,4BAA4B;mCAM5B,0BAA0B;6BAA1B,0BAA0B;sCAI1B,6BAA6B;gCAA7B,6BAA6B;+BAQ7B,sBAAsB;yBAAtB,sBAAsB;oCACsB,2BAA2B;8BAA3B,2BAA2B;4BAcvE,mBAAmB;sBAAnB,mBAAmB;0CAAnB,mBAAmB;sCAAnB,mBAAmB;sCAAnB,mBAAmB;6BAMnB,oBAAoB;uBAApB,oBAAoB;mCAnBuB,2BAA2B;8BAA3B,2BAA2B;uCAItE,8BAA8B;iCAA9B,8BAA8B;+BACI,sBAAsB;yBAAtB,sBAAsB;iCAClB,wBAAwB;2BAAxB,wBAAwB;mCAcnB,2BAA2B;8BAA3B,2BAA2B;2BAC5C,kBAAkB;qBAAlB,kBAAkB;6BACd,oBAAoB;uBAApB,oBAAoB;6BACR,0BAA0B;mCAA1B,0BAA0B;sBArCpE,0BAA0B;4BAA1B,0BAA0B;4BAiC1B,oBAAoB;kCAApB,oBAAoB;6BArBpB,sBAAsB;mCAAtB,sBAAsB;+BAAtB,sBAAsB;oCAAtB,sBAAsB;4BA+BtB,oBAAoB;uBAApB,oBAAoB;6BAApB,oBAAoB;kCAApB,oBAAoB;yBACc,sBAAsB;+BAAtB,sBAAsB;uCAIxD,8BAA8B;iCAA9B,8BAA8B;qCACgB,4BAA4B;+BAA5B,4BAA4B;mCAChC,0BAA0B;6BAA1B,0BAA0B;8CAIpE,qCAAqC;wCAArC,qCAAqC;4BAmCT,mBAAmB;sBAAnB,mBAAmB;kCAS/C,yBAAyB;4BAAzB,yBAAyB;sCAAzB,yBAAyB;gCAAzB,yBAAyB;qCAAzB,yBAAyB;8BASzB,qBAAqB;wBAArB,qBAAqB;mCAArB,qBAAqB;6BAArB,qBAAqB;uDAArB,qBAAqB;yCACiC,gCAAgC;mCAAhC,gCAAgC;sCA5CtF,6BAA6B;+BAA7B,6BAA6B;wCAW7B,+BAA+B;iCAA/B,+BAA+B;qCAA/B,+BAA+B;0CAA/B,+BAA+B;yCAA/B,+BAA+B;oCAA/B,+BAA+B;mCAA/B,+BAA+B;sCAA/B,+BAA+B;kCAA/B,+BAA+B;oCAfF,8BAA8B;mCAsD3D,2BAA2B;8BAA3B,2BAA2B;gCAA3B,2BAA2B;mCAA3B,2BAA2B;+DAoB3B,mCAAmC;qCAAnC,mCAAmC;mEAAnC,mCAAmC;yEAAnC,mCAAmC;mEAAnC,mCAAmC;qEAAnC,mCAAmC;2BA7ED,2BAA2B;6BAA3B,2BAA2B;oCAChB,4BAA4B;+BAA5B,4BAA4B;0BAkBtD,sBAAsB;oCASzC,uBAAuB;iCA1BG,0BAA0B;mCA0BpD,uBAAuB;kCAAvB,uBAAuB;oCACM,qBAAqB;mCADlD,uBAAuB;+BAAvB,uBAAuB;gCAAvB,uBAAuB;kCAAvB,uBAAuB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"AAoJA;;;iBAEC;yBApFwB,oBAAoB;qBADxB,gBAAgB;4BAjEF,mBAAmB;sBAAnB,mBAAmB;qCAI/C,4BAA4B;+BAA5B,4BAA4B;mCAM5B,0BAA0B;6BAA1B,0BAA0B;sCAI1B,6BAA6B;gCAA7B,6BAA6B;+BAQ7B,sBAAsB;yBAAtB,sBAAsB;oCACsB,2BAA2B;8BAA3B,2BAA2B;4BAcvE,mBAAmB;sBAAnB,mBAAmB;0CAAnB,mBAAmB;sCAAnB,mBAAmB;sCAAnB,mBAAmB;6BAMnB,oBAAoB;uBAApB,oBAAoB;mCAnBuB,2BAA2B;8BAA3B,2BAA2B;uCAItE,8BAA8B;iCAA9B,8BAA8B;+BACI,sBAAsB;yBAAtB,sBAAsB;iCAClB,wBAAwB;2BAAxB,wBAAwB;mCAcnB,2BAA2B;8BAA3B,2BAA2B;2BAC5C,kBAAkB;qBAAlB,kBAAkB;6BACd,oBAAoB;uBAApB,oBAAoB;6BACR,0BAA0B;mCAA1B,0BAA0B;sBArCpE,0BAA0B;4BAA1B,0BAA0B;4BAiC1B,oBAAoB;kCAApB,oBAAoB;6BArBpB,sBAAsB;mCAAtB,sBAAsB;+BAAtB,sBAAsB;oCAAtB,sBAAsB;4BA+BtB,oBAAoB;uBAApB,oBAAoB;6BAApB,oBAAoB;kCAApB,oBAAoB;yBACc,sBAAsB;+BAAtB,sBAAsB;uCAIxD,8BAA8B;iCAA9B,8BAA8B;qCACgB,4BAA4B;+BAA5B,4BAA4B;mCAChC,0BAA0B;6BAA1B,0BAA0B;8CAIpE,qCAAqC;wCAArC,qCAAqC;4BAmCT,mBAAmB;sBAAnB,mBAAmB;kCAS/C,yBAAyB;4BAAzB,yBAAyB;sCAAzB,yBAAyB;gCAAzB,yBAAyB;qCAAzB,yBAAyB;8BASzB,qBAAqB;wBAArB,qBAAqB;mCAArB,qBAAqB;6BAArB,qBAAqB;uDAArB,qBAAqB;yCACiC,gCAAgC;mCAAhC,gCAAgC;sCA5CtF,6BAA6B;+BAA7B,6BAA6B;wCAW7B,+BAA+B;iCAA/B,+BAA+B;qCAA/B,+BAA+B;0CAA/B,+BAA+B;yCAA/B,+BAA+B;oCAA/B,+BAA+B;mCAA/B,+BAA+B;sCAA/B,+BAA+B;kCAA/B,+BAA+B;oCAfF,8BAA8B;mCAsD3D,2BAA2B;8BAA3B,2BAA2B;gCAA3B,2BAA2B;mCAA3B,2BAA2B;+DAsB3B,mCAAmC;qCAAnC,mCAAmC;mEAAnC,mCAAmC;yEAAnC,mCAAmC;mEAAnC,mCAAmC;qEAAnC,mCAAmC;yEAAnC,mCAAmC;2EAAnC,mCAAmC;2BA/E+B,2BAA2B;6BAA3B,2BAA2B;+CAA3B,2BAA2B;oCAChD,4BAA4B;+BAA5B,4BAA4B;0BAkBtD,sBAAsB;oCASzC,uBAAuB;iCA1BG,0BAA0B;mCA0BpD,uBAAuB;kCAAvB,uBAAuB;oCACM,qBAAqB;mCADlD,uBAAuB;+BAAvB,uBAAuB;gCAAvB,uBAAuB;kCAAvB,uBAAuB"}

package/dist/models/dataDownloads.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dataDownloads.d.ts","sourceRoot":"","sources":["../../src/models/dataDownloads.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DE;AAqDF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA0E;AAY1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAIE;qBA/JmB,UAAU"}
+{"version":3,"file":"dataDownloads.d.ts","sourceRoot":"","sources":["../../src/models/dataDownloads.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DE;AA2DF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA0E;AAY1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAIE;qBAtKmB,UAAU"}

package/dist/utils/dataDownloadValidation.d.ts

@@ -18,4 +18,9 @@ export function validateDownloadEmail({ email }?: {}): {
     code: "invalid_email";
     message: string;
 }[];
+export function normalizeDownloadTimezone(value: any): any;
+export function validateDownloadTimezone({ timezone }?: {}): {
+    code: "invalid_timezone";
+    message: string;
+}[];
 //# sourceMappingURL=dataDownloadValidation.d.ts.map

package/dist/utils/dataDownloadValidation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dataDownloadValidation.d.ts","sourceRoot":"","sources":["../../src/utils/dataDownloadValidation.js"],"names":[],"mappings":"AAUA,gCAAiC;AAUjC;;;;;GAKG;AAmBI;;;IAcN;AAIM;;;IAcN;AAgBM,wDAMN;AAIM;;;IAqBN"}
+{"version":3,"file":"dataDownloadValidation.d.ts","sourceRoot":"","sources":["../../src/utils/dataDownloadValidation.js"],"names":[],"mappings":"AAYA,gCAAiC;AAUjC;;;;;GAKG;AAmBI;;;IAcN;AAIM;;;IAcN;AAgBM,wDAMN;AAIM;;;IAqBN;AAOM,2DAWN;AAOM;;;IAaN"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@justair/justair-library",
-  "version": "7.3.0-alpha.e85bbda",
+  "version": "7.3.0-alpha.f340581",
   "description": "JustAir Internal Library",
   "main": "src/index.js",
   "type": "module",

package/src/constants/dataDownloads.js

@@ -13,4 +13,7 @@
 // as a third type — add it here and register its discriminator in
 // models/dataDownloads.js, so no consumer has to hardcode the string.
 
-export const DATA_DOWNLOAD_TYPES = ["AQI", "Sample"];
+// Frozen because every importer in a process gets this same instance — one
+// consumer calling .sort() or .push() would silently reorder the picker for
+// all of them. Matches DATA_DOWNLOAD_ERRORS in dataDownloadValidation.js.
+export const DATA_DOWNLOAD_TYPES = Object.freeze(["AQI", "Sample"]);

package/src/constants/pollutants.js

@@ -151,6 +151,12 @@ export const PARAMETERS = {
     origin: null,
     impacts: null,
   },
+  // ---- T/RH/DP and their _AMB pairs (JA-3058). Does not apply to WD/WS below. ----
+  // Bare ids (T/RH/DP) are enclosure-internal, for corrections and fog detection only. The _AMB
+  // ids are true ambient and the only ones safe for public display or Heat Index. Never substitute
+  // one for the other. Caveat: five suppliers still write outdoor dew point into DP, so DP is
+  // exempt from the public-display filter until JA-3061 re-points them. See "Ambient vs internal
+  // met parameters" in CLAUDE.md before wiring up.
   DP: {
     id: "DP",
     label: "Dew Point",
@@ -161,6 +167,16 @@ export const PARAMETERS = {
     origin: null,
     impacts: null,
   },
+  DP_AMB: {
+    id: "DP_AMB",
+    label: "Ambient Dew Point",
+    name: "Ambient Dew Point (DP_AMB)",
+    unit: "°F",
+    type: "Weather",
+    rfc: null,
+    origin: null,
+    impacts: null,
+  },
   RH: {
     id: "RH",
     label: "Humidity",
@@ -171,6 +187,16 @@ export const PARAMETERS = {
     origin: null,
     impacts: null,
   },
+  RH_AMB: {
+    id: "RH_AMB",
+    label: "Ambient Humidity",
+    name: "Ambient Relative Humidity (RH_AMB)",
+    unit: "%",
+    type: "Weather",
+    rfc: null,
+    origin: null,
+    impacts: null,
+  },
   T: {
     id: "T",
     label: "Temperature",
@@ -181,6 +207,16 @@ export const PARAMETERS = {
     origin: null,
     impacts: null,
   },
+  T_AMB: {
+    id: "T_AMB",
+    label: "Ambient Temperature",
+    name: "Ambient Temperature (T_AMB)",
+    unit: "°F",
+    type: "Weather",
+    rfc: null,
+    origin: null,
+    impacts: null,
+  },
   WD: {
     id: "WD",
     label: "Wind Direction",
@@ -293,6 +329,16 @@ export const PARAMETERS = {
   },
 };
 
+// Internal parameter id -> its ambient counterpart (JA-3058). Lets consumers filter on data
+// instead of hardcoding the six met ids: the keys are the enclosure-internal parameters that must
+// stay off public surfaces, the values are the ambient ones that are safe to show. Kept in sync
+// with PARAMETERS by a test in tests/pollutants.test.js.
+export const INTERNAL_TO_AMBIENT_PARAMETERS = Object.freeze({
+  T: "T_AMB",
+  RH: "RH_AMB",
+  DP: "DP_AMB",
+});
+
 // Parameters analyzed from physical air samples in a laboratory.
 // These correspond to SampleSites.parameters and are not measured by real-time sensors.
 export const HEAVY_METALS = {

package/src/constants/tests/constantsBarrel.test.js

@@ -4,14 +4,15 @@
 // importing PARAMETERS / HEAVY_METALS through the barrel must see the exact
 // same objects as before.
 import * as barrel from '../index.js';
-import { PARAMETERS, HEAVY_METALS } from '../pollutants.js';
+import { PARAMETERS, HEAVY_METALS, INTERNAL_TO_AMBIENT_PARAMETERS } from '../pollutants.js';
 import { ALERT_LEVEL_WEIGHTS, getAlertWeight } from '../alertLevels.js';
 import { DEFAULT_TIMEZONE } from '../timezones.js';
 import { DATA_DOWNLOAD_TYPES } from '../dataDownloads.js';
 
-test('barrel re-exports PARAMETERS and HEAVY_METALS unchanged (identity, not copies)', () => {
+test('barrel re-exports the pollutants constants unchanged (identity, not copies)', () => {
   expect(barrel.PARAMETERS).toBe(PARAMETERS);
   expect(barrel.HEAVY_METALS).toBe(HEAVY_METALS);
+  expect(barrel.INTERNAL_TO_AMBIENT_PARAMETERS).toBe(INTERNAL_TO_AMBIENT_PARAMETERS);
 });
 
 test('barrel exports the alert-level constants', () => {

package/src/constants/tests/pollutants.test.js

@@ -1,4 +1,4 @@
-import { PARAMETERS, HEAVY_METALS } from "../pollutants.js";
+import { PARAMETERS, HEAVY_METALS, INTERNAL_TO_AMBIENT_PARAMETERS } from "../pollutants.js";
 
 const REQUIRED_FIELDS = ["id", "label", "name", "unit", "type"];
 const VALID_TYPES = [
@@ -69,6 +69,28 @@ function sharedAssertions(constants) {
 
 describe("PARAMETERS", () => {
   sharedAssertions(PARAMETERS);
+
+  // JA-3060: Processing-Engine hardcodes these ids, so lock the ambient/internal pairing.
+  const ambientKeys = Object.keys(PARAMETERS).filter((key) => key.endsWith("_AMB"));
+
+  test("the _AMB parameter set is exactly T, RH and DP", () => {
+    expect(ambientKeys.sort()).toEqual(["DP_AMB", "RH_AMB", "T_AMB"]);
+  });
+
+  test("INTERNAL_TO_AMBIENT_PARAMETERS matches the _AMB ids actually defined", () => {
+    expect(Object.values(INTERNAL_TO_AMBIENT_PARAMETERS).sort()).toEqual(ambientKeys.sort());
+    Object.entries(INTERNAL_TO_AMBIENT_PARAMETERS).forEach(([bare, ambient]) => {
+      expect(PARAMETERS[bare]).toBeDefined();
+      expect(ambient).toBe(`${bare}_AMB`);
+    });
+  });
+
+  test.each(ambientKeys)("%s pairs with its bare parameter on unit and type", (key) => {
+    const bare = PARAMETERS[key.replace(/_AMB$/, "")];
+    expect(bare).toBeDefined();
+    expect(PARAMETERS[key].unit).toBe(bare.unit);
+    expect(PARAMETERS[key].type).toBe(bare.type);
+  });
 });
 
 describe("HEAVY_METALS", () => {

package/src/constants/timezones.js

@@ -3,4 +3,10 @@
 // Originally lived in utils/quietHours.js (JA-3054); moved here once a
 // second, unrelated domain (dataDownloads.js, JA-3080) needed it too.
 
+// Deliberately no DOWNLOAD_TIMEZONES / TIMEZONE_OPTIONS list here. The
+// download modal's "Set Timezone" dropdown offers display labels ("Eastern
+// Standard Time (EST)") over IANA values, and labels are a view concern:
+// this library has no i18n and no view layer, so a label map would drift from
+// design the first time the copy changed. The validator accepts any zone Intl
+// accepts (utils/timezone.js), so the consumer owns which subset it offers.
 export const DEFAULT_TIMEZONE = "America/New_York";

package/src/index.js

@@ -65,7 +65,7 @@ import {
 } from "./models/changeStreamCheckpoints.js";
 import Database from "./config/db.js"; // Import the new Database class
 import CustomLogger from "./config/logger.js";
-import { PARAMETERS, HEAVY_METALS } from "./constants/pollutants.js";
+import { PARAMETERS, HEAVY_METALS, INTERNAL_TO_AMBIENT_PARAMETERS } from "./constants/pollutants.js";
 import { ALERT_LEVEL_WEIGHTS, getAlertWeight } from "./constants/alertLevels.js";
 import { DEFAULT_TIMEZONE } from "./constants/timezones.js";
 import { DATA_DOWNLOAD_TYPES } from "./constants/dataDownloads.js";
@@ -142,6 +142,8 @@ import {
   validateMaxDateRange as validateDataDownloadMaxDateRange,
   validateDownloadEmail as validateDataDownloadEmail,
   normalizeDownloadEmail as normalizeDataDownloadEmail,
+  validateDownloadTimezone as validateDataDownloadTimezone,
+  normalizeDownloadTimezone as normalizeDataDownloadTimezone,
 } from "./utils/dataDownloadValidation.js";
 
 export function createLoggerInstance({ DATADOG_API_KEY, APPLICATION_NAME }) {
@@ -249,9 +251,12 @@ export {
   validateDataDownloadMaxDateRange,
   validateDataDownloadEmail,
   normalizeDataDownloadEmail,
+  validateDataDownloadTimezone,
+  normalizeDataDownloadTimezone,
   // Pollutant constants
   PARAMETERS,
   HEAVY_METALS,
+  INTERNAL_TO_AMBIENT_PARAMETERS,
   // AQI alert-level hierarchy (single source of truth)
   ALERT_LEVEL_WEIGHTS,
   getAlertWeight,

package/src/models/dataDownloads.js

@@ -1,13 +1,14 @@
 import mongoose from "mongoose";
 import { DATA_DOWNLOAD_TYPES } from "../constants/dataDownloads.js";
 import { DEFAULT_TIMEZONE } from "../constants/timezones.js";
-import { isValidIANATimezone } from "../utils/timezone.js";
 import {
   DATA_DOWNLOAD_ERRORS,
   validateDateOrder,
   validateMaxDateRange,
   validateDownloadEmail,
   normalizeDownloadEmail,
+  validateDownloadTimezone,
+  normalizeDownloadTimezone,
 } from "../utils/dataDownloadValidation.js";
 
 // DataDownloads — one doc per data download request (JA-3080). Written by
@@ -30,10 +31,10 @@ const dataDownloadSchema = new mongoose.Schema(
     },
     dateRangeStart: { type: Date, required: [true, "dateRangeStart is required"] },
     dateRangeEnd: { type: Date, required: [true, "dateRangeEnd is required"] },
-    // `default` only applies to `undefined`, not `null`, so an explicit
-    // `timezone: null` (the normal shape of "didn't pick one" in a JSON body)
-    // is coerced in a setter — setters run on query updates, the pre('validate')
-    // hook below does not.
+    // `default` only applies to `undefined`, not `null` or "", so both of the
+    // other "didn't pick one" shapes (a JSON body's null, an untouched HTML
+    // <select>'s empty string) are coerced in a setter — setters run on query
+    // updates, the pre('validate') hook below does not.
     //
     // This guarantees less than "always valid": `runValidators` defaults to
     // false on query updates, so an updateOne can still persist a bad zone.
@@ -42,9 +43,9 @@ const dataDownloadSchema = new mongoose.Schema(
       type: String,
       trim: true,
       default: DEFAULT_TIMEZONE,
-      set: (value) => (value === null ? DEFAULT_TIMEZONE : value),
+      set: normalizeDownloadTimezone,
       validate: {
-        validator: isValidIANATimezone,
+        validator: (value) => validateDownloadTimezone({ timezone: value }).length === 0,
         message: "timezone must be a valid IANA timezone identifier",
         type: DATA_DOWNLOAD_ERRORS.INVALID_TIMEZONE,
       },
@@ -93,6 +94,12 @@ const dataDownloadSchema = new mongoose.Schema(
 //
 // Passes the error code as invalidate()'s `kind` so a caught ValidationError
 // can be classified via err.errors.<path>.kind, not by message wording.
+//
+// Same caveat the `timezone` field carries: pre('validate') never runs on a
+// query update, so a `$set` of dateRangeStart/dateRangeEnd can persist a
+// reversed or over-length range even with { runValidators: true }. Deliberate
+// — the rules are cross-field, and query updates have no full document to
+// check. Writers should go through create()/save(); readers must still defend.
 dataDownloadSchema.pre("validate", function () {
   const rangeErrors = validateDateOrder({ start: this.dateRangeStart, end: this.dateRangeEnd });
   for (const error of rangeErrors) {

package/src/utils/dataDownloadValidation.js

@@ -1,10 +1,12 @@
 // Data download validation (JA-3080/JA-3245): the shared field and cross-field
 // rules for a DataDownloads document — date range order, the AQI-only length
-// cap, and the optional email. Pure functions, no DB, no clock reads. Same
-// shape as quietHours.js's cross-field validator.
+// cap, the optional email, and the timezone. Pure functions, no DB, no clock
+// reads. Same shape as quietHours.js's cross-field validator.
 //
 // Two separate rules, deliberately not one function: end-must-not-precede-
 // start applies to every download kind, but the 31-day cap is AQI-only.
+import { isValidIANATimezone } from "./timezone.js";
+import { DEFAULT_TIMEZONE } from "../constants/timezones.js";
 
 // Messaging only ("range cannot exceed 31 days"). validateMaxDateRange is the
 // sole authority on the enforced bound; don't rebuild the cap from this.
@@ -122,3 +124,41 @@ export const validateDownloadEmail = ({ email } = {}) => {
     },
   ];
 };
+
+// Every shape of "didn't pick one" resolves to the default, mirroring
+// normalizeDownloadEmail's blank-collapses-to-null contract. An untouched HTML
+// <select> posts "" and a JSON body usually carries null, so treating only one
+// of them as unset rejects a download for a field the user never touched.
+// `undefined` passes through so the schema's own `default` still applies.
+export const normalizeDownloadTimezone = (value) => {
+  if (value === undefined) {
+    return value;
+  }
+  if (value === null) {
+    return DEFAULT_TIMEZONE;
+  }
+  if (typeof value === "string" && value.trim() === "") {
+    return DEFAULT_TIMEZONE;
+  }
+  return value;
+};
+
+// Returns { code, message }[]; empty = valid. Anything normalizeDownloadTimezone
+// resolves to the default is valid here too, so a consumer pre-validating a
+// request body accepts exactly what the model stores. isValidIANATimezone alone
+// rejects null and "", which would fail a request the model saves happily —
+// the write-path/read-path split the email rules exist to avoid.
+export const validateDownloadTimezone = ({ timezone } = {}) => {
+  if (normalizeDownloadTimezone(timezone) !== timezone) {
+    return [];
+  }
+  if (timezone === undefined || isValidIANATimezone(timezone)) {
+    return [];
+  }
+  return [
+    {
+      code: DATA_DOWNLOAD_ERRORS.INVALID_TIMEZONE,
+      message: "timezone must be a valid IANA timezone identifier",
+    },
+  ];
+};

package/src/utils/tests/dataDownloadValidation.test.js

@@ -4,8 +4,11 @@ import {
   validateDateOrder,
   validateMaxDateRange,
   validateDownloadEmail,
+  validateDownloadTimezone,
+  normalizeDownloadTimezone,
   normalizeDownloadEmail,
 } from "../dataDownloadValidation.js";
+import { DEFAULT_TIMEZONE } from "../../constants/timezones.js";
 
 const DAY_MS = 24 * 60 * 60 * 1000;
 const HOUR_MS = 60 * 60 * 1000;
@@ -155,3 +158,56 @@ describe("validateDownloadEmail (email is optional — JA-3080)", () => {
     ]);
   });
 });
+
+describe("validateDownloadTimezone", () => {
+  test.each(["America/New_York", "America/Detroit", "UTC", "Asia/Tokyo"])(
+    "accepts %s",
+    (timezone) => {
+      expect(validateDownloadTimezone({ timezone })).toEqual([]);
+    }
+  );
+
+  // The schema setter resolves both to DEFAULT_TIMEZONE, so a consumer
+  // pre-validating a request body must accept what the model stores.
+  // An untouched <select> posts "", a JSON body usually carries null. Both mean
+  // "didn't pick one", so both must validate the way the setter resolves them.
+  test.each([null, undefined, "", "   "])(
+    "treats %p as valid (the setter fills the default)",
+    (timezone) => {
+      expect(validateDownloadTimezone({ timezone })).toEqual([]);
+    }
+  );
+
+  test("accepts a call with no argument at all", () => {
+    expect(validateDownloadTimezone()).toEqual([]);
+  });
+
+  test.each(["America/Fake_City", "Not/A_Zone", 5, {}])(
+    "flags %p with INVALID_TIMEZONE",
+    (timezone) => {
+      expect(validateDownloadTimezone({ timezone })).toEqual([
+        expect.objectContaining({ code: DATA_DOWNLOAD_ERRORS.INVALID_TIMEZONE }),
+      ]);
+    }
+  );
+});
+
+describe("normalizeDownloadTimezone", () => {
+  test.each([null, "", "   "])("resolves %p to the default", (value) => {
+    expect(normalizeDownloadTimezone(value)).toBe(DEFAULT_TIMEZONE);
+  });
+
+  // Passes through so the schema's own `default` still applies.
+  test("leaves undefined alone", () => {
+    expect(normalizeDownloadTimezone(undefined)).toBeUndefined();
+  });
+
+  test("leaves a real zone untouched", () => {
+    expect(normalizeDownloadTimezone("Asia/Tokyo")).toBe("Asia/Tokyo");
+  });
+
+  // Validation, not normalization, is what rejects these.
+  test.each(["Not/A_Zone", 5])("leaves invalid input %p for the validator", (value) => {
+    expect(normalizeDownloadTimezone(value)).toBe(value);
+  });
+});