@atmosx/event-product-parser 3.0.48 → 3.0.51

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atmosx/event-product-parser",
-	"version": "3.0.48",
+	"version": "3.0.51",
 	"description": "NOAA Weather Wire & NWS API Parser - Built for standalone and Project AtmosphericX Integration.",
 	"main": "dist/cjs/index.cjs",
 	"module": "dist/esm/index.mjs",
@@ -12,7 +12,6 @@
 	"scripts": {
 		"start": "cd ./test && node ./index.js",
 		"build": "tsup && cd ./test && node ./index.js",
-		"heap-memory-errors": "node --heap-prof --heap-prof-name=heap-profile-%p.heapsnapshot ./test/index.js",
 		"publish": "tsup && npm publish --access public",
 		"publish-beta-branch": "tsup && npm publish --tag v3-beta-branch --access public"
 	},
@@ -39,6 +38,7 @@
 		"express": "5.2.1",
 		"express-ws": "5.0.2",
 		"jszip": "3.10.1",
+		"p-queue": "^9.3.0",
 		"polygon-clipping": "0.15.7",
 		"say": "0.16.0",
 		"shapefile": "0.6.6",

package/src/@building/building.attachments.ts

@@ -17,11 +17,11 @@
 
 */
 
-import { bootstrap } from "../bootstrap"
 import { TypeEvent } from "../@types/type.event"
-import { getLatestIssuance } from "../@modules/@utilities/utilities.getLatestIssuance";
+import { bootstrap } from "../bootstrap"
 import { dict_states } from "../@dictionaries/dictionaries.states"
 import { dict_expressions } from "../@dictionaries/dictionaries.expressions"
