atmosx-nwws-parser 1.0.20311 → 1.0.20314

package/dist/cjs/index.cjs

@@ -8,6 +8,7 @@ var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __pow = Math.pow;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues = (a, b) => {
   for (var prop in b || (b = {}))
@@ -85,9 +86,9 @@ __export(index_exports, {
   StanzaParser: () => stanza_default,
   TextParser: () => text_default,
   UGCParser: () => ugc_default,
+  Utils: () => utils_default,
   VtecParser: () => vtec_default,
-  default: () => index_default,
-  types: () => types_exports
+  default: () => index_default
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -98,12 +99,13 @@ var events = __toESM(require("events"));
 var xmpp = __toESM(require("@xmpp/client"));
 var shapefile = __toESM(require("shapefile"));
 var xml2js = __toESM(require("xml2js"));
-var cron = __toESM(require("node-cron"));
+var jobs = __toESM(require("croner"));
 var import_better_sqlite3 = __toESM(require("better-sqlite3"));
 var import_axios = __toESM(require("axios"));
 var import_crypto = __toESM(require("crypto"));
 var import_os = __toESM(require("os"));
 var import_say = __toESM(require("say"));
+var import_child_process = __toESM(require("child_process"));
 
 // src/dictionaries/events.ts
 var EVENTS = {
@@ -621,53 +623,51 @@ var CANCEL_SIGNATURES = [
   "has weakened below severe"
 ];
 var MESSAGE_SIGNATURES = [
-  { regex: /\r?\n/g, replacement: " " },
-  { regex: /\s+/g, replacement: " " },
   { regex: /\*/g, replacement: "." },
   { regex: /\bUTC\b/g, replacement: "Coordinated Universal Time" },
   { regex: /\bGMT\b/g, replacement: "Greenwich Mean Time" },
-  { regex: /\bEST\b/g, replacement: "Eastern Standard Time" },
-  { regex: /\bEDT\b/g, replacement: "Eastern Daylight Time" },
-  { regex: /\bCST\b/g, replacement: "Central Standard Time" },
-  { regex: /\bCDT\b/g, replacement: "Central Daylight Time" },
-  { regex: /\bMST\b/g, replacement: "Mountain Standard Time" },
-  { regex: /\bMDT\b/g, replacement: "Mountain Daylight Time" },
-  { regex: /\bPST\b/g, replacement: "Pacific Standard Time" },
-  { regex: /\bPDT\b/g, replacement: "Pacific Daylight Time" },
-  { regex: /\bAKST\b/g, replacement: "Alaska Standard Time" },
-  { regex: /\bAKDT\b/g, replacement: "Alaska Daylight Time" },
-  { regex: /\bHST\b/g, replacement: "Hawaii Standard Time" },
-  { regex: /\bHDT\b/g, replacement: "Hawaii Daylight Time" },
-  { regex: /\bmph\b/g, replacement: "miles per hour" },
-  { regex: /\bkm\/h\b/g, replacement: "kilometers per hour" },
-  { regex: /\bkmh\b/g, replacement: "kilometers per hour" },
-  { regex: /\bkt\b/g, replacement: "knots" },
-  { regex: /\bNE\b/g, replacement: "northeast" },
-  { regex: /\bNW\b/g, replacement: "northwest" },
-  { regex: /\bSE\b/g, replacement: "southeast" },
-  { regex: /\bSW\b/g, replacement: "southwest" },
-  { regex: /\bNM\b/g, replacement: "nautical miles" },
-  { regex: /\bdeg\b/g, replacement: "degrees" },
-  { regex: /\btstm\b/g, replacement: "thunderstorm" },
-  { regex: /\bmm\b/g, replacement: "millimeters" },
-  { regex: /\bcm\b/g, replacement: "centimeters" },
-  { regex: /\bin\b/g, replacement: "inches" },
-  { regex: /\bft\b/g, replacement: "feet" },
-  { regex: /\bmi\b/g, replacement: "miles" },
-  { regex: /\bhr\b/g, replacement: "hour" },
-  { regex: /\bhourly\b/g, replacement: "per hour" },
-  { regex: /\bkg\b/g, replacement: "kilograms" },
-  { regex: /\bg\/kg\b/g, replacement: "grams per kilogram" },
-  { regex: /\bmb\b/g, replacement: "millibars" },
-  { regex: /\bhPa\b/g, replacement: "hectopascals" },
-  { regex: /\bPa\b/g, replacement: "pascals" },
-  { regex: /\bKPa\b/g, replacement: "kilopascals" },
-  { regex: /\bC\/hr\b/g, replacement: "degrees Celsius per hour" },
-  { regex: /\bF\/hr\b/g, replacement: "degrees Fahrenheit per hour" },
-  { regex: /\bC\/min\b/g, replacement: "degrees Celsius per minute" },
-  { regex: /\bF\/min\b/g, replacement: "degrees Fahrenheit per minute" },
-  { regex: /\bC\b/g, replacement: "degrees Celsius" },
-  { regex: /\bF\b/g, replacement: "degrees Fahrenheit" }
+  { regex: /\bEST\b(?!\w)/g, replacement: "Eastern Standard Time" },
+  { regex: /\bEDT\b(?!\w)/g, replacement: "Eastern Daylight Time" },
+  { regex: /\bCST\b(?!\w)/g, replacement: "Central Standard Time" },
+  { regex: /\bCDT\b(?!\w)/g, replacement: "Central Daylight Time" },
+  { regex: /\bMST\b(?!\w)/g, replacement: "Mountain Standard Time" },
+  { regex: /\bMDT\b(?!\w)/g, replacement: "Mountain Daylight Time" },
+  { regex: /\bPST\b(?!\w)/g, replacement: "Pacific Standard Time" },
+  { regex: /\bPDT\b(?!\w)/g, replacement: "Pacific Daylight Time" },
+  { regex: /\bAKST\b(?!\w)/g, replacement: "Alaska Standard Time" },
+  { regex: /\bAKDT\b(?!\w)/g, replacement: "Alaska Daylight Time" },
+  { regex: /\bHST\b(?!\w)/g, replacement: "Hawaii Standard Time" },
+  { regex: /\bHDT\b(?!\w)/g, replacement: "Hawaii Daylight Time" },
+  { regex: /\bmph\b(?!\w)/g, replacement: "miles per hour" },
+  { regex: /\bkm\/h\b(?!\w)/g, replacement: "kilometers per hour" },
+  { regex: /\bkmh\b(?!\w)/g, replacement: "kilometers per hour" },
+  { regex: /\bkt\b(?!\w)/g, replacement: "knots" },
+  { regex: /\bNE\b(?!\w)/g, replacement: "northeast" },
+  { regex: /\bNW\b(?!\w)/g, replacement: "northwest" },
+  { regex: /\bSE\b(?!\w)/g, replacement: "southeast" },
+  { regex: /\bSW\b(?!\w)/g, replacement: "southwest" },
+  { regex: /\bNM\b(?!\w)/g, replacement: "nautical miles" },
+  { regex: /\bdeg\b(?!\w)/g, replacement: "degrees" },
+  { regex: /\btstm\b(?!\w)/g, replacement: "thunderstorm" },
+  { regex: /\bmm\b(?!\w)/g, replacement: "millimeters" },
+  { regex: /\bcm\b(?!\w)/g, replacement: "centimeters" },
+  { regex: /\bin.\b(?!\w)/g, replacement: "inches" },
+  { regex: /\bft\b(?!\w)/g, replacement: "feet" },
+  { regex: /\bmi\b(?!\w)/g, replacement: "miles" },
+  { regex: /\bhr\b(?!\w)/g, replacement: "hour" },
+  { regex: /\bhourly\b(?!\w)/g, replacement: "per hour" },
+  { regex: /\bkg\b(?!\w)/g, replacement: "kilograms" },
+  { regex: /\bg\/kg\b(?!\w)/g, replacement: "grams per kilogram" },
+  { regex: /\bmb\b(?!\w)/g, replacement: "millibars" },
+  { regex: /\bhPa\b(?!\w)/g, replacement: "hectopascals" },
+  { regex: /\bPa\b(?!\w)/g, replacement: "pascals" },
+  { regex: /\bKPa\b(?!\w)/g, replacement: "kilopascals" },
+  { regex: /\bC\/hr\b(?!\w)/g, replacement: "degrees Celsius per hour" },
+  { regex: /\bF\/hr\b(?!\w)/g, replacement: "degrees Fahrenheit per hour" },
+  { regex: /\bC\/min\b(?!\w)/g, replacement: "degrees Celsius per minute" },
+  { regex: /\bF\/min\b(?!\w)/g, replacement: "degrees Fahrenheit per minute" },
+  { regex: /\bC\b(?!\w)/g, replacement: "degrees Celsius" },
+  { regex: /\bF\b(?!\w)/g, replacement: "degrees Fahrenheit" }
 ];
 
 // src/dictionaries/icao.ts
@@ -918,11 +918,12 @@ var packages = {
   shapefile,
   xml2js,
   sqlite3: import_better_sqlite3.default,
-  cron,
+  jobs,
   axios: import_axios.default,
   crypto: import_crypto.default,
   os: import_os.default,
-  say: import_say.default
+  say: import_say.default,
+  child: import_child_process.default
 };
 var cache = {
   isReady: true,
@@ -934,55 +935,64 @@ var cache = {
   session: null,
   lastConnect: null,
   db: null,
+  lastWarn: null,
+  totalLocationWarns: 0,
   events: new events.EventEmitter(),
   isProcessingAudioQueue: false,
-  audioQueue: []
+  audioQueue: [],
+  currentLocations: {}
 };
 var settings = {
   database: path.join(process.cwd(), "shapefiles.db"),
-  isNWWS: true,
-  catchUnhandledExceptions: false,
-  NoaaWeatherWireService: {
-    clientReconnections: {
-      canReconnect: true,
-      currentInterval: 60
+  is_wire: true,
+  journal: true,
+  noaa_weather_wire_service_settings: {
+    reconnection_settings: {
+      enabled: true,
+      interval: 60
     },
-    clientCredentials: {
+    credentials: {
       username: null,
       password: null,
       nickname: "AtmosphericX Standalone Parser"
     },
     cache: {
-      read: false,
-      maxSizeMB: 5,
-      maxHistory: 5e3,
+      enabled: false,
+      max_file_size: 5,
+      max_db_history: 5e3,
       directory: null
     },
-    alertPreferences: {
-      isCapOnly: false,
-      isShapefileUGC: false
+    preferences: {
+      cap_only: false,
+      shapefile_coordinates: false
     }
   },
-  NationalWeatherService: {
-    checkInterval: 15,
-    endpoint: "https://api.weather.gov/alerts/active"
+  national_weather_service_settings: {
+    interval: 15,
+    endpoint: `https://api.weather.gov/alerts/active`
   },
-  global: {
-    useParentEvents: true,
-    betterEventParsing: true,
-    alertFiltering: {
-      filteredEvents: [],
-      filteredICOAs: [],
-      ignoredICOAs: [`KWNS`],
-      ignoredEvents: [`Xx`, `Test Message`],
-      ugcFilter: [],
-      stateFilter: [],
-      checkExpired: true
+  global_settings: {
+    parent_events_only: true,
+    better_event_parsing: true,
+    filtering: {
+      events: [],
+      filtered_icoa: [],
+      ignored_icoa: [`KWNS`],
+      ignored_events: [`Xx`, `Test Message`],
+      ugc_filter: [],
+      state_filter: [],
+      check_expired: true,
+      ignore_text_products: true,
+      location: {
+        max_distance: 100,
+        unit: `miles`,
+        filter: false
+      }
     },
-    easSettings: {
-      easAlerts: [],
-      easDirectory: null,
-      easIntroWav: null
+    eas_settings: {
+      directory: null,
+      intro_wav: null,
+      festival_tts_voice: `kal_diphone`
     }
   }
 };
@@ -1040,31 +1050,47 @@ var definitions = {
     { id: `Z`, file: `Marine` }
   ],
   messages: {
-    shapefile_creation: `[NOTICE] DO NOT CLOSE THIS PROJECT UNTIL THE SHAPEFILES ARE DONE COMPLETING!
+    shapefile_creation: `DO NOT CLOSE THIS PROJECT UNTIL THE SHAPEFILES ARE DONE COMPLETING!
 	 THIS COULD TAKE A WHILE DEPENDING ON THE SPEED OF YOUR STORAGE!!
 	 IF YOU CLOSE YOUR PROJECT, THE SHAPEFILES WILL NOT BE CREATED AND YOU WILL NEED TO DELETE ${settings.database} AND RESTART TO CREATE THEM AGAIN!`,
-    shapefile_creation_finished: `[NOTICE] SHAPEFILES HAVE BEEN SUCCESSFULLY CREATED AND THE DATABASE IS READY FOR USE!`,
-    not_ready: "[ERROR] You can NOT create another instance without shutting down the current one first, please make sure to call the stop() method first!",
-    invalid_nickname: "[WARNING] The nickname you provided is invalid, please provide a valid nickname to continue.",
-    eas_no_directory: "[WARNING] You have not set a directory for EAS audio files to be saved to, please set the 'easDirectory' setting in the global settings to enable EAS audio generation."
+    shapefile_creation_finished: `SHAPEFILES HAVE BEEN SUCCESSFULLY CREATED AND THE DATABASE IS READY FOR USE!`,
+    not_ready: `You can NOT create another instance without shutting down the current one first, please make sure to call the stop() method first!`,
+    invalid_nickname: `The nickname you provided is invalid, please provide a valid nickname to continue.`,
+    eas_no_directory: `You have not set a directory for EAS audio files to be saved to, please set the 'directory' setting in the global settings to enable EAS audio generation.`,
+    invalid_coordinates: `The coordinates you provided are invalid, please provide valid latitude and longitude values. Attempted: {lat}, {lon}.`,
+    no_current_locations: `No current location has been set, operations will be haulted until a location is set or location filtering is disabled.`,
+    disabled_location_warning: `Exceeded maximum warnings for invalid or missing lat/lon coordinates. Location filtering has been ignored until you set valid coordinates or disable location filtering.`,
+    reconnect_too_fast: `The client is attempting to reconnect too fast. This may be due to network instability. Reconnection attempt has been halted for safety.`,
+    dump_cache: `Found {count} cached alert files and will begin dumping them shortly...`,
+    dump_cache_complete: `Completed dumping all cached alert files.`,
+    eas_missing_festival: `Festival TTS engine is not installed or not found in PATH. Please install Festival to enable EAS audio generation on Linux and macOS systems.`
   }
 };
 
-// src/types.ts
-var types_exports = {};
-
 // src/parsers/stanza.ts
 var StanzaParser = class {
   /**
-   * validate handles the validation of incoming XMPP stanzas to ensure they contain valid alert data.
-   * You can also feed debug / cache data directly into this function by specifying the second parameter
-   * which is the attributes object that would normally be parsed from the XMPP stanza.
+   * @function validate
+   * @description
+   *     Validates and parses a stanza message, extracting its attributes and metadata.
+   *     Handles both raw message strings (for debug/testing) and actual stanza objects.
+   *     Determines whether the message is a CAP alert, contains VTEC codes, or contains UGCs,
+   *     and identifies the AWIPS product type and prefix.
    *
-   * @public
    * @static
-   * @param {*} stanza 
-   * @param {(boolean | types.TypeAttributes)} [isDebug=false] 
-   * @returns {{ message: any; attributes: types.TypeAttributes; isCap: any; isVtec: boolean; isCapDescription: any; awipsType: any; isApi: boolean; ignore: boolean; }} 
+   * @param {any} stanza
+   * @param {boolean | types.StanzaAttributes} [isDebug=false]
+   * @returns {{
+   *     message: string;
+   *     attributes: types.StanzaAttributes;
+   *     isCap: boolean,
+   *     isVtec: boolean;
+   *     isCapDescription: boolean;
+   *     awipsType: Record<string, string>;
+   *     isApi: boolean;
+   *     ignore: boolean;
+   *     isUGC?: boolean;
+   * }}
    */
   static validate(stanza, isDebug = false) {
     var _a;
@@ -1090,67 +1116,71 @@ var StanzaParser = class {
           const isVtec = message.match(definitions.expressions.vtec) != null;
           const isUGC = message.match(definitions.expressions.ugc1) != null;
           const awipsType = this.getType(attributes);
-          const isApi = false;
-          this.cache({ message, attributes, isCap, isVtec, awipsType: awipsType.type, awipsPrefix: awipsType.prefix });
-          return { message, attributes, isCap, isApi, isVtec, isUGC, isCapDescription, awipsType, ignore: false };
+          this.cache(message, { attributes, isCap, isVtec, awipsType });
+          return { message, attributes, isCap, isVtec, isUGC, isCapDescription, awipsType, isApi: false, ignore: false };
         }
       }
     }
     return { message: null, attributes: null, isApi: null, isCap: null, isVtec: null, isUGC: null, isCapDescription: null, awipsType: null, ignore: true };
   }
   /**
-   * getType determines the AWIPS type of the alert based on its attributes, specifically the awipsid.
-   * If no matching type is found, it defaults to 'default'.
+   * @function getType
+   * @description
+   *     Determines the AWIPS product type and prefix from a stanza's attributes.
+   *     Returns a default type of 'XX' if the attributes are missing or the AWIPS ID
+   *     does not match any known definitions.
    *
    * @private
    * @static
-   * @param {unknown} attributes 
-   * @returns {*} 
+   * @param {unknown} attributes
+   * @returns {Record<string, string>}
    */
   static getType(attributes) {
     const attrs = attributes;
-    if (!attrs || !attrs.awipsid) return { type: `XX`, prefix: `XX` };
-    for (const [prefix, type] of Object.entries(definitions.awips)) {
+    if (!(attrs == null ? void 0 : attrs.awipsid)) return { type: "XX", prefix: "XX" };
+    const awipsDefs = definitions.awips;
+    for (const [prefix, type] of Object.entries(awipsDefs)) {
       if (attrs.awipsid.startsWith(prefix)) {
         return { type, prefix };
       }
     }
-    return { type: `XX`, prefix: `XX` };
+    return { type: "XX", prefix: "XX" };
   }
   /**
-   * cache stores the compiled alert data into a cache file if caching is enabled in the settings.
+   * @function cache
+   * @description
+   *     Saves a compiled stanza message to the local cache directory.
+   *     Ensures the message contains "STANZA ATTRIBUTES..." metadata and timestamps,
+   *     and appends the formatted entry to both a category-specific file and a general cache file.
    *
    * @private
    * @static
-   * @param {unknown} compiled 
+   * @async
+   * @param {unknown} compiled
+   * @returns {Promise<void>}
    */
-  static cache(compiled) {
-    const data = compiled;
-    const settings2 = settings;
-    if (!settings2.NoaaWeatherWireService.cache.directory) return;
-    if (!packages.fs.existsSync(settings2.NoaaWeatherWireService.cache.directory)) {
-      packages.fs.mkdirSync(settings2.NoaaWeatherWireService.cache.directory, { recursive: true });
-    }
-    data.message = data.message.replace(/\$\$/g, `
-STANZA ATTRIBUTES...${JSON.stringify(data.attributes)}
-ISSUED TIME...${(/* @__PURE__ */ new Date()).toISOString()}
-$$$
-`);
-    if (!data.message.includes(`STANZA ATTRIBUTES...`)) {
-      data.message += `
-STANZA ATTRIBUTES...${JSON.stringify(data.attributes)}
-ISSUED TIME...${(/* @__PURE__ */ new Date()).toISOString()}
-$$
-`;
-    }
-    packages.fs.appendFileSync(`${settings2.NoaaWeatherWireService.cache.directory}/category-${data.awipsPrefix}-${data.awipsType}s-${data.isCap ? `cap` : `raw`}${data.isVtec ? `-vtec` : ``}.bin`, `=================================================
-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}
-=================================================
-${data.message}`, "utf8");
-    packages.fs.appendFileSync(`${settings2.NoaaWeatherWireService.cache.directory}/cache-${data.isCap ? `cap` : `raw`}${data.isVtec ? `-vtec` : ``}.bin`, `=================================================
-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}
-=================================================
-${data.message}`, "utf8");
+  static cache(message, compiled) {
+    return __async(this, null, function* () {
+      if (!compiled) return;
+      const data = compiled;
+      const settings2 = settings;
+      const { fs: fs2, path: path2 } = packages;
+      if (!message || !settings2.noaa_weather_wire_service_settings.cache.directory) return;
+      const cacheDir = settings2.noaa_weather_wire_service_settings.cache.directory;
+      if (!fs2.existsSync(cacheDir)) fs2.mkdirSync(cacheDir, { recursive: true });
+      const prefix = `category-${data.awipsType.prefix}-${data.awipsType.type}s`;
+      const suffix = `${data.isCap ? "cap" : "raw"}${data.isVtec ? "-vtec" : ""}`;
+      const categoryFile = path2.join(cacheDir, `${prefix}-${suffix}.bin`);
+      const cacheFile = path2.join(cacheDir, `cache-${suffix}.bin`);
+      const entry = `[SoF]
+STANZA ATTRIBUTES...${JSON.stringify(compiled)}
+[EoF]
+${message}`;
+      yield Promise.all([
+        fs2.promises.appendFile(categoryFile, entry, "utf8"),
+        fs2.promises.appendFile(cacheFile, entry, "utf8")
+      ]);
+    });
   }
 };
 var stanza_default = StanzaParser;
@@ -1158,14 +1188,19 @@ var stanza_default = StanzaParser;
 // src/parsers/text.ts
 var TextParser = class {
   /**
-   * textProductToString extracts a specific value from a text-based weather product message based on a given key and optional removal strings.
+   * @function textProductToString
+   * @description
+   *     Searches a text product message for a line containing a specific value,
+   *     extracts the substring immediately following that value, and optionally
+   *     removes additional specified strings. Cleans up the extracted string by
+   *     trimming whitespace and removing any remaining occurrences of the search
+   *     value or '<' characters.
    *
-   * @public
    * @static
-   * @param {string} message 
-   * @param {string} value 
-   * @param {string[]} [removal=[]] 
-   * @returns {(string | null)} 
+   * @param {string} message
+   * @param {string} value
+   * @param {string[]} [removal=[]]
+   * @returns {string | null}
    */
   static textProductToString(message, value, removal = []) {
     const lines = message.split("\n");
@@ -1182,12 +1217,16 @@ var TextParser = class {
     return null;
   }
   /**
-   * textProductToPolygon extracts geographical coordinates from a text-based weather product message and returns them as an array of [longitude, latitude] pairs.
+   * @function textProductToPolygon
+   * @description
+   *     Parses a text product message to extract polygon coordinates based on
+   *     LAT...LON data. Coordinates are converted to [latitude, longitude] pairs
+   *     with longitude negated (assumes Western Hemisphere). If the polygon has
+   *     more than two points, the first point is repeated at the end to close it.
    *
-   * @public
    * @static
-   * @param {string} message 
-   * @returns {[number, number][]} 
+   * @param {string} message
+   * @returns {[number, number][]}
    */
   static textProductToPolygon(message) {
     const coordinates = [];
@@ -1207,13 +1246,16 @@ var TextParser = class {
     return coordinates;
   }
   /**
-   * textProductToDescription extracts the main description from a text-based weather product message.
+   * @function textProductToDescription
+   * @description
+   *     Extracts a clean description portion from a text product message, optionally
+   *     removing a handle and any extra metadata such as "STANZA ATTRIBUTES...".
+   *     Also trims and normalizes whitespace.
    *
-   * @public
    * @static
-   * @param {string} message 
-   * @param {string} [handle=null] 
-   * @returns {string} 
+   * @param {string} message
+   * @param {string | null} [handle=null]
+   * @returns {string}
    */
   static textProductToDescription(message, handle = null) {
     const original = message;
@@ -1241,32 +1283,21 @@ var TextParser = class {
         message = latEnd !== -1 ? afterHandle.substring(0, latEnd).trim() : afterHandle.trim();
       }
     }
-    return message.replace(/\s+/g, " ").trim().startsWith("ISSUED TIME...") ? original : message.trim();
-  }
-  /**
-   * awipTextToEvent converts an AWIPS ID prefix from a text-based weather product message to its corresponding event type and prefix.
-   *
-   * @public
-   * @static
-   * @param {string} message 
-   * @returns {{ type: any; prefix: any; }} 
-   */
-  static awipTextToEvent(message) {
-    for (const [prefix, type] of Object.entries(definitions.awips)) {
-      if (message.startsWith(prefix)) {
-        return { type, prefix };
-      }
-    }
-    return { type: `XX`, prefix: `XX` };
+    return message.replace(/\s+/g, " ").trim().startsWith("STANZA ATTRIBUTES...") ? original : message.split("STANZA ATTRIBUTES...")[0].trim();
   }
   /**
-   * getXmlValues recursively searches a parsed XML object for specified keys and extracts their values.
+   * @function getXmlValues
+   * @description
+   *     Recursively extracts specified values from a parsed XML-like object.
+   *     Searches both object keys and array items for matching keys (case-insensitive)
+   *     and returns the corresponding values. If multiple unique values are found for
+   *     a key, an array is returned; if one value is found, it returns that value; 
+   *     if none are found, returns `null`.
    *
-   * @public
    * @static
-   * @param {*} parsed 
-   * @param {string[]} valuesToExtract 
-   * @returns {Record<string, any>} 
+   * @param {any} parsed
+   * @param {string[]} valuesToExtract
+   * @returns {Record<string, string | string[] | null>}
    */
   static getXmlValues(parsed, valuesToExtract) {
     const extracted = {};
@@ -1311,45 +1342,63 @@ var text_default = TextParser;
 // src/parsers/ugc.ts
 var UGCParser = class {
   /**
-   * ugcExtractor extracts and parses UGC codes from a given message string.
+   * @function ugcExtractor
+   * @description
+   *     Extracts UGC (Universal Geographic Code) information from a message.
+   *     This includes parsing the header, resolving zones, calculating the expiry
+   *     date, and retrieving associated location names from the database.
    *
-   * @public
    * @static
    * @async
-   * @param {string} message 
-   * @returns {unknown} 
+   * @param {string} message
+   * @returns {Promise<types.UGCEntry | null>}
    */
   static ugcExtractor(message) {
     return __async(this, null, function* () {
       const header = this.getHeader(message);
+      if (!header) return null;
       const zones = this.getZones(header);
+      if (zones.length === 0) return null;
       const expiry = this.getExpiry(message);
       const locations = yield this.getLocations(zones);
-      const ugc = zones.length > 0 ? { zones, locations, expiry } : null;
-      return ugc;
+      return {
+        zones,
+        locations,
+        expiry
+      };
     });
   }
   /**
-   * getHeader extracts the UGC header from a UGC message string.
+   * @function getHeader
+   * @description
+   *     Extracts the UGC header from a message by locating patterns defined in
+   *     `ugc1` and `ugc2` regular expressions. Removes all whitespace and the
+   *     trailing character from the matched header.
    *
-   * @public
    * @static
-   * @param {string} message 
-   * @returns {*} 
+   * @param {string} message
+   * @returns {string | null}
    */
   static getHeader(message) {
     const start = message.search(new RegExp(definitions.expressions.ugc1, "gimu"));
-    const end = message.substring(start).search(new RegExp(definitions.expressions.ugc2, "gimu"));
-    const full = message.substring(start, start + end).replace(/\s+/g, "").slice(0, -1);
-    return full;
+    if (start === -1) return null;
+    const subMessage = message.substring(start);
+    const end = subMessage.search(new RegExp(definitions.expressions.ugc2, "gimu"));
+    if (end === -1) return null;
+    const full = subMessage.substring(0, end).replace(/\s+/g, "").slice(0, -1);
+    return full || null;
   }
   /**
-   * getExpiry extracts the expiry date and time from a UGC message and returns it as a Date object.
+   * @function getExpiry
+   * @description
+   *     Extracts an expiration date from a message using the UGC3 format.
+   *     The function parses day, hour, and minute from the message and constructs
+   *     a Date object in the current month and year. Returns `null` if no valid
+   *     expiration is found.
    *
-   * @public
    * @static
-   * @param {string} message 
-   * @returns {*} 
+   * @param {string} message
+   * @returns {Date | null}
    */
   static getExpiry(message) {
     const start = message.match(new RegExp(definitions.expressions.ugc3, "gimu"));
@@ -1364,42 +1413,53 @@ var UGCParser = class {
     return null;
   }
   /**
-   * getLocations retrieves unique location names for the provided UGC zone codes from the database.
+   * @function getLocations
+   * @description
+   *     Retrieves human-readable location names for an array of zone identifiers
+   *     from the shapefiles database. If a zone is not found, the zone ID itself
+   *     is returned. Duplicate locations are removed and the result is sorted.
    *
-   * @public
    * @static
    * @async
-   * @param {String[]} zones 
-   * @returns {unknown} 
+   * @param {string[]} zones
+   * @returns {Promise<string[]>}
    */
   static getLocations(zones) {
     return __async(this, null, function* () {
       const locations = [];
       for (let i = 0; i < zones.length; i++) {
         const id = zones[i].trim();
-        const located = yield cache.db.prepare(`SELECT location FROM shapefiles WHERE id = ?`).get(id);
+        const located = yield cache.db.prepare(
+          `
+                SELECT location FROM shapefiles WHERE id = ?`
+        ).get(id);
         located != void 0 ? locations.push(located.location) : locations.push(id);
       }
       return Array.from(new Set(locations)).sort();
     });
   }
   /**
-   * getCoordinates retrieves geographical coordinates for the provided UGC zone codes from the database.
+   * @function getCoordinates
+   * @description
+   *     Retrieves geographic coordinates for an array of zone identifiers
+   *     from the shapefiles database. Returns the coordinates of the first
+   *     polygon found for any matching zone.
    *
-   * @public
    * @static
-   * @param {String[]} zones 
-   * @returns {{}} 
+   * @param {string[]} zones
+   * @returns {[number, number][]}
    */
   static getCoordinates(zones) {
     let coordinates = [];
     for (let i = 0; i < zones.length; i++) {
       const id = zones[i].trim();
-      let located = cache.db.prepare(`SELECT geometry FROM shapefiles WHERE id = ?`).get(id);
-      if (located != void 0) {
-        let geometry = JSON.parse(located.geometry);
+      const row = cache.db.prepare(
+        `SELECT geometry FROM shapefiles WHERE id = ?`
+      ).get(id);
+      if (row != void 0) {
+        let geometry = JSON.parse(row.geometry);
         if ((geometry == null ? void 0 : geometry.type) === "Polygon") {
-          coordinates.push(...geometry.coordinates[0].map((coord) => [coord[0], coord[1]]));
+          coordinates.push(...geometry.coordinates[0].map((coord) => [coord[1], coord[0]]));
           break;
         }
       }
@@ -1407,31 +1467,46 @@ var UGCParser = class {
     return coordinates;
   }
   /**
-   * getZones parses a UGC header string and returns an array of individual UGC zone codes.
+   * @function getZones
+   * @description
+   *     Parses a UGC header string and returns an array of individual zone
+   *     identifiers. Handles ranges indicated with `>` and preserves the
+   *     state and format prefixes.
    *
-   * @public
    * @static
-   * @param {string} header 
-   * @returns {*} 
+   * @param {string} header
+   * @returns {string[]}
    */
   static getZones(header) {
     const ugcSplit = header.split("-");
     const zones = [];
     let state = ugcSplit[0].substring(0, 2);
-    let format = ugcSplit[0].substring(2, 3);
-    for (let i = 0; i < ugcSplit.length; i++) {
-      if (/^[A-Z]/.test(ugcSplit[i])) {
-        state = ugcSplit[i].substring(0, 2);
-        if (ugcSplit[i].includes(">")) {
-          let [start, end] = ugcSplit[i].split(">"), startNum = parseInt(start.substring(3), 10), endNum = parseInt(end, 10);
-          for (let j = startNum; j <= endNum; j++) zones.push(`${state}${format}${j.toString().padStart(3, "0")}`);
-        } else zones.push(ugcSplit[i]);
+    const format = ugcSplit[0].substring(2, 3);
+    for (const part of ugcSplit) {
+      if (/^[A-Z]/.test(part)) {
+        state = part.substring(0, 2);
+        if (part.includes(">")) {
+          const [start, end] = part.split(">");
+          const startNum = parseInt(start.substring(3), 10);
+          const endNum = parseInt(end, 10);
+          for (let j = startNum; j <= endNum; j++) {
+            zones.push(`${state}${format}${j.toString().padStart(3, "0")}`);
+          }
+        } else {
+          zones.push(part);
+        }
         continue;
       }
-      if (ugcSplit[i].includes(">")) {
-        let [start, end] = ugcSplit[i].split(">"), startNum = parseInt(start, 10), endNum = parseInt(end, 10);
-        for (let j = startNum; j <= endNum; j++) zones.push(`${state}${format}${j.toString().padStart(3, "0")}`);
-      } else zones.push(`${state}${format}${ugcSplit[i]}`);
+      if (part.includes(">")) {
+        const [start, end] = part.split(">");
+        const startNum = parseInt(start, 10);
+        const endNum = parseInt(end, 10);
+        for (let j = startNum; j <= endNum; j++) {
+          zones.push(`${state}${format}${j.toString().padStart(3, "0")}`);
+        }
+      } else {
+        zones.push(`${state}${format}${part}`);
+      }
     }
     return zones.filter((item) => item !== "");
   }
@@ -1441,43 +1516,50 @@ var ugc_default = UGCParser;
 // src/parsers/vtec.ts
 var VtecParser = class {
   /**
-   * vtecExtractor extracts and parses VTEC codes from a given message string.
+   * @function vtecExtractor
+   * @description
+   *     Extracts VTEC entries from a raw NWWS message string and returns
+   *     structured objects containing type, tracking, event, status,
+   *     WMO identifiers, and expiry date.
    *
-   * @public
    * @static
-   * @async
-   * @param {string} message 
-   * @returns {unknown} 
+   * @param {string} message
+   * @returns {Promise<types.VtecEntry[] | null>}
    */
   static vtecExtractor(message) {
     return __async(this, null, function* () {
-      const vtecs = [];
+      var _a;
       const matches = message.match(new RegExp(definitions.expressions.vtec, "g"));
       if (!matches) return null;
-      for (let i = 0; i < matches.length; i++) {
-        const vtec = matches[i];
-        const parts = vtec.split(`.`);
-        const dates = parts[6].split(`-`);
+      const vtecs = [];
+      for (const vtec of matches) {
+        const parts = vtec.split(".");
+        if (parts.length < 7) continue;
+        const dates = parts[6].split("-");
         vtecs.push({
           raw: vtec,
           type: definitions.productTypes[parts[0]],
           tracking: `${parts[2]}-${parts[3]}-${parts[4]}-${parts[5]}`,
           event: `${definitions.events[parts[3]]} ${definitions.actions[parts[4]]}`,
           status: definitions.status[parts[1]],
-          wmo: message.match(new RegExp(definitions.expressions.wmo, "gimu")),
+          wmo: (_a = message.match(new RegExp(definitions.expressions.wmo, "gimu"))) != null ? _a : [],
           expires: this.parseExpiryDate(dates)
         });
       }
-      return vtecs;
+      return vtecs.length ? vtecs : null;
     });
   }
   /**
-   * parseExpiryDate converts VTEC expiry date format to a standard ISO 8601 format with timezone adjustment.
+   * @function parseExpiryDate
+   * @description
+   *     Converts a NWWS VTEC/expiry timestamp string into a formatted local ISO date string
+   *     with an Eastern Time offset (-04:00). Returns `Invalid Date Format` if the input
+   *     is `000000T0000Z`.
    *
    * @private
    * @static
-   * @param {String[]} args 
-   * @returns {string} 
+   * @param {string[]} args
+   * @returns {string}
    */
   static parseExpiryDate(args) {
     if (args[1] == `000000T0000Z`) return `Invalid Date Format`;
@@ -1492,38 +1574,48 @@ var vtec_default = VtecParser;
 // src/parsers/types/vtec.ts
 var VTECAlerts = class {
   /**
-   * event processes validated VTEC alert messages, extracting relevant information and compiling it into structured event objects.
+   * @function event
+   * @description
+   *     Processes a validated stanza message, extracting VTEC and UGC entries,
+   *     computing base properties, generating headers, and preparing structured
+   *     event objects for downstream handling. Each extracted event is enriched
+   *     with metadata, performance timing, and history information.
    *
-   * @public
    * @static
    * @async
-   * @param {types.TypeCompiled} validated 
-   * @returns {*} 
+   * @param {types.StanzaCompiled} validated
+   * @returns {Promise<void>}
    */
   static event(validated) {
     return __async(this, null, function* () {
-      var _a;
+      var _a, _b;
       let processed = [];
-      const messages = (_a = validated.message.split(/(?=\$\$)/g)) == null ? void 0 : _a.map((msg) => msg.trim());
-      if (!messages || messages.length == 0) return;
-      for (let i = 0; i < messages.length; i++) {
-        const tick = performance.now();
-        const message = messages[i];
-        const getVTEC = yield vtec_default.vtecExtractor(message);
-        const getUGC = yield ugc_default.ugcExtractor(message);
-        if (getVTEC != null && getUGC != null) {
-          for (let j = 0; j < getVTEC.length; j++) {
-            const vtec = getVTEC[j];
-            const getBaseProperties = yield events_default.getBaseProperties(message, validated, getUGC, vtec);
-            const getHeader = events_default.getHeader(__spreadValues(__spreadValues({}, validated.attributes), getBaseProperties.attributes), getBaseProperties, vtec);
-            processed.push({
-              performance: performance.now() - tick,
-              tracking: vtec.tracking,
-              header: getHeader,
-              vtec: vtec.raw,
-              history: [{ description: getBaseProperties.description, issued: getBaseProperties.issued, type: vtec.status }],
-              properties: __spreadValues({ event: vtec.event, parent: vtec.event, action_type: vtec.status }, getBaseProperties)
-            });
+      const blocks = (_a = validated.message.split(/\[SoF\]/gim)) == null ? void 0 : _a.map((msg) => msg.trim());
+      for (const block of blocks) {
+        const cachedAttribute = block.match(/STANZA ATTRIBUTES\.\.\.(\{.*\})/);
+        const messages = (_b = block.split(/(?=\$\$)/g)) == null ? void 0 : _b.map((msg) => msg.trim());
+        if (!messages || messages.length == 0) return;
+        for (let i = 0; i < messages.length; i++) {
+          const tick = performance.now();
+          const message = messages[i];
+          const attributes = cachedAttribute != null ? JSON.parse(cachedAttribute[1]) : validated;
+          const getVTEC = yield vtec_default.vtecExtractor(message);
+          const getUGC = yield ugc_default.ugcExtractor(message);
+          if (getVTEC != null && getUGC != null) {
+            for (let j = 0; j < getVTEC.length; j++) {
+              const vtec = getVTEC[j];
+              const getBaseProperties = yield events_default.getBaseProperties(message, attributes, getUGC, vtec);
+              const getHeader = events_default.getHeader(__spreadValues(__spreadValues({}, validated.attributes), getBaseProperties.metadata), getBaseProperties, vtec);
+              processed.push({
+                performance: performance.now() - tick,
+                source: `vtec-parser`,
+                tracking: vtec.tracking,
+                header: getHeader,
+                vtec: vtec.raw,
+                history: [{ description: getBaseProperties.description, issued: getBaseProperties.issued, type: vtec.status }],
+                properties: __spreadValues({ event: vtec.event, parent: vtec.event, action_type: vtec.status }, getBaseProperties)
+              });
+            }
           }
         }
       }
@@ -1536,62 +1628,80 @@ var vtec_default2 = VTECAlerts;
 // src/parsers/types/ugc.ts
 var UGCAlerts = class {
   /**
-   * getTracking generates a unique tracking identifier based on the sender's ICAO code and a hash of the UGC zones.
+   * @function getTracking
+   * @description
+   *    Generates a unique tracking identifier for an event using the sender's ICAO
+   *    and some attributes.
    *
    * @private
    * @static
-   * @param {types.BaseProperties} baseProperties 
-   * @param {string[]} zones 
+   * @param {types.EventProperties} baseProperties 
    * @returns {string} 
    */
-  static getTracking(baseProperties, zones) {
-    return `${baseProperties.sender_icao} (${packages.crypto.createHash("md5").update(zones.join(``)).digest("hex")}})`;
+  static getTracking(baseProperties) {
+    return `${baseProperties.sender_icao}-${baseProperties.metadata.attributes.ttaaii}-${baseProperties.metadata.attributes.id.slice(-4)}`;
   }
   /**
-   * getEvent determines the event name based on offshore definitions or formats it from the attributes.
+   * @function getEvent
+   * @description
+   *     Determines the human-readable event name from a message and AWIPS attributes.
+   *     - Checks if the message contains any predefined offshore event keywords
+   *       and returns the matching offshore event if found.
+   *     - Otherwise, returns a formatted event type string from the provided attributes,
+   *       capitalizing the first letter of each word.
    *
    * @private
    * @static
-   * @param {string} message 
-   * @param {Record<string, any>} attributes 
-   * @returns {*} 
+   * @param {string} message
+   * @param {Record<string, any>} attributes
+   * @returns {string}
    */
-  static getEvent(message, attributes) {
+  static getEvent(message, metadata) {
     const offshoreEvent = Object.keys(definitions.offshore).find((event) => message.toLowerCase().includes(event.toLowerCase()));
     if (offshoreEvent != void 0) return Object.keys(definitions.offshore).find((event) => message.toLowerCase().includes(event.toLowerCase()));
-    return attributes.type.split(`-`).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(` `);
+    return metadata.awipsType.type.split(`-`).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(` `);
   }
   /**
-   * event processes validated UGC alert messages, extracting relevant information and compiling it into structured event objects.
+   * @function event
+   * @description
+   *     Processes a validated stanza message, extracting UGC entries and
+   *     computing base properties for non-VTEC events. Each extracted event
+   *     is enriched with metadata, performance timing, and history information,
+   *     then filtered and emitted via `EventParser.validateEvents`.
    *
-   * @public
    * @static
    * @async
-   * @param {types.TypeCompiled} validated 
-   * @returns {*} 
+   * @param {types.StanzaCompiled} validated
+   * @returns {Promise<void>}
    */
   static event(validated) {
     return __async(this, null, function* () {
-      var _a;
+      var _a, _b;
       let processed = [];
-      const messages = (_a = validated.message.split(/(?=\$\$|ISSUED TIME...|=================================================)/g)) == null ? void 0 : _a.map((msg) => msg.trim());
-      if (!messages || messages.length == 0) return;
-      for (let i = 0; i < messages.length; i++) {
-        const tick = performance.now();
-        const message = messages[i];
-        const getUGC = yield ugc_default.ugcExtractor(message);
-        if (getUGC != null) {
-          const getBaseProperties = yield events_default.getBaseProperties(message, validated, getUGC);
-          const getHeader = events_default.getHeader(__spreadValues(__spreadValues({}, validated.attributes), getBaseProperties.attributes), getBaseProperties);
-          const getEvent = this.getEvent(message, getBaseProperties.attributes.getAwip);
-          processed.push({
-            performance: performance.now() - tick,
-            tracking: this.getTracking(getBaseProperties, getUGC.zones),
-            header: getHeader,
-            vtec: `N/A`,
-            history: [{ description: getBaseProperties.description, issued: getBaseProperties.issued, type: `Issued` }],
-            properties: __spreadValues({ event: getEvent, parent: getEvent, action_type: `Issued` }, getBaseProperties)
-          });
+      const blocks = (_a = validated.message.split(/\[SoF\]/gim)) == null ? void 0 : _a.map((msg) => msg.trim());
+      for (const block of blocks) {
+        const cachedAttribute = block.match(/STANZA ATTRIBUTES\.\.\.(\{.*\})/);
+        const messages = (_b = block.split(/(?=\$\$)/g)) == null ? void 0 : _b.map((msg) => msg.trim());
+        if (!messages || messages.length == 0) return;
+        for (let i = 0; i < messages.length; i++) {
+          const tick = performance.now();
+          const message = messages[i];
+          const getUGC = yield ugc_default.ugcExtractor(message);
+          if (getUGC != null) {
+            const attributes = cachedAttribute != null ? JSON.parse(cachedAttribute[1]) : validated;
+            const getBaseProperties = yield events_default.getBaseProperties(message, attributes, getUGC);
+            const getHeader = events_default.getHeader(__spreadValues(__spreadValues({}, attributes), getBaseProperties.metadata), getBaseProperties);
+            const getEvent = this.getEvent(message, attributes);
+            processed.push({
+              performance: performance.now() - tick,
+              source: `ugc-parser`,
+              tracking: this.getTracking(getBaseProperties),
+              header: getHeader,
+              vtec: `N/A`,
+              history: [{ description: getBaseProperties.description, issued: getBaseProperties.issued, type: `Issued` }],
+              properties: __spreadValues({ event: getEvent, parent: getEvent, action_type: `Issued` }, getBaseProperties)
+            });
+          }
         }
       }
       events_default.validateEvents(processed);
@@ -1601,126 +1711,202 @@ var UGCAlerts = class {
 var ugc_default2 = UGCAlerts;
 
 // src/parsers/types/text.ts
-var UGCAlerts2 = class {
+var TextAlerts = class {
+  /**
+   * @function getTracking
+   * @description
+   *    Generates a unique tracking identifier for an event using the sender's ICAO
+   *    and some attributes.
+   *
+   * @private
+   * @static
+   * @param {types.EventProperties} baseProperties 
+   * @returns {string} 
+   */
   static getTracking(baseProperties) {
-    return `${baseProperties.sender_icao}`;
+    return `${baseProperties.sender_icao}-${baseProperties.metadata.attributes.ttaaii}-${baseProperties.metadata.attributes.id.slice(-4)}`;
   }
-  static getEvent(message, attributes) {
+  /**
+   * @function getEvent
+   * @description
+   *     Determines the event name from a text message and its AWIPS attributes.
+   *     If the message contains a known offshore event keyword, that offshore
+   *     event is returned. Otherwise, the event type from the AWIPS attributes
+   *     is formatted into a human-readable string with each word capitalized.
+   *
+   * @private
+   * @static
+   * @param {string} message
+   * @param {types.StanzaAttributes} metadata
+   * @returns {string}
+   */
+  static getEvent(message, metadata) {
     const offshoreEvent = Object.keys(definitions.offshore).find((event) => message.toLowerCase().includes(event.toLowerCase()));
-    if (offshoreEvent) return Object.keys(definitions.offshore).find((event) => message.toLowerCase().includes(event.toLowerCase()));
-    return attributes.type.split(`-`).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(` `);
+    if (offshoreEvent != void 0) return Object.keys(definitions.offshore).find((event) => message.toLowerCase().includes(event.toLowerCase()));
+    return metadata.awipsType.type.split(`-`).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(` `);
   }
+  /**
+   * @function event
+   * @description
+   *     Processes a compiled text-based NOAA Stanza message and extracts relevant
+   *     event information. Splits the message into multiple segments based on
+   *     markers such as "$$", "ISSUED TIME...", or separator lines, generates
+   *     base properties, headers, event names, and tracking information for
+   *     each segment, then validates and emits the processed events.
+   *
+   * @public
+   * @static
+   * @async
+   * @param {types.StanzaCompiled} validated
+   * @returns {Promise<void>}
+   */
   static event(validated) {
     return __async(this, null, function* () {
-      var _a;
+      var _a, _b;
       let processed = [];
-      const messages = (_a = validated.message.split(/(?=\$\$|ISSUED TIME...|=================================================)/g)) == null ? void 0 : _a.map((msg) => msg.trim());
-      if (!messages || messages.length == 0) return;
-      for (let i = 0; i < messages.length; i++) {
-        const tick = performance.now();
-        const message = messages[i];
-        const getBaseProperties = yield events_default.getBaseProperties(message, validated);
-        const getHeader = events_default.getHeader(__spreadValues(__spreadValues({}, validated.attributes), getBaseProperties.attributes), getBaseProperties);
-        const getEvent = this.getEvent(message, getBaseProperties.attributes.getAwip);
-        processed.push({
-          performance: performance.now() - tick,
-          tracking: this.getTracking(getBaseProperties),
-          header: getHeader,
-          vtec: `N/A`,
-          history: [{ description: getBaseProperties.description, issued: getBaseProperties.issued, type: `Issued` }],
-          properties: __spreadValues({ event: getEvent, parent: getEvent, action_type: `Issued` }, getBaseProperties)
-        });
+      const blocks = (_a = validated.message.split(/\[SoF\]/gim)) == null ? void 0 : _a.map((msg) => msg.trim());
+      for (const block of blocks) {
+        const cachedAttribute = block.match(/STANZA ATTRIBUTES\.\.\.(\{.*\})/);
+        const messages = (_b = block.split(/(?=\$\$)/g)) == null ? void 0 : _b.map((msg) => msg.trim());
+        if (!messages || messages.length == 0) return;
+        for (let i = 0; i < messages.length; i++) {
+          const tick = performance.now();
+          const message = messages[i];
+          const attributes = cachedAttribute != null ? JSON.parse(cachedAttribute[1]) : validated;
+          const getBaseProperties = yield events_default.getBaseProperties(message, attributes);
+          const getHeader = events_default.getHeader(__spreadValues(__spreadValues({}, validated.attributes), getBaseProperties.metadata), getBaseProperties);
+          const getEvent = this.getEvent(message, attributes);
+          processed.push({
+            performance: performance.now() - tick,
+            source: `text-parser`,
+            tracking: this.getTracking(getBaseProperties),
+            header: getHeader,
+            vtec: `N/A`,
+            history: [{ description: getBaseProperties.description, issued: getBaseProperties.issued, type: `Issued` }],
+            properties: __spreadValues({ event: getEvent, parent: getEvent, action_type: `Issued` }, getBaseProperties)
+          });
+        }
       }
       events_default.validateEvents(processed);
     });
   }
 };
-var text_default2 = UGCAlerts2;
+var text_default2 = TextAlerts;
 
 // src/parsers/types/cap.ts
 var CapAlerts = class {
-  static getTracking(extracted) {
+  /**
+   * @function getTracking
+   * @description
+   *   Generates a unique tracking identifier for a CAP alert based on extracted XML values.
+   *   If VTEC information is available, it constructs the tracking ID from the VTEC components.
+   *   Otherwise, it uses the WMO identifier along with TTAI and CCCC attributes.
+   *
+   * @private
+   * @static
+   * @param {Record<string, string>} extracted 
+   * @returns {string} 
+   */
+  static getTracking(extracted, metadata) {
     return extracted.vtec ? (() => {
       const vtecValue = Array.isArray(extracted.vtec) ? extracted.vtec[0] : extracted.vtec;
       const splitVTEC = vtecValue.split(".");
       return `${splitVTEC[2]}-${splitVTEC[3]}-${splitVTEC[4]}-${splitVTEC[5]}`;
-    })() : `${extracted.wmoidentifier} (${extracted.ugc})`;
+    })() : `${extracted.wmoidentifier.substring(extracted.wmoidentifier.length - 4)}-${metadata.attributes.ttaaii}-${metadata.attributes.id.slice(-4)}`;
   }
+  /**
+   * @function event
+   * @description
+   *    Processes validated CAP alert messages, extracting relevant information and compiling it into structured event objects.   
+   *
+   * @public
+   * @static
+   * @async
+   * @param {types.StanzaCompiled} validated 
+   * @returns {*} 
+   */
   static event(validated) {
     return __async(this, null, function* () {
-      var _a;
+      var _a, _b;
       let processed = [];
-      const messages = (_a = validated.message.match(/<\?xml[\s\S]*?<\/alert>/g)) == null ? void 0 : _a.map((msg) => msg.trim());
-      if (messages == null || messages.length === 0) return;
-      for (let message of messages) {
-        const tick = performance.now();
-        message = message.substring(message.indexOf(`<?xml version="1.0"`), message.lastIndexOf(`>`) + 1);
-        const parser = new packages.xml2js.Parser({ explicitArray: false, mergeAttrs: true, trim: true });
-        const parsed = yield parser.parseStringPromise(message);
-        if (parsed == null || parsed.alert == null) continue;
-        const extracted = text_default.getXmlValues(parsed, [
-          `vtec`,
-          `wmoidentifier`,
-          `ugc`,
-          `areadesc`,
-          `expires`,
-          `sent`,
-          `msgtype`,
-          `description`,
-          `event`,
-          `sendername`,
-          `tornadodetection`,
-          `polygon`,
-          `maxHailSize`,
-          `maxWindGust`,
-          `thunderstormdamagethreat`,
-          `tornadodamagethreat`,
-          `waterspoutdetection`,
-          `flooddetection`
-        ]);
-        const getHeader = events_default.getHeader(__spreadValues({}, validated.attributes));
-        const getSource = text_default.textProductToString(extracted.description, `SOURCE...`, [`.`]) || `N/A`;
-        processed.push({
-          performance: performance.now() - tick,
-          tracking: this.getTracking(extracted),
-          header: getHeader,
-          vtec: extracted.vtec || `N/A`,
-          history: [{ description: extracted.description || `N/A`, issued: extracted.sent ? new Date(extracted.sent).toLocaleString() : `N/A`, type: extracted.msgtype || `N/A` }],
-          properties: {
-            locations: extracted.areadesc || `N/A`,
-            event: extracted.event || `N/A`,
-            issued: extracted.sent ? new Date(extracted.sent).toLocaleString() : `N/A`,
-            expires: extracted.expires ? new Date(extracted.expires).toLocaleString() : `N/A`,
-            parent: extracted.event || `N/A`,
-            action_type: extracted.msgtype || `N/A`,
-            description: extracted.description || `N/A`,
-            sender_name: extracted.sendername || `N/A`,
-            sender_icao: extracted.wmoidentifier ? extracted.wmoidentifier.substring(extracted.wmoidentifier.length - 4) : `N/A`,
-            attributes: validated.attributes,
-            geocode: {
-              UGC: [extracted.ugc]
-            },
-            parameters: {
-              wmo: extracted.wmoidentifier || `N/A`,
-              source: getSource,
-              max_hail_size: extracted.maxHailSize || `N/A`,
-              max_wind_gust: extracted.maxWindGust || `N/A`,
-              damage_threat: extracted.thunderstormdamagethreat || `N/A`,
-              tornado_detection: extracted.tornadodetection || extracted.waterspoutdetection || `N/A`,
-              flood_detection: extracted.flooddetection || `N/A`,
-              discussion_tornado_intensity: `N/A`,
-              discussion_wind_intensity: `N/A`,
-              discussion_hail_intensity: `N/A`
-            },
-            geometry: extracted.polygon ? {
-              type: `Polygon`,
-              coordinates: extracted.polygon.split(` `).map((coord) => {
-                const [lat, lon] = coord.split(`,`).map((num) => parseFloat(num));
-                return [lat, lon];
-              })
-            } : null
-          }
-        });
+      const tick = performance.now();
+      const blocks = (_a = validated.message.split(/\[SoF\]/gim)) == null ? void 0 : _a.map((msg) => msg.trim());
+      for (const block of blocks) {
+        const cachedAttribute = block.match(/STANZA ATTRIBUTES\.\.\.(\{.*\})/);
+        const messages = (_b = block.split(/(?=\$\$)/g)) == null ? void 0 : _b.map((msg) => msg.trim());
+        if (!messages || messages.length == 0) return;
+        for (let i = 0; i < messages.length; i++) {
+          let message = messages[i];
+          const attributes = cachedAttribute != null ? JSON.parse(cachedAttribute[1]) : validated;
+          message = message.substring(message.indexOf(`<?xml version="1.0"`), message.lastIndexOf(`>`) + 1);
+          const parser = new packages.xml2js.Parser({ explicitArray: false, mergeAttrs: true, trim: true });
+          const parsed = yield parser.parseStringPromise(message);
+          if (parsed == null || parsed.alert == null) continue;
+          const extracted = text_default.getXmlValues(parsed, [
+            `vtec`,
+            `wmoidentifier`,
+            `ugc`,
+            `areadesc`,
+            `expires`,
+            `sent`,
+            `msgtype`,
+            `description`,
+            `event`,
+            `sendername`,
+            `tornadodetection`,
+            `polygon`,
+            `maxHailSize`,
+            `maxWindGust`,
+            `thunderstormdamagethreat`,
+            `tornadodamagethreat`,
+            `waterspoutdetection`,
+            `flooddetection`
+          ]);
+          const getHeader = events_default.getHeader(__spreadValues({}, validated.attributes));
+          const getSource = text_default.textProductToString(extracted.description, `SOURCE...`, [`.`]) || `N/A`;
+          processed.push({
+            performance: performance.now() - tick,
+            source: `cap-parser`,
+            tracking: this.getTracking(extracted, attributes),
+            header: getHeader,
+            vtec: extracted.vtec || `N/A`,
+            history: [{ description: extracted.description || `N/A`, issued: extracted.sent ? new Date(extracted.sent).toLocaleString() : `N/A`, type: extracted.msgtype || `N/A` }],
+            properties: {
+              locations: extracted.areadesc || `N/A`,
+              event: extracted.event || `N/A`,
+              issued: extracted.sent ? new Date(extracted.sent).toLocaleString() : `N/A`,
+              expires: extracted.expires ? new Date(extracted.expires).toLocaleString() : `N/A`,
+              parent: extracted.event || `N/A`,
+              action_type: extracted.msgtype || `N/A`,
+              description: extracted.description || `N/A`,
+              sender_name: extracted.sendername || `N/A`,
+              sender_icao: extracted.wmoidentifier ? extracted.wmoidentifier.substring(extracted.wmoidentifier.length - 4) : `N/A`,
+              attributes: validated.attributes,
+              geocode: {
+                UGC: [extracted.ugc]
+              },
+              parameters: {
+                wmo: extracted.wmoidentifier || `N/A`,
+                source: getSource,
+                max_hail_size: extracted.maxHailSize || `N/A`,
+                max_wind_gust: extracted.maxWindGust || `N/A`,
+                damage_threat: extracted.thunderstormdamagethreat || `N/A`,
+                tornado_detection: extracted.tornadodetection || extracted.waterspoutdetection || `N/A`,
+                flood_detection: extracted.flooddetection || `N/A`,
+                discussion_tornado_intensity: `N/A`,
+                discussion_wind_intensity: `N/A`,
+                discussion_hail_intensity: `N/A`
+              },
+              geometry: extracted.polygon ? {
+                type: `Polygon`,
+                coordinates: extracted.polygon.split(` `).map((coord) => {
+                  const [lat, lon] = coord.split(`,`).map((num) => parseFloat(num));
+                  return [lat, lon];
+                })
+              } : null
+            }
+          });
+        }
       }
       events_default.validateEvents(processed);
     });
@@ -1730,19 +1916,52 @@ var cap_default = CapAlerts;
 
 // src/parsers/types/api.ts
 var APIAlerts = class {
+  /**
+   * @function getTracking
+   * @description
+   *   Generates a unique tracking identifier for a CAP alert based on extracted XML values.
+   *   If VTEC information is available, it constructs the tracking ID from the VTEC components.
+   *   Otherwise, it uses the WMO identifier along with TTAI and CCCC attributes.
+   *
+   * @private
+   * @static
+   * @param {Record<string, string>} extracted 
+   * @returns {string} 
+   */
   static getTracking(extracted) {
     return extracted.vtec ? (() => {
       const vtecValue = Array.isArray(extracted.vtec) ? extracted.vtec[0] : extracted.vtec;
       const splitVTEC = vtecValue.split(".");
       return `${splitVTEC[2]}-${splitVTEC[3]}-${splitVTEC[4]}-${splitVTEC[5]}`;
-    })() : `${extracted.wmoidentifier} (${extracted.ugc})`;
+    })() : `${extracted.wmoidentifier}`;
   }
+  /**
+   * @function getICAO
+   * @description
+   *    Extracts the sender's ICAO code and corresponding name from a VTEC string.    
+   *
+   * @private
+   * @static
+   * @param {string} vtec 
+   * @returns {{ icao: any; name: any; }} 
+   */
   static getICAO(vtec) {
     var _a, _b;
     const icao = vtec ? vtec.split(`.`)[2] : `N/A`;
     const name = (_b = (_a = definitions.ICAO) == null ? void 0 : _a[icao]) != null ? _b : `N/A`;
     return { icao, name };
   }
+  /**
+   * @function event
+   * @description
+   *   Processes validated API alert messages, extracting relevant information and compiling it into structured event objects.
+   *
+   * @public
+   * @static
+   * @async
+   * @param {types.StanzaCompiled} validated 
+   * @returns {*} 
+   */
   static event(validated) {
     return __async(this, null, function* () {
       var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D, _E, _F, _G, _H, _I, _J, _K, _L, _M, _N, _O, _P, _Q, _R, _S, _T, _U, _V, _W, _X, _Y, _Z, __, _$, _aa, _ba, _ca, _da, _ea, _fa, _ga, _ha, _ia;
@@ -1761,6 +1980,7 @@ var APIAlerts = class {
         const getOffice = this.getICAO(getVTEC || ``);
         processed.push({
           performance: performance.now() - tick,
+          source: `api-parser`,
           tracking: this.getTracking({ vtec: getVTEC, wmoidentifier: getWmo, ugc: getUgc ? getUgc.join(`,`) : null }),
           header: getHeader,
           vtec: getVTEC || `N/A`,
@@ -1799,7 +2019,7 @@ var APIAlerts = class {
               type: ((_fa = feature == null ? void 0 : feature.geometry) == null ? void 0 : _fa.type) || "Polygon",
               coordinates: (_ia = (_ha = (_ga = feature == null ? void 0 : feature.geometry) == null ? void 0 : _ga.coordinates) == null ? void 0 : _ha[0]) == null ? void 0 : _ia.map((coord) => {
                 const [lat, lon] = Array.isArray(coord) ? coord : [0, 0];
-                return [lat, lon];
+                return [lon, lat];
               })
             } : null
           }
@@ -1811,1080 +2031,1410 @@ var APIAlerts = class {
 };
 var api_default = APIAlerts;
 
-// src/eas.ts
-var EAS = class {
+// src/parsers/events.ts
+var EventParser = class {
   /**
-   * generateEASAudio creates an EAS-compliant audio file in WAV format containing the provided message and VTEC header.
+   * @function getBaseProperties
+   * @description
+   *     Extracts and compiles the core properties of a weather
+   *     alert message into a structured object. Combines parsed
+   *     textual data, UGC information, VTEC entries, and additional
+   *     metadata for downstream use.
    *
-   * @public
    * @static
-   * @param {string} message 
-   * @param {string} vtec 
-   * @returns {*} 
+   * @async
+   * @param {string} message
+   * @param {types.StanzaCompiled} validated
+   * @param {types.UGCEntry} [ugc=null]
+   * @param {types.VtecEntry} [vtec=null]
+   * @returns {Promise<Record<string, any>>}
    */
-  static generateEASAudio(message, vtec) {
-    return new Promise((resolve) => __async(this, null, function* () {
+  static getBaseProperties(message, metadata, ugc = null, vtec = null) {
+    return __async(this, null, function* () {
+      var _a, _b;
       const settings2 = settings;
-      for (const { regex, replacement } of definitions.messageSignatures) {
-        message = message.replace(regex, replacement);
-      }
-      const assetsDir = settings2.global.easSettings.easDirectory;
-      if (!assetsDir) {
-        console.warn(definitions.messages.eas_no_directory);
-        return resolve(null);
-      }
-      const rngFile = `${vtec.replace(/[^a-zA-Z0-9]/g, `_`)}`.substring(0, 32).replace(/^_+|_+$/g, "");
-      if (!packages.fs.existsSync(assetsDir)) {
-        packages.fs.mkdirSync(assetsDir);
+      const definitions2 = {
+        tornado: text_default.textProductToString(message, `TORNADO...`) || text_default.textProductToString(message, `WATERSPOUT...`) || `N/A`,
+        hail: text_default.textProductToString(message, `MAX HAIL SIZE...`, [`IN`]) || text_default.textProductToString(message, `HAIL...`, [`IN`]) || `N/A`,
+        gusts: text_default.textProductToString(message, `MAX WIND GUST...`) || text_default.textProductToString(message, `WIND...`) || `N/A`,
+        flood: text_default.textProductToString(message, `FLASH FLOOD...`) || `N/A`,
+        damage: text_default.textProductToString(message, `DAMAGE THREAT...`) || `N/A`,
+        source: text_default.textProductToString(message, `SOURCE...`, [`.`]) || `N/A`,
+        polygon: text_default.textProductToPolygon(message),
+        description: text_default.textProductToDescription(message, (_a = vtec == null ? void 0 : vtec.raw) != null ? _a : null),
+        wmo: message.match(new RegExp(definitions.expressions.wmo, "imu")),
+        mdTorIntensity: text_default.textProductToString(message, `MOST PROBABLE PEAK TORNADO INTENSITY...`) || `N/A`,
+        mdWindGusts: text_default.textProductToString(message, `MOST PROBABLE PEAK WIND GUST...`) || `N/A`,
+        mdHailSize: text_default.textProductToString(message, `MOST PROBABLE PEAK HAIL SIZE...`) || `N/A`
+      };
+      const getOffice = this.getICAO(vtec, metadata, definitions2.wmo);
+      const getCorrectIssued = this.getCorrectIssuedDate(metadata);
+      const getCorrectExpiry = this.getCorrectExpiryDate(vtec, ugc);
+      const base = {
+        locations: (ugc == null ? void 0 : ugc.locations.join(`; `)) || `No Location Specified (UGC Missing)`,
+        issued: getCorrectIssued,
+        expires: getCorrectExpiry,
+        geocode: { UGC: (ugc == null ? void 0 : ugc.zones) || [`XX000`] },
+        description: definitions2.description,
+        sender_name: getOffice.name,
+        sender_icao: getOffice.icao,
+        metadata: __spreadValues({}, Object.fromEntries(Object.entries(metadata).filter(([key]) => key !== "message"))),
+        parameters: {
+          wmo: Array.isArray(definitions2.wmo) ? definitions2.wmo[0] : (_b = definitions2.wmo) != null ? _b : `N/A`,
+          source: definitions2.source,
+          max_hail_size: definitions2.hail,
+          max_wind_gust: definitions2.gusts,
+          damage_threat: definitions2.damage,
+          tornado_detection: definitions2.tornado,
+          flood_detection: definitions2.flood,
+          discussion_tornado_intensity: definitions2.mdTorIntensity,
+          discussion_wind_intensity: definitions2.mdWindGusts,
+          discussion_hail_intensity: definitions2.mdHailSize
+        },
+        geometry: definitions2.polygon.length > 0 ? { type: "Polygon", coordinates: definitions2.polygon } : null
+      };
+      if (settings2.noaa_weather_wire_service_settings.preferences.shapefile_coordinates && base.geometry == null && ugc != null) {
+        const coordinates = yield ugc_default.getCoordinates(ugc.zones);
+        base.geometry = { type: "Polygon", coordinates };
       }
-      const tmpTTS = packages.path.join(assetsDir, `/tmp/${rngFile}.wav`);
-      const outTTS = packages.path.join(assetsDir, `/output/${rngFile}.wav`);
-      const voice = process.platform === "win32" ? "Microsoft David Desktop" : "en-US-GuyNeural";
-      if (!packages.fs.existsSync(packages.path.join(assetsDir, `/tmp`))) {
-        packages.fs.mkdirSync(packages.path.join(assetsDir, `/tmp`), { recursive: true });
+      return base;
+    });
+  }
+  /**
+   * @function betterParsedEventName
+   * @description
+   *     Enhances the parsing of an event name using additional criteria
+   *     from its description and parameters. Can optionally use
+   *     the original parent event name instead.
+   *
+   * @static
+   * @param {types.EventCompiled} event
+   * @param {boolean} [betterParsing=false]
+   * @param {boolean} [useParentEvents=false]
+   * @returns {string}
+   */
+  static betterParsedEventName(event, betterParsing, useParentEvents) {
+    var _a, _b, _c, _d, _e, _f;
+    let eventName = (_b = (_a = event == null ? void 0 : event.properties) == null ? void 0 : _a.event) != null ? _b : `Unknown Event`;
+    const defEventTable = definitions.enhancedEvents;
+    const properties = event == null ? void 0 : event.properties;
+    const parameters = properties == null ? void 0 : properties.parameters;
+    const description = (_c = properties == null ? void 0 : properties.description) != null ? _c : `Unknown Description`;
+    const damageThreatTag = (_d = parameters == null ? void 0 : parameters.damage_threat) != null ? _d : `N/A`;
+    const tornadoThreatTag = (_e = parameters == null ? void 0 : parameters.tornado_detection) != null ? _e : `N/A`;
+    if (!betterParsing) {
+      return eventName;
+    }
+    for (const eventGroup of defEventTable) {
+      const [baseEvent, conditions] = Object.entries(eventGroup)[0];
+      if (eventName === baseEvent) {
+        for (const [specificEvent, condition] of Object.entries(conditions)) {
+          const conditionMet = condition.description && description.includes(condition.description.toLowerCase()) || condition.condition && condition.condition(damageThreatTag || tornadoThreatTag);
+          if (conditionMet) {
+            eventName = specificEvent;
+            break;
+          }
+        }
+        if (baseEvent === "Severe Thunderstorm Warning" && tornadoThreatTag === "POSSIBLE" && !eventName.includes("(TPROB)")) eventName += " (TPROB)";
+        break;
       }
-      if (!packages.fs.existsSync(packages.path.join(assetsDir, `/output`))) {
-        packages.fs.mkdirSync(packages.path.join(assetsDir, `/output`), { recursive: true });
-      }
-      packages.say.export(message, voice, 1, tmpTTS);
-      yield utils_default.sleep(2500);
-      let ttsBuffer = null;
-      while (!packages.fs.existsSync(tmpTTS) || (ttsBuffer = packages.fs.readFileSync(tmpTTS)).length === 0) {
-        yield utils_default.sleep(500);
-      }
-      const ttsWav = this.parseWavPCM16(ttsBuffer);
-      const ttsSamples = this.resamplePCM16(ttsWav.samples, ttsWav.sampleRate, 8e3);
-      const ttsRadio = this.applyNWREffect(ttsSamples, 8e3);
-      let toneRadio = null;
-      if (packages.fs.existsSync(settings2.global.easSettings.easIntroWav)) {
-        const toneBuffer = packages.fs.readFileSync(settings2.global.easSettings.easIntroWav);
-        const toneWav = this.parseWavPCM16(toneBuffer);
-        const toneSamples = toneWav.sampleRate !== 8e3 ? this.resamplePCM16(toneWav.samples, toneWav.sampleRate, 8e3) : toneWav.samples;
-        toneRadio = this.applyNWREffect(toneSamples, 8e3);
-      }
-      let build = toneRadio != null ? [toneRadio, this.generateSilence(0.5, 8e3)] : [];
-      build.push(this.generateSAMEHeader(vtec, 3, 8e3, { preMarkSec: 1.1, gapSec: 0.5 }), this.generateSilence(0.5, 8e3), this.generateAttentionTone(8, 8e3), this.generateSilence(0.5, 8e3), ttsRadio);
-      for (let i = 0; i < 3; i++) {
-        build.push(this.generateSAMEHeader(vtec, 1, 8e3, { preMarkSec: 0.5, gapSec: 0.1 }));
-        build.push(this.generateSilence(0.5, 8e3));
-      }
-      const allSamples = this.concatPCM16(build);
-      const finalSamples = this.addNoise(allSamples, 2e-3);
-      const outBuffer = this.encodeWavPCM16(Array.from(finalSamples).map((v) => ({ value: v })), 8e3);
-      packages.fs.writeFileSync(outTTS, outBuffer);
-      try {
-        packages.fs.unlinkSync(tmpTTS);
-      } catch (error) {
-        if (error.code !== "EBUSY") {
-          throw error;
-        }
-      }
-      return Promise.resolve(outTTS);
-    }));
-  }
-  /**
-   * encodeWavPCM16 encodes an array of samples into a WAV PCM 16-bit Buffer.
-   *
-   * @private
-   * @static
-   * @param {Record<string, number>[]} samples 
-   * @param {number} [sampleRate=8000] 
-   * @returns {Buffer} 
-   */
-  static encodeWavPCM16(samples, sampleRate = 8e3) {
-    const bytesPerSample = 2;
-    const blockAlign = 1 * bytesPerSample;
-    const byteRate = sampleRate * blockAlign;
-    const subchunk2Size = samples.length * bytesPerSample;
-    const chunkSize = 36 + subchunk2Size;
-    const buffer = Buffer.alloc(44 + subchunk2Size);
-    let o = 0;
-    buffer.write("RIFF", o);
-    o += 4;
-    buffer.writeUInt32LE(chunkSize, o);
-    o += 4;
-    buffer.write("WAVE", o);
-    o += 4;
-    buffer.write("fmt ", o);
-    o += 4;
-    buffer.writeUInt32LE(16, o);
-    o += 4;
-    buffer.writeUInt16LE(1, o);
-    o += 2;
-    buffer.writeUInt16LE(1, o);
-    o += 2;
-    buffer.writeUInt32LE(sampleRate, o);
-    o += 4;
-    buffer.writeUInt32LE(byteRate, o);
-    o += 4;
-    buffer.writeUInt16LE(blockAlign, o);
-    o += 2;
-    buffer.writeUInt16LE(16, o);
-    o += 2;
-    buffer.write("data", o);
-    o += 4;
-    buffer.writeUInt32LE(subchunk2Size, o);
-    o += 4;
-    for (let i = 0; i < samples.length; i++, o += 2) {
-      buffer.writeInt16LE(samples[i].value, o);
     }
-    return buffer;
+    return useParentEvents ? (_f = event == null ? void 0 : event.properties) == null ? void 0 : _f.event : eventName;
   }
   /**
-   * parseWavPCM16 decodes a WAV PCM 16-bit Buffer into its sample data and format information.
+   * @function validateEvents
+   * @description
+   *     Processes an array of event objects and filters them based on
+   *     global and EAS filtering settings, location constraints, and
+   *     other criteria such as expired or test products. Valid events
+   *     trigger relevant event emitters.
    *
-   * @private
    * @static
-   * @param {Buffer} buffer 
-   * @returns {{ samples: any; sampleRate: any; channels: any; bitsPerSample: any; }} 
+   * @param {unknown[]} events
+   * @returns {void}
    */
-  static parseWavPCM16(buffer) {
-    if (buffer.toString("ascii", 0, 4) !== "RIFF" || buffer.toString("ascii", 8, 12) !== "WAVE") {
-      return null;
-    }
-    let fmt = null;
-    let data = null;
-    let i = 12;
-    while (i + 8 <= buffer.length) {
-      const id = buffer.toString("ascii", i, i + 4);
-      const size = buffer.readUInt32LE(i + 4);
-      const start = i + 8;
-      const end = start + size;
-      if (id === "fmt ") fmt = buffer.slice(start, end);
-      if (id === "data") data = buffer.slice(start, end);
-      i = end + size % 2;
+  static validateEvents(events2) {
+    var _a, _b, _c, _d, _e;
+    if (events2.length == 0) return;
+    const filteringSettings = (_b = (_a = settings) == null ? void 0 : _a.global_settings) == null ? void 0 : _b.filtering;
+    const locationSettings = filteringSettings == null ? void 0 : filteringSettings.location;
+    const easSettings = (_d = (_c = settings) == null ? void 0 : _c.global_settings) == null ? void 0 : _d.eas_settings;
+    const globalSettings = (_e = settings) == null ? void 0 : _e.global_settings;
+    const sets = {};
+    const bools = {};
+    const megered = __spreadValues(__spreadValues(__spreadValues(__spreadValues({}, filteringSettings), easSettings), globalSettings), locationSettings);
+    for (const key in megered) {
+      const setting = megered[key];
+      if (Array.isArray(setting)) {
+        sets[key] = new Set(setting.map((item) => item.toLowerCase()));
+      }
+      if (typeof setting === "boolean") {
+        bools[key] = setting;
+      }
     }
-    if (!fmt || !data) return null;
-    const audioFormat = fmt.readUInt16LE(0);
-    const channels = fmt.readUInt16LE(2);
-    const sampleRate = fmt.readUInt32LE(4);
-    const bitsPerSample = fmt.readUInt16LE(14);
-    if (audioFormat !== 1 || bitsPerSample !== 16 || channels !== 1) {
-      return null;
+    const filtered = events2.filter((alert) => {
+      var _a2, _b2, _d2;
+      const originalEvent = this.buildDefaultSignature(alert);
+      const props = originalEvent == null ? void 0 : originalEvent.properties;
+      const ugcs = (_b2 = (_a2 = props == null ? void 0 : props.geocode) == null ? void 0 : _a2.UGC) != null ? _b2 : [];
+      const _c2 = originalEvent, { performance: performance2, header } = _c2, eventWithoutPerformance = __objRest(_c2, ["performance", "header"]);
+      originalEvent.properties.parent = originalEvent.properties.event;
+      originalEvent.properties.event = this.betterParsedEventName(originalEvent, bools == null ? void 0 : bools.better_event_parsing, bools == null ? void 0 : bools.parent_events_only);
+      originalEvent.hash = packages.crypto.createHash("md5").update(JSON.stringify(eventWithoutPerformance)).digest("hex");
+      originalEvent.properties.distance = this.getLocationDistances(props, bools == null ? void 0 : bools.filter, locationSettings == null ? void 0 : locationSettings.max_distance, locationSettings == null ? void 0 : locationSettings.unit);
+      if (!((_d2 = originalEvent.properties.distance) == null ? void 0 : _d2.in_range) && (bools == null ? void 0 : bools.filter)) {
+        return false;
+      }
+      if (originalEvent.properties.is_test == true && (bools == null ? void 0 : bools.ignore_text_products)) return false;
+      if ((bools == null ? void 0 : bools.check_expired) && originalEvent.properties.is_cancelled == true) return false;
+      for (const key in sets) {
+        const setting = sets[key];
+        if (key === "events" && setting.size > 0 && !setting.has(originalEvent.properties.event.toLowerCase())) return false;
+        if (key === "ignored_events" && setting.size > 0 && setting.has(originalEvent.properties.event.toLowerCase())) return false;
+        if (key === "filtered_icoa" && setting.size > 0 && props.sender_icao != null && !setting.has(props.sender_icao.toLowerCase())) return false;
+        if (key === "ignored_icoa" && setting.size > 0 && props.sender_icao != null && setting.has(props.sender_icao.toLowerCase())) return false;
+        if (key === "ugc_filter" && setting.size > 0 && ugcs.length > 0 && !ugcs.some((ugc) => setting.has(ugc.toLowerCase()))) return false;
+        if (key === "state_filter" && setting.size > 0 && ugcs.length > 0 && !ugcs.some((ugc) => setting.has(ugc.substring(0, 2).toLowerCase()))) return false;
+      }
+      cache.events.emit(`on${originalEvent.properties.parent.replace(/\s+/g, "")}`);
+      cache.events.emit(`on${originalEvent.properties.event.replace(/\s+/g, "")}`);
+      return true;
+    });
+    if (filtered.length > 0) {
+      cache.events.emit(`onAlerts`, filtered);
     }
-    const samples = new Int16Array(data.buffer, data.byteOffset, data.length / 2);
-    return { samples: new Int16Array(samples), sampleRate, channels, bitsPerSample };
   }
   /**
-   * concatPCM16 concatenates multiple Int16Array buffers into a single Int16Array buffer.
+   * @function getHeader
+   * @description
+   *     Constructs a standardized alert header string using provided
+   *     stanza attributes, event properties, and optional VTEC data.
    *
-   * @private
    * @static
-   * @param {Int16Array[]} arrays 
-   * @returns {*} 
+   * @param {types.StanzaAttributes} attributes
+   * @param {types.EventProperties} [properties]
+   * @param {types.VtecEntry} [vtec]
+   * @returns {string}
    */
-  static concatPCM16(arrays) {
-    let total = 0;
-    for (const a of arrays) total += a.length;
-    const out = new Int16Array(total);
-    let o = 0;
-    for (const a of arrays) {
-      out.set(a, o);
-      o += a.length;
-    }
-    return out;
+  static getHeader(attributes, properties, vtec) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const parent = `ATSX`;
+    const alertType = (_d = (_c = (_a = attributes == null ? void 0 : attributes.awipsType) == null ? void 0 : _a.type) != null ? _c : (_b = attributes == null ? void 0 : attributes.getAwip) == null ? void 0 : _b.prefix) != null ? _d : `XX`;
+    const ugc = ((_e = properties == null ? void 0 : properties.geocode) == null ? void 0 : _e.UGC) != null ? (_f = properties == null ? void 0 : properties.geocode) == null ? void 0 : _f.UGC.join(`-`) : `000000`;
+    const status = (vtec == null ? void 0 : vtec.status) || "Issued";
+    const issued = (properties == null ? void 0 : properties.issued) != null ? (_g = new Date(properties == null ? void 0 : properties.issued)) == null ? void 0 : _g.toISOString().replace(/[-:]/g, "").split(".")[0] : (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").split(".")[0];
+    const sender = (properties == null ? void 0 : properties.sender_icao) || `XXXX`;
+    const header = `ZCZC-${parent}-${alertType}-${ugc}-${status}-${issued}-${sender}-`;
+    return header;
   }
   /**
-   * pcm16toFloat converts an Int16Array of PCM 16-bit samples to a Float32Array of normalized float samples.
+   * @function eventHandler
+   * @description
+   *     Routes a validated stanza object to the appropriate alert handler
+   *     based on its type flags: API, CAP, VTEC, UGC, or plain text.
    *
-   * @private
    * @static
-   * @param {Int16Array} int16 
-   * @returns {*} 
+   * @param {types.StanzaCompiled} validated
+   * @returns {void}
    */
-  static pcm16toFloat(int16) {
-    const out = new Float32Array(int16.length);
-    for (let i = 0; i < int16.length; i++) out[i] = int16[i] / 32768;
-    return out;
+  static eventHandler(metadata) {
+    if (metadata.isApi) return api_default.event(metadata);
+    if (metadata.isCap) return cap_default.event(metadata);
+    if (!metadata.isCap && metadata.isVtec && metadata.isUGC) return vtec_default2.event(metadata);
+    if (!metadata.isCap && !metadata.isVtec && metadata.isUGC) return ugc_default2.event(metadata);
+    if (!metadata.isCap && !metadata.isVtec && !metadata.isUGC) return text_default2.event(metadata);
   }
   /**
-   * floatToPcm16 converts a Float32Array of normalized float samples to an Int16Array of PCM 16-bit samples.
+   * @function getICAO
+   * @description
+   *     Determines the ICAO code and corresponding name for an event.
+   *     Priority is given to the VTEC tracking code, then the attributes' `cccc` property, 
+   *     and finally the WMO code if available. Returns "N/A" if none are found.
    *
    * @private
    * @static
-   * @param {Float32Array} float32 
-   * @returns {*} 
+   * @param {types.VtecEntry | null} vtec
+   * @param {Record<string, string>} attributes
+   * @param {RegExpMatchArray | string | null} WMO
+   * @returns {{ icao: string; name: string }}
    */
-  static floatToPcm16(float32) {
-    const out = new Int16Array(float32.length);
-    for (let i = 0; i < float32.length; i++) {
-      let v = Math.max(-1, Math.min(1, float32[i]));
-      out[i] = Math.round(v * 32767);
-    }
-    return out;
+  static getICAO(vtec, metadata, WMO) {
+    var _a, _b, _c, _d;
+    const icao = vtec != null ? vtec == null ? void 0 : vtec.tracking.split(`-`)[0] : (_b = (_a = metadata.attributes) == null ? void 0 : _a.cccc) != null ? _b : WMO != null ? Array.isArray(WMO) ? WMO[0] : WMO : `N/A`;
+    const name = (_d = (_c = definitions.ICAO) == null ? void 0 : _c[icao]) != null ? _d : `N/A`;
+    return { icao, name };
   }
   /**
-   * resamplePCM16 resamples an Int16Array of PCM 16-bit samples from the original sample rate to the target sample rate using linear interpolation.
+   * @function getCorrectIssuedDate
+   * @description
+   *     Determines the issued date for an event based on the provided attributes.
+   *     Falls back to the current date and time if no valid issue date is available.
    *
    * @private
    * @static
-   * @param {Int16Array} int16 
-   * @param {number} originalRate 
-   * @param {number} targetRate 
-   * @returns {*} 
+   * @param {Record<string, string>} attributes
+   * @returns {string}
    */
-  static resamplePCM16(int16, originalRate, targetRate) {
-    if (originalRate === targetRate) return int16;
-    const ratio = targetRate / originalRate;
-    const outLen = Math.max(1, Math.round(int16.length * ratio));
-    const out = new Int16Array(outLen);
-    for (let i = 0; i < outLen; i++) {
-      const pos = i / ratio;
-      const i0 = Math.floor(pos);
-      const i1 = Math.min(i0 + 1, int16.length - 1);
-      const frac = pos - i0;
-      const v = int16[i0] * (1 - frac) + int16[i1] * frac;
-      out[i] = Math.round(v);
-    }
-    return out;
+  static getCorrectIssuedDate(metadata) {
+    var _a;
+    const time = metadata.attributes.issue != null ? new Date(metadata.attributes.issue).toLocaleString() : ((_a = metadata.attributes) == null ? void 0 : _a.issue) != null ? new Date(metadata.attributes.issue).toLocaleString() : (/* @__PURE__ */ new Date()).toLocaleString();
+    if (time == `Invalid Date`) return (/* @__PURE__ */ new Date()).toLocaleString();
+    return time;
   }
   /**
-   * generateSilence creates an Int16Array of PCM 16-bit samples representing silence for the specified duration in milliseconds.
+   * @function getCorrectExpiryDate
+   * @description
+   *     Determines the most appropriate expiry date for an event using VTEC or UGC data.
+   *     Falls back to one hour from the current time if no valid expiry is available.
    *
    * @private
    * @static
-   * @param {number} ms 
-   * @param {number} [sampleRate=8000] 
-   * @returns {*} 
+   * @param {types.VtecEntry} vtec
+   * @param {types.UGCEntry} ugc
+   * @returns {string}
    */
-  static generateSilence(ms, sampleRate = 8e3) {
-    return new Int16Array(Math.floor(ms * sampleRate));
+  static getCorrectExpiryDate(vtec, ugc) {
+    const time = (vtec == null ? void 0 : vtec.expires) && !isNaN(new Date(vtec.expires).getTime()) ? new Date(vtec.expires).toLocaleString() : (ugc == null ? void 0 : ugc.expiry) != null ? new Date(ugc.expiry).toLocaleString() : new Date((/* @__PURE__ */ new Date()).getTime() + 1 * 60 * 60 * 1e3).toLocaleString();
+    if (time == `Invalid Date`) return new Date((/* @__PURE__ */ new Date()).getTime() + 1 * 60 * 60 * 1e3).toLocaleString();
+    return time;
   }
   /**
-   * generateAttentionTone creates an Int16Array of PCM 16-bit samples representing the EAS attention tone for the specified duration in milliseconds.
+   * @function getLocationDistances
+   * @description
+   *     Calculates distances from an event's geometry to all current tracked locations.
+   *     Optionally filters locations by a maximum distance.
    *
    * @private
    * @static
-   * @param {*} ms 
-   * @param {number} [sampleRate=8000] 
-   * @returns {*} 
+   * @param {types.EventProperties} [properties]
+   * @param {boolean} [isFiltered=false]
+   * @param {number} [maxDistance]
+   * @param {string} [unit='miles']
+   * @returns {{ range?: Record<string, {unit: string, distance: number}>, in_range: boolean }}
    */
-  static generateAttentionTone(ms, sampleRate = 8e3) {
-    const len = Math.floor(ms * sampleRate);
-    const out = new Int16Array(len);
-    const f1 = 853;
-    const f2 = 960;
-    const twoPi = Math.PI * 2;
-    const amp = 0.1;
-    const fadeLen = Math.floor(sampleRate * 0);
-    for (let i = 0; i < len; i++) {
-      const t = i / sampleRate;
-      const s = Math.sin(twoPi * f1 * t) + Math.sin(twoPi * f2 * t);
-      let gain = 1;
-      if (i < fadeLen) gain = i / fadeLen;
-      else if (i > len - fadeLen) gain = (len - i) / fadeLen;
-      const v = Math.max(-1, Math.min(1, s / 2 * amp * gain));
-      out[i] = Math.round(v * 32767);
+  static getLocationDistances(properties, isFiltered, maxDistance, unit) {
+    let inRange = false;
+    const totalTracks = Object.keys(cache.currentLocations).length;
+    if (properties.geometry != null) {
+      for (const key in cache.currentLocations) {
+        const coordinates = cache.currentLocations[key];
+        const singleCoord = properties.geometry.coordinates;
+        const center = singleCoord.reduce((acc, [lat, lon]) => [acc[0] + lat, acc[1] + lon], [0, 0]).map((sum) => sum / singleCoord.length);
+        const validUnit = unit === "miles" || unit === "kilometers" ? unit : "miles";
+        const distance = utils_default.calculateDistance({ lat: coordinates.lat, lon: coordinates.lon }, { lat: center[0], lon: center[1] }, validUnit);
+        if (!properties.distance) {
+          properties.distance = {};
+        }
+        properties.distance[key] = { unit, distance };
+      }
+      if (!isFiltered) {
+        return { range: properties.distance, in_range: true };
+      }
+      for (const key in properties.distance) {
+        if (properties.distance[key].distance <= maxDistance) {
+          inRange = true;
+        }
+      }
+      return { range: properties.distance, in_range: totalTracks == 0 ? true : inRange };
     }
-    return out;
+    return { in_range: false };
   }
   /**
-   * applyNWREffect applies a series of audio processing effects to simulate the sound characteristics of NOAA Weather Radio broadcasts.
+   * @function buildDefaultSignature
+   * @description
+   *     Populates default properties for an event object, including action type flags,
+   *     tags, and status updates. Determines if the event is issued, updated, or cancelled
+   *     based on correlations, description content, VTEC codes, and expiration time.
    *
    * @private
    * @static
-   * @param {Int16Array} int16 
-   * @param {number} [sampleRate=8000] 
-   * @returns {*} 
+   * @param {any} event
+   * @returns {any}
    */
-  static applyNWREffect(int16, sampleRate = 8e3) {
-    const hpCut = 3555;
-    const lpCut = 1600;
-    const noiseLevel = 0;
-    const crushBits = 8;
-    const x = this.pcm16toFloat(int16);
-    const dt = 1 / sampleRate;
-    const rcHP = 1 / (2 * Math.PI * hpCut);
-    const aHP = rcHP / (rcHP + dt);
-    let yHP = 0, xPrev = 0;
-    for (let i = 0; i < x.length; i++) {
-      const xi = x[i];
-      yHP = aHP * (yHP + xi - xPrev);
-      xPrev = xi;
-      x[i] = yHP;
+  static buildDefaultSignature(event) {
+    var _a, _b;
+    const props = (_a = event.properties) != null ? _a : {};
+    const statusCorrelation = definitions.correlations.find((c) => c.type === props.action_type);
+    const defEventTags = definitions.tags;
+    const tags = Object.entries(defEventTags).filter(([key]) => props == null ? void 0 : props.description.toLowerCase().includes(key.toLowerCase())).map(([, value]) => value);
+    props.tags = tags.length > 0 ? tags : [`N/A`];
+    const setAction = (type) => {
+      props.is_cancelled = type === `C`;
+      props.is_updated = type === `U`;
+      props.is_issued = type === `I`;
+    };
+    if (statusCorrelation) {
+      props.action_type = (_b = statusCorrelation.forward) != null ? _b : props.action_type;
+      props.is_updated = !!statusCorrelation.update;
+      props.is_issued = !!statusCorrelation.new;
+      props.is_cancelled = !!statusCorrelation.cancel;
+    } else {
+      setAction(`I`);
     }
-    const rcLP = 1 / (2 * Math.PI * lpCut);
-    const aLP = dt / (rcLP + dt);
-    let yLP = 0;
-    for (let i = 0; i < x.length; i++) {
-      yLP = yLP + aLP * (x[i] - yLP);
-      x[i] = yLP;
+    if (props.description) {
+      const detectedPhrase = definitions.cancelSignatures.find((sig) => props.description.toLowerCase().includes(sig.toLowerCase()));
+      if (detectedPhrase) {
+        setAction(`C`);
+      }
     }
-    const compGain = 2;
-    const norm = Math.tanh(compGain);
-    for (let i = 0; i < x.length; i++) x[i] = Math.tanh(x[i] * compGain) / norm;
-    const levels = Math.pow(2, crushBits) - 1;
-    return this.floatToPcm16(x);
+    if (event.vtec) {
+      const getType = event.vtec.split(`.`)[0];
+      const isTestProduct = definitions.productTypes[getType] == `Test Product`;
+      if (isTestProduct) {
+        setAction(`C`);
+        props.is_test = true;
+      }
+    }
+    if (new Date(props == null ? void 0 : props.expires).getTime() < (/* @__PURE__ */ new Date()).getTime()) {
+      setAction(`C`);
+    }
+    return event;
   }
+};
+var events_default = EventParser;
+
+// src/database.ts
+var Database = class {
   /**
-   * addNoise adds low-level white noise to an Int16Array of PCM 16-bit samples to simulate analog broadcast imperfections.
+   * @function stanzaCacheImport
+   * @description
+   *     Inserts a single NWWS stanza into the database cache. If the total number
+   *     of stanzas exceeds the configured maximum history, it deletes the oldest
+   *     entries to maintain the limit. Duplicate stanzas are ignored.
    *
-   * @private
    * @static
-   * @param {Int16Array} int16 
-   * @param {number} [noiseLevel=0.02] 
-   * @returns {*} 
+   * @async
+   * @param {string} stanza
+   *     The raw stanza XML or text to store in the database.
+   * 
+   * @returns {Promise<void>}
+   *     Resolves when the stanza has been inserted and any necessary pruning
+   *     of old stanzas has been performed.
+   *
+   * @example
+   *     await Database.stanzaCacheImport("<alert>...</alert>");
    */
-  static addNoise(int16, noiseLevel = 0.02) {
-    const x = this.pcm16toFloat(int16);
-    for (let i = 0; i < x.length; i++) x[i] += (Math.random() * 2 - 1) * noiseLevel;
-    let peak = 0;
-    for (let i = 0; i < x.length; i++) peak = Math.max(peak, Math.abs(x[i]));
-    if (peak > 1) for (let i = 0; i < x.length; i++) x[i] *= 0.98 / peak;
-    return this.floatToPcm16(x);
+  static stanzaCacheImport(stanza) {
+    return __async(this, null, function* () {
+      const settings2 = settings;
+      try {
+        const db = cache.db;
+        if (!db) return;
+        db.prepare(`INSERT OR IGNORE INTO stanzas (stanza) VALUES (?)`).run(stanza);
+        const countRow = db.prepare(`SELECT COUNT(*) AS total FROM stanzas`).get();
+        const totalRows = countRow.total;
+        const maxHistory = settings2.noaa_weather_wire_service_settings.cache.max_db_history;
+        if (totalRows > maxHistory) {
+          const rowsToDelete = Math.floor((totalRows - maxHistory) / 2);
+          if (rowsToDelete > 0) {
+            db.prepare(`
+                        DELETE FROM stanzas 
+                        WHERE rowid IN (
+                            SELECT rowid 
+                            FROM stanzas 
+                            ORDER BY rowid ASC 
+                            LIMIT ?
+                        )
+                    `).run(rowsToDelete);
+          }
+        }
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        utils_default.warn(`Failed to import stanza into cache: ${msg}`);
+      }
+    });
   }
   /**
-   * asciiTo8N1Bits converts an ASCII string to a sequence of bits using 8-N-1 encoding (8 data bits, no parity, 1 stop bit).
+   * @function loadDatabase
+   * @description
+   *     Initializes the application's SQLite database, creating necessary tables
+   *     for storing stanzas and shapefiles. If the shapefiles table is empty,
+   *     it imports predefined shapefiles from disk, processes their features,
+   *     and populates the database. Emits warnings during the import process.
    *
-   * @private
    * @static
-   * @param {string} str 
-   * @returns {{}} 
+   * @async
+   * @returns {Promise<void>}
+   *     Resolves when the database and shapefiles have been initialized.
+   *
+   * @example
+   *     await Database.loadDatabase();
+   *     console.log('Database initialized and shapefiles imported.');
    */
-  static asciiTo8N1Bits(str) {
-    const bits = [];
-    for (let i = 0; i < str.length; i++) {
-      const c = str.charCodeAt(i) & 255;
-      bits.push(0);
-      for (let b = 0; b < 8; b++) bits.push(c >> b & 1);
-      bits.push(1, 1);
-    }
-    return bits;
+  static loadDatabase() {
+    return __async(this, null, function* () {
+      const settings2 = settings;
+      try {
+        const { fs: fs2, path: path2, sqlite3: sqlite32, shapefile: shapefile2 } = packages;
+        if (!fs2.existsSync(settings2.database)) fs2.writeFileSync(settings2.database, "");
+        cache.db = new sqlite32(settings2.database);
+        cache.db.prepare(`
+                CREATE TABLE IF NOT EXISTS stanzas (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    stanza TEXT
+                )
+            `).run();
+        cache.db.prepare(`
+                CREATE TABLE IF NOT EXISTS shapefiles (
+                    id TEXT PRIMARY KEY,
+                    location TEXT,
+                    geometry TEXT
+                )
+            `).run();
+        const shapefileCount = cache.db.prepare(`SELECT COUNT(*) AS count FROM shapefiles`).get().count;
+        if (shapefileCount === 0) {
+          utils_default.warn(definitions.messages.shapefile_creation);
+          for (const shape of definitions.shapefiles) {
+            const filepath = path2.resolve(__dirname, "../../shapefiles", shape.file);
+            const { features } = yield shapefile2.read(filepath, filepath);
+            utils_default.warn(`Importing ${features.length} entries from ${shape.file}...`);
+            const insertStmt = cache.db.prepare(`
+                        INSERT OR REPLACE INTO shapefiles (id, location, geometry) VALUES (?, ?, ?)
+                    `);
+            const insertTransaction = cache.db.transaction((entries) => {
+              for (const feature of entries) {
+                const { properties, geometry } = feature;
+                let final, location;
+                if (properties.FIPS) {
+                  final = `${properties.STATE}${shape.id}${properties.FIPS.substring(2)}`;
+                  location = `${properties.COUNTYNAME}, ${properties.STATE}`;
+                } else if (properties.FULLSTAID) {
+                  final = `${properties.ST}${shape.id}${properties.WFO}`;
+                  location = `${properties.CITY}, ${properties.STATE}`;
+                } else if (properties.STATE) {
+                  final = `${properties.STATE}${shape.id}${properties.ZONE}`;
+                  location = `${properties.NAME}, ${properties.STATE}`;
+                } else {
+                  final = properties.ID;
+                  location = properties.NAME;
+                }
+                insertStmt.run(final, location, JSON.stringify(geometry));
+              }
+            });
+            insertTransaction(features);
+          }
+          utils_default.warn(definitions.messages.shapefile_creation_finished);
+        }
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        utils_default.warn(`Failed to load database: ${msg}`);
+      }
+    });
   }
-  /**
-   * generateAFSK generates an Int16Array of PCM 16-bit samples representing AFSK modulation of the provided bit sequence.
+};
+var database_default = Database;
+
+// src/xmpp.ts
+var Xmpp = class {
+  /** 
+   * @function isSessionReconnectionEligible
+   * @description
+   *     Checks if the XMPP session has been inactive longer than the given interval
+   *     and, if so, attempts a controlled reconnection.
    *
-   * @private
+   * @async
    * @static
-   * @param {number[]} bits 
-   * @param {number} [sampleRate=8000] 
-   * @returns {*} 
+   * @param {number} currentInterval
+   * @returns {Promise<void>}
    */
-  static generateAFSK(bits, sampleRate = 8e3) {
-    const baud = 520.83;
-    const markFreq = 2083.3;
-    const spaceFreq = 1562.5;
-    const amplitude = 0.6;
-    const twoPi = Math.PI * 2;
-    const result = [];
-    let phase = 0;
-    let frac = 0;
-    for (let b = 0; b < bits.length; b++) {
-      const bit = bits[b];
-      const freq = bit ? markFreq : spaceFreq;
-      const samplesPerBit = sampleRate / baud + frac;
-      const n = Math.round(samplesPerBit);
-      frac = samplesPerBit - n;
-      const inc = twoPi * freq / sampleRate;
-      for (let i = 0; i < n; i++) {
-        result.push(Math.round(Math.sin(phase) * amplitude * 32767));
-        phase += inc;
-        if (phase > twoPi) phase -= twoPi;
+  static isSessionReconnectionEligible(currentInterval) {
+    return __async(this, null, function* () {
+      const settings2 = settings;
+      const lastStanzaElapsed = Date.now() - cache.lastStanza;
+      const threshold = currentInterval * 1e3;
+      if (!cache.isConnected && !cache.sigHalt || !cache.session) {
+        return;
       }
-    }
-    const fadeSamples = Math.floor(sampleRate * 2e-3);
-    for (let i = 0; i < fadeSamples; i++) {
-      const gain = i / fadeSamples;
-      result[i] = Math.round(result[i] * gain);
-      result[result.length - 1 - i] = Math.round(result[result.length - 1 - i] * gain);
-    }
-    return Int16Array.from(result);
+      if (lastStanzaElapsed < threshold) {
+        return;
+      }
+      if (cache.attemptingReconnect) {
+        return;
+      }
+      cache.attemptingReconnect = true;
+      cache.isConnected = false;
+      cache.totalReconnects += 1;
+      try {
+        cache.events.emit("onReconnection", {
+          reconnects: cache.totalReconnects,
+          lastStanza: lastStanzaElapsed,
+          lastName: settings2.noaa_weather_wire_service_settings.credentials.nickname
+        });
+        yield cache.session.stop().catch(() => {
+        });
+        yield cache.session.start().catch(() => {
+        });
+      } catch (err) {
+        utils_default.warn(`XMPP reconnection failed: ${err.message}`);
+      } finally {
+        cache.attemptingReconnect = false;
+      }
+    });
   }
   /**
-   * generateSAMEHeader generates an Int16Array of PCM 16-bit samples representing the SAME header repeated the specified number of times.
+   * @function deploySession
+   * @description
+   *     Initializes the NOAA Weather Wire Service (NWWS-OI) XMPP client session and
+   *     manages its lifecycle events including connection, disconnection, errors,
+   *     and message handling.
    *
-   * @private
+   * @async
    * @static
-   * @param {string} vtec 
-   * @param {number} repeats 
-   * @param {number} [sampleRate=8000] 
-   * @param {{preMarkSec?: number, gapSec?: number}} [options={}] 
-   * @returns {*} 
+   * @returns {Promise<void>}
    */
-  static generateSAMEHeader(vtec, repeats, sampleRate = 8e3, options = {}) {
-    var _a, _b;
-    const preMarkSec = (_a = options.preMarkSec) != null ? _a : 0.3;
-    const gapSec = (_b = options.gapSec) != null ? _b : 0.1;
-    const bursts = [];
-    const gap = this.generateSilence(gapSec, sampleRate);
-    for (let i = 0; i < repeats; i++) {
-      const bodyBits = this.asciiTo8N1Bits(vtec);
-      const body = this.generateAFSK(bodyBits, sampleRate);
-      const extendedBodyDuration = Math.round(preMarkSec * sampleRate);
-      const extendedBody = new Int16Array(extendedBodyDuration + gap.length);
-      for (let j = 0; j < extendedBodyDuration; j++) {
-        extendedBody[j] = Math.round(body[j % body.length] * 0.2);
+  static deploySession() {
+    return __async(this, null, function* () {
+      var _a, _b;
+      const settings2 = settings;
+      (_b = (_a = settings2.noaa_weather_wire_service_settings.credentials).nickname) != null ? _b : _a.nickname = settings2.noaa_weather_wire_service_settings.credentials.username;
+      cache.session = packages.xmpp.client({
+        service: "xmpp://nwws-oi.weather.gov",
+        domain: "nwws-oi.weather.gov",
+        username: settings2.noaa_weather_wire_service_settings.credentials.username,
+        password: settings2.noaa_weather_wire_service_settings.credentials.password
+      });
+      cache.session.on("online", (address) => __async(null, null, function* () {
+        const now = Date.now();
+        if (cache.lastConnect && now - cache.lastConnect < 1e4) {
+          cache.sigHalt = true;
+          utils_default.warn(definitions.messages.reconnect_too_fast);
+          yield utils_default.sleep(2e3);
+          yield cache.session.stop().catch(() => {
+          });
+          return;
+        }
+        cache.isConnected = true;
+        cache.sigHalt = false;
+        cache.lastConnect = now;
+        cache.session.send(packages.xmpp.xml("presence", {
+          to: `nwws@conference.nwws-oi.weather.gov/${settings2.noaa_weather_wire_service_settings.credentials.nickname}`,
+          xmlns: "http://jabber.org/protocol/muc"
+        }));
+        cache.events.emit("onConnection", settings2.noaa_weather_wire_service_settings.credentials.nickname);
+        if (cache.attemptingReconnect) return;
+        cache.attemptingReconnect = true;
+        yield utils_default.sleep(15e3);
+        cache.attemptingReconnect = false;
+      }));
+      cache.session.on("offline", () => {
+        cache.isConnected = false;
+        cache.sigHalt = true;
+        utils_default.warn("XMPP connection went offline");
+      });
+      cache.session.on("error", (error) => {
+        cache.isConnected = false;
+        cache.sigHalt = true;
+        utils_default.warn(`XMPP connection error: ${error.message}`);
+      });
+      cache.session.on("stanza", (stanza) => __async(null, null, function* () {
+        var _a2;
+        try {
+          cache.lastStanza = Date.now();
+          if (stanza.is("message")) {
+            const validate = stanza_default.validate(stanza);
+            const skipMessage = validate.ignore || validate.isCap && !settings2.noaa_weather_wire_service_settings.preferences.cap_only || !validate.isCap && settings2.noaa_weather_wire_service_settings.preferences.cap_only || validate.isCap && !validate.isCapDescription;
+            if (skipMessage) return;
+            events_default.eventHandler(validate);
+            database_default.stanzaCacheImport(JSON.stringify(validate));
+            cache.events.emit("onMessage", validate);
+          }
+          if (stanza.is("presence") && ((_a2 = stanza.attrs.from) == null ? void 0 : _a2.startsWith("nwws@conference.nwws-oi.weather.gov/"))) {
+            const occupant = stanza.attrs.from.split("/").slice(1).join("/");
+            cache.events.emit("onOccupant", {
+              occupant,
+              type: stanza.attrs.type === "unavailable" ? "unavailable" : "available"
+            });
+          }
+        } catch (err) {
+          utils_default.warn(`Error processing stanza: ${err.message}`);
+        }
+      }));
+      try {
+        yield cache.session.start();
+      } catch (err) {
+        utils_default.warn(`Failed to start XMPP session: ${err.message}`);
       }
-      extendedBody.set(gap, extendedBodyDuration);
-      bursts.push(extendedBody);
-      if (i !== repeats - 1) bursts.push(gap);
-    }
-    return this.concatPCM16(bursts);
+    });
   }
 };
-var eas_default = EAS;
+var xmpp_default = Xmpp;
 
-// src/parsers/events.ts
-var EventParser = class {
+// src/utils.ts
+var Utils = class _Utils {
   /**
-   * getBaseProperties extracts and compiles the base properties of an alert message, including location, timing, description, sender information, and various parameters.
+   * @function sleep
+   * @description
+   *     Pauses execution for a specified number of milliseconds.
    *
-   * @public
    * @static
    * @async
-   * @param {string} message 
-   * @param {types.TypeCompiled} validated 
-   * @param {types.UGCParsed} [ugc=null] 
-   * @param {types.VTECParsed} [vtec=null] 
-   * @returns {Promise<types.BaseProperties>} 
+   * @param {number} ms
+   * @returns {Promise<void>}
    */
-  static getBaseProperties(message, validated, ugc = null, vtec = null) {
+  static sleep(ms) {
     return __async(this, null, function* () {
-      var _a, _b, _c, _d, _e, _f, _g, _h;
-      const settings2 = settings;
-      const definitions2 = {
-        tornado: text_default.textProductToString(message, `TORNADO...`) || text_default.textProductToString(message, `WATERSPOUT...`) || `N/A`,
-        hail: text_default.textProductToString(message, `MAX HAIL SIZE...`, [`IN`]) || text_default.textProductToString(message, `HAIL...`, [`IN`]) || `N/A`,
-        gusts: text_default.textProductToString(message, `MAX WIND GUST...`) || text_default.textProductToString(message, `WIND...`) || `N/A`,
-        flood: text_default.textProductToString(message, `FLASH FLOOD...`) || `N/A`,
-        damage: text_default.textProductToString(message, `DAMAGE THREAT...`) || `N/A`,
-        source: text_default.textProductToString(message, `SOURCE...`, [`.`]) || `N/A`,
-        attributes: text_default.textProductToString(message, `STANZA ATTRIBUTES...`) ? JSON.parse(text_default.textProductToString(message, `STANZA ATTRIBUTES...`)) : null,
-        polygon: text_default.textProductToPolygon(message),
-        description: text_default.textProductToDescription(message, (_a = vtec == null ? void 0 : vtec.raw) != null ? _a : null),
-        wmo: message.match(new RegExp(definitions.expressions.wmo, "imu")),
-        mdTorIntensity: text_default.textProductToString(message, `MOST PROBABLE PEAK TORNADO INTENSITY...`) || `N/A`,
-        mdWindGusts: text_default.textProductToString(message, `MOST PROBABLE PEAK WIND GUST...`) || `N/A`,
-        mdHailSize: text_default.textProductToString(message, `MOST PROBABLE PEAK HAIL SIZE...`) || `N/A`
-      };
-      const getOffice = this.getICAO(vtec, (_c = (_b = validated.attributes) != null ? _b : definitions2.attributes) != null ? _c : {}, definitions2.wmo);
-      const getCorrectIssued = this.getCorrectIssuedDate((_e = (_d = definitions2.attributes) != null ? _d : validated.attributes) != null ? _e : {});
-      const getCorrectExpiry = this.getCorrectExpiryDate(vtec, ugc);
-      const getAwip = text_default.awipTextToEvent((_g = (_f = definitions2.attributes) == null ? void 0 : _f.awipsid) != null ? _g : validated.awipsType.prefix);
-      const base = {
-        locations: (ugc == null ? void 0 : ugc.locations.join(`; `)) || `No Location Specified (UGC Missing)`,
-        issued: getCorrectIssued,
-        expires: getCorrectExpiry,
-        geocode: { UGC: (ugc == null ? void 0 : ugc.zones) || [`XX000`] },
-        description: definitions2.description,
-        sender_name: getOffice.name,
-        sender_icao: getOffice.icao,
-        attributes: __spreadProps(__spreadValues(__spreadValues({}, validated.attributes), definitions2.attributes), {
-          getAwip
-        }),
-        parameters: {
-          wmo: Array.isArray(definitions2.wmo) ? definitions2.wmo[0] : (_h = definitions2.wmo) != null ? _h : `N/A`,
-          source: definitions2.source,
-          max_hail_size: definitions2.hail,
-          max_wind_gust: definitions2.gusts,
-          damage_threat: definitions2.damage,
-          tornado_detection: definitions2.tornado,
-          flood_detection: definitions2.flood,
-          discussion_tornado_intensity: definitions2.mdTorIntensity,
-          discussion_wind_intensity: definitions2.mdWindGusts,
-          discussion_hail_intensity: definitions2.mdHailSize
-        },
-        geometry: definitions2.polygon.length > 0 ? { type: "Polygon", coordinates: definitions2.polygon } : null
-      };
-      if (settings2.NoaaWeatherWireService.alertPreferences.isShapefileUGC && base.geometry == null && ugc != null) {
-        const coordinates = yield ugc_default.getCoordinates(ugc.zones);
-        base.geometry = { type: "Polygon", coordinates };
-      }
-      return base;
+      return new Promise((resolve) => setTimeout(resolve, ms));
     });
   }
   /**
-   * enhanceEvent refines the event name based on specific conditions and tags found in the event's description and parameters.
+   * @function warn
+   * @description
+   *     Emits a log event and prints a warning to the console. Throttles repeated
+   *     warnings within a short interval unless `force` is `true`.
    *
-   * @public
    * @static
-   * @param {types.TypeAlert} event 
-   * @returns {{ eventName: any; tags: any; }} 
+   * @param {string} message
+   * @param {boolean} [force=false]
    */
-  static enhanceEvent(event) {
-    var _a, _b, _c, _d, _e;
-    let eventName = (_b = (_a = event == null ? void 0 : event.properties) == null ? void 0 : _a.event) != null ? _b : `Unknown Event`;
-    const defEventTable = definitions.enhancedEvents;
-    const defEventTags = definitions.tags;
-    const properties = event == null ? void 0 : event.properties;
-    const parameters = properties == null ? void 0 : properties.parameters;
-    const description = (_c = properties == null ? void 0 : properties.description) != null ? _c : `Unknown Description`;
-    const damageThreatTag = (_d = parameters == null ? void 0 : parameters.damage_threat) != null ? _d : `N/A`;
-    const tornadoThreatTag = (_e = parameters == null ? void 0 : parameters.tornado_detection) != null ? _e : `N/A`;
-    for (const eventGroup of defEventTable) {
-      const [baseEvent, conditions] = Object.entries(eventGroup)[0];
-      if (eventName === baseEvent) {
-        for (const [specificEvent, condition] of Object.entries(conditions)) {
-          const conditionMet = condition.description && description.includes(condition.description.toLowerCase()) || condition.condition && condition.condition(damageThreatTag || tornadoThreatTag);
-          if (conditionMet) {
-            eventName = specificEvent;
-            break;
+  static warn(message, force = false) {
+    cache.events.emit("log", message);
+    if (!settings.journal) return;
+    if (cache.lastWarn != null && Date.now() - cache.lastWarn < 500 && !force) return;
+    cache.lastWarn = Date.now();
+    console.warn(`\x1B[33m[ATMOSX-PARSER]\x1B[0m [${(/* @__PURE__ */ new Date()).toLocaleString()}] ${message}`);
+  }
+  /**
+   * @function loadCollectionCache
+   * @description
+   *     Loads cached NWWS messages from disk, validates them, and passes them
+   *     to the event parser. Honors CAP preferences and ignores empty or
+   *     incompatible files.
+   *
+   * @static
+   * @async
+   */
+  static loadCollectionCache() {
+    return __async(this, null, function* () {
+      try {
+        const settings2 = settings;
+        if (settings2.noaa_weather_wire_service_settings.cache.enabled && settings2.noaa_weather_wire_service_settings.cache.directory) {
+          if (!packages.fs.existsSync(settings2.noaa_weather_wire_service_settings.cache.directory)) return;
+          const cacheDir = settings2.noaa_weather_wire_service_settings.cache.directory;
+          const getAllFiles = packages.fs.readdirSync(cacheDir).filter((file) => file.endsWith(".bin") && file.startsWith("cache-"));
+          this.warn(definitions.messages.dump_cache.replace(`{count}`, getAllFiles.length.toString()), true);
+          yield this.sleep(2e3);
+          for (const file of getAllFiles) {
+            const filepath = packages.path.join(cacheDir, file);
+            const readFile = packages.fs.readFileSync(filepath, { encoding: "utf-8" });
+            const readSize = packages.fs.statSync(filepath).size;
+            if (readSize == 0) {
+              continue;
+            }
+            const isCap = readFile.includes(`<?xml`);
+            if (isCap && !settings2.noaa_weather_wire_service_settings.preferences.cap_only) continue;
+            if (!isCap && settings2.noaa_weather_wire_service_settings.preferences.cap_only) continue;
+            const validate = stanza_default.validate(readFile, { isCap, raw: true });
+            yield events_default.eventHandler(validate);
           }
+          this.warn(definitions.messages.dump_cache_complete, true);
         }
-        if (baseEvent === "Severe Thunderstorm Warning" && damageThreatTag === "POSSIBLE" && !eventName.includes("(TPROB)")) eventName += " (TPROB)";
-        break;
+      } catch (error) {
+        _Utils.warn(`Failed to load cache: ${error.stack}`);
+      }
+    });
+  }
+  /**
+   * @function loadGeoJsonData
+   * @description
+   *     Fetches GeoJSON data from the National Weather Service endpoint and
+   *     passes it to the event parser for processing.
+   *
+   * @static
+   * @async
+   */
+  static loadGeoJsonData() {
+    return __async(this, null, function* () {
+      try {
+        const settings2 = settings;
+        const response = yield this.createHttpRequest(
+          settings2.national_weather_service_settings.endpoint
+        );
+        if (response.error) return;
+        events_default.eventHandler({
+          message: JSON.stringify(response.message),
+          attributes: {},
+          isCap: true,
+          isApi: true,
+          isVtec: false,
+          isUGC: false,
+          isCapDescription: false,
+          awipsType: { type: "api", prefix: "AP" },
+          ignore: false
+        });
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        _Utils.warn(`Failed to load National Weather Service GeoJSON Data: ${msg}`);
+      }
+    });
+  }
+  /**
+   * @function createHttpRequest
+   * @description
+   *     Performs an HTTP GET request with default headers and timeout, returning
+   *     either the response data or an error message.
+   *
+   * @static
+   * @template T
+   * @param {string} url
+   * @param {types.HTTPSettings} [options]
+   * @returns {Promise<{ error: boolean; message: T | string }>}
+   */
+  static createHttpRequest(url, options) {
+    return __async(this, null, function* () {
+      var _a;
+      const defaultOptions = {
+        timeout: 1e4,
+        headers: {
+          "User-Agent": "AtmosphericX",
+          "Accept": "application/geo+json, text/plain, */*; q=0.9",
+          "Accept-Language": "en-US,en;q=0.9"
+        }
+      };
+      const requestOptions = __spreadProps(__spreadValues(__spreadValues({}, defaultOptions), options), {
+        headers: __spreadValues(__spreadValues({}, defaultOptions.headers), (_a = options == null ? void 0 : options.headers) != null ? _a : {})
+      });
+      try {
+        const resp = yield packages.axios.get(url, {
+          headers: requestOptions.headers,
+          timeout: requestOptions.timeout,
+          maxRedirects: 0,
+          validateStatus: (status) => status === 200 || status === 500
+        });
+        return { error: false, message: resp.data };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { error: true, message: msg };
+      }
+    });
+  }
+  /**
+   * @function garbageCollectionCache
+   * @description
+   *     Deletes cache files exceeding the specified size limit to free disk space.
+   *     Recursively traverses the cache directory and removes files larger than
+   *     the given maximum.
+   *
+   * @static
+   * @param {number} maxFileMegabytes
+   */
+  static garbageCollectionCache(maxFileMegabytes) {
+    try {
+      const settings2 = settings;
+      const cacheDir = settings2.noaa_weather_wire_service_settings.cache.directory;
+      if (!cacheDir) return;
+      const { fs: fs2, path: path2 } = packages;
+      if (!fs2.existsSync(cacheDir)) return;
+      const maxBytes = maxFileMegabytes * 1024 * 1024;
+      const stackDirs = [cacheDir];
+      const files = [];
+      while (stackDirs.length) {
+        const currentDir = stackDirs.pop();
+        fs2.readdirSync(currentDir).forEach((file) => {
+          const fullPath = path2.join(currentDir, file);
+          const stat = fs2.statSync(fullPath);
+          if (stat.isDirectory()) stackDirs.push(fullPath);
+          else files.push({ file: fullPath, size: stat.size });
+        });
       }
+      files.forEach((f) => {
+        if (f.size > maxBytes) fs2.unlinkSync(f.file);
+      });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      _Utils.warn(`Failed to perform garbage collection: ${msg}`);
     }
-    const tags = Object.entries(defEventTags).filter(([key]) => description.includes(key.toLowerCase())).map(([, value]) => value);
-    return { eventName, tags: tags.length > 0 ? tags : [`N/A`] };
   }
   /**
-   * getCorrectExpiryDate determines the correct expiration date for an alert based on VTEC information or UGC zones.
+   * @function handleCronJob
+   * @description
+   *     Performs scheduled tasks for NWWS XMPP session maintenance or GeoJSON data
+   *     updates depending on the job type.
    *
-   * @public
    * @static
-   * @param {unknown[]} events 
+   * @param {boolean} isWire
    */
-  static validateEvents(events2) {
-    var _a, _b, _c, _d, _e;
-    if (events2.length == 0) return;
-    const settings2 = settings;
-    const filteringSettings = (_b = (_a = settings) == null ? void 0 : _a.global) == null ? void 0 : _b.alertFiltering;
-    const easSettings = (_d = (_c = settings) == null ? void 0 : _c.global) == null ? void 0 : _d.easSettings;
-    const globalSettings = (_e = settings) == null ? void 0 : _e.global;
-    const sets = {};
-    const bools = {};
-    const megered = __spreadValues(__spreadValues(__spreadValues({}, filteringSettings), easSettings), globalSettings);
-    for (const key in megered) {
-      const setting = megered[key];
-      if (Array.isArray(setting)) {
-        sets[key] = new Set(setting.map((item) => item.toLowerCase()));
+  static handleCronJob(isWire) {
+    try {
+      const settings2 = settings;
+      const cache2 = settings2.noaa_weather_wire_service_settings.cache;
+      const reconnections = settings2.noaa_weather_wire_service_settings.reconnection_settings;
+      if (isWire) {
+        if (cache2.enabled) {
+          void this.garbageCollectionCache(cache2.max_file_size);
+        }
+        if (reconnections.enabled) {
+          void xmpp_default.isSessionReconnectionEligible(reconnections.interval);
+        }
+      } else {
+        void this.loadGeoJsonData();
       }
-      if (typeof setting === "boolean") {
-        bools[key] = setting;
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      _Utils.warn(`Failed to perform scheduled tasks (${isWire ? "NWWS" : "GeoJSON"}): ${msg}`);
+    }
+  }
+  /**
+   * @function mergeClientSettings
+   * @description
+   *     Recursively merges a ClientSettings object into a target object,
+   *     preserving nested structures and overriding existing values.
+   *
+   * @static
+   * @param {Record<string, unknown>} target
+   * @param {types.ClientSettingsTypes} settings
+   * @returns {Record<string, unknown>}
+   */
+  static mergeClientSettings(target, settings2) {
+    for (const key in settings2) {
+      if (!Object.prototype.hasOwnProperty.call(settings2, key)) continue;
+      const value = settings2[key];
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        if (!target[key] || typeof target[key] !== "object" || Array.isArray(target[key])) {
+          target[key] = {};
+        }
+        this.mergeClientSettings(target[key], value);
+      } else {
+        target[key] = value;
       }
     }
-    const filtered = events2.filter((alert) => {
-      var _a2, _b2, _d2, _e2;
-      const originalEvent = alert;
-      const props = originalEvent == null ? void 0 : originalEvent.properties;
-      const ugcs = (_b2 = (_a2 = props == null ? void 0 : props.geocode) == null ? void 0 : _a2.UGC) != null ? _b2 : [];
-      const _c2 = originalEvent, { performance: performance2, header } = _c2, eventWithoutPerformance = __objRest(_c2, ["performance", "header"]);
-      if (bools == null ? void 0 : bools.betterEventParsing) {
-        const { eventName, tags } = this.enhanceEvent(originalEvent);
-        originalEvent.properties.event = eventName;
-        originalEvent.properties.tags = tags;
+    return target;
+  }
+  /**
+   * @function calculateDistance
+   * @description
+   *     Calculates the great-circle distance between two geographic coordinates
+   *     using the haversine formula.
+   *
+   * @static
+   * @param {types.Coordinates} coord1
+   * @param {types.Coordinates} coord2
+   * @param {'miles' | 'kilometers'} [unit='miles']
+   * @returns {number}
+   */
+  static calculateDistance(coord1, coord2, unit = "miles") {
+    if (!coord1 || !coord2) return 0;
+    const { lat: lat1, lon: lon1 } = coord1;
+    const { lat: lat2, lon: lon2 } = coord2;
+    if ([lat1, lon1, lat2, lon2].some((v) => typeof v !== "number")) return 0;
+    const toRad = (deg) => deg * Math.PI / 180;
+    const R = unit === "miles" ? 3958.8 : 6371;
+    const dLat = toRad(lat2 - lat1);
+    const dLon = toRad(lon2 - lon1);
+    const a = __pow(Math.sin(dLat / 2), 2) + Math.cos(toRad(lat1)) * Math.cos(toRad(lat2)) * __pow(Math.sin(dLon / 2), 2);
+    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    return Math.round(R * c * 100) / 100;
+  }
+  /**
+   * @function isReadyToProcess
+   * @description
+   *     Determines whether processing can continue based on the current
+   *     tracked locations and filter state. Emits limited warnings if no
+   *     locations are available.
+   *
+   * @static
+   * @param {boolean} isFiltering
+   * @returns {boolean}
+   */
+  static isReadyToProcess(isFiltering) {
+    const totalTracks = Object.keys(cache.currentLocations).length;
+    if (totalTracks > 0) {
+      cache.totalLocationWarns = 0;
+      return true;
+    }
+    if (!isFiltering) return true;
+    if (cache.totalLocationWarns < 3) {
+      _Utils.warn(definitions.messages.no_current_locations);
+      cache.totalLocationWarns++;
+      return false;
+    }
+    _Utils.warn(definitions.messages.disabled_location_warning, true);
+    return true;
+  }
+};
+var utils_default = Utils;
+
+// src/eas.ts
+var EAS = class {
+  /**
+   * @function generateEASAudio
+   * @description
+   *     Generates an EAS (Emergency Alert System) audio file for a given message
+   *     and SAME/VTEC code. The audio is composed of optional intro tones, SAME
+   *     headers, attention tones, TTS narration of the message, and repeated
+   *     SAME headers. The resulting audio is processed for NWR-style broadcast
+   *     quality and saved as a WAV file.
+   *
+   * @static
+   * @async
+   * @param {string} message
+   * @param {string} vtec
+   * @returns {Promise<string | null>}
+   */
+  static generateEASAudio(message, vtec) {
+    return new Promise((resolve) => __async(this, null, function* () {
+      const settings2 = settings;
+      const assetsDir = settings2.global_settings.eas_settings.directory;
+      const rngFile = `${vtec.replace(/[^a-zA-Z0-9]/g, `_`)}`.substring(0, 32).replace(/^_+|_+$/g, "");
+      const os2 = packages.os.platform();
+      for (const { regex, replacement } of definitions.messageSignatures) {
+        message = message.replace(regex, replacement);
       }
-      const eventCheck = (bools == null ? void 0 : bools.useParentEvents) ? (_d2 = props.parent) == null ? void 0 : _d2.toLowerCase() : (_e2 = props.event) == null ? void 0 : _e2.toLowerCase();
-      const statusCorrelation = definitions.correlations.find((c) => c.type === originalEvent.properties.action_type);
-      for (const key in sets) {
-        const setting = sets[key];
-        if (key === "filteredEvents" && setting.size > 0 && eventCheck != null && !setting.has(eventCheck)) return false;
-        if (key === "ignoredEvents" && setting.size > 0 && eventCheck != null && setting.has(eventCheck)) return false;
-        if (key === "filteredICOAs" && setting.size > 0 && props.sender_icao != null && !setting.has(props.sender_icao.toLowerCase())) return false;
-        if (key === "ignoredICOAs" && setting.size > 0 && props.sender_icao != null && setting.has(props.sender_icao.toLowerCase())) return false;
-        if (key === "ugcFilter" && setting.size > 0 && ugcs.length > 0 && !ugcs.some((ugc) => setting.has(ugc.toLowerCase()))) return false;
-        if (key === "stateFilter" && setting.size > 0 && ugcs.length > 0 && !ugcs.some((ugc) => setting.has(ugc.substring(0, 2).toLowerCase()))) return false;
-        if (key === "easAlerts" && setting.size > 0 && eventCheck != null && setting.has(eventCheck) && settings2.isNWWS) {
-          eas_default.generateEASAudio(props.description, alert.header);
+      if (!assetsDir) {
+        utils_default.warn(definitions.messages.eas_no_directory);
+        return resolve(null);
+      }
+      if (!packages.fs.existsSync(assetsDir)) {
+        packages.fs.mkdirSync(assetsDir);
+      }
+      const tmpTTS = packages.path.join(assetsDir, `/tmp/${rngFile}.wav`);
+      const outTTS = packages.path.join(assetsDir, `/output/${rngFile}.wav`);
+      const voice = process.platform === "win32" ? "Microsoft David Desktop" : "en-US-GuyNeural";
+      if (!packages.fs.existsSync(packages.path.join(assetsDir, `/tmp`))) {
+        packages.fs.mkdirSync(packages.path.join(assetsDir, `/tmp`), { recursive: true });
+      }
+      if (!packages.fs.existsSync(packages.path.join(assetsDir, `/output`))) {
+        packages.fs.mkdirSync(packages.path.join(assetsDir, `/output`), { recursive: true });
+      }
+      if (os2 == "win32") {
+        packages.say.export(message, voice, 1, tmpTTS);
+      }
+      if (os2 == "linux") {
+        message = message.replace(/[\r\n]+/g, " ");
+        const festivalCommand = `echo "${message.replace(/"/g, '\\"')}" | text2wave -o "${tmpTTS}"`;
+        packages.child.execSync(festivalCommand);
+      }
+      yield utils_default.sleep(3500);
+      let ttsBuffer = null;
+      while (!packages.fs.existsSync(tmpTTS) || (ttsBuffer = packages.fs.readFileSync(tmpTTS)).length === 0) {
+        yield utils_default.sleep(25);
+      }
+      const ttsWav = this.parseWavPCM16(ttsBuffer);
+      const ttsSamples = this.resamplePCM16(ttsWav.samples, ttsWav.sampleRate, 8e3);
+      const ttsRadio = this.applyNWREffect(ttsSamples, 8e3);
+      let toneRadio = null;
+      if (packages.fs.existsSync(settings2.global_settings.eas_settings.intro_wav)) {
+        const toneBuffer = packages.fs.readFileSync(settings2.global_settings.eas_settings.intro_wav);
+        const toneWav = this.parseWavPCM16(toneBuffer);
+        if (toneWav == null) {
+          console.log(`[EAS] Intro tone WAV file is not valid PCM 16-bit format.`);
+          return resolve(null);
         }
+        const toneSamples = toneWav.sampleRate !== 8e3 ? this.resamplePCM16(toneWav.samples, toneWav.sampleRate, 8e3) : toneWav.samples;
+        toneRadio = this.applyNWREffect(toneSamples, 8e3);
       }
-      for (const key in bools) {
-        const setting = bools[key];
-        if (key === "checkExpired" && setting && new Date(props == null ? void 0 : props.expires).getTime() < (/* @__PURE__ */ new Date()).getTime()) return false;
-      }
-      originalEvent.properties.action_type = statusCorrelation ? statusCorrelation.forward : originalEvent.properties.action_type;
-      originalEvent.properties.is_updated = statusCorrelation ? statusCorrelation.update == true : false;
-      originalEvent.properties.is_issued = statusCorrelation ? statusCorrelation.new == true : false;
-      originalEvent.properties.is_cancelled = statusCorrelation ? statusCorrelation.cancel == true : false;
-      originalEvent.hash = packages.crypto.createHash("md5").update(JSON.stringify(eventWithoutPerformance)).digest("hex");
-      if (props.description) {
-        const detectedPhrase = definitions.cancelSignatures.find((sig) => props.description.toLowerCase().includes(sig.toLowerCase()));
-        if (detectedPhrase) {
-          originalEvent.properties.action_type = "Cancel";
-          originalEvent.properties.is_cancelled = true;
-        }
+      let build = toneRadio != null ? [toneRadio, this.generateSilence(0.5, 8e3)] : [];
+      build.push(this.generateSAMEHeader(vtec, 3, 8e3, { preMarkSec: 1.1, gapSec: 0.5 }), this.generateSilence(0.5, 8e3), this.generateAttentionTone(8, 8e3), this.generateSilence(0.5, 8e3), ttsRadio);
+      for (let i = 0; i < 3; i++) {
+        build.push(this.generateSAMEHeader(vtec, 1, 8e3, { preMarkSec: 0.5, gapSec: 0.1 }));
+        build.push(this.generateSilence(0.5, 8e3));
       }
-      if (originalEvent.vtec) {
-        const getType = originalEvent.vtec.split(`.`)[0];
-        const isTestProduct = definitions.productTypes[getType] == `Test Product`;
-        if (isTestProduct) {
-          return false;
+      const allSamples = this.concatPCM16(build);
+      const finalSamples = this.addNoise(allSamples, 2e-3);
+      const outBuffer = this.encodeWavPCM16(Array.from(finalSamples).map((v) => ({ value: v })), 8e3);
+      packages.fs.writeFileSync(outTTS, outBuffer);
+      try {
+        packages.fs.unlinkSync(tmpTTS);
+      } catch (error) {
+        if (error.code !== "EBUSY") {
+          throw error;
         }
       }
-      if (bools.checkExpired && originalEvent.properties.is_cancelled == true) return false;
-      cache.events.emit(`on${originalEvent.properties.parent.replace(/\s+/g, "")}`);
-      return true;
-    });
-    if (filtered.length > 0) {
-      cache.events.emit(`onAlerts`, filtered);
-    }
-  }
-  /**
-   * getHeader constructs a standardized alert header string based on provided attributes, properties, and VTEC information.
-   *
-   * @public
-   * @static
-   * @param {types.TypeAttributes} attributes 
-   * @param {?types.BaseProperties} [properties] 
-   * @param {?types.VTECParsed} [vtec] 
-   * @returns {string} 
-   */
-  static getHeader(attributes, properties, vtec) {
-    var _a, _b, _c, _d, _e, _f, _g;
-    const parent = `ATSX`;
-    const alertType = (_d = (_c = (_a = attributes == null ? void 0 : attributes.awipsType) == null ? void 0 : _a.type) != null ? _c : (_b = attributes == null ? void 0 : attributes.getAwip) == null ? void 0 : _b.prefix) != null ? _d : `XX`;
-    const ugc = ((_e = properties == null ? void 0 : properties.geocode) == null ? void 0 : _e.UGC) != null ? (_f = properties == null ? void 0 : properties.geocode) == null ? void 0 : _f.UGC.join(`-`) : `000000`;
-    const status = (vtec == null ? void 0 : vtec.status) || "Issued";
-    const issued = (properties == null ? void 0 : properties.issued) != null ? (_g = new Date(properties == null ? void 0 : properties.issued)) == null ? void 0 : _g.toISOString().replace(/[-:]/g, "").split(".")[0] : (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").split(".")[0];
-    const sender = (properties == null ? void 0 : properties.sender_icao) || `XXXX`;
-    const header = `ZCZC-${parent}-${alertType}-${ugc}-${status}-${issued}-${sender}-`;
-    return header;
+      return resolve(outTTS);
+    }));
   }
   /**
-   * eventHandler routes the validated alert message to the appropriate event parser based on its type (API, CAP, VTEC, UGC, or plain text).
+   * @function encodeWavPCM16
+   * @description
+   *     Encodes an array of 16-bit PCM samples into a standard WAV file buffer.
+   *     Produces mono audio with 16 bits per sample and a specified sample rate.
    *
-   * @public
-   * @static
-   * @param {types.TypeCompiled} validated 
-   * @returns {*} 
-   */
-  static eventHandler(validated) {
-    if (validated.isApi) return api_default.event(validated);
-    if (validated.isCap) return cap_default.event(validated);
-    if (!validated.isCap && validated.isVtec && validated.isUGC) return vtec_default2.event(validated);
-    if (!validated.isCap && !validated.isVtec && validated.isUGC) return ugc_default2.event(validated);
-    if (!validated.isCap && !validated.isVtec && !validated.isUGC) return text_default2.event(validated);
-  }
-  /**
-   * getICAO retrieves the ICAO code and corresponding office name based on VTEC tracking information, message attributes, or WMO code.
+   *     The input `samples` array should be an array of objects containing a
+   *     numeric `value` property representing the PCM sample.
    *
    * @private
    * @static
-   * @param {types.VTECParsed} vtec 
-   * @param {Record<string, string>} attributes 
-   * @param {(RegExpMatchArray | string | null)} WMO 
-   * @returns {{ icao: any; name: any; }} 
+   * @param {Record<string, number>[]} samples
+   * @param {number} [sampleRate=8000]
+   * @returns {Buffer}
    */
-  static getICAO(vtec, attributes, WMO) {
-    var _a, _b, _c;
-    const icao = vtec != null ? vtec == null ? void 0 : vtec.tracking.split(`-`)[0] : (_a = attributes == null ? void 0 : attributes.cccc) != null ? _a : WMO != null ? Array.isArray(WMO) ? WMO[0] : WMO : `N/A`;
-    const name = (_c = (_b = definitions.ICAO) == null ? void 0 : _b[icao]) != null ? _c : `N/A`;
-    return { icao, name };
+  static encodeWavPCM16(samples, sampleRate = 8e3) {
+    const bytesPerSample = 2;
+    const blockAlign = 1 * bytesPerSample;
+    const byteRate = sampleRate * blockAlign;
+    const subchunk2Size = samples.length * bytesPerSample;
+    const chunkSize = 36 + subchunk2Size;
+    const buffer = Buffer.alloc(44 + subchunk2Size);
+    let o = 0;
+    buffer.write("RIFF", o);
+    o += 4;
+    buffer.writeUInt32LE(chunkSize, o);
+    o += 4;
+    buffer.write("WAVE", o);
+    o += 4;
+    buffer.write("fmt ", o);
+    o += 4;
+    buffer.writeUInt32LE(16, o);
+    o += 4;
+    buffer.writeUInt16LE(1, o);
+    o += 2;
+    buffer.writeUInt16LE(1, o);
+    o += 2;
+    buffer.writeUInt32LE(sampleRate, o);
+    o += 4;
+    buffer.writeUInt32LE(byteRate, o);
+    o += 4;
+    buffer.writeUInt16LE(blockAlign, o);
+    o += 2;
+    buffer.writeUInt16LE(16, o);
+    o += 2;
+    buffer.write("data", o);
+    o += 4;
+    buffer.writeUInt32LE(subchunk2Size, o);
+    o += 4;
+    for (let i = 0; i < samples.length; i++, o += 2) {
+      buffer.writeInt16LE(samples[i].value, o);
+    }
+    return buffer;
   }
   /**
-   * getCorrectIssuedDate ensures the issued date is valid and falls back to the current date if not.
+   * @function parseWavPCM16
+   * @description
+   *     Parses a WAV buffer containing 16-bit PCM mono audio and extracts
+   *     the sample data along with format information.
    *
-   * @private
-   * @static
-   * @param {Record<string, string>} attributes 
-   * @returns {*} 
-   */
-  static getCorrectIssuedDate(attributes) {
-    const time = attributes.issue != null ? new Date(attributes.issue).toLocaleString() : (attributes == null ? void 0 : attributes.issue) != null ? new Date(attributes.issue).toLocaleString() : (/* @__PURE__ */ new Date()).toLocaleString();
-    if (time == `Invalid Date`) return (/* @__PURE__ */ new Date()).toLocaleString();
-    return time;
-  }
-  /**
-   * getCorrectExpiryDate determines the correct expiration date for an alert based on VTEC information or UGC zones.
+   *     Only supports PCM format (audioFormat = 1), 16 bits per sample,
+   *     and single-channel (mono) audio. Returns `null` if the buffer
+   *     is invalid or does not meet these requirements.
    *
    * @private
    * @static
-   * @param {types.VTECParsed} vtec 
-   * @param {types.UGCParsed} ugc 
-   * @returns {*} 
-   */
-  static getCorrectExpiryDate(vtec, ugc) {
-    const time = (vtec == null ? void 0 : vtec.expires) && !isNaN(new Date(vtec.expires).getTime()) ? new Date(vtec.expires).toLocaleString() : (ugc == null ? void 0 : ugc.expiry) != null ? new Date(ugc.expiry).toLocaleString() : new Date((/* @__PURE__ */ new Date()).getTime() + 1 * 60 * 60 * 1e3).toLocaleString();
-    if (time == `Invalid Date`) return new Date((/* @__PURE__ */ new Date()).getTime() + 1 * 60 * 60 * 1e3).toLocaleString();
-    return time;
-  }
-};
-var events_default = EventParser;
-
-// src/database.ts
-var Database = class {
-  /**
-   * handleAlertCache stores a unique alert in the SQLite database and ensures the total number of alerts does not exceed 5000.
-   *
-   * @public
-   * @static
-   * @async
-   * @param {*} alert 
-   * @returns {*} 
+   * @param {Buffer} buffer
+   * @returns { { samples: Int16Array; sampleRate: number; channels: number; bitsPerSample: number } | null }
    */
-  static stanzaCacheImport(stanza) {
-    return __async(this, null, function* () {
-      const settings2 = settings;
-      cache.db.prepare(`INSERT OR IGNORE INTO stanzas (stanza) VALUES (?)`).run(stanza);
-      const count = cache.db.prepare(`SELECT COUNT(*) as total FROM stanzas`).get();
-      if (count.total > settings2.NoaaWeatherWireService.cache.maxHistory) {
-        cache.db.prepare(`DELETE FROM stanzas WHERE rowid IN (SELECT rowid FROM stanzas ORDER BY rowid ASC LIMIT ?)`).run(count.total - settings2.NoaaWeatherWireService.cache.maxHistory / 2);
-      }
-    });
+  static parseWavPCM16(buffer) {
+    if (buffer.toString("ascii", 0, 4) !== "RIFF" || buffer.toString("ascii", 8, 12) !== "WAVE") {
+      return null;
+    }
+    let fmt = null;
+    let data = null;
+    let i = 12;
+    while (i + 8 <= buffer.length) {
+      const id = buffer.toString("ascii", i, i + 4);
+      const size = buffer.readUInt32LE(i + 4);
+      const start = i + 8;
+      const end = start + size;
+      if (id === "fmt ") fmt = buffer.slice(start, end);
+      if (id === "data") data = buffer.slice(start, end);
+      i = end + size % 2;
+    }
+    if (!fmt || !data) return null;
+    const audioFormat = fmt.readUInt16LE(0);
+    const channels = fmt.readUInt16LE(2);
+    const sampleRate = fmt.readUInt32LE(4);
+    const bitsPerSample = fmt.readUInt16LE(14);
+    if (audioFormat !== 1 || bitsPerSample !== 16 || channels !== 1) {
+      return null;
+    }
+    const samples = new Int16Array(data.buffer, data.byteOffset, data.length / 2);
+    return { samples: new Int16Array(samples), sampleRate, channels, bitsPerSample };
   }
   /**
-   * loadDatabase initializes the SQLite database and imports shapefile data if the database or table does not exist.
+   * @function concatPCM16
+   * @description
+   *     Concatenates multiple Int16Array PCM audio buffers into a single
+   *     contiguous Int16Array.
    *
-   * @public
+   * @private
    * @static
-   * @async
-   * @returns {Promise<void>} 
+   * @param {Int16Array[]} arrays
+   * @returns {Int16Array}
    */
-  static loadDatabase() {
-    return __async(this, null, function* () {
-      const settings2 = settings;
-      try {
-        if (!packages.fs.existsSync(settings2.database)) {
-          packages.fs.writeFileSync(settings2.database, "");
-        }
-        cache.db = new packages.sqlite3(settings2.database);
-        const shapfileTable = cache.db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='shapefiles'`).get();
-        const stanzaTable = cache.db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='stanzas'`).get();
-        if (!stanzaTable) {
-          cache.db.prepare(`CREATE TABLE stanzas (id INTEGER PRIMARY KEY AUTOINCREMENT, stanza TEXT)`).run();
-        }
-        if (!shapfileTable) {
-          cache.db.prepare(`CREATE TABLE shapefiles (id TEXT PRIMARY KEY, location TEXT, geometry TEXT)`).run();
-          console.log(definitions.messages.shapefile_creation);
-          for (const shape of definitions.shapefiles) {
-            const { id, file } = shape;
-            const filepath = packages.path.join(__dirname, `../../shapefiles`, file);
-            const { features } = yield packages.shapefile.read(filepath, filepath);
-            console.log(`Importing ${features.length} entries from ${file}...`);
-            const insertStmt = cache.db.prepare(`INSERT OR REPLACE INTO shapefiles (id, location, geometry)VALUES (?, ?, ?)`);
-            const insertTransaction = cache.db.transaction((entries) => {
-              for (const feature of entries) {
-                const { properties, geometry } = feature;
-                let final, location;
-                switch (true) {
-                  case !!properties.FIPS:
-                    final = `${properties.STATE}${id}${properties.FIPS.substring(2)}`;
-                    location = `${properties.COUNTYNAME}, ${properties.STATE}`;
-                    break;
-                  case !!properties.FULLSTAID:
-                    final = `${properties.ST}${id}${properties.WFO}`;
-                    location = `${properties.CITY}, ${properties.STATE}`;
-                    break;
-                  case !!properties.STATE:
-                    final = `${properties.STATE}${id}${properties.ZONE}`;
-                    location = `${properties.NAME}, ${properties.STATE}`;
-                    break;
-                  default:
-                    final = properties.ID;
-                    location = properties.NAME;
-                    break;
-                }
-                insertStmt.run(final, location, JSON.stringify(geometry));
-              }
-            });
-            yield insertTransaction(features);
-          }
-          console.log(definitions.messages.shapefile_creation_finished);
-        }
-      } catch (error) {
-        cache.events.emit("onError", { code: "error-load-database", message: `Failed to load database: ${error.message}` });
-      }
-    });
+  static concatPCM16(arrays) {
+    let total = 0;
+    for (const a of arrays) total += a.length;
+    const out = new Int16Array(total);
+    let o = 0;
+    for (const a of arrays) {
+      out.set(a, o);
+      o += a.length;
+    }
+    return out;
   }
-};
-var database_default = Database;
-
-// src/xmpp.ts
-var Xmpp = class {
   /**
-   * isSessionReconnectionEligible checks if the XMPP session is eligible for reconnection based on the last 
-   * received stanza time and current interval.
+   * @function pcm16toFloat
+   * @description
+   *     Converts a PCM16 Int16Array audio buffer to a Float32Array
+   *     with normalized values in the range [-1, 1).
    *
-   * @public
+   * @private
    * @static
-   * @async
-   * @param {number} currentInterval 
-   * @returns {Promise<void>} 
+   * @param {Int16Array} int16
+   * @returns {Float32Array}
    */
-  static isSessionReconnectionEligible(currentInterval) {
-    return __async(this, null, function* () {
-      const settings2 = settings;
-      if ((cache.isConnected || cache.sigHalt) && cache.session) {
-        const lastStanza = Date.now() - cache.lastStanza;
-        if (lastStanza >= currentInterval * 1e3) {
-          if (!cache.attemptingReconnect) {
-            cache.attemptingReconnect = true;
-            cache.isConnected = false;
-            cache.totalReconnects += 1;
-            cache.events.emit(`onReconnect`, { reconnects: cache.totalReconnects, lastStanza, lastName: settings2.NoaaWeatherWireService.clientCredentials.nickname });
-            yield cache.session.stop().catch(() => {
-            });
-            yield cache.session.start().catch(() => {
-            });
-          }
-        }
-      }
-    });
+  static pcm16toFloat(int16) {
+    const out = new Float32Array(int16.length);
+    for (let i = 0; i < int16.length; i++) out[i] = int16[i] / 32768;
+    return out;
   }
   /**
-   * deploySession initializes and starts the XMPP client session, setting up event listeners for 
-   * connection management and message handling. This function is specifically tailored for
-   * NoaaWeatherWireService and connects to their XMPP server.
+   * @function floatToPcm16
+   * @description
+   *     Converts a Float32Array of audio samples in the range [-1, 1]
+   *     to a PCM16 Int16Array.
    *
-   * @public
+   * @private
    * @static
-   * @async
-   * @returns {Promise<void>} 
+   * @param {Float32Array} float32
+   * @returns {Int16Array}
    */
-  static deploySession() {
-    return __async(this, null, function* () {
-      var _a, _b;
-      const settings2 = settings;
-      cache.session = packages.xmpp.client({
-        service: `xmpp://nwws-oi.weather.gov`,
-        domain: `nwws-oi.weather.gov`,
-        username: settings2.NoaaWeatherWireService.clientCredentials.username,
-        password: settings2.NoaaWeatherWireService.clientCredentials.password
-      });
-      (_b = (_a = settings2.NoaaWeatherWireService.clientCredentials).nickname) != null ? _b : _a.nickname = settings2.NoaaWeatherWireService.clientCredentials.username;
-      cache.session.on(`online`, (address) => __async(null, null, function* () {
-        if (cache.lastConnect && Date.now() - cache.lastConnect < 10 * 1e3) {
-          cache.sigHalt = true;
-          utils_default.sleep(2 * 1e3).then(() => __async(null, null, function* () {
-            yield cache.session.stop();
-          }));
-          cache.events.emit(`onError`, { code: `error-reconnecting-too-fast`, message: `The client is attempting to reconnect too fast. Please wait a few seconds before trying again.` });
-          return;
-        }
-        cache.isConnected = true;
-        cache.sigHalt = false;
-        cache.lastConnect = Date.now();
-        cache.session.send(packages.xmpp.xml("presence", { to: `nwws@conference.nwws-oi.weather.gov/${settings2.NoaaWeatherWireService.clientCredentials.nickname}`, xmlns: "http://jabber.org/protocol/muc" }));
-        cache.session.send(packages.xmpp.xml("presence", { to: `nwws@conference.nwws-oi.weather.gov`, type: "available" }));
-        cache.events.emit(`onConnection`, settings2.NoaaWeatherWireService.clientCredentials.nickname);
-        if (cache.attemptingReconnect) {
-          utils_default.sleep(15 * 1e3).then(() => {
-            cache.attemptingReconnect = false;
-          });
-        }
-      }));
-      cache.session.on(`offline`, () => __async(null, null, function* () {
-        cache.isConnected = false;
-        cache.sigHalt = true;
-        cache.events.emit(`onError`, { code: `connection-lost`, message: `XMPP connection went offline` });
-      }));
-      cache.session.on(`error`, (error) => __async(null, null, function* () {
-        cache.isConnected = false;
-        cache.sigHalt = true;
-        cache.events.emit(`onError`, { code: `connection-error`, message: error.message });
-      }));
-      cache.session.on(`stanza`, (stanza) => __async(null, null, function* () {
-        try {
-          cache.lastStanza = Date.now();
-          if (stanza.is(`message`)) {
-            const validate = stanza_default.validate(stanza);
-            if (validate.ignore || validate.isCap && !settings2.NoaaWeatherWireService.alertPreferences.isCapOnly || !validate.isCap && settings2.NoaaWeatherWireService.alertPreferences.isCapOnly || validate.isCap && !validate.isCapDescription) return;
-            events_default.eventHandler(validate);
-            cache.events.emit(`onMessage`, validate);
-            database_default.stanzaCacheImport(JSON.stringify(validate));
-          }
-          if (stanza.is(`presence`) && stanza.attrs.from && stanza.attrs.from.startsWith("nwws@conference.nwws-oi.weather.gov/")) {
-            const occupant = stanza.attrs.from.split("/").slice(1).join("/");
-            cache.events.emit("onOccupant", { occupant, type: stanza.attrs.type === "unavailable" ? "unavailable" : "available" });
-          }
-        } catch (e) {
-          cache.events.emit(`onError`, { code: `error-processing-stanza`, message: e.message });
-        }
-      }));
-      yield cache.session.start();
-    });
+  static floatToPcm16(float32) {
+    const out = new Int16Array(float32.length);
+    for (let i = 0; i < float32.length; i++) {
+      let v = Math.max(-1, Math.min(1, float32[i]));
+      out[i] = Math.round(v * 32767);
+    }
+    return out;
   }
-};
-var xmpp_default = Xmpp;
-
-// src/utils.ts
-var Utils = class {
   /**
-   * Zzzzzzz... yeah not much to explain here. Simple sleep function that returns a promise after the specified milliseconds.
+   * @function resamplePCM16
+   * @description
+   *     Resamples a PCM16 audio buffer from an original sample rate to a
+   *     target sample rate using linear interpolation.
    *
-   * @public
+   * @private
    * @static
-   * @async
-   * @param {number} ms 
-   * @returns {Promise<void>} 
+   * @param {Int16Array} int16
+   * @param {number} originalRate
+   * @param {number} targetRate
+   * @returns {Int16Array}
    */
-  static sleep(ms) {
-    return __async(this, null, function* () {
-      return new Promise((resolve) => setTimeout(resolve, ms));
-    });
+  static resamplePCM16(int16, originalRate, targetRate) {
+    if (originalRate === targetRate) return int16;
+    const ratio = targetRate / originalRate;
+    const outLen = Math.max(1, Math.round(int16.length * ratio));
+    const out = new Int16Array(outLen);
+    for (let i = 0; i < outLen; i++) {
+      const pos = i / ratio;
+      const i0 = Math.floor(pos);
+      const i1 = Math.min(i0 + 1, int16.length - 1);
+      const frac = pos - i0;
+      const v = int16[i0] * (1 - frac) + int16[i1] * frac;
+      out[i] = Math.round(v);
+    }
+    return out;
   }
   /**
-   * loadCollectionCache reads cached alert files from the specified cache directory and processes them.
+   * @function generateSilence
+   * @description
+   *     Generates a PCM16 audio buffer containing silence for a specified
+   *     duration.
    *
-   * @public
+   * @private
    * @static
-   * @async
-   * @returns {Promise<void>} 
+   * @param {number} ms
+   * @param {number} [sampleRate=8000]
+   * @returns {Int16Array}
    */
-  static loadCollectionCache() {
-    return __async(this, null, function* () {
-      try {
-        const settings2 = settings;
-        if (settings2.NoaaWeatherWireService.cache.read && settings2.NoaaWeatherWireService.cache.directory) {
-          if (!packages.fs.existsSync(settings2.NoaaWeatherWireService.cache.directory)) return;
-          const cacheDir = settings2.NoaaWeatherWireService.cache.directory;
-          const getAllFiles = packages.fs.readdirSync(cacheDir).filter((file) => file.endsWith(".bin") && file.startsWith("cache-"));
-          for (const file of getAllFiles) {
-            const filepath = packages.path.join(cacheDir, file);
-            const readFile = packages.fs.readFileSync(filepath, { encoding: "utf-8" });
-            const readSize = packages.fs.statSync(filepath).size;
-            if (readSize == 0) {
-              continue;
-            }
-            const isCap = readFile.includes(`<?xml`);
-            if (isCap && !settings2.NoaaWeatherWireService.alertPreferences.isCapOnly) continue;
-            if (!isCap && settings2.NoaaWeatherWireService.alertPreferences.isCapOnly) continue;
-            const validate = stanza_default.validate(readFile, { awipsid: file, isCap, raw: true, issue: void 0 });
-            yield events_default.eventHandler(validate);
-          }
-        }
-      } catch (error) {
-        cache.events.emit("onError", { code: "error-load-cache", message: `Failed to load cache: ${error.message}` });
-      }
-    });
+  static generateSilence(ms, sampleRate = 8e3) {
+    return new Int16Array(Math.floor(ms * sampleRate));
   }
   /**
-   * loadGeoJsonData fetches GeoJSON data from the National Weather Service endpoint and processes each alert.
+   * @function generateAttentionTone
+   * @description
+   *     Generates a dual-frequency Attention Tone (853 Hz and 960 Hz) used in
+   *     EAS/SAME alerts. Produces a PCM16 buffer of the specified duration.
    *
-   * @public
+   * @private
    * @static
-   * @async
-   * @returns {Promise<void>} 
+   * @param {number} ms
+   * @param {number} [sampleRate=8000]
+   * @returns {Int16Array}
    */
-  static loadGeoJsonData() {
-    return __async(this, null, function* () {
-      try {
-        const settings2 = settings;
-        const response = yield this.createHttpRequest(settings2.NationalWeatherService.endpoint);
-        if (!response.error) {
-          events_default.eventHandler({ message: JSON.stringify(response.message), attributes: {}, isCap: true, isApi: true, isVtec: false, isUGC: false, isCapDescription: false, awipsType: { type: "api", prefix: "AP" }, ignore: false });
-        }
-      } catch (error) {
-        cache.events.emit("onError", { code: "error-fetching-nws-data", message: `Failed to fetch NWS data: ${error.message}` });
-      }
-    });
+  static generateAttentionTone(ms, sampleRate = 8e3) {
+    const len = Math.floor(ms * sampleRate);
+    const out = new Int16Array(len);
+    const f1 = 853;
+    const f2 = 960;
+    const twoPi = Math.PI * 2;
+    const amp = 0.1;
+    const fadeLen = Math.floor(sampleRate * 0);
+    for (let i = 0; i < len; i++) {
+      const t = i / sampleRate;
+      const s = Math.sin(twoPi * f1 * t) + Math.sin(twoPi * f2 * t);
+      let gain = 1;
+      if (i < fadeLen) gain = i / fadeLen;
+      else if (i > len - fadeLen) gain = (len - i) / fadeLen;
+      const v = Math.max(-1, Math.min(1, s / 2 * amp * gain));
+      out[i] = Math.round(v * 32767);
+    }
+    return out;
   }
   /**
-   * detectUncaughtExceptions sets up a global handler for uncaught exceptions in the Node.js process,
+   * @function applyNWREffect
+   * @description
+   *     Applies a National Weather Radio (NWR)-style audio effect to a PCM16
+   *     buffer, including high-pass and low-pass filtering, soft clipping
+   *     compression, and optional bit reduction to simulate vintage broadcast
+   *     characteristics.
    *
-   * @public
+   * @private
    * @static
+   * @param {Int16Array} int16
+   * @param {number} [sampleRate=8000]
+   * @returns {Int16Array}
    */
-  static detectUncaughtExceptions() {
-    if (cache.events.listenerCount("uncaughtException") > 0) return;
-    cache.events.on("uncaughtException", (error) => {
-      cache.events.emit(`onError`, { message: `Uncaught Exception: ${error.message}`, code: `error-uncaught-exception`, stack: error.stack });
-    });
+  static applyNWREffect(int16, sampleRate = 8e3) {
+    const hpCut = 3555;
+    const lpCut = 1600;
+    const noiseLevel = 0;
+    const crushBits = 8;
+    const x = this.pcm16toFloat(int16);
+    const dt = 1 / sampleRate;
+    const rcHP = 1 / (2 * Math.PI * hpCut);
+    const aHP = rcHP / (rcHP + dt);
+    let yHP = 0, xPrev = 0;
+    for (let i = 0; i < x.length; i++) {
+      const xi = x[i];
+      yHP = aHP * (yHP + xi - xPrev);
+      xPrev = xi;
+      x[i] = yHP;
+    }
+    const rcLP = 1 / (2 * Math.PI * lpCut);
+    const aLP = dt / (rcLP + dt);
+    let yLP = 0;
+    for (let i = 0; i < x.length; i++) {
+      yLP = yLP + aLP * (x[i] - yLP);
+      x[i] = yLP;
+    }
+    const compGain = 2;
+    const norm = Math.tanh(compGain);
+    for (let i = 0; i < x.length; i++) x[i] = Math.tanh(x[i] * compGain) / norm;
+    const levels = Math.pow(2, crushBits) - 1;
+    return this.floatToPcm16(x);
   }
   /**
-   * createHttpRequest performs an HTTP GET request to the specified URL with optional settings.
+   * @function addNoise
+   * @description
+   *     Adds random noise to a PCM16 audio buffer and normalizes the signal
+   *     to prevent clipping. Useful for simulating real-world signal conditions
+   *     or reducing digital artifacts.
    *
-   * @public
+   * @private
    * @static
-   * @async
-   * @param {string} url 
-   * @param {?types.HTTPSettings} [options] 
-   * @returns {unknown} 
+   * @param {Int16Array} int16
+   * @param {number} [noiseLevel=0.02]
+   * @returns {Int16Array}
    */
-  static createHttpRequest(url, options) {
-    return __async(this, null, function* () {
-      var _a, _b;
-      const defaultOptions = {
-        timeout: 1e4,
-        headers: {
-          "User-Agent": "AtmosphericX",
-          "Accept": "application/geo+json, text/plain, */*; q=0.9",
-          "Accept-Language": "en-US,en;q=0.9"
-        }
-      };
-      const requestOptions = __spreadProps(__spreadValues(__spreadValues({}, defaultOptions), options), {
-        headers: __spreadValues(__spreadValues({}, defaultOptions.headers), (_a = options == null ? void 0 : options.headers) != null ? _a : {})
-      });
-      try {
-        const resp = yield packages.axios.get(url, {
-          headers: requestOptions.headers,
-          timeout: requestOptions.timeout,
-          maxRedirects: 0,
-          validateStatus: (status) => status === 200 || status === 500
-        });
-        return { error: false, message: resp.data };
-      } catch (err) {
-        return { error: true, message: (_b = err == null ? void 0 : err.message) != null ? _b : String(err) };
-      }
-    });
+  static addNoise(int16, noiseLevel = 0.02) {
+    const x = this.pcm16toFloat(int16);
+    for (let i = 0; i < x.length; i++) x[i] += (Math.random() * 2 - 1) * noiseLevel;
+    let peak = 0;
+    for (let i = 0; i < x.length; i++) peak = Math.max(peak, Math.abs(x[i]));
+    if (peak > 1) for (let i = 0; i < x.length; i++) x[i] *= 0.98 / peak;
+    return this.floatToPcm16(x);
   }
   /**
-   * garbageCollectionCache removes files from the cache directory that exceed the specified maximum file size in megabytes.
+   * @function asciiTo8N1Bits
+   * @description
+   *     Converts an ASCII string into a sequence of bits using the 8N1 framing
+   *     convention (1 start bit, 8 data bits, 2 stop bits) commonly used in
+   *     serial and EAS transmissions.
    *
-   * @public
+   * @private
    * @static
-   * @param {number} maxFileMegabytes 
+   * @param {string} str
+   * @returns {number[]}
    */
-  static garbageCollectionCache(maxFileMegabytes) {
-    try {
-      const settings2 = settings;
-      if (!settings2.NoaaWeatherWireService.cache.directory) return;
-      if (!packages.fs.existsSync(settings2.NoaaWeatherWireService.cache.directory)) return;
-      const maxBytes = maxFileMegabytes * 1024 * 1024;
-      const cacheDirectory = settings2.NoaaWeatherWireService.cache.directory;
-      const stackFiles = [cacheDirectory], files = [];
-      while (stackFiles.length) {
-        const currentDirectory = stackFiles.pop();
-        packages.fs.readdirSync(currentDirectory).forEach((file) => {
-          const fullPath = packages.path.join(currentDirectory, file);
-          const stat = packages.fs.statSync(fullPath);
-          if (stat.isDirectory()) stackFiles.push(fullPath);
-          else files.push({ file: fullPath, size: stat.size });
-        });
-      }
-      if (!files.length) return;
-      files.forEach((f) => {
-        if (f.size > maxBytes) packages.fs.unlinkSync(f.file);
-      });
-    } catch (error) {
-      cache.events.emit("onError", { code: "error-garbage-collection", message: `Failed to perform garbage collection: ${error.message}` });
+  static asciiTo8N1Bits(str) {
+    const bits = [];
+    for (let i = 0; i < str.length; i++) {
+      const c = str.charCodeAt(i) & 255;
+      bits.push(0);
+      for (let b = 0; b < 8; b++) bits.push(c >> b & 1);
+      bits.push(1, 1);
     }
+    return bits;
   }
   /**
-   * handleCronJob performs periodic tasks based on whether the client is connected to NWWS or fetching data from NWS.
+   * @function generateAFSK
+   * @description
+   *     Converts a sequence of bits into AFSK-modulated PCM16 audio data for EAS
+   *     alerts. Applies a fade-in and fade-out to reduce clicks and generates
+   *     the audio at the specified sample rate.
    *
-   * @public
+   * @private
    * @static
-   * @param {boolean} isNwws 
+   * @param {number[]} bits
+   * @param {number} [sampleRate=8000]
+   * @returns {Int16Array}
    */
-  static handleCronJob(isNwws) {
-    try {
-      const settings2 = settings;
-      if (isNwws) {
-        if (settings2.NoaaWeatherWireService.cache.read) void this.garbageCollectionCache(settings2.NoaaWeatherWireService.cache.maxSizeMB);
-        if (settings2.NoaaWeatherWireService.clientReconnections.canReconnect) void xmpp_default.isSessionReconnectionEligible(settings2.NoaaWeatherWireService.clientReconnections.currentInterval);
-      } else {
-        void this.loadGeoJsonData();
+  static generateAFSK(bits, sampleRate = 8e3) {
+    const baud = 520.83;
+    const markFreq = 2083.3;
+    const spaceFreq = 1562.5;
+    const amplitude = 0.6;
+    const twoPi = Math.PI * 2;
+    const result = [];
+    let phase = 0;
+    let frac = 0;
+    for (let b = 0; b < bits.length; b++) {
+      const bit = bits[b];
+      const freq = bit ? markFreq : spaceFreq;
+      const samplesPerBit = sampleRate / baud + frac;
+      const n = Math.round(samplesPerBit);
+      frac = samplesPerBit - n;
+      const inc = twoPi * freq / sampleRate;
+      for (let i = 0; i < n; i++) {
+        result.push(Math.round(Math.sin(phase) * amplitude * 32767));
+        phase += inc;
+        if (phase > twoPi) phase -= twoPi;
       }
-    } catch (error) {
-      cache.events.emit("onError", { code: "error-cron-job", message: `Failed to perform scheduled tasks: ${error.message}` });
     }
+    const fadeSamples = Math.floor(sampleRate * 2e-3);
+    for (let i = 0; i < fadeSamples; i++) {
+      const gain = i / fadeSamples;
+      result[i] = Math.round(result[i] * gain);
+      result[result.length - 1 - i] = Math.round(result[result.length - 1 - i] * gain);
+    }
+    return Int16Array.from(result);
   }
   /**
-   * mergeClientSettings merges user-provided settings into the existing client settings, allowing for nested objects to be merged correctly.
+   * @function generateSAMEHeader
+   * @description
+   *     Generates a SAME (Specific Area Message Encoding) audio header for
+   *     EAS alerts. Converts a VTEC string into AFSK-modulated PCM16 audio,
+   *     optionally repeating the signal with pre-mark and gap intervals.
    *
-   * @public
+   * @private
    * @static
-   * @param {Record<string, any>} target 
-   * @param {Record<string, any>} settings 
+   * @param {string} vtec
+   * @param {number} repeats
+   * @param {number} [sampleRate=8000]
+   * @param {{preMarkSec?: number, gapSec?: number}} [options={}]
+   * @returns {Int16Array}
    */
-  static mergeClientSettings(target, settings2) {
-    for (const key in settings2) {
-      if (settings2.hasOwnProperty(key)) {
-        if (typeof settings2[key] === "object" && settings2[key] !== null && !Array.isArray(settings2[key])) {
-          if (!target[key] || typeof target[key] !== "object") {
-            target[key] = {};
-          }
-          this.mergeClientSettings(target[key], settings2[key]);
-        } else {
-          target[key] = settings2[key];
-        }
+  static generateSAMEHeader(vtec, repeats, sampleRate = 8e3, options = {}) {
+    var _a, _b;
+    const preMarkSec = (_a = options.preMarkSec) != null ? _a : 0.3;
+    const gapSec = (_b = options.gapSec) != null ? _b : 0.1;
+    const bursts = [];
+    const gap = this.generateSilence(gapSec, sampleRate);
+    for (let i = 0; i < repeats; i++) {
+      const bodyBits = this.asciiTo8N1Bits(vtec);
+      const body = this.generateAFSK(bodyBits, sampleRate);
+      const extendedBodyDuration = Math.round(preMarkSec * sampleRate);
+      const extendedBody = new Int16Array(extendedBodyDuration + gap.length);
+      for (let j = 0; j < extendedBodyDuration; j++) {
+        extendedBody[j] = Math.round(body[j % body.length] * 0.2);
       }
+      extendedBody.set(gap, extendedBodyDuration);
+      bursts.push(extendedBody);
+      if (i !== repeats - 1) bursts.push(gap);
     }
+    return this.concatPCM16(bursts);
   }
 };
-var utils_default = Utils;
+var eas_default = EAS;
 
 // src/index.ts
 var AlertManager = class {
@@ -2892,63 +3442,103 @@ var AlertManager = class {
     this.start(metadata);
   }
   /**
-   * setDisplayName allows you to set or update the nickname of the client for identification purposes.
-   * This does require you to restart the XMPP client if you are using NoaaWeatherWireService for primary data.
-   * Changing this setting does not affect the username used for authentication.
-   * 
-   * @public
-   * @param {?string} [name] 
+   * @function setDisplayName
+   * @description
+   *     Sets the display nickname for the NWWS XMPP session. Trims the provided
+   *     name and validates it, emitting a warning if the name is empty or invalid.
+   *
+   * @param {string} [name]
    */
   setDisplayName(name) {
     const settings2 = settings;
     const trimmed = name == null ? void 0 : name.trim();
     if (!trimmed) {
-      cache.events.emit(`onError`, { code: `error-invalid-nickname`, message: definitions.messages.invalid_nickname });
+      utils_default.warn(definitions.messages.invalid_nickname);
       return;
     }
-    settings2.NoaaWeatherWireService.clientCredentials.nickname = trimmed;
+    settings2.noaa_weather_wire_service_settings.credentials.nickname = trimmed;
   }
   /**
-   * getAllAlertTypes provides a comprehensive list of all possible alert event and action combinations
+   * @function setCurrentLocation
+   * @description
+   *     Sets the current location with a name and geographic coordinates.
+   *     Validates the coordinates before updating the cache, emitting warnings
+   *     if values are missing or invalid.
    *
-   * @public
-   * @returns {{}} 
+   * @param {string} locationName
+   * @param {types.Coordinates} [coordinates]
    */
-  getAllAlertTypes() {
-    const events2 = /* @__PURE__ */ new Set();
-    const actions = /* @__PURE__ */ new Set();
-    const combinations = [];
-    Object.values(definitions.events).forEach((event) => events2.add(event));
-    Object.values(definitions.actions).forEach((action) => actions.add(action));
-    Array.from(events2).forEach((event) => {
-      Array.from(actions).forEach((action) => {
-        combinations.push(`${event} ${action}`);
-      });
+  setCurrentLocation(locationName, coordinates) {
+    if (!coordinates) {
+      utils_default.warn(`Coordinates not provided for location: ${locationName}`);
+      return;
+    }
+    const { lat, lon } = coordinates;
+    if (typeof lat !== "number" || typeof lon !== "number" || lat < -90 || lat > 90 || lon < -180 || lon > 180) {
+      utils_default.warn(definitions.messages.invalid_coordinates.replace("{lat}", String(lat)).replace("{lon}", String(lon)));
+      return;
+    }
+    cache.currentLocations[locationName] = coordinates;
+  }
+  /**
+   * @function createEasAudio
+   * @description
+   *     Generates an EAS (Emergency Alert System) audio file using the provided
+   *     description and header.
+   *
+   * @async
+   * @param {string} description
+   * @param {string} header
+   * @returns {Promise<Buffer>}
+   */
+  createEasAudio(description, header) {
+    return __async(this, null, function* () {
+      return yield eas_default.generateEASAudio(description, header);
     });
-    return combinations;
   }
   /**
-   * searchAlertDatbase allows you to search the internal alert database for previously received alerts up to 50,000 records.
+   * @function getAllAlertTypes
+   * @description
+   *     Generates a list of all possible alert types by combining defined
+   *     event names with action names.
+   *
+   * @returns {string[]}
+   */
+  getAllAlertTypes() {
+    const events2 = new Set(Object.values(definitions.events));
+    const actions = new Set(Object.values(definitions.actions));
+    return Array.from(events2).flatMap(
+      (event) => Array.from(actions).map((action) => `${event} ${action}`)
+    );
+  }
+  /**
+   * @function searchStanzaDatabase
+   * @description
+   *     Searches the stanza database for entries containing the specified query.
+   *     Escapes SQL wildcard characters and returns results in descending order
+   *     by ID, up to the specified limit.
    *
-   * @public
    * @async
-   * @param {string} query 
-   * @returns {unknown} 
+   * @param {string} query
+   * @param {number} [limit=250]
+   * @returns {Promise<any[]>}
    */
-  searchStanzaDatabase(query) {
+  searchStanzaDatabase(query, limit = 250) {
     return __async(this, null, function* () {
-      return yield cache.db.prepare(`SELECT * FROM stanzas WHERE stanza LIKE ? ORDER BY id DESC LIMIT 250`).all(`%${query}%`);
+      const escapeLike = (s) => s.replace(/[%_]/g, "\\$&");
+      const rows = yield cache.db.prepare(`SELECT * FROM stanzas WHERE stanza LIKE ? ESCAPE '\\' ORDER BY id DESC LIMIT ${limit}`).all(`%${escapeLike(query)}%`);
+      return rows;
     });
   }
   /**
-   * setSettings allow you to dynamically update the settings of the AlertManager instance. This doesn't
-   * require a refresh of the instance. However, if you are switching to NWWS->NWS or vice versa,
-   * you will need to call stop() and then start() for changes to take effect.
+   * @function setSettings
+   * @description
+   *     Merges the provided client settings into the current configuration,
+   *     preserving nested structures.
    *
-   * @public
    * @async
-   * @param {types.ClientSettings} settings 
-   * @returns {Promise<void>} 
+   * @param {types.ClientSettingsTypes} settings
+   * @returns {Promise<void>}
    */
   setSettings(settings2) {
     return __async(this, null, function* () {
@@ -2956,71 +3546,97 @@ var AlertManager = class {
     });
   }
   /**
-   * onEvent allows the client to listen for specific events emitted by the parser.
-   * Events include:
-   * - onAlerts: Emitted when a batch of new alerts have been fully parsed
-   * - onMessage: Emitted when a raw CAP/XML has been parsed by the StanzaParser
-   * - onError: Emitted when an error occurs within the parser
-   * - onConnection: Emitted when the XMPP client connects successfully
-   * - onReconnect: Emitted when the XMPP client is attempting to reconnect
-   * - onOccupant: Emitted when an occupant joins or leaves the XMPP MUC room (NWWS only)
-   * - onAnyEventType (Ex. onTornadoWarning) Emitted when a specific alert event type is received
-   * 
-   * @public
-   * @param {string} event 
-   * @param {(...args: any[]) => void} callback 
-   * @returns {() => void} 
+   * @function on
+   * @description
+   *     Registers a callback for a specific event and returns a function
+   *     to unregister the listener.
+   *
+   * @param {string} event
+   * @param {(...args: any[]) => void} callback
+   * @returns {() => void}
    */
-  onEvent(event, callback) {
+  on(event, callback) {
     cache.events.on(event, callback);
     return () => cache.events.off(event, callback);
   }
   /**
-   * start initializes the AlertManager instance, setting up necessary configurations and connections.
-   * This method must be called before the instance can begin processing alerts.
+   * @function start
+   * @description
+   *     Initializes the client with the provided settings, starts the NWWS XMPP
+   *     session if applicable, loads cached messages, and sets up scheduled
+   *     tasks (cron jobs) for ongoing processing.
    *
-   * @public
    * @async
-   * @param {Record<string, string>} [metadata={}] 
-   * @returns {Promise<void>} 
+   * @param {types.ClientSettingsTypes} metadata
+   * @returns {Promise<void>}
    */
   start(metadata) {
     return __async(this, null, function* () {
+      var _a, _b;
       if (!cache.isReady) {
-        console.log(definitions.messages.not_ready);
-        return Promise.resolve();
+        utils_default.warn(definitions.messages.not_ready);
+        return;
       }
       this.setSettings(metadata);
-      if (settings.catchUnhandledExceptions) {
-        utils_default.detectUncaughtExceptions();
-      }
       const settings2 = settings;
-      this.isNoaaWeatherWireService = settings.isNWWS;
+      this.isNoaaWeatherWireService = settings2.is_wire;
       cache.isReady = false;
+      while (!utils_default.isReadyToProcess((_b = (_a = settings2.global_settings.filtering.location) == null ? void 0 : _a.filter) != null ? _b : false)) {
+        yield utils_default.sleep(2e3);
+      }
       if (this.isNoaaWeatherWireService) {
-        yield database_default.loadDatabase();
-        yield xmpp_default.deploySession();
-        yield utils_default.loadCollectionCache();
+        try {
+          yield database_default.loadDatabase();
+          yield xmpp_default.deploySession();
+          yield utils_default.loadCollectionCache();
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          utils_default.warn(`Failed to initialize NWWS services: ${msg}`);
+        }
       }
       utils_default.handleCronJob(this.isNoaaWeatherWireService);
-      packages.cron.schedule(`*/${!this.isNoaaWeatherWireService ? settings2.NationalWeatherService.checkInterval : 5} * * * * *`, () => {
+      if (this.job) {
+        try {
+          this.job.stop();
+        } catch (e) {
+          utils_default.warn(`Failed to stop existing cron job.`);
+        }
+        this.job = null;
+      }
+      const interval = !this.isNoaaWeatherWireService ? settings2.national_weather_service_settings.interval : 5;
+      this.job = new packages.jobs.Cron(`*/${interval} * * * * *`, () => {
         utils_default.handleCronJob(this.isNoaaWeatherWireService);
       });
     });
   }
   /**
-   * stop terminates the AlertManager instance, closing any active connections and cleaning up resources.
+   * @function stop
+   * @description
+   *     Stops active scheduled tasks (cron job) and, if connected, the NWWS
+   *     XMPP session. Updates relevant cache flags to indicate the session
+   *     is no longer active.
    *
-   * @public
    * @async
-   * @returns {Promise<void>} 
+   * @returns {Promise<void>}
    */
   stop() {
     return __async(this, null, function* () {
       cache.isReady = true;
-      packages.cron.getTasks().forEach((task) => task.stop());
-      if (cache.session && this.isNoaaWeatherWireService) {
-        yield cache.session.stop();
+      if (this.job) {
+        try {
+          this.job.stop();
+        } catch (e) {
+          utils_default.warn(`Failed to stop cron job.`);
+        }
+        this.job = null;
+      }
+      const session = cache.session;
+      if (session && this.isNoaaWeatherWireService) {
+        try {
+          yield session.stop();
+        } catch (e) {
+          utils_default.warn(`Failed to stop XMPP session.`);
+        }
         cache.sigHalt = true;
         cache.isConnected = false;
         cache.session = null;
@@ -3039,6 +3655,6 @@ var index_default = AlertManager;
   StanzaParser,
   TextParser,
   UGCParser,
-  VtecParser,
-  types
+  Utils,
+  VtecParser
 });