@mostlyrightmd/core 0.1.0-rc.7

package/dist/validator.cjs

@@ -0,0 +1,1870 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/validator.ts
+var validator_exports = {};
+__export(validator_exports, {
+  validateRows: () => validateRows
+});
+module.exports = __toCommonJS(validator_exports);
+
+// src/exceptions/index.ts
+function toJsonSafe(value, seen) {
+  const visited = seen ?? /* @__PURE__ */ new WeakSet();
+  if (value === null || value === void 0) {
+    return null;
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : null;
+  }
+  if (typeof value === "bigint") {
+    if (value >= BigInt(Number.MIN_SAFE_INTEGER) && value <= BigInt(Number.MAX_SAFE_INTEGER)) {
+      return Number(value);
+    }
+    return { _repr_only: true, value: value.toString() };
+  }
+  if (value instanceof Date) {
+    if (Number.isNaN(value.getTime())) {
+      return null;
+    }
+    return value.toISOString();
+  }
+  if (Array.isArray(value)) {
+    if (visited.has(value)) {
+      return { _cycle: true, value: String(value) };
+    }
+    visited.add(value);
+    try {
+      return value.map((item) => toJsonSafe(item, visited));
+    } finally {
+      visited.delete(value);
+    }
+  }
+  if (typeof value === "object") {
+    if (visited.has(value)) {
+      return { _cycle: true, value: String(value) };
+    }
+    visited.add(value);
+    try {
+      const out = {};
+      for (const key of Object.keys(value)) {
+        if (typeof key !== "string") {
+          throw new TypeError(`toJsonSafe dict keys must be string; got ${typeof key}`);
+        }
+        out[key] = toJsonSafe(value[key], visited);
+      }
+      return out;
+    } finally {
+      visited.delete(value);
+    }
+  }
+  return { _repr_only: true, value: String(value) };
+}
+var TradewindsError = class extends Error {
+  /** Subclass override — the stable string enum surfaced via `errorCode`. */
+  static defaultErrorCode = "TRADEWINDS_ERROR";
+  errorCode;
+  source;
+  requestId;
+  constructor(message = "", options = {}) {
+    super(message);
+    this.name = new.target.name;
+    const ctor = this.constructor;
+    this.errorCode = options.errorCode ?? ctor.defaultErrorCode;
+    this.source = options.source ?? null;
+    this.requestId = options.requestId ?? null;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  /**
+   * Subclass hook returning the structured attributes for `toDict`.
+   * Values are passed through `toJsonSafe` by `toDict()`, so subclasses
+   * don't need to coerce values themselves.
+   */
+  payload() {
+    return {
+      error_code: this.errorCode,
+      message: this.message,
+      source: this.source,
+      request_id: this.requestId
+    };
+  }
+  /** Return a JSON-safe dict suitable for MCP `error.data`. */
+  toDict() {
+    const safe = toJsonSafe(this.payload());
+    return safe;
+  }
+};
+var SchemaValidationError = class extends TradewindsError {
+  static defaultErrorCode = "SCHEMA_VALIDATION_FAILED";
+  schemaId;
+  violations;
+  quarantineCount;
+  sampleViolations;
+  constructor(message, options) {
+    super(message, options);
+    this.schemaId = options.schemaId;
+    this.violations = [...options.violations ?? []];
+    this.quarantineCount = options.quarantineCount ?? 0;
+    this.sampleViolations = [...options.sampleViolations ?? []];
+  }
+  payload() {
+    return {
+      ...super.payload(),
+      schema_id: this.schemaId,
+      violations: this.violations,
+      quarantine_count: this.quarantineCount,
+      sample_violations: this.sampleViolations
+    };
+  }
+};
+var SourceMismatchError = class extends TradewindsError {
+  static defaultErrorCode = "SOURCE_MISMATCH";
+  /** Canonical role-name vocabulary (design.md §R). */
+  static VALID_ROLES = /* @__PURE__ */ new Set([
+    "observations",
+    "forecasts",
+    "settlement"
+  ]);
+  schemaSource;
+  dataSource;
+  role;
+  catalogWarning;
+  constructor(message, options) {
+    super(message, options);
+    this.schemaSource = options.schemaSource;
+    this.dataSource = options.dataSource;
+    this.role = options.role ?? null;
+    this.catalogWarning = options.catalogWarning ?? null;
+  }
+  payload() {
+    return {
+      ...super.payload(),
+      schema_source: this.schemaSource,
+      data_source: this.dataSource,
+      role: this.role,
+      catalog_warning: this.catalogWarning
+    };
+  }
+};
+
+// src/schemas/validators/schema_forecast_iem_mos_v1.js
+var schema_forecast_iem_mos_v1 = validate21;
+var schema32 = { "$id": "https://mostlyright.dev/schemas/schema.forecast.iem_mos.v1.json", "$schema": "https://json-schema.org/draft/2020-12/schema", "imperialRenames": { "dew_point_c": "dew_point_F", "temp_c": "temp_F", "wind_speed_ms": "wind_speed_kt" }, "properties": { "dew_point_c": { "description": "units: celsius", "type": ["null", "number"] }, "forecast_hour": { "description": "units: hours \u2014 (valid_at - issued_at).total_seconds() / 3600", "type": "integer" }, "issued_at": { "description": "model run time (from source `runtime` field)", "format": "date-time", "type": "string" }, "model": { "description": "e.g. NBE, GFS, LAV, MET", "type": "string" }, "precip_probability": { "description": "units: probability \u2014 bounded [0, 1]", "type": ["null", "number"] }, "sky_cover_pct": { "description": "units: percent \u2014 bounded [0, 100]", "type": ["integer", "null"] }, "station": { "type": "string" }, "temp_c": { "description": "units: celsius", "type": ["null", "number"] }, "valid_at": { "description": "forecast target time (from source `ftime`)", "format": "date-time", "type": "string" }, "wind_dir_deg": { "description": "units: degrees", "type": ["integer", "null"] }, "wind_speed_ms": { "description": "units: m/s", "type": ["null", "number"] } }, "required": ["forecast_hour", "issued_at", "model", "station", "valid_at"], "title": "schema.forecast.iem_mos.v1", "type": "object", "version": "v1" };
+function validate21(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  ;
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate21.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.forecast_hour === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "forecast_hour" }, message: "must have required property 'forecast_hour'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.issued_at === void 0) {
+      const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "issued_at" }, message: "must have required property 'issued_at'" };
+      if (vErrors === null) {
+        vErrors = [err1];
+      } else {
+        vErrors.push(err1);
+      }
+      errors++;
+    }
+    if (data.model === void 0) {
+      const err2 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "model" }, message: "must have required property 'model'" };
+      if (vErrors === null) {
+        vErrors = [err2];
+      } else {
+        vErrors.push(err2);
+      }
+      errors++;
+    }
+    if (data.station === void 0) {
+      const err3 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "station" }, message: "must have required property 'station'" };
+      if (vErrors === null) {
+        vErrors = [err3];
+      } else {
+        vErrors.push(err3);
+      }
+      errors++;
+    }
+    if (data.valid_at === void 0) {
+      const err4 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "valid_at" }, message: "must have required property 'valid_at'" };
+      if (vErrors === null) {
+        vErrors = [err4];
+      } else {
+        vErrors.push(err4);
+      }
+      errors++;
+    }
+    if (data.dew_point_c !== void 0) {
+      let data0 = data.dew_point_c;
+      if (data0 !== null && !(typeof data0 == "number")) {
+        const err5 = { instancePath: instancePath + "/dew_point_c", schemaPath: "#/properties/dew_point_c/type", keyword: "type", params: { type: schema32.properties.dew_point_c.type }, message: "must be null,number" };
+        if (vErrors === null) {
+          vErrors = [err5];
+        } else {
+          vErrors.push(err5);
+        }
+        errors++;
+      }
+    }
+    if (data.forecast_hour !== void 0) {
+      let data1 = data.forecast_hour;
+      if (!(typeof data1 == "number" && (!(data1 % 1) && !isNaN(data1)))) {
+        const err6 = { instancePath: instancePath + "/forecast_hour", schemaPath: "#/properties/forecast_hour/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+        if (vErrors === null) {
+          vErrors = [err6];
+        } else {
+          vErrors.push(err6);
+        }
+        errors++;
+      }
+    }
+    if (data.issued_at !== void 0) {
+      if (!(typeof data.issued_at === "string")) {
+        const err7 = { instancePath: instancePath + "/issued_at", schemaPath: "#/properties/issued_at/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err7];
+        } else {
+          vErrors.push(err7);
+        }
+        errors++;
+      }
+    }
+    if (data.model !== void 0) {
+      if (typeof data.model !== "string") {
+        const err8 = { instancePath: instancePath + "/model", schemaPath: "#/properties/model/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err8];
+        } else {
+          vErrors.push(err8);
+        }
+        errors++;
+      }
+    }
+    if (data.precip_probability !== void 0) {
+      let data4 = data.precip_probability;
+      if (data4 !== null && !(typeof data4 == "number")) {
+        const err9 = { instancePath: instancePath + "/precip_probability", schemaPath: "#/properties/precip_probability/type", keyword: "type", params: { type: schema32.properties.precip_probability.type }, message: "must be null,number" };
+        if (vErrors === null) {
+          vErrors = [err9];
+        } else {
+          vErrors.push(err9);
+        }
+        errors++;
+      }
+    }
+    if (data.sky_cover_pct !== void 0) {
+      let data5 = data.sky_cover_pct;
+      if (!(typeof data5 == "number" && (!(data5 % 1) && !isNaN(data5))) && data5 !== null) {
+        const err10 = { instancePath: instancePath + "/sky_cover_pct", schemaPath: "#/properties/sky_cover_pct/type", keyword: "type", params: { type: schema32.properties.sky_cover_pct.type }, message: "must be integer,null" };
+        if (vErrors === null) {
+          vErrors = [err10];
+        } else {
+          vErrors.push(err10);
+        }
+        errors++;
+      }
+    }
+    if (data.station !== void 0) {
+      if (typeof data.station !== "string") {
+        const err11 = { instancePath: instancePath + "/station", schemaPath: "#/properties/station/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err11];
+        } else {
+          vErrors.push(err11);
+        }
+        errors++;
+      }
+    }
+    if (data.temp_c !== void 0) {
+      let data7 = data.temp_c;
+      if (data7 !== null && !(typeof data7 == "number")) {
+        const err12 = { instancePath: instancePath + "/temp_c", schemaPath: "#/properties/temp_c/type", keyword: "type", params: { type: schema32.properties.temp_c.type }, message: "must be null,number" };
+        if (vErrors === null) {
+          vErrors = [err12];
+        } else {
+          vErrors.push(err12);
+        }
+        errors++;
+      }
+    }
+    if (data.valid_at !== void 0) {
+      if (!(typeof data.valid_at === "string")) {
+        const err13 = { instancePath: instancePath + "/valid_at", schemaPath: "#/properties/valid_at/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err13];
+        } else {
+          vErrors.push(err13);
+        }
+        errors++;
+      }
+    }
+    if (data.wind_dir_deg !== void 0) {
+      let data9 = data.wind_dir_deg;
+      if (!(typeof data9 == "number" && (!(data9 % 1) && !isNaN(data9))) && data9 !== null) {
+        const err14 = { instancePath: instancePath + "/wind_dir_deg", schemaPath: "#/properties/wind_dir_deg/type", keyword: "type", params: { type: schema32.properties.wind_dir_deg.type }, message: "must be integer,null" };
+        if (vErrors === null) {
+          vErrors = [err14];
+        } else {
+          vErrors.push(err14);
+        }
+        errors++;
+      }
+    }
+    if (data.wind_speed_ms !== void 0) {
+      let data10 = data.wind_speed_ms;
+      if (data10 !== null && !(typeof data10 == "number")) {
+        const err15 = { instancePath: instancePath + "/wind_speed_ms", schemaPath: "#/properties/wind_speed_ms/type", keyword: "type", params: { type: schema32.properties.wind_speed_ms.type }, message: "must be null,number" };
+        if (vErrors === null) {
+          vErrors = [err15];
+        } else {
+          vErrors.push(err15);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err16 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err16];
+    } else {
+      vErrors.push(err16);
+    }
+    errors++;
+  }
+  validate21.errors = vErrors;
+  return errors === 0;
+}
+validate21.evaluated = { "props": { "dew_point_c": true, "forecast_hour": true, "issued_at": true, "model": true, "precip_probability": true, "sky_cover_pct": true, "station": true, "temp_c": true, "valid_at": true, "wind_dir_deg": true, "wind_speed_ms": true }, "dynamicProps": false, "dynamicItems": false };
+
+// src/schemas/validators/schema_observation_ledger_v1.js
+var schema_observation_ledger_v1 = validate23;
+var schema34 = { "$id": "https://mostlyright.dev/schemas/schema.observation_ledger.v1.json", "$schema": "https://json-schema.org/draft/2020-12/schema", "properties": { "as_of_time": { "format": "date-time", "type": ["null", "string"] }, "dewpoint_c": { "description": "units: celsius", "type": ["null", "number"] }, "ingestion_id": { "type": ["null", "string"] }, "observation_kind": { "enum": ["METAR", "SPECI", null], "type": ["null", "string"] }, "observation_quality": { "description": "Lineage row-quality flag per LINEAGE-01; distinct from qc_status enum slot AND distinct from the obs_qc_status bitmask column per QC-05.", "enum": ["clean", "flagged", "suspect", null], "type": ["null", "string"] }, "observation_type": { "enum": ["METAR", "SPECI"], "type": "string" }, "observed_at": { "format": "date-time", "type": "string" }, "parser_name": { "enum": ["ghcnh", "iem", "mostlyright_v1", "ncei", null], "type": ["null", "string"] }, "parser_version": { "type": ["null", "string"] }, "provenance": { "enum": ["legacy", "reingested", null], "type": ["null", "string"] }, "qc_status": { "enum": ["clean", "flagged", "suspect", null], "type": ["null", "string"] }, "source": { "description": "ncei reserved per D-2.1-09; never written in v0.1.0.", "enum": ["awc", "ghcnh", "iem", "ncei"], "type": "string" }, "source_received_at": { "type": ["null", "string"] }, "station_code": { "type": "string" }, "temp_c": { "description": "units: celsius", "type": ["null", "number"] } }, "required": ["observation_type", "observed_at", "source", "station_code"], "title": "schema.observation_ledger.v1", "type": "object", "version": "v1" };
+function validate23(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  ;
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate23.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.observation_type === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "observation_type" }, message: "must have required property 'observation_type'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.observed_at === void 0) {
+      const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "observed_at" }, message: "must have required property 'observed_at'" };
+      if (vErrors === null) {
+        vErrors = [err1];
+      } else {
+        vErrors.push(err1);
+      }
+      errors++;
+    }
+    if (data.source === void 0) {
+      const err2 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "source" }, message: "must have required property 'source'" };
+      if (vErrors === null) {
+        vErrors = [err2];
+      } else {
+        vErrors.push(err2);
+      }
+      errors++;
+    }
+    if (data.station_code === void 0) {
+      const err3 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "station_code" }, message: "must have required property 'station_code'" };
+      if (vErrors === null) {
+        vErrors = [err3];
+      } else {
+        vErrors.push(err3);
+      }
+      errors++;
+    }
+    if (data.as_of_time !== void 0) {
+      let data0 = data.as_of_time;
+      if (data0 !== null && typeof data0 !== "string") {
+        const err4 = { instancePath: instancePath + "/as_of_time", schemaPath: "#/properties/as_of_time/type", keyword: "type", params: { type: schema34.properties.as_of_time.type }, message: "must be null,string" };
+        if (vErrors === null) {
+          vErrors = [err4];
+        } else {
+          vErrors.push(err4);
+        }
+        errors++;
+      }
+    }
+    if (data.dewpoint_c !== void 0) {
+      let data1 = data.dewpoint_c;
+      if (data1 !== null && !(typeof data1 == "number")) {
+        const err5 = { instancePath: instancePath + "/dewpoint_c", schemaPath: "#/properties/dewpoint_c/type", keyword: "type", params: { type: schema34.properties.dewpoint_c.type }, message: "must be null,number" };
+        if (vErrors === null) {
+          vErrors = [err5];
+        } else {
+          vErrors.push(err5);
+        }
+        errors++;
+      }
+    }
+    if (data.ingestion_id !== void 0) {
+      let data2 = data.ingestion_id;
+      if (data2 !== null && typeof data2 !== "string") {
+        const err6 = { instancePath: instancePath + "/ingestion_id", schemaPath: "#/properties/ingestion_id/type", keyword: "type", params: { type: schema34.properties.ingestion_id.type }, message: "must be null,string" };
+        if (vErrors === null) {
+          vErrors = [err6];
+        } else {
+          vErrors.push(err6);
+        }
+        errors++;
+      }
+    }
+    if (data.observation_kind !== void 0) {
+      let data3 = data.observation_kind;
+      if (data3 !== null && typeof data3 !== "string") {
+        const err7 = { instancePath: instancePath + "/observation_kind", schemaPath: "#/properties/observation_kind/type", keyword: "type", params: { type: schema34.properties.observation_kind.type }, message: "must be null,string" };
+        if (vErrors === null) {
+          vErrors = [err7];
+        } else {
+          vErrors.push(err7);
+        }
+        errors++;
+      }
+      if (!(data3 === "METAR" || data3 === "SPECI" || data3 === null)) {
+        const err8 = { instancePath: instancePath + "/observation_kind", schemaPath: "#/properties/observation_kind/enum", keyword: "enum", params: { allowedValues: schema34.properties.observation_kind.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err8];
+        } else {
+          vErrors.push(err8);
+        }
+        errors++;
+      }
+    }
+    if (data.observation_quality !== void 0) {
+      let data4 = data.observation_quality;
+      if (data4 !== null && typeof data4 !== "string") {
+        const err9 = { instancePath: instancePath + "/observation_quality", schemaPath: "#/properties/observation_quality/type", keyword: "type", params: { type: schema34.properties.observation_quality.type }, message: "must be null,string" };
+        if (vErrors === null) {
+          vErrors = [err9];
+        } else {
+          vErrors.push(err9);
+        }
+        errors++;
+      }
+      if (!(data4 === "clean" || data4 === "flagged" || data4 === "suspect" || data4 === null)) {
+        const err10 = { instancePath: instancePath + "/observation_quality", schemaPath: "#/properties/observation_quality/enum", keyword: "enum", params: { allowedValues: schema34.properties.observation_quality.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err10];
+        } else {
+          vErrors.push(err10);
+        }
+        errors++;
+      }
+    }
+    if (data.observation_type !== void 0) {
+      let data5 = data.observation_type;
+      if (typeof data5 !== "string") {
+        const err11 = { instancePath: instancePath + "/observation_type", schemaPath: "#/properties/observation_type/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err11];
+        } else {
+          vErrors.push(err11);
+        }
+        errors++;
+      }
+      if (!(data5 === "METAR" || data5 === "SPECI")) {
+        const err12 = { instancePath: instancePath + "/observation_type", schemaPath: "#/properties/observation_type/enum", keyword: "enum", params: { allowedValues: schema34.properties.observation_type.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err12];
+        } else {
+          vErrors.push(err12);
+        }
+        errors++;
+      }
+    }
+    if (data.observed_at !== void 0) {
+      if (!(typeof data.observed_at === "string")) {
+        const err13 = { instancePath: instancePath + "/observed_at", schemaPath: "#/properties/observed_at/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err13];
+        } else {
+          vErrors.push(err13);
+        }
+        errors++;
+      }
+    }
+    if (data.parser_name !== void 0) {
+      let data7 = data.parser_name;
+      if (data7 !== null && typeof data7 !== "string") {
+        const err14 = { instancePath: instancePath + "/parser_name", schemaPath: "#/properties/parser_name/type", keyword: "type", params: { type: schema34.properties.parser_name.type }, message: "must be null,string" };
+        if (vErrors === null) {
+          vErrors = [err14];
+        } else {
+          vErrors.push(err14);
+        }
+        errors++;
+      }
+      if (!(data7 === "ghcnh" || data7 === "iem" || data7 === "mostlyright_v1" || data7 === "ncei" || data7 === null)) {
+        const err15 = { instancePath: instancePath + "/parser_name", schemaPath: "#/properties/parser_name/enum", keyword: "enum", params: { allowedValues: schema34.properties.parser_name.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err15];
+        } else {
+          vErrors.push(err15);
+        }
+        errors++;
+      }
+    }
+    if (data.parser_version !== void 0) {
+      let data8 = data.parser_version;
+      if (data8 !== null && typeof data8 !== "string") {
+        const err16 = { instancePath: instancePath + "/parser_version", schemaPath: "#/properties/parser_version/type", keyword: "type", params: { type: schema34.properties.parser_version.type }, message: "must be null,string" };
+        if (vErrors === null) {
+          vErrors = [err16];
+        } else {
+          vErrors.push(err16);
+        }
+        errors++;
+      }
+    }
+    if (data.provenance !== void 0) {
+      let data9 = data.provenance;
+      if (data9 !== null && typeof data9 !== "string") {
+        const err17 = { instancePath: instancePath + "/provenance", schemaPath: "#/properties/provenance/type", keyword: "type", params: { type: schema34.properties.provenance.type }, message: "must be null,string" };
+        if (vErrors === null) {
+          vErrors = [err17];
+        } else {
+          vErrors.push(err17);
+        }
+        errors++;
+      }
+      if (!(data9 === "legacy" || data9 === "reingested" || data9 === null)) {
+        const err18 = { instancePath: instancePath + "/provenance", schemaPath: "#/properties/provenance/enum", keyword: "enum", params: { allowedValues: schema34.properties.provenance.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err18];
+        } else {
+          vErrors.push(err18);
+        }
+        errors++;
+      }
+    }
+    if (data.qc_status !== void 0) {
+      let data10 = data.qc_status;
+      if (data10 !== null && typeof data10 !== "string") {
+        const err19 = { instancePath: instancePath + "/qc_status", schemaPath: "#/properties/qc_status/type", keyword: "type", params: { type: schema34.properties.qc_status.type }, message: "must be null,string" };
+        if (vErrors === null) {
+          vErrors = [err19];
+        } else {
+          vErrors.push(err19);
+        }
+        errors++;
+      }
+      if (!(data10 === "clean" || data10 === "flagged" || data10 === "suspect" || data10 === null)) {
+        const err20 = { instancePath: instancePath + "/qc_status", schemaPath: "#/properties/qc_status/enum", keyword: "enum", params: { allowedValues: schema34.properties.qc_status.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err20];
+        } else {
+          vErrors.push(err20);
+        }
+        errors++;
+      }
+    }
+    if (data.source !== void 0) {
+      let data11 = data.source;
+      if (typeof data11 !== "string") {
+        const err21 = { instancePath: instancePath + "/source", schemaPath: "#/properties/source/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err21];
+        } else {
+          vErrors.push(err21);
+        }
+        errors++;
+      }
+      if (!(data11 === "awc" || data11 === "ghcnh" || data11 === "iem" || data11 === "ncei")) {
+        const err22 = { instancePath: instancePath + "/source", schemaPath: "#/properties/source/enum", keyword: "enum", params: { allowedValues: schema34.properties.source.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err22];
+        } else {
+          vErrors.push(err22);
+        }
+        errors++;
+      }
+    }
+    if (data.source_received_at !== void 0) {
+      let data12 = data.source_received_at;
+      if (data12 !== null && typeof data12 !== "string") {
+        const err23 = { instancePath: instancePath + "/source_received_at", schemaPath: "#/properties/source_received_at/type", keyword: "type", params: { type: schema34.properties.source_received_at.type }, message: "must be null,string" };
+        if (vErrors === null) {
+          vErrors = [err23];
+        } else {
+          vErrors.push(err23);
+        }
+        errors++;
+      }
+    }
+    if (data.station_code !== void 0) {
+      if (typeof data.station_code !== "string") {
+        const err24 = { instancePath: instancePath + "/station_code", schemaPath: "#/properties/station_code/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err24];
+        } else {
+          vErrors.push(err24);
+        }
+        errors++;
+      }
+    }
+    if (data.temp_c !== void 0) {
+      let data14 = data.temp_c;
+      if (data14 !== null && !(typeof data14 == "number")) {
+        const err25 = { instancePath: instancePath + "/temp_c", schemaPath: "#/properties/temp_c/type", keyword: "type", params: { type: schema34.properties.temp_c.type }, message: "must be null,number" };
+        if (vErrors === null) {
+          vErrors = [err25];
+        } else {
+          vErrors.push(err25);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err26 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err26];
+    } else {
+      vErrors.push(err26);
+    }
+    errors++;
+  }
+  validate23.errors = vErrors;
+  return errors === 0;
+}
+validate23.evaluated = { "props": { "as_of_time": true, "dewpoint_c": true, "ingestion_id": true, "observation_kind": true, "observation_quality": true, "observation_type": true, "observed_at": true, "parser_name": true, "parser_version": true, "provenance": true, "qc_status": true, "source": true, "source_received_at": true, "station_code": true, "temp_c": true }, "dynamicProps": false, "dynamicItems": false };
+
+// src/schemas/validators/schema_observation_qc_v1.js
+var schema_observation_qc_v1 = validate24;
+var schema35 = { "$id": "https://mostlyright.dev/schemas/schema.observation_qc.v1.json", "$schema": "https://json-schema.org/draft/2020-12/schema", "properties": { "as_of_time": { "format": "date-time", "type": ["null", "string"] }, "detector_metadata": { "description": "JSON-serialized detector payload; shape per qc_system.", "type": ["null", "string"] }, "field": { "description": "Observation column the rule evaluated (e.g. temp_c).", "type": "string" }, "flag": { "enum": ["clean", "flagged", "suspect"], "type": "string" }, "ingestion_id": { "type": ["null", "string"] }, "observation_kind": { "enum": ["METAR", "SPECI", null], "type": ["null", "string"] }, "observed_at": { "format": "date-time", "type": "string" }, "parser_name": { "type": ["null", "string"] }, "qc_system": { "type": "string" }, "qc_version": { "type": "string" }, "rule_id": { "type": "string" }, "source": { "enum": ["awc", "ghcnh", "iem", "ncei"], "type": "string" }, "station_code": { "type": "string" } }, "required": ["field", "flag", "observed_at", "qc_system", "qc_version", "rule_id", "source", "station_code"], "title": "schema.observation_qc.v1", "type": "object", "version": "v1" };
+function validate24(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  ;
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate24.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.field === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "field" }, message: "must have required property 'field'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.flag === void 0) {
+      const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "flag" }, message: "must have required property 'flag'" };
+      if (vErrors === null) {
+        vErrors = [err1];
+      } else {
+        vErrors.push(err1);
+      }
+      errors++;
+    }
+    if (data.observed_at === void 0) {
+      const err2 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "observed_at" }, message: "must have required property 'observed_at'" };
+      if (vErrors === null) {
+        vErrors = [err2];
+      } else {
+        vErrors.push(err2);
+      }
+      errors++;
+    }
+    if (data.qc_system === void 0) {
+      const err3 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "qc_system" }, message: "must have required property 'qc_system'" };
+      if (vErrors === null) {
+        vErrors = [err3];
+      } else {
+        vErrors.push(err3);
+      }
+      errors++;
+    }
+    if (data.qc_version === void 0) {
+      const err4 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "qc_version" }, message: "must have required property 'qc_version'" };
+      if (vErrors === null) {
+        vErrors = [err4];
+      } else {
+        vErrors.push(err4);
+      }
+      errors++;
+    }
+    if (data.rule_id === void 0) {
+      const err5 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "rule_id" }, message: "must have required property 'rule_id'" };
+      if (vErrors === null) {
+        vErrors = [err5];
+      } else {
+        vErrors.push(err5);
+      }
+      errors++;
+    }
+    if (data.source === void 0) {
+      const err6 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "source" }, message: "must have required property 'source'" };
+      if (vErrors === null) {
+        vErrors = [err6];
+      } else {
+        vErrors.push(err6);
+      }
+      errors++;
+    }
+    if (data.station_code === void 0) {
+      const err7 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "station_code" }, message: "must have required property 'station_code'" };
+      if (vErrors === null) {
+        vErrors = [err7];
+      } else {
+        vErrors.push(err7);
+      }
+      errors++;
+    }
+    if (data.as_of_time !== void 0) {
+      let data0 = data.as_of_time;
+      if (data0 !== null && typeof data0 !== "string") {
+        const err8 = { instancePath: instancePath + "/as_of_time", schemaPath: "#/properties/as_of_time/type", keyword: "type", params: { type: schema35.properties.as_of_time.type }, message: "must be null,string" };
+        if (vErrors === null) {
+          vErrors = [err8];
+        } else {
+          vErrors.push(err8);
+        }
+        errors++;
+      }
+    }
+    if (data.detector_metadata !== void 0) {
+      let data1 = data.detector_metadata;
+      if (data1 !== null && typeof data1 !== "string") {
+        const err9 = { instancePath: instancePath + "/detector_metadata", schemaPath: "#/properties/detector_metadata/type", keyword: "type", params: { type: schema35.properties.detector_metadata.type }, message: "must be null,string" };
+        if (vErrors === null) {
+          vErrors = [err9];
+        } else {
+          vErrors.push(err9);
+        }
+        errors++;
+      }
+    }
+    if (data.field !== void 0) {
+      if (typeof data.field !== "string") {
+        const err10 = { instancePath: instancePath + "/field", schemaPath: "#/properties/field/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err10];
+        } else {
+          vErrors.push(err10);
+        }
+        errors++;
+      }
+    }
+    if (data.flag !== void 0) {
+      let data3 = data.flag;
+      if (typeof data3 !== "string") {
+        const err11 = { instancePath: instancePath + "/flag", schemaPath: "#/properties/flag/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err11];
+        } else {
+          vErrors.push(err11);
+        }
+        errors++;
+      }
+      if (!(data3 === "clean" || data3 === "flagged" || data3 === "suspect")) {
+        const err12 = { instancePath: instancePath + "/flag", schemaPath: "#/properties/flag/enum", keyword: "enum", params: { allowedValues: schema35.properties.flag.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err12];
+        } else {
+          vErrors.push(err12);
+        }
+        errors++;
+      }
+    }
+    if (data.ingestion_id !== void 0) {
+      let data4 = data.ingestion_id;
+      if (data4 !== null && typeof data4 !== "string") {
+        const err13 = { instancePath: instancePath + "/ingestion_id", schemaPath: "#/properties/ingestion_id/type", keyword: "type", params: { type: schema35.properties.ingestion_id.type }, message: "must be null,string" };
+        if (vErrors === null) {
+          vErrors = [err13];
+        } else {
+          vErrors.push(err13);
+        }
+        errors++;
+      }
+    }
+    if (data.observation_kind !== void 0) {
+      let data5 = data.observation_kind;
+      if (data5 !== null && typeof data5 !== "string") {
+        const err14 = { instancePath: instancePath + "/observation_kind", schemaPath: "#/properties/observation_kind/type", keyword: "type", params: { type: schema35.properties.observation_kind.type }, message: "must be null,string" };
+        if (vErrors === null) {
+          vErrors = [err14];
+        } else {
+          vErrors.push(err14);
+        }
+        errors++;
+      }
+      if (!(data5 === "METAR" || data5 === "SPECI" || data5 === null)) {
+        const err15 = { instancePath: instancePath + "/observation_kind", schemaPath: "#/properties/observation_kind/enum", keyword: "enum", params: { allowedValues: schema35.properties.observation_kind.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err15];
+        } else {
+          vErrors.push(err15);
+        }
+        errors++;
+      }
+    }
+    if (data.observed_at !== void 0) {
+      if (!(typeof data.observed_at === "string")) {
+        const err16 = { instancePath: instancePath + "/observed_at", schemaPath: "#/properties/observed_at/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err16];
+        } else {
+          vErrors.push(err16);
+        }
+        errors++;
+      }
+    }
+    if (data.parser_name !== void 0) {
+      let data7 = data.parser_name;
+      if (data7 !== null && typeof data7 !== "string") {
+        const err17 = { instancePath: instancePath + "/parser_name", schemaPath: "#/properties/parser_name/type", keyword: "type", params: { type: schema35.properties.parser_name.type }, message: "must be null,string" };
+        if (vErrors === null) {
+          vErrors = [err17];
+        } else {
+          vErrors.push(err17);
+        }
+        errors++;
+      }
+    }
+    if (data.qc_system !== void 0) {
+      if (typeof data.qc_system !== "string") {
+        const err18 = { instancePath: instancePath + "/qc_system", schemaPath: "#/properties/qc_system/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err18];
+        } else {
+          vErrors.push(err18);
+        }
+        errors++;
+      }
+    }
+    if (data.qc_version !== void 0) {
+      if (typeof data.qc_version !== "string") {
+        const err19 = { instancePath: instancePath + "/qc_version", schemaPath: "#/properties/qc_version/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err19];
+        } else {
+          vErrors.push(err19);
+        }
+        errors++;
+      }
+    }
+    if (data.rule_id !== void 0) {
+      if (typeof data.rule_id !== "string") {
+        const err20 = { instancePath: instancePath + "/rule_id", schemaPath: "#/properties/rule_id/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err20];
+        } else {
+          vErrors.push(err20);
+        }
+        errors++;
+      }
+    }
+    if (data.source !== void 0) {
+      let data11 = data.source;
+      if (typeof data11 !== "string") {
+        const err21 = { instancePath: instancePath + "/source", schemaPath: "#/properties/source/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err21];
+        } else {
+          vErrors.push(err21);
+        }
+        errors++;
+      }
+      if (!(data11 === "awc" || data11 === "ghcnh" || data11 === "iem" || data11 === "ncei")) {
+        const err22 = { instancePath: instancePath + "/source", schemaPath: "#/properties/source/enum", keyword: "enum", params: { allowedValues: schema35.properties.source.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err22];
+        } else {
+          vErrors.push(err22);
+        }
+        errors++;
+      }
+    }
+    if (data.station_code !== void 0) {
+      if (typeof data.station_code !== "string") {
+        const err23 = { instancePath: instancePath + "/station_code", schemaPath: "#/properties/station_code/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err23];
+        } else {
+          vErrors.push(err23);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err24 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err24];
+    } else {
+      vErrors.push(err24);
+    }
+    errors++;
+  }
+  validate24.errors = vErrors;
+  return errors === 0;
+}
+validate24.evaluated = { "props": { "as_of_time": true, "detector_metadata": true, "field": true, "flag": true, "ingestion_id": true, "observation_kind": true, "observed_at": true, "parser_name": true, "qc_system": true, "qc_version": true, "rule_id": true, "source": true, "station_code": true }, "dynamicProps": false, "dynamicItems": false };
+
+// src/schemas/validators/schema_observation_v1.js
+var schema_observation_v1 = validate20;
+var schema31 = { "$id": "https://mostlyright.dev/schemas/schema.observation.v1.json", "$schema": "https://json-schema.org/draft/2020-12/schema", "imperialRenames": { "dew_point_c": "dew_point_F", "event_time": "utc_datetime", "precip_mm_1h": "precip_in_1h", "sky_base_1_m": "sky_base_1_ft", "sky_base_2_m": "sky_base_2_ft", "sky_base_3_m": "sky_base_3_ft", "sky_base_4_m": "sky_base_4_ft", "temp_c": "temp_F", "visibility_m": "vsby", "wind_gust_ms": "gust_kt", "wind_speed_ms": "wind_speed_kt" }, "properties": { "dew_point_c": { "description": "units: celsius \u2014 bounded", "type": ["null", "number"] }, "event_time": { "description": "observation valid time", "format": "date-time", "type": "string" }, "metar_raw": { "description": "raw METAR text if source has it; null for AWC JSON (structured-only)", "type": ["null", "string"] }, "observation_type": { "description": "METAR | SPECI; defaults METAR when source can't distinguish (e.g. AWC JSON)", "enum": ["METAR", "SPECI"], "type": "string" }, "precip_mm_1h": { "description": "units: mm \u2014 hourly precip (METAR p01i, converted from inches)", "type": ["null", "number"] }, "sky_base_1_m": { "description": "units: meters \u2014 first cloud layer base height (converted from feet)", "type": ["null", "number"] }, "sky_base_2_m": { "description": "units: meters", "type": ["null", "number"] }, "sky_base_3_m": { "description": "units: meters", "type": ["null", "number"] }, "sky_base_4_m": { "description": "units: meters", "type": ["null", "number"] }, "sky_cover_1": { "description": "first cloud layer cover code", "enum": ["BKN", "CLR", "FEW", "OVC", "SCT", "VV", null], "type": ["null", "string"] }, "sky_cover_2": { "description": "second layer; null if not present", "enum": ["BKN", "CLR", "FEW", "OVC", "SCT", "VV", null], "type": ["null", "string"] }, "sky_cover_3": { "description": "third layer; null if not present", "enum": ["BKN", "CLR", "FEW", "OVC", "SCT", "VV", null], "type": ["null", "string"] }, "sky_cover_4": { "description": "fourth layer; null if not present", "enum": ["BKN", "CLR", "FEW", "OVC", "SCT", "VV", null], "type": ["null", "string"] }, "slp_hpa": { "description": "units: hPa \u2014 sea-level pressure (canonical aviation unit, not converted across modes)", "type": ["null", "number"] }, "station": { "description": "ICAO/ASOS station ID (e.g. KORD)", "type": "string" }, "temp_c": { "description": "units: celsius \u2014 bounded TEMP_MIN_C..TEMP_MAX_C", "type": ["null", "number"] }, "visibility_m": { "description": "units: meters \u2014 converted from statute miles", "type": ["null", "number"] }, "wind_dir_deg": { "description": "units: degrees \u2014 0-360, bounded", "type": ["integer", "null"] }, "wind_gust_ms": { "description": "units: m/s \u2014 converted from kt", "type": ["null", "number"] }, "wind_speed_ms": { "description": "units: m/s \u2014 converted from kt", "type": ["null", "number"] } }, "required": ["event_time", "observation_type", "station"], "title": "schema.observation.v1", "type": "object", "version": "v1" };
+function validate20(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  ;
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate20.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.event_time === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "event_time" }, message: "must have required property 'event_time'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.observation_type === void 0) {
+      const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "observation_type" }, message: "must have required property 'observation_type'" };
+      if (vErrors === null) {
+        vErrors = [err1];
+      } else {
+        vErrors.push(err1);
+      }
+      errors++;
+    }
+    if (data.station === void 0) {
+      const err2 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "station" }, message: "must have required property 'station'" };
+      if (vErrors === null) {
+        vErrors = [err2];
+      } else {
+        vErrors.push(err2);
+      }
+      errors++;
+    }
+    if (data.dew_point_c !== void 0) {
+      let data0 = data.dew_point_c;
+      if (data0 !== null && !(typeof data0 == "number")) {
+        const err3 = { instancePath: instancePath + "/dew_point_c", schemaPath: "#/properties/dew_point_c/type", keyword: "type", params: { type: schema31.properties.dew_point_c.type }, message: "must be null,number" };
+        if (vErrors === null) {
+          vErrors = [err3];
+        } else {
+          vErrors.push(err3);
+        }
+        errors++;
+      }
+    }
+    if (data.event_time !== void 0) {
+      if (!(typeof data.event_time === "string")) {
+        const err4 = { instancePath: instancePath + "/event_time", schemaPath: "#/properties/event_time/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err4];
+        } else {
+          vErrors.push(err4);
+        }
+        errors++;
+      }
+    }
+    if (data.metar_raw !== void 0) {
+      let data2 = data.metar_raw;
+      if (data2 !== null && typeof data2 !== "string") {
+        const err5 = { instancePath: instancePath + "/metar_raw", schemaPath: "#/properties/metar_raw/type", keyword: "type", params: { type: schema31.properties.metar_raw.type }, message: "must be null,string" };
+        if (vErrors === null) {
+          vErrors = [err5];
+        } else {
+          vErrors.push(err5);
+        }
+        errors++;
+      }
+    }
+    if (data.observation_type !== void 0) {
+      let data3 = data.observation_type;
+      if (typeof data3 !== "string") {
+        const err6 = { instancePath: instancePath + "/observation_type", schemaPath: "#/properties/observation_type/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err6];
+        } else {
+          vErrors.push(err6);
+        }
+        errors++;
+      }
+      if (!(data3 === "METAR" || data3 === "SPECI")) {
+        const err7 = { instancePath: instancePath + "/observation_type", schemaPath: "#/properties/observation_type/enum", keyword: "enum", params: { allowedValues: schema31.properties.observation_type.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err7];
+        } else {
+          vErrors.push(err7);
+        }
+        errors++;
+      }
+    }
+    if (data.precip_mm_1h !== void 0) {
+      let data4 = data.precip_mm_1h;
+      if (data4 !== null && !(typeof data4 == "number")) {
+        const err8 = { instancePath: instancePath + "/precip_mm_1h", schemaPath: "#/properties/precip_mm_1h/type", keyword: "type", params: { type: schema31.properties.precip_mm_1h.type }, message: "must be null,number" };
+        if (vErrors === null) {
+          vErrors = [err8];
+        } else {
+          vErrors.push(err8);
+        }
+        errors++;
+      }
+    }
+    if (data.sky_base_1_m !== void 0) {
+      let data5 = data.sky_base_1_m;
+      if (data5 !== null && !(typeof data5 == "number")) {
+        const err9 = { instancePath: instancePath + "/sky_base_1_m", schemaPath: "#/properties/sky_base_1_m/type", keyword: "type", params: { type: schema31.properties.sky_base_1_m.type }, message: "must be null,number" };
+        if (vErrors === null) {
+          vErrors = [err9];
+        } else {
+          vErrors.push(err9);
+        }
+        errors++;
+      }
+    }
+    if (data.sky_base_2_m !== void 0) {
+      let data6 = data.sky_base_2_m;
+      if (data6 !== null && !(typeof data6 == "number")) {
+        const err10 = { instancePath: instancePath + "/sky_base_2_m", schemaPath: "#/properties/sky_base_2_m/type", keyword: "type", params: { type: schema31.properties.sky_base_2_m.type }, message: "must be null,number" };
+        if (vErrors === null) {
+          vErrors = [err10];
+        } else {
+          vErrors.push(err10);
+        }
+        errors++;
+      }
+    }
+    if (data.sky_base_3_m !== void 0) {
+      let data7 = data.sky_base_3_m;
+      if (data7 !== null && !(typeof data7 == "number")) {
+        const err11 = { instancePath: instancePath + "/sky_base_3_m", schemaPath: "#/properties/sky_base_3_m/type", keyword: "type", params: { type: schema31.properties.sky_base_3_m.type }, message: "must be null,number" };
+        if (vErrors === null) {
+          vErrors = [err11];
+        } else {
+          vErrors.push(err11);
+        }
+        errors++;
+      }
+    }
+    if (data.sky_base_4_m !== void 0) {
+      let data8 = data.sky_base_4_m;
+      if (data8 !== null && !(typeof data8 == "number")) {
+        const err12 = { instancePath: instancePath + "/sky_base_4_m", schemaPath: "#/properties/sky_base_4_m/type", keyword: "type", params: { type: schema31.properties.sky_base_4_m.type }, message: "must be null,number" };
+        if (vErrors === null) {
+          vErrors = [err12];
+        } else {
+          vErrors.push(err12);
+        }
+        errors++;
+      }
+    }
+    if (data.sky_cover_1 !== void 0) {
+      let data9 = data.sky_cover_1;
+      if (data9 !== null && typeof data9 !== "string") {
+        const err13 = { instancePath: instancePath + "/sky_cover_1", schemaPath: "#/properties/sky_cover_1/type", keyword: "type", params: { type: schema31.properties.sky_cover_1.type }, message: "must be null,string" };
+        if (vErrors === null) {
+          vErrors = [err13];
+        } else {
+          vErrors.push(err13);
+        }
+        errors++;
+      }
+      if (!(data9 === "BKN" || data9 === "CLR" || data9 === "FEW" || data9 === "OVC" || data9 === "SCT" || data9 === "VV" || data9 === null)) {
+        const err14 = { instancePath: instancePath + "/sky_cover_1", schemaPath: "#/properties/sky_cover_1/enum", keyword: "enum", params: { allowedValues: schema31.properties.sky_cover_1.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err14];
+        } else {
+          vErrors.push(err14);
+        }
+        errors++;
+      }
+    }
+    if (data.sky_cover_2 !== void 0) {
+      let data10 = data.sky_cover_2;
+      if (data10 !== null && typeof data10 !== "string") {
+        const err15 = { instancePath: instancePath + "/sky_cover_2", schemaPath: "#/properties/sky_cover_2/type", keyword: "type", params: { type: schema31.properties.sky_cover_2.type }, message: "must be null,string" };
+        if (vErrors === null) {
+          vErrors = [err15];
+        } else {
+          vErrors.push(err15);
+        }
+        errors++;
+      }
+      if (!(data10 === "BKN" || data10 === "CLR" || data10 === "FEW" || data10 === "OVC" || data10 === "SCT" || data10 === "VV" || data10 === null)) {
+        const err16 = { instancePath: instancePath + "/sky_cover_2", schemaPath: "#/properties/sky_cover_2/enum", keyword: "enum", params: { allowedValues: schema31.properties.sky_cover_2.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err16];
+        } else {
+          vErrors.push(err16);
+        }
+        errors++;
+      }
+    }
+    if (data.sky_cover_3 !== void 0) {
+      let data11 = data.sky_cover_3;
+      if (data11 !== null && typeof data11 !== "string") {
+        const err17 = { instancePath: instancePath + "/sky_cover_3", schemaPath: "#/properties/sky_cover_3/type", keyword: "type", params: { type: schema31.properties.sky_cover_3.type }, message: "must be null,string" };
+        if (vErrors === null) {
+          vErrors = [err17];
+        } else {
+          vErrors.push(err17);
+        }
+        errors++;
+      }
+      if (!(data11 === "BKN" || data11 === "CLR" || data11 === "FEW" || data11 === "OVC" || data11 === "SCT" || data11 === "VV" || data11 === null)) {
+        const err18 = { instancePath: instancePath + "/sky_cover_3", schemaPath: "#/properties/sky_cover_3/enum", keyword: "enum", params: { allowedValues: schema31.properties.sky_cover_3.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err18];
+        } else {
+          vErrors.push(err18);
+        }
+        errors++;
+      }
+    }
+    if (data.sky_cover_4 !== void 0) {
+      let data12 = data.sky_cover_4;
+      if (data12 !== null && typeof data12 !== "string") {
+        const err19 = { instancePath: instancePath + "/sky_cover_4", schemaPath: "#/properties/sky_cover_4/type", keyword: "type", params: { type: schema31.properties.sky_cover_4.type }, message: "must be null,string" };
+        if (vErrors === null) {
+          vErrors = [err19];
+        } else {
+          vErrors.push(err19);
+        }
+        errors++;
+      }
+      if (!(data12 === "BKN" || data12 === "CLR" || data12 === "FEW" || data12 === "OVC" || data12 === "SCT" || data12 === "VV" || data12 === null)) {
+        const err20 = { instancePath: instancePath + "/sky_cover_4", schemaPath: "#/properties/sky_cover_4/enum", keyword: "enum", params: { allowedValues: schema31.properties.sky_cover_4.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err20];
+        } else {
+          vErrors.push(err20);
+        }
+        errors++;
+      }
+    }
+    if (data.slp_hpa !== void 0) {
+      let data13 = data.slp_hpa;
+      if (data13 !== null && !(typeof data13 == "number")) {
+        const err21 = { instancePath: instancePath + "/slp_hpa", schemaPath: "#/properties/slp_hpa/type", keyword: "type", params: { type: schema31.properties.slp_hpa.type }, message: "must be null,number" };
+        if (vErrors === null) {
+          vErrors = [err21];
+        } else {
+          vErrors.push(err21);
+        }
+        errors++;
+      }
+    }
+    if (data.station !== void 0) {
+      if (typeof data.station !== "string") {
+        const err22 = { instancePath: instancePath + "/station", schemaPath: "#/properties/station/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err22];
+        } else {
+          vErrors.push(err22);
+        }
+        errors++;
+      }
+    }
+    if (data.temp_c !== void 0) {
+      let data15 = data.temp_c;
+      if (data15 !== null && !(typeof data15 == "number")) {
+        const err23 = { instancePath: instancePath + "/temp_c", schemaPath: "#/properties/temp_c/type", keyword: "type", params: { type: schema31.properties.temp_c.type }, message: "must be null,number" };
+        if (vErrors === null) {
+          vErrors = [err23];
+        } else {
+          vErrors.push(err23);
+        }
+        errors++;
+      }
+    }
+    if (data.visibility_m !== void 0) {
+      let data16 = data.visibility_m;
+      if (data16 !== null && !(typeof data16 == "number")) {
+        const err24 = { instancePath: instancePath + "/visibility_m", schemaPath: "#/properties/visibility_m/type", keyword: "type", params: { type: schema31.properties.visibility_m.type }, message: "must be null,number" };
+        if (vErrors === null) {
+          vErrors = [err24];
+        } else {
+          vErrors.push(err24);
+        }
+        errors++;
+      }
+    }
+    if (data.wind_dir_deg !== void 0) {
+      let data17 = data.wind_dir_deg;
+      if (!(typeof data17 == "number" && (!(data17 % 1) && !isNaN(data17))) && data17 !== null) {
+        const err25 = { instancePath: instancePath + "/wind_dir_deg", schemaPath: "#/properties/wind_dir_deg/type", keyword: "type", params: { type: schema31.properties.wind_dir_deg.type }, message: "must be integer,null" };
+        if (vErrors === null) {
+          vErrors = [err25];
+        } else {
+          vErrors.push(err25);
+        }
+        errors++;
+      }
+    }
+    if (data.wind_gust_ms !== void 0) {
+      let data18 = data.wind_gust_ms;
+      if (data18 !== null && !(typeof data18 == "number")) {
+        const err26 = { instancePath: instancePath + "/wind_gust_ms", schemaPath: "#/properties/wind_gust_ms/type", keyword: "type", params: { type: schema31.properties.wind_gust_ms.type }, message: "must be null,number" };
+        if (vErrors === null) {
+          vErrors = [err26];
+        } else {
+          vErrors.push(err26);
+        }
+        errors++;
+      }
+    }
+    if (data.wind_speed_ms !== void 0) {
+      let data19 = data.wind_speed_ms;
+      if (data19 !== null && !(typeof data19 == "number")) {
+        const err27 = { instancePath: instancePath + "/wind_speed_ms", schemaPath: "#/properties/wind_speed_ms/type", keyword: "type", params: { type: schema31.properties.wind_speed_ms.type }, message: "must be null,number" };
+        if (vErrors === null) {
+          vErrors = [err27];
+        } else {
+          vErrors.push(err27);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err28 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err28];
+    } else {
+      vErrors.push(err28);
+    }
+    errors++;
+  }
+  validate20.errors = vErrors;
+  return errors === 0;
+}
+validate20.evaluated = { "props": { "dew_point_c": true, "event_time": true, "metar_raw": true, "observation_type": true, "precip_mm_1h": true, "sky_base_1_m": true, "sky_base_2_m": true, "sky_base_3_m": true, "sky_base_4_m": true, "sky_cover_1": true, "sky_cover_2": true, "sky_cover_3": true, "sky_cover_4": true, "slp_hpa": true, "station": true, "temp_c": true, "visibility_m": true, "wind_dir_deg": true, "wind_gust_ms": true, "wind_speed_ms": true }, "dynamicProps": false, "dynamicItems": false };
+
+// src/schemas/validators/schema_settlement_cli_v1.js
+var schema_settlement_cli_v1 = validate22;
+var schema33 = { "$id": "https://mostlyright.dev/schemas/schema.settlement.cli.v1.json", "$schema": "https://json-schema.org/draft/2020-12/schema", "properties": { "cli_data_quality": { "description": "NWS CLI data-quality marker (Pitfall 6/16). Allows downstream code to filter or weight settlement rows by issuer quality without re-parsing the product header.", "enum": ["clean", "flagged_instrument", "flagged_late", "flagged_other", "missing"], "type": "string" }, "event_time": { "description": "00:00 local time on observation_date converted to UTC; for sort/join only", "format": "date-time", "type": "string" }, "observation_date": { "description": "local climate day per NWS convention (no timezone applied to the date itself)", "format": "date", "type": "string" }, "precipitation_in": { "description": "units: inches", "type": ["null", "number"] }, "product_release_time": { "description": "parsed from CLI product header (_climate.py::_parse_product_timestamp)", "format": "date-time", "type": "string" }, "report_type": { "description": "preliminary | final | correction; dedup priority preliminary < final < correction", "enum": ["correction", "final", "preliminary"], "type": "string" }, "settlement_finality": { "description": "provisional | final | superseded. Kalshi NHIGH/NLOW settlement contractually requires 'final'; 'provisional' values are kept for early-look research only.", "enum": ["final", "provisional", "superseded"], "type": "string" }, "snowfall_in": { "description": "units: inches", "type": ["null", "number"] }, "station": { "description": "ICAO/ASOS station ID", "type": "string" }, "station_tz": { "description": "IANA timezone for the station (e.g. America/Chicago for KORD). Required for local-climate-day semantics; see \xA7U.", "type": "string" }, "temp_max_F": { "description": "units: fahrenheit \u2014 daily high (uppercase F for consistency with obs imperial mode)", "type": ["null", "number"] }, "temp_min_F": { "description": "units: fahrenheit \u2014 daily low", "type": ["null", "number"] } }, "required": ["cli_data_quality", "event_time", "observation_date", "product_release_time", "report_type", "settlement_finality", "station", "station_tz"], "title": "schema.settlement.cli.v1", "type": "object", "version": "v1" };
+function validate22(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  ;
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate22.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.cli_data_quality === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "cli_data_quality" }, message: "must have required property 'cli_data_quality'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.event_time === void 0) {
+      const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "event_time" }, message: "must have required property 'event_time'" };
+      if (vErrors === null) {
+        vErrors = [err1];
+      } else {
+        vErrors.push(err1);
+      }
+      errors++;
+    }
+    if (data.observation_date === void 0) {
+      const err2 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "observation_date" }, message: "must have required property 'observation_date'" };
+      if (vErrors === null) {
+        vErrors = [err2];
+      } else {
+        vErrors.push(err2);
+      }
+      errors++;
+    }
+    if (data.product_release_time === void 0) {
+      const err3 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "product_release_time" }, message: "must have required property 'product_release_time'" };
+      if (vErrors === null) {
+        vErrors = [err3];
+      } else {
+        vErrors.push(err3);
+      }
+      errors++;
+    }
+    if (data.report_type === void 0) {
+      const err4 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "report_type" }, message: "must have required property 'report_type'" };
+      if (vErrors === null) {
+        vErrors = [err4];
+      } else {
+        vErrors.push(err4);
+      }
+      errors++;
+    }
+    if (data.settlement_finality === void 0) {
+      const err5 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "settlement_finality" }, message: "must have required property 'settlement_finality'" };
+      if (vErrors === null) {
+        vErrors = [err5];
+      } else {
+        vErrors.push(err5);
+      }
+      errors++;
+    }
+    if (data.station === void 0) {
+      const err6 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "station" }, message: "must have required property 'station'" };
+      if (vErrors === null) {
+        vErrors = [err6];
+      } else {
+        vErrors.push(err6);
+      }
+      errors++;
+    }
+    if (data.station_tz === void 0) {
+      const err7 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "station_tz" }, message: "must have required property 'station_tz'" };
+      if (vErrors === null) {
+        vErrors = [err7];
+      } else {
+        vErrors.push(err7);
+      }
+      errors++;
+    }
+    if (data.cli_data_quality !== void 0) {
+      let data0 = data.cli_data_quality;
+      if (typeof data0 !== "string") {
+        const err8 = { instancePath: instancePath + "/cli_data_quality", schemaPath: "#/properties/cli_data_quality/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err8];
+        } else {
+          vErrors.push(err8);
+        }
+        errors++;
+      }
+      if (!(data0 === "clean" || data0 === "flagged_instrument" || data0 === "flagged_late" || data0 === "flagged_other" || data0 === "missing")) {
+        const err9 = { instancePath: instancePath + "/cli_data_quality", schemaPath: "#/properties/cli_data_quality/enum", keyword: "enum", params: { allowedValues: schema33.properties.cli_data_quality.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err9];
+        } else {
+          vErrors.push(err9);
+        }
+        errors++;
+      }
+    }
+    if (data.event_time !== void 0) {
+      if (!(typeof data.event_time === "string")) {
+        const err10 = { instancePath: instancePath + "/event_time", schemaPath: "#/properties/event_time/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err10];
+        } else {
+          vErrors.push(err10);
+        }
+        errors++;
+      }
+    }
+    if (data.observation_date !== void 0) {
+      if (!(typeof data.observation_date === "string")) {
+        const err11 = { instancePath: instancePath + "/observation_date", schemaPath: "#/properties/observation_date/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err11];
+        } else {
+          vErrors.push(err11);
+        }
+        errors++;
+      }
+    }
+    if (data.precipitation_in !== void 0) {
+      let data3 = data.precipitation_in;
+      if (data3 !== null && !(typeof data3 == "number")) {
+        const err12 = { instancePath: instancePath + "/precipitation_in", schemaPath: "#/properties/precipitation_in/type", keyword: "type", params: { type: schema33.properties.precipitation_in.type }, message: "must be null,number" };
+        if (vErrors === null) {
+          vErrors = [err12];
+        } else {
+          vErrors.push(err12);
+        }
+        errors++;
+      }
+    }
+    if (data.product_release_time !== void 0) {
+      if (!(typeof data.product_release_time === "string")) {
+        const err13 = { instancePath: instancePath + "/product_release_time", schemaPath: "#/properties/product_release_time/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err13];
+        } else {
+          vErrors.push(err13);
+        }
+        errors++;
+      }
+    }
+    if (data.report_type !== void 0) {
+      let data5 = data.report_type;
+      if (typeof data5 !== "string") {
+        const err14 = { instancePath: instancePath + "/report_type", schemaPath: "#/properties/report_type/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err14];
+        } else {
+          vErrors.push(err14);
+        }
+        errors++;
+      }
+      if (!(data5 === "correction" || data5 === "final" || data5 === "preliminary")) {
+        const err15 = { instancePath: instancePath + "/report_type", schemaPath: "#/properties/report_type/enum", keyword: "enum", params: { allowedValues: schema33.properties.report_type.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err15];
+        } else {
+          vErrors.push(err15);
+        }
+        errors++;
+      }
+    }
+    if (data.settlement_finality !== void 0) {
+      let data6 = data.settlement_finality;
+      if (typeof data6 !== "string") {
+        const err16 = { instancePath: instancePath + "/settlement_finality", schemaPath: "#/properties/settlement_finality/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err16];
+        } else {
+          vErrors.push(err16);
+        }
+        errors++;
+      }
+      if (!(data6 === "final" || data6 === "provisional" || data6 === "superseded")) {
+        const err17 = { instancePath: instancePath + "/settlement_finality", schemaPath: "#/properties/settlement_finality/enum", keyword: "enum", params: { allowedValues: schema33.properties.settlement_finality.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err17];
+        } else {
+          vErrors.push(err17);
+        }
+        errors++;
+      }
+    }
+    if (data.snowfall_in !== void 0) {
+      let data7 = data.snowfall_in;
+      if (data7 !== null && !(typeof data7 == "number")) {
+        const err18 = { instancePath: instancePath + "/snowfall_in", schemaPath: "#/properties/snowfall_in/type", keyword: "type", params: { type: schema33.properties.snowfall_in.type }, message: "must be null,number" };
+        if (vErrors === null) {
+          vErrors = [err18];
+        } else {
+          vErrors.push(err18);
+        }
+        errors++;
+      }
+    }
+    if (data.station !== void 0) {
+      if (typeof data.station !== "string") {
+        const err19 = { instancePath: instancePath + "/station", schemaPath: "#/properties/station/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err19];
+        } else {
+          vErrors.push(err19);
+        }
+        errors++;
+      }
+    }
+    if (data.station_tz !== void 0) {
+      if (typeof data.station_tz !== "string") {
+        const err20 = { instancePath: instancePath + "/station_tz", schemaPath: "#/properties/station_tz/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err20];
+        } else {
+          vErrors.push(err20);
+        }
+        errors++;
+      }
+    }
+    if (data.temp_max_F !== void 0) {
+      let data10 = data.temp_max_F;
+      if (data10 !== null && !(typeof data10 == "number")) {
+        const err21 = { instancePath: instancePath + "/temp_max_F", schemaPath: "#/properties/temp_max_F/type", keyword: "type", params: { type: schema33.properties.temp_max_F.type }, message: "must be null,number" };
+        if (vErrors === null) {
+          vErrors = [err21];
+        } else {
+          vErrors.push(err21);
+        }
+        errors++;
+      }
+    }
+    if (data.temp_min_F !== void 0) {
+      let data11 = data.temp_min_F;
+      if (data11 !== null && !(typeof data11 == "number")) {
+        const err22 = { instancePath: instancePath + "/temp_min_F", schemaPath: "#/properties/temp_min_F/type", keyword: "type", params: { type: schema33.properties.temp_min_F.type }, message: "must be null,number" };
+        if (vErrors === null) {
+          vErrors = [err22];
+        } else {
+          vErrors.push(err22);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err23 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err23];
+    } else {
+      vErrors.push(err23);
+    }
+    errors++;
+  }
+  validate22.errors = vErrors;
+  return errors === 0;
+}
+validate22.evaluated = { "props": { "cli_data_quality": true, "event_time": true, "observation_date": true, "precipitation_in": true, "product_release_time": true, "report_type": true, "settlement_finality": true, "snowfall_in": true, "station": true, "station_tz": true, "temp_max_F": true, "temp_min_F": true }, "dynamicProps": false, "dynamicItems": false };
+
+// src/schemas/validators/format-map.ts
+var FORMAT_MAPS = Object.freeze({
+  "schema.forecast.iem_mos.v1": Object.freeze({
+    "issued_at": "date-time",
+    "valid_at": "date-time"
+  }),
+  "schema.observation_ledger.v1": Object.freeze({
+    "as_of_time": "date-time",
+    "observed_at": "date-time"
+  }),
+  "schema.observation_qc.v1": Object.freeze({
+    "as_of_time": "date-time",
+    "observed_at": "date-time"
+  }),
+  "schema.observation.v1": Object.freeze({
+    "event_time": "date-time"
+  }),
+  "schema.settlement.cli.v1": Object.freeze({
+    "event_time": "date-time",
+    "observation_date": "date",
+    "product_release_time": "date-time"
+  })
+});
+function getFormatMap(schemaId) {
+  return FORMAT_MAPS[schemaId] ?? null;
+}
+
+// src/schemas/validators/index.ts
+var VALIDATORS = {
+  "schema.forecast.iem_mos.v1": schema_forecast_iem_mos_v1,
+  "schema.observation_ledger.v1": schema_observation_ledger_v1,
+  "schema.observation_qc.v1": schema_observation_qc_v1,
+  "schema.observation.v1": schema_observation_v1,
+  "schema.settlement.cli.v1": schema_settlement_cli_v1
+};
+function getValidator(schemaId) {
+  return VALIDATORS[schemaId] ?? null;
+}
+
+// src/validator.ts
+var SAMPLE_CAP = 10;
+var ISO_DATE_ONLY_REGEX = /^\d{4}-\d{2}-\d{2}$/;
+var ISO_DATETIME_SEPARATOR_REGEX = /[T ]/;
+var ISO_DATETIME_TZ_SUFFIX_REGEX = /(?:Z|[+-]\d{2}:?\d{2})$/;
+var ISO_DATETIME_DATE_PREFIX_REGEX = /^\d{4}-\d{2}-\d{2}/;
+function isIsoDate(v) {
+  if (typeof v !== "string") return false;
+  if (!ISO_DATE_ONLY_REGEX.test(v)) return false;
+  const ms = Date.parse(`${v}T00:00:00Z`);
+  if (!Number.isFinite(ms)) return false;
+  const reparsed = new Date(ms).toISOString().slice(0, 10);
+  return reparsed === v;
+}
+function isIsoDateTime(v) {
+  if (typeof v !== "string") return false;
+  const trimmed = v.trim();
+  if (trimmed.length === 0) return false;
+  if (!ISO_DATETIME_DATE_PREFIX_REGEX.test(trimmed)) return false;
+  if (!ISO_DATETIME_SEPARATOR_REGEX.test(trimmed)) return false;
+  if (!ISO_DATETIME_TZ_SUFFIX_REGEX.test(trimmed)) return false;
+  const ms = Date.parse(trimmed);
+  if (!Number.isFinite(ms)) return false;
+  const dateMatch = /^(\d{4})-(\d{2})-(\d{2})/.exec(trimmed);
+  if (dateMatch === null) return false;
+  const litYear = Number(dateMatch[1]);
+  const litMonth = Number(dateMatch[2]);
+  const litDay = Number(dateMatch[3]);
+  let offsetMin = 0;
+  const tzMatch = /(Z|[+-]\d{2}:?\d{2})$/.exec(trimmed);
+  const tz = tzMatch === null ? void 0 : tzMatch[1];
+  if (tz !== void 0 && tz !== "Z") {
+    const sign = tz.startsWith("-") ? -1 : 1;
+    const body = tz.slice(1).replace(":", "");
+    const hh = Number(body.slice(0, 2));
+    const mm = Number(body.slice(2, 4));
+    offsetMin = sign * (hh * 60 + mm);
+  }
+  const sourceMs = ms + offsetMin * 6e4;
+  const sourceDate = new Date(sourceMs);
+  return sourceDate.getUTCFullYear() === litYear && sourceDate.getUTCMonth() + 1 === litMonth && sourceDate.getUTCDate() === litDay;
+}
+var SCHEMA_REGISTERED_SOURCE = Object.freeze({
+  "schema.observation.v1": "iem.archive",
+  "schema.settlement.cli.v1": "cli.archive",
+  "schema.forecast.iem_mos.v1": "iem.archive",
+  "schema.observation_ledger.v1": "iem.archive",
+  "schema.observation_qc.v1": "iem.archive"
+});
+function mapAjvErrorToViolation(err, rowIdx) {
+  const keyword = err.keyword;
+  if (keyword === "required") {
+    const missing = err.params.missingProperty;
+    if (typeof missing === "string") {
+      return { rule: "required_column_missing", column: missing, row_idx: rowIdx };
+    }
+    return { rule: "required_column_missing", row_idx: rowIdx };
+  }
+  if (keyword === "type") {
+    const column2 = err.instancePath.replace(/^\//, "").replace(/\//g, ".");
+    return {
+      rule: "dtype_mismatch",
+      column: column2,
+      row_idx: rowIdx
+    };
+  }
+  if (keyword === "enum") {
+    const column2 = err.instancePath.replace(/^\//, "").replace(/\//g, ".");
+    return {
+      rule: "enum_value_violation",
+      column: column2,
+      row_idx: rowIdx
+    };
+  }
+  const column = err.instancePath.replace(/^\//, "").replace(/\//g, ".");
+  if (column.length > 0) {
+    return { rule: "dtype_mismatch", column, row_idx: rowIdx };
+  }
+  return { rule: "dtype_mismatch", row_idx: rowIdx };
+}
+function detectMixedNullSentinels(rows) {
+  const cols = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    for (const [k, v] of Object.entries(row)) {
+      const entry = cols.get(k) ?? { hasNull: false, hasUndef: false };
+      if (v === null) entry.hasNull = true;
+      if (v === void 0) entry.hasUndef = true;
+      cols.set(k, entry);
+    }
+  }
+  const mixed = [];
+  for (const [k, e] of cols) {
+    if (e.hasNull && e.hasUndef) mixed.push(k);
+  }
+  return mixed;
+}
+function validateRows(rows, schemaId, opts = {}) {
+  const validate = getValidator(schemaId);
+  if (validate == null) {
+    throw new SchemaValidationError(`Unknown schema_id ${JSON.stringify(schemaId)}`, {
+      schemaId,
+      violations: [{ rule: "unknown_schema_id" }],
+      quarantineCount: rows.length,
+      sampleViolations: []
+    });
+  }
+  if (opts.allowSourceDrift !== void 0) {
+    if (typeof opts.allowSourceDrift !== "string") {
+      throw new TypeError(
+        `allowSourceDrift must be a non-empty reason string; got ${typeof opts.allowSourceDrift}`
+      );
+    }
+    if (opts.allowSourceDrift.trim().length === 0) {
+      throw new RangeError(
+        "allowSourceDrift must be a non-empty reason string (stripped whitespace)"
+      );
+    }
+  }
+  const firstRow = rows.length > 0 ? rows[0] : void 0;
+  const resolvedSource = opts.source ?? (firstRow !== void 0 ? firstRow.source : void 0);
+  if (resolvedSource === void 0 || resolvedSource === null) {
+    throw new SchemaValidationError(
+      "DataFrame missing source attribute; cannot validate source-identity",
+      {
+        schemaId,
+        violations: [{ rule: "source_attr_required" }],
+        quarantineCount: rows.length,
+        sampleViolations: []
+      }
+    );
+  }
+  const registeredSource = SCHEMA_REGISTERED_SOURCE[schemaId];
+  if (registeredSource !== void 0 && resolvedSource !== registeredSource && opts.allowSourceDrift === void 0) {
+    throw new SourceMismatchError(
+      `Source drift: data is ${JSON.stringify(resolvedSource)}, schema expects ${JSON.stringify(registeredSource)}`,
+      {
+        schemaSource: registeredSource,
+        dataSource: resolvedSource
+      }
+    );
+  }
+  if (rows.length > 0) {
+    const hasSourceColumn = rows.some((r) => "source" in r);
+    if (!hasSourceColumn) {
+      throw new SchemaValidationError(
+        "Rows are missing the per-row 'source' overlay column required by canonical-schema producers.",
+        {
+          schemaId,
+          violations: [{ column: "source", rule: "source_column_required" }],
+          quarantineCount: rows.length,
+          sampleViolations: []
+        }
+      );
+    }
+    const badRows = [];
+    for (let i = 0; i < rows.length; i++) {
+      const r = rows[i];
+      const v = r.source;
+      if (v == null || v !== resolvedSource) {
+        badRows.push({ row_idx: i, source: v ?? null });
+      }
+    }
+    if (badRows.length > 0) {
+      const distinctBad = Array.from(
+        new Set(badRows.map(({ source }) => source == null ? "<null>" : String(source)))
+      ).slice(0, SAMPLE_CAP);
+      throw new SourceMismatchError(
+        `Per-row 'source' column has ${badRows.length} row(s) not matching resolved source=${JSON.stringify(resolvedSource)}; distinct bad values: ${JSON.stringify(distinctBad)}`,
+        {
+          schemaSource: resolvedSource,
+          dataSource: distinctBad[0] ?? "<null>"
+        }
+      );
+    }
+  }
+  const violations = [];
+  for (let i = 0; i < rows.length; i++) {
+    const r = rows[i];
+    const ok = validate(r);
+    if (!ok && validate.errors != null) {
+      for (const err of validate.errors) {
+        const value = r;
+        const column = err.instancePath.replace(/^\//, "");
+        if (err.keyword === "type" && value !== void 0 && column.length > 0 && value[column] === null) {
+          violations.push({
+            rule: "non_nullable_has_nulls",
+            column,
+            row_idx: i
+          });
+        } else {
+          violations.push(mapAjvErrorToViolation(err, i));
+        }
+        if (violations.length >= SAMPLE_CAP * 2) break;
+      }
+    }
+  }
+  const formatMap = getFormatMap(schemaId);
+  if (formatMap !== null) {
+    for (let i = 0; i < rows.length; i++) {
+      const r = rows[i];
+      for (const [propName, kind] of Object.entries(formatMap)) {
+        if (!(propName in r)) continue;
+        const v = r[propName];
+        if (v == null) continue;
+        const valid = kind === "date" ? isIsoDate(v) : isIsoDateTime(v);
+        if (!valid) {
+          violations.push({
+            rule: "dtype_mismatch",
+            column: propName,
+            row_idx: i,
+            value: v
+          });
+        }
+        if (violations.length >= SAMPLE_CAP * 2) break;
+      }
+      if (violations.length >= SAMPLE_CAP * 2) break;
+    }
+  }
+  const mixedColumns = detectMixedNullSentinels(rows);
+  for (const col of mixedColumns) {
+    violations.push({ rule: "mixed_null_sentinels", column: col });
+  }
+  let resolvedRetrievedAt = opts.retrievedAt;
+  if (resolvedRetrievedAt === void 0) {
+    let maxInstantMs = Number.NEGATIVE_INFINITY;
+    let maxValue;
+    for (const r of rows) {
+      const v = r.retrieved_at;
+      if (typeof v !== "string" || v.length === 0) continue;
+      const ms = Date.parse(v);
+      if (!Number.isFinite(ms)) continue;
+      if (ms > maxInstantMs) {
+        maxInstantMs = ms;
+        maxValue = v;
+      }
+    }
+    if (maxValue !== void 0) resolvedRetrievedAt = maxValue;
+  }
+  if (resolvedRetrievedAt === void 0) {
+    violations.push({ rule: "retrieved_at_required" });
+  }
+  if (violations.length > 0) {
+    throw new SchemaValidationError(
+      `Schema validation failed with ${violations.length} violation(s) under ${schemaId}`,
+      {
+        schemaId,
+        violations,
+        quarantineCount: rows.length,
+        sampleViolations: violations.slice(0, SAMPLE_CAP)
+      }
+    );
+  }
+  if (resolvedRetrievedAt === void 0) {
+    throw new Error(
+      "internal invariant: resolvedRetrievedAt is undefined but violations array was empty"
+    );
+  }
+  return {
+    rowCount: rows.length,
+    source: resolvedSource,
+    retrievedAt: resolvedRetrievedAt
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  validateRows
+});
+//# sourceMappingURL=validator.cjs.map