+import { getLatestIssuance } from "../@modules/@utilities/utilities.getLatestIssuance";
 
 interface GetEventAttachmentsResponse { 
     name: string
@@ -43,9 +43,9 @@ export const getEventAttachments = (event: TypeEvent): GetEventAttachmentsRespon
     const watchNumber = event?.properties?.watch_parameters?.watch_number;
     const locations = event?.properties?.locations_array;
     const events = [
-        { target: "Day 1", attachment: `https://www.spc.noaa.gov/products/outlook/day1otlk_${issuanceTime}.png` },
-        { target: "Day 2", attachment: `https://www.spc.noaa.gov/products/outlook/day2otlk.png` },
-        { target: "Day 3", attachment: `https://www.spc.noaa.gov/products/outlook/day3otlk.png` },
+        { target: "SPC Day 1 Outlook", attachment: `https://www.spc.noaa.gov/products/outlook/day1otlk_${issuanceTime}.png` },
+        { target: "SPC Day 2 Outlook", attachment: `https://www.spc.noaa.gov/products/outlook/day2otlk.png` },
+        { target: "SPC Day 3 Outlook", attachment: `https://www.spc.noaa.gov/products/outlook/day3otlk.png` },
         { target: "Mesoscale Discussion", attachment: `https://www.spc.noaa.gov/products/md/mcd${spcNumber}.png` },
         { target: "Tornado Watch", attachment: `https://www.spc.noaa.gov/products/watch/ww${watchNumber}_radar_big.gif` },
         { target: "PDS Tornado Watch", attachment: `https://www.spc.noaa.gov/products/watch/ww${watchNumber}_radar_big.gif` },

package/src/@building/building.create.ts

@@ -24,8 +24,9 @@ import { text } from "../@events/events.text"
 import { ugc } from "../@events/events.ugc"
 import { vtec } from "../@events/events.vtec"
 import { api } from "../@events/events.api"
+import { validateEvents } from "./building.validate"
 
-export const createEvent = async (stanza: TypeStanzaCompiled): Promise<void | string> => {
+export const createEvent = async (stanza: TypeStanzaCompiled, ignorePushing?: boolean): Promise<void | string> => {
     const settings = bootstrap.settings as TypeSettings
     const StanzaSettings = settings.NOAAWeatherWireServiceSettings.StanzaSettings;
 
@@ -34,9 +35,22 @@ export const createEvent = async (stanza: TypeStanzaCompiled): Promise<void | st
     const isTextEvent = (!stanza.isVTEC && !stanza.isUGC)
     const isNWWS = (stanza.isNWWS)
 
-    if (!isNWWS) return await api(stanza)
-    if (!StanzaSettings.DisableVTEC && isVtecEvent) return await vtec(stanza)
-    if (!StanzaSettings.DisableUGC && isUgcEvent) return await ugc(stanza);
-    if (!StanzaSettings.DisableText && isTextEvent) return await text(stanza);
+    switch (true) {
+        case (!isNWWS):
+            await api(stanza)
+            break;
+        case (isNWWS && !StanzaSettings.DisableVTEC && isVtecEvent):
+            await vtec(stanza)
+            break;
+        case (isNWWS && !StanzaSettings.DisableUGC && isUgcEvent):
+            await ugc(stanza)
+            break;
+        case (isNWWS && !StanzaSettings.DisableText && isTextEvent):
+            await text(stanza)
+            break;
+    }
+    if (!ignorePushing) {
+        validateEvents(bootstrap.cache.processed)
+    }
     return 'nothing picked';
 }

package/src/@building/building.enhance.ts

@@ -19,8 +19,8 @@
 
 import { TypeEvent } from "../@types/type.event";
 import { TypeSettings } from "../@types/type.settings";
-import { bootstrap } from "../bootstrap"
 import { dict_enhanced } from "../@dictionaries/dictionaries.enhanced"
+import { bootstrap } from "../bootstrap"
 
 export const getEventEnhancedName = (event: TypeEvent): string => {
     const configurations = bootstrap.settings as TypeSettings

package/src/@building/building.geometry.ts

@@ -17,9 +17,9 @@
 
 */
 
-import { getSettings } from "../@modules/@utilities/utilities.getSettings";
 import { TypeSettings } from "../@types/type.settings"
 import { TypeEvent } from "../@types/type.event"
+import { getSettings } from "../@modules/@utilities/utilities.getSettings";
 import { getZonePolygon } from "../@parsers/@ugc/ugc.coordinates";
 
 interface GetGeometryResponse { 

package/src/@building/building.polygon.ts

@@ -17,10 +17,9 @@
 
 */
 
-
 import { TypeEvent } from "../@types/type.event"
-import { getEventGeometry } from "./building.geometry"
 import { bootstrap } from "../bootstrap"
+import { getEventGeometry } from "./building.geometry"
 import { getShapeNearestPoint } from "../@modules/@utilities/utilities.getShapeNearestPoint"
 
 interface GetEventNodesResponse { 

package/src/@building/building.signature.ts

@@ -24,7 +24,6 @@ import { dict_testing} from "../@dictionaries/dictionaries.testing"
 import { dict_products } from "../@dictionaries/dictionaries.products";
 import { dict_hail } from "../@dictionaries/dictionaries.hail"
 
-
 export const getEventSignature = (event: TypeEvent): TypeEvent => {
     const properties = event?.properties;
     const vtec = event?.properties?.metadata?.vtec

package/src/@building/building.tracking.ts

@@ -57,12 +57,12 @@ export const getEventTracking = (options: GetTrackingOptions): string => {
             return `${splitPVTEC[2]}.${splitPVTEC[3]}.${splitPVTEC[4]}.${splitPVTEC[5]}`;
         }
         const wmoMatch = options.organization?.wmoidentifier?.match(/([A-Z]{4}\d{2})\s+([A-Z]{4})/);
-        const station = wmoMatch?.[2] ?? 'N/A';
+        const station = wmoMatch?.[2] ?? '---';
         if (options.organization.featureId) {
             const idMatch = options.organization.featureId.match(/([a-f0-9]+)\.(\d+)\.(\d+)$/);
-            return `${station}.${idMatch?.[0]?.replace(/\./g, '') ?? 'N/A'}`;
+            return `${station}.${idMatch?.[0]?.replace(/\./g, '') ?? '---'}`;
         }
-        const id = wmoMatch?.[1] ?? 'N/A';
-        return `${station}.${id?.replace(/\./g, '') ?? 'N/A'}`;
+        const id = wmoMatch?.[1] ?? '---';
+        return `${station}.${id?.replace(/\./g, '') ?? '---'}`;
     }
 }

package/src/@building/building.validate.ts

@@ -17,7 +17,6 @@
 
 */
 
-import { createHash } from "crypto"
 import { TypeEvent } from "../@types/type.event";
 import { TypeSettings } from "../@types/type.settings";
 import { bootstrap } from "../bootstrap"
@@ -29,9 +28,13 @@ import { getEventGeometry } from "./building.geometry";
 import { getEventAttachments } from "./building.attachments";
 import { updateNode } from "../@manager/manager.updateNodes";
 import { setEventEmit } from "../@modules/@utilities/utilities.setEventEmit";
+import { setDebug } from "../@modules/@utilities/utilities.setDebug";
+import { getMatched } from "../@modules/@utilities/utilities.getMatched";
+import { createHash } from "crypto"
 
 export const validateEvents = async (events: TypeEvent[]): Promise<void> => {
-    if (events.length === 0) return;
+    const tick = performance.now();
+    if (events.length === 0) return
     const configurations = bootstrap.settings as TypeSettings
     const sets = {} as Record<string, Set<string>>;
     const bools = {} as Record<string, boolean>;
@@ -42,6 +45,7 @@ export const validateEvents = async (events: TypeEvent[]): Promise<void> => {
         if (typeof setting === 'boolean') { bools[key] = setting; }
     }
     const filterd = events.filter((event: TypeEvent) => {
+        bootstrap.cache.processed = bootstrap.cache.processed.filter((e) => e !== event);
         const define = getEventSignature(event) as TypeEvent;
         const properties = define.properties;
         const zones = properties.geocode.ugc;
@@ -51,11 +55,11 @@ export const validateEvents = async (events: TypeEvent[]): Promise<void> => {
         if (filteredProperties?.metadata && 'ms' in filteredProperties.metadata) {
             delete filteredProperties.metadata.ms;
         }
+        
         filteredProperties.metadata = filteredProperties.metadata ?? {} as any;
         properties.metadata.hash = createHash("sha256").update(JSON.stringify(filteredProperties)).digest("hex")  
         properties.metadata.attachments = getEventAttachments(event)
         setEventEmit({ event: `onProductType${enhancedEventName.replace(/\s+/g, '')}`, metadata: define });
-        
         if (properties.status_metadata.is_test) { 
             setEventEmit({ event: `onTestProduct`, metadata: define })
             if (bools?.IgnoreTestProducts) return false; 
@@ -80,14 +84,15 @@ export const validateEvents = async (events: TypeEvent[]): Promise<void> => {
 
         for (const key in sets) {
             const setting = sets[key]
-            if (key === 'ListeningEvents' && setting.size > 0 && !setting.has(define.properties.event.toLowerCase())) { 
+            const values = [...setting];
+            if (key === 'ListeningEvents' && setting.size > 0 && !getMatched(values, define.properties.event)) {
                 setEventEmit({
                     event: `onFilteredEvent`,
                     metadata: define
                 }); 
                 return false 
             } 
-            if (key === 'IgnoredEvents' && setting.size > 0 && setting.has(define.properties.event.toLowerCase())) { 
+            if (key === 'IgnoredEvents' && setting.size > 0 && getMatched(values, define.properties.event)) {
                 setEventEmit({
                     event: `onIgnoredEvent`,
                     metadata: define
@@ -126,7 +131,6 @@ export const validateEvents = async (events: TypeEvent[]): Promise<void> => {
         return true;
     })
 
-    
     if (!configurations?.GlobalSettings?.DisableGeometryParsing) {
         for (const event of filterd) {
             event.geometry = await getEventGeometry(event)
@@ -144,4 +148,5 @@ export const validateEvents = async (events: TypeEvent[]): Promise<void> => {
         metadata: bootstrap.cache.events,
         limited: true
     })
+    setDebug({ title: `@building.validate`, message: `Filtered ${filterd.length} events which took ${performance.now() - tick} ms` })
 }

package/src/@core/core.clearEvents.ts

@@ -20,7 +20,6 @@
 import { bootstrap } from "../bootstrap";
 import { setEventEmit } from "../@modules/@utilities/utilities.setEventEmit";
 
-
 export const clearEvents = (): void => {
     bootstrap.cache.events.features = [];
     bootstrap.cache.hashes = [];

package/src/@core/core.createEvent.ts

@@ -18,7 +18,6 @@
 */
 
 import { validateEvents } from "../@building/building.validate";
-import { dict_correlations } from "../@dictionaries/dictionaries.correlations";
 
 interface CreateEventOptions { 
     event: string

package/src/@core/core.getEvents.ts

@@ -19,7 +19,6 @@
 
 import { bootstrap } from "../bootstrap";
 
-
 export const getEvents = (): any => {
     return bootstrap.cache.events
 }

package/src/@core/core.getNodes.ts

@@ -19,7 +19,6 @@
 
 import { bootstrap } from "../bootstrap";
 
-
 export const getNodes = (): any => {
     return bootstrap.cache.nodes
 }

package/src/@core/core.getRandomEvent.ts

@@ -19,7 +19,6 @@
 
 import { bootstrap } from "../bootstrap";
 
-
 export const getRandomEvent = (): any => {
     return bootstrap.cache.events.features[Math.floor(Math.random() * bootstrap.cache.events.features.length)]
 }

package/src/@core/core.getVersion.ts

@@ -19,7 +19,6 @@
 
 import { bootstrap } from "../bootstrap";
 
-
 export const getVersion = (): any => {
     return bootstrap.version
 }

package/src/@dictionaries/dictionaries.awips.ts

@@ -296,9 +296,9 @@ export const dict_awips: Record<string, string> = {
     SVR: `severe-thunderstorm-warning`,
     SVS: `severe-weather-statement`,
     SWOMCD: `mesoscale-discussion`,
-    SWODY1: `day-1`,
-    SWODY2: `day-2`,
-    SWODY3: `day-3`,
+    SWODY1: `spc-day-1-outlook`,
+    SWODY2: `spc-day-2-outlook`,
+    SWODY3: `spc-day-3-outlook`,
     SWS: `state-weather-summary`,
     SYN: `regional-weather-synopsis`,
     TAF: `terminal-aerodrome-forecast`,

package/src/@events/events.api.ts

@@ -18,23 +18,21 @@
 */
 
 import { TypeStanzaCompiled } from "../@types/type.compiled"
-import { TypeEvent } from "../@types/type.event";
+import { TypePVTEC } from "../@types/type.pvtec";
+import { dict_icao } from "../@dictionaries/dictionaries.icao";
+import { bootstrap } from "../bootstrap";
 import { getEventTracking } from "../@building/building.tracking";
-import { validateEvents } from "../@building/building.validate";
 import { pvExtract } from "../@parsers/@pvtec/pvtec.extract"
 import { getEventTags } from "../@building/building.tags";
 import { getTextFromProduct } from "../@parsers/@text/text.getTextFromProduct";
-import { dict_icao } from "../@dictionaries/dictionaries.icao";
-import { TypePVTEC } from "../@types/type.pvtec";
-
+import { setDebug } from "../@modules/@utilities/utilities.setDebug";
 
 export const api = async (stanza: TypeStanzaCompiled): Promise<void> => {
-    let processed: TypeEvent[] = [];
-    const messages =  Object.values(JSON.parse(stanza.message).features) as any;
+    const messages = Object.values(JSON.parse(stanza.message).features) as any;
     for (const feature of messages) {
         const tick = performance.now();
         const pVtec = pvExtract(feature?.properties?.parameters?.VTEC?.[0]) ?? null as TypePVTEC[]
-        processed.push({
+        bootstrap.cache.processed.push({
             type: `Feature`,
             geometry: {
                 type: `Point`,
@@ -114,6 +112,6 @@ export const api = async (stanza: TypeStanzaCompiled): Promise<void> => {
                 }
             }
         })
+        setDebug({ title: `@events.api`, message: `Event process took ${performance.now() - tick} ms` })
     }
-    validateEvents(processed)
 }

package/src/@events/events.text.ts

@@ -19,15 +19,14 @@
 
 import { TypeAttributes } from "../@types/type.attributes";
 import { TypeStanzaCompiled } from "../@types/type.compiled"
-import { TypeEvent } from "../@types/type.event";
+import { dict_matches } from "../@dictionaries/dictionaries.matches";
+import { bootstrap } from "../bootstrap";
 import { properties } from "../@building/building.properties";
 import { getEventHeader } from "../@building/building.headers";
-import { dict_matches } from "../@dictionaries/dictionaries.matches";
 import { getEventTracking } from "../@building/building.tracking";
-import { validateEvents } from "../@building/building.validate";
+import { setDebug } from "../@modules/@utilities/utilities.setDebug";
 
 export const text = async (stanza: TypeStanzaCompiled): Promise<void> => {
-    let processed: TypeEvent[] = [];
     const getMessages = stanza?.message
         ?.split(/(?=\$\$)/g)
         ?.map(message => message.trim())
@@ -46,7 +45,7 @@ export const text = async (stanza: TypeStanzaCompiled): Promise<void> => {
             event = stanza.getType.type.split(`-`).map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(` `)
             isStatement = true;
         }
-        processed.push({
+        bootstrap.cache.processed.push({
             type: `Feature`,
             geometry: {
                 type: `Point`,
@@ -77,6 +76,6 @@ export const text = async (stanza: TypeStanzaCompiled): Promise<void> => {
                 }
             }
         })  
+        setDebug({ title: `@events.text`, message: `Event process took ${performance.now() - tick} ms` })
     }
-    validateEvents(processed)
 }

package/src/@events/events.ugc.ts

@@ -19,16 +19,15 @@
 
 import { TypeAttributes } from "../@types/type.attributes";
 import { TypeStanzaCompiled } from "../@types/type.compiled"
-import { TypeEvent } from "../@types/type.event";
 import { dict_matches } from "../@dictionaries/dictionaries.matches";
+import { bootstrap } from "../bootstrap";
 import { ugcExtract } from "../@parsers/@ugc/ugc.extract";
 import { properties } from "../@building/building.properties";
 import { getEventHeader } from "../@building/building.headers";
 import { getEventTracking } from "../@building/building.tracking";
-import { validateEvents } from "../@building/building.validate";
+import { setDebug } from "../@modules/@utilities/utilities.setDebug";
 
 export const ugc = async (stanza: TypeStanzaCompiled): Promise<void> => {
-    let processed: TypeEvent[] = [];
     const getMessages = stanza?.message
         ?.split(/(?=\$\$)/g)
         ?.map(message => message.trim())
@@ -38,6 +37,7 @@ export const ugc = async (stanza: TypeStanzaCompiled): Promise<void> => {
         const tick = performance.now();
         const attributes = stanza?.attributes as TypeAttributes
         const ugc = await ugcExtract(message)
+
         if (ugc != null ) {
             const props = properties({ message, attributes, ugc: ugc })
             const issued = new Date(attributes.issue)
@@ -49,7 +49,7 @@ export const ugc = async (stanza: TypeStanzaCompiled): Promise<void> => {
                 event = stanza.getType.type.split(`-`).map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(` `)
                 isStatement = true;
             }
-            processed.push({
+            bootstrap.cache.processed.push({
                 type: `Feature`,
                 geometry: {
                     type: `Point`,
@@ -80,7 +80,7 @@ export const ugc = async (stanza: TypeStanzaCompiled): Promise<void> => {
                     }
                 }
             })
+            setDebug({ title: `@events.ugc`, message: `Event process took ${performance.now() - tick} ms` })
         }
     }
-    validateEvents(processed)
 }

package/src/@events/events.vtec.ts

@@ -19,19 +19,18 @@
 
 import { TypeAttributes } from "../@types/type.attributes";
 import { TypeStanzaCompiled } from "../@types/type.compiled"
-import { TypeEvent } from "../@types/type.event";
 import { TypePVTEC } from "../@types/type.pvtec";
 import { TypeHVTEC } from "../@types/type.hvtec";
+import { bootstrap } from "../bootstrap";
 import { pvExtract } from "../@parsers/@pvtec/pvtec.extract";
 import { hvExtract } from "../@parsers/@hvtec/hvtec.extract";
 import { ugcExtract } from "../@parsers/@ugc/ugc.extract";
 import { properties } from "../@building/building.properties";
 import { getEventHeader } from "../@building/building.headers";
 import { getEventTracking } from "../@building/building.tracking";
-import { validateEvents } from "../@building/building.validate";
+import { setDebug } from "../@modules/@utilities/utilities.setDebug";
 
 export const vtec = async (stanza: TypeStanzaCompiled): Promise<void> => {
-    let processed: TypeEvent[] = [];
     const getMessages = stanza?.message
         ?.split(/(?=\$\$)/g)
         ?.map(message => message.trim())
@@ -50,7 +49,7 @@ export const vtec = async (stanza: TypeStanzaCompiled): Promise<void> => {
                 const header = getEventHeader({properties: props, getType: stanza.getType, vtec: vtec})
                 const issued = new Date(attributes.issue)?? new Date()
                 const expires = new Date(vtec.expires)
-                processed.push({
+                bootstrap.cache.processed.push({
                     type: `Feature`,
                     geometry: {
                         type: `Point`,
@@ -81,8 +80,8 @@ export const vtec = async (stanza: TypeStanzaCompiled): Promise<void> => {
                         }
                     }
                 })
+                setDebug({ title: `@events.vtec`, message: `Event process took ${performance.now() - tick} ms` })
             }
         }
     }
-    validateEvents(processed)
 }

package/src/@manager/manager.mkEvent.ts

@@ -17,13 +17,14 @@
 
 */
 
-import { setEventEmit } from "../@modules/@utilities/utilities.setEventEmit";
 import { TypeEvent } from "../@types/type.event";
+import { TypeSettings } from "../@types/type.settings";
 import { bootstrap } from "../bootstrap"
 import { setHash } from "./manager.setHash";
 import { updateListener } from "./manager.updateListener";
 import { updateNode } from "./manager.updateNodes";
-import { TypeSettings } from "../@types/type.settings";
+import { setEventEmit } from "../@modules/@utilities/utilities.setEventEmit";
+import { setTimeoutAction } from "../@modules/@utilities/utilities.setTimeoutAction";
 
 export const mkEvent = async (event: TypeEvent): Promise<void> => {
     const settings = bootstrap.settings as TypeSettings;
@@ -40,14 +41,18 @@ export const mkEvent = async (event: TypeEvent): Promise<void> => {
     const isFilteredLocation = await updateNode(event).then(() => event.properties.metadata.filtered_proximity);
     if (!isFilteredLocation && settings.GlobalSettings.EventFiltering.NodeLocationFiltering) { return }
 
-    setEventEmit({
-        event: `onEventStatus`,
-        metadata: {
-            type: getFeature ? `Updated` : `New`,
-            event: event
-        },
-        message: `[${getFeature ? 'Updated' : 'New'}] ${event.properties.event} (${event.properties.status}) (${event.properties.metadata.tracking})`
-    })
+    const isRatelimited = setTimeoutAction({ identifier: getTracking, interval: 1, max: 1, addTime: true })
+    if (!isRatelimited.limited) {
+        setEventEmit({
+            event: `onEventStatus`,
+            metadata: {
+                type: getFeature ? `Updated` : `New`,
+                event: event
+            },
+            message: `[${getFeature ? 'Updated' : 'New'}] ${event.properties.event} (${event.properties.status}) (${event.properties.metadata.tracking})`
+        })
+    }
+
     if (settings.GlobalSettings.EventManagement) {
         if (event.properties.status_metadata.is_issued || event.properties.status_metadata.is_updated) {
             if (getFeature) { 
@@ -79,10 +84,10 @@ export const mkEvent = async (event: TypeEvent): Promise<void> => {
                         },
                     }
                 };
-                updateListener(bootstrap.cache.events.features[getIndex])
+                await updateListener(bootstrap.cache.events.features[getIndex])
             } else { 
                 features.push(event)
-                updateListener(event)
+                await updateListener(event)
             }
         }
     }

package/src/@manager/manager.rmEvent.ts

@@ -17,12 +17,13 @@
 
 */
 
-import { setEventEmit } from "../@modules/@utilities/utilities.setEventEmit";
 import { TypeEvent } from "../@types/type.event";
 import { bootstrap } from "../bootstrap"
+import { setEventEmit } from "../@modules/@utilities/utilities.setEventEmit";
+import { setTimeoutAction } from "../@modules/@utilities/utilities.setTimeoutAction";
 import { updateListener } from "./manager.updateListener";
 
-export const rmEvent = (event: TypeEvent): void => {
+export const rmEvent = async (event: TypeEvent): Promise<void> => {
     const getEvent = bootstrap.cache.events.features.find(f => f?.properties?.metadata?.tracking === event?.properties?.metadata?.tracking);
     const cachedStatus = event.properties.status;
     event.properties.expires = new Date().toISOString();
@@ -38,9 +39,10 @@ export const rmEvent = (event: TypeEvent): void => {
             message: `[Removed] ${event.properties.event} (${event.properties.status}) (${event.properties.metadata.tracking})`
         })
         setEventEmit({ event: `onExpiredProduct`, metadata: event })
-        if (cachedStatus != `Statement`) updateListener(event)
+        if (cachedStatus != `Statement`) await updateListener(event)
         bootstrap.cache.events.features.splice(bootstrap.cache.events.features.indexOf(getEvent), 1);
         bootstrap.cache.hashes = bootstrap.cache.hashes.filter(hash => hash.tracking !== event.properties.metadata.tracking);
+        setTimeoutAction({ identifier: event.properties.metadata.tracking, expire: true })
     }
     setEventEmit({
         event: `onEventCache`,

package/src/@manager/manager.setHash.ts

@@ -21,7 +21,6 @@ import { TypeEvent } from "../@types/type.event";
 import { TypeHash } from "../@types/type.hash"
 import { bootstrap } from "../bootstrap"
 
-
 export const setHash = (event: TypeEvent, entry: TypeHash): void => {
     if (entry) {
         entry.hashes.push(event.properties.metadata.hash);

package/src/@manager/manager.updateEvents.ts

@@ -17,17 +17,15 @@
 
 */
 
-import { getFormattedTime } from "../@modules/@utilities/utilities.getFormattedTime";
 import { TypeEvent } from "../@types/type.event";
 import { bootstrap } from "../bootstrap"
 import { rmEvent } from "./manager.rmEvent";
 
-
 export const updateEvents = async (selectedEvent?: TypeEvent): Promise<void> => {
     const events = bootstrap.cache.events.features;
     async function update(evt: TypeEvent) {
         if (new Date(evt.properties.expires) < new Date()) {
-            rmEvent(evt);
+            await rmEvent(evt);
         }
     }
     if (!selectedEvent) { await Promise.all(events.map(async (evt) => { await update(evt) })) }