@loadstrike/loadstrike-sdk 0.1.0

package/dist/cjs/correlation.js

@@ -0,0 +1,1009 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrossPlatformTrackingRuntime = exports.TrackingFieldSelector = exports.RedisCorrelationStore = exports.InMemoryCorrelationStore = exports.CorrelationStoreConfiguration = exports.RedisCorrelationStoreOptions = exports.TrackingPayloadBuilder = void 0;
+const node_crypto_1 = require("node:crypto");
+const redis_1 = require("redis");
+class TrackingPayloadBuilder {
+    constructor() {
+        this.Headers = {};
+        this.body = new Uint8Array();
+    }
+    get Body() {
+        return new Uint8Array(this.body);
+    }
+    setBody(body) {
+        this.body = normalizeTrackingBodyToBytes(body);
+    }
+    SetBody(body) {
+        this.setBody(body);
+    }
+    build() {
+        return createTrackingPayload({
+            headers: { ...this.Headers },
+            body: new Uint8Array(this.body),
+            contentType: this.ContentType,
+            messagePayloadType: this.MessagePayloadType,
+            jsonSettings: cloneRecord(this.JsonSettings),
+            jsonConvertSettings: cloneRecord(this.JsonConvertSettings)
+        });
+    }
+    Build() {
+        return this.build();
+    }
+}
+exports.TrackingPayloadBuilder = TrackingPayloadBuilder;
+class RedisCorrelationStoreOptions {
+    constructor() {
+        this.ConnectionString = "";
+        this.Database = -1;
+        this.KeyPrefix = "loadstrike";
+        this.EntryTtlSeconds = 60 * 60;
+    }
+    get EntryTtl() {
+        return this.EntryTtlSeconds;
+    }
+    set EntryTtl(value) {
+        this.EntryTtlSeconds = value;
+    }
+    validate() {
+        if (!this.ConnectionString.trim()) {
+            throw new Error("Redis ConnectionString must be provided.");
+        }
+        if (!this.KeyPrefix.trim()) {
+            throw new Error("Redis KeyPrefix must be provided.");
+        }
+        if (!Number.isFinite(this.EntryTtlSeconds) || this.EntryTtlSeconds <= 0) {
+            throw new RangeError("Redis EntryTtl must be greater than zero.");
+        }
+    }
+    Validate() {
+        this.validate();
+    }
+}
+exports.RedisCorrelationStoreOptions = RedisCorrelationStoreOptions;
+class CorrelationStoreConfiguration {
+    constructor() {
+        this.Kind = "InMemory";
+    }
+    static inMemory() {
+        return new CorrelationStoreConfiguration();
+    }
+    static InMemory() {
+        return CorrelationStoreConfiguration.inMemory();
+    }
+    static redisStore(options) {
+        if (!(options instanceof RedisCorrelationStoreOptions)) {
+            throw new TypeError("Redis correlation store options must be provided.");
+        }
+        const configuration = new CorrelationStoreConfiguration();
+        configuration.Kind = "Redis";
+        configuration.Redis = options;
+        return configuration;
+    }
+    static RedisStore(options) {
+        return CorrelationStoreConfiguration.redisStore(options);
+    }
+    validate() {
+        if (this.Kind === "Redis") {
+            if (!(this.Redis instanceof RedisCorrelationStoreOptions)) {
+                throw new Error("Redis options must be provided for Redis correlation store.");
+            }
+            this.Redis.validate();
+        }
+    }
+    Validate() {
+        this.validate();
+    }
+}
+exports.CorrelationStoreConfiguration = CorrelationStoreConfiguration;
+class InMemoryCorrelationStore {
+    constructor() {
+        this.pendingByTrackingId = new Map();
+        this.pendingByEventId = new Map();
+        this.sourceOccurrences = new Map();
+        this.destinationOccurrences = new Map();
+    }
+    set(entry) {
+        const normalized = normalizeCorrelationEntry(entry);
+        const queue = this.pendingByTrackingId.get(normalized.trackingId) ?? [];
+        queue.push(normalized);
+        this.pendingByTrackingId.set(normalized.trackingId, queue);
+        this.pendingByEventId.set(normalized.eventId ?? "", normalized);
+    }
+    get(trackingId) {
+        const queue = this.pendingByTrackingId.get(trackingId);
+        return queue && queue.length > 0 ? hydrateCorrelationEntry(queue[0]) : null;
+    }
+    delete(trackingId) {
+        const queue = this.pendingByTrackingId.get(trackingId);
+        if (!queue || queue.length === 0) {
+            return;
+        }
+        const removed = queue.shift();
+        if (removed?.eventId) {
+            this.pendingByEventId.delete(removed.eventId);
+        }
+        if (queue.length === 0) {
+            this.pendingByTrackingId.delete(trackingId);
+            return;
+        }
+        this.pendingByTrackingId.set(trackingId, queue);
+    }
+    all() {
+        const entries = [];
+        for (const queue of this.pendingByTrackingId.values()) {
+            for (const entry of queue) {
+                entries.push(hydrateCorrelationEntry(entry));
+            }
+        }
+        return entries;
+    }
+    collectExpired(nowMs = Date.now(), maxCount = 0) {
+        void nowMs;
+        void maxCount;
+        return [];
+    }
+    incrementSourceOccurrences(trackingId) {
+        const next = (this.sourceOccurrences.get(trackingId) ?? 0) + 1;
+        this.sourceOccurrences.set(trackingId, next);
+        return next;
+    }
+    incrementDestinationOccurrences(trackingId) {
+        const next = (this.destinationOccurrences.get(trackingId) ?? 0) + 1;
+        this.destinationOccurrences.set(trackingId, next);
+        return next;
+    }
+    registerSource(trackingId, sourceTimestampUtc) {
+        const entry = normalizeCorrelationEntry({
+            trackingId,
+            eventId: generateCorrelationEventId(trackingId, sourceTimestampUtc),
+            sourceTimestampUtc,
+            destinationTimestampUtc: null,
+            producedUtc: sourceTimestampUtc,
+            payload: createTrackingPayload({})
+        });
+        this.set(entry);
+        return entry;
+    }
+    tryMatchDestination(trackingId, destinationTimestampUtc) {
+        const source = this.get(trackingId);
+        if (!source) {
+            return null;
+        }
+        this.delete(trackingId);
+        return hydrateCorrelationEntry({
+            ...source,
+            destinationTimestampUtc
+        });
+    }
+    tryExpire(eventId) {
+        const entry = this.pendingByEventId.get(eventId);
+        if (!entry) {
+            return false;
+        }
+        this.pendingByEventId.delete(eventId);
+        const queue = this.pendingByTrackingId.get(entry.trackingId);
+        if (!queue) {
+            return true;
+        }
+        const next = queue.filter((value) => value.eventId !== eventId);
+        if (next.length === 0) {
+            this.pendingByTrackingId.delete(entry.trackingId);
+        }
+        else {
+            this.pendingByTrackingId.set(entry.trackingId, next);
+        }
+        return true;
+    }
+}
+exports.InMemoryCorrelationStore = InMemoryCorrelationStore;
+class RedisCorrelationStore {
+    constructor(client, prefix = "loadstrike", options = {}) {
+        this.fallback = new InMemoryCorrelationStore();
+        this.fallbackExpiry = new Map();
+        this.client = client ?? null;
+        this.prefix = prefix;
+        this.pendingIndexKey = `${this.prefix}:pending:index`;
+        this.entryTtlMs = Math.max(Math.trunc(options.entryTtlMs ?? 3600000), 0);
+        this.now = options.now ?? (() => Date.now());
+    }
+    static fromOptions(options, runNamespace) {
+        options.validate();
+        const prefix = `${options.KeyPrefix}:${runNamespace}`;
+        return new RedisCorrelationStore(createRedisStoreClient(options.ConnectionString, options.Database), prefix, {
+            entryTtlMs: Math.max(Math.trunc(options.EntryTtlSeconds * 1000), 1)
+        });
+    }
+    async set(entry) {
+        const normalized = normalizeCorrelationEntry(entry);
+        if (!this.client?.set || !this.client.get || !this.client.del) {
+            this.fallback.set(normalized);
+            this.trackFallbackExpiry(normalized);
+            return;
+        }
+        await this.writeEntry(normalized);
+        await this.enqueuePendingId(normalized.trackingId, normalized.eventId ?? "");
+        await this.appendPendingIndexId(normalized.eventId ?? "");
+    }
+    async get(trackingId) {
+        if (!this.client?.set || !this.client.get || !this.client.del) {
+            while (true) {
+                const entry = this.fallback.get(trackingId);
+                if (!entry) {
+                    return null;
+                }
+                if (!isEntryExpired(entry, this.fallbackExpiry.get(entry.eventId ?? ""), this.now())) {
+                    return entry;
+                }
+                if (entry.eventId) {
+                    this.fallback.tryExpire(entry.eventId);
+                    this.fallbackExpiry.delete(entry.eventId);
+                    continue;
+                }
+                this.fallback.delete(trackingId);
+            }
+        }
+        const queue = await this.readQueue(trackingId);
+        while (queue.length > 0) {
+            const eventId = queue[0];
+            const entry = await this.readEntry(eventId);
+            if (!entry) {
+                queue.shift();
+                await this.writeQueue(trackingId, queue);
+                await this.removePendingIndexId(eventId);
+                continue;
+            }
+            if (isEntryExpired(entry, entry.expiresUtc, this.now())) {
+                await this.tryExpire(eventId);
+                continue;
+            }
+            return hydrateCorrelationEntry(entry);
+        }
+        return null;
+    }
+    async delete(trackingId) {
+        if (!this.client?.set || !this.client.get || !this.client.del) {
+            const existing = this.fallback.get(trackingId);
+            this.fallback.delete(trackingId);
+            if (existing?.eventId) {
+                this.fallbackExpiry.delete(existing.eventId);
+            }
+            return;
+        }
+        const queue = await this.readQueue(trackingId);
+        const eventId = queue.shift();
+        if (!eventId) {
+            return;
+        }
+        await this.writeQueue(trackingId, queue);
+        await this.deleteEventKey(eventId);
+        await this.removePendingIndexId(eventId);
+    }
+    async all() {
+        if (!this.client?.set || !this.client.get || !this.client.del) {
+            await this.collectExpired(this.now());
+            return this.fallback.all();
+        }
+        const pendingIds = await this.readPendingIndexIds();
+        const entries = [];
+        const activeIds = [];
+        for (const eventId of pendingIds) {
+            const entry = await this.readEntry(eventId);
+            if (!entry) {
+                continue;
+            }
+            if (isEntryExpired(entry, entry.expiresUtc, this.now())) {
+                await this.tryExpire(eventId);
+                continue;
+            }
+            entries.push(hydrateCorrelationEntry(entry));
+            activeIds.push(eventId);
+        }
+        if (activeIds.length !== pendingIds.length) {
+            await this.writePendingIndexIds(activeIds);
+        }
+        return entries;
+    }
+    async collectExpired(nowMs = this.now(), maxCount = 0) {
+        const limit = maxCount > 0 ? Math.trunc(maxCount) : Number.POSITIVE_INFINITY;
+        const expired = [];
+        if (limit <= 0) {
+            return expired;
+        }
+        if (!this.client?.set || !this.client.get || !this.client.del) {
+            for (const entry of this.fallback.all()) {
+                if (expired.length >= limit) {
+                    break;
+                }
+                const expiresUtc = this.fallbackExpiry.get(entry.eventId ?? "");
+                if (!isEntryExpired(entry, expiresUtc, nowMs)) {
+                    continue;
+                }
+                if (entry.eventId && this.fallback.tryExpire(entry.eventId)) {
+                    this.fallbackExpiry.delete(entry.eventId);
+                    expired.push(entry);
+                }
+            }
+            return expired;
+        }
+        const pendingIds = await this.readPendingIndexIds();
+        const activeIds = [];
+        for (const eventId of pendingIds) {
+            if (expired.length >= limit) {
+                activeIds.push(eventId);
+                continue;
+            }
+            const entry = await this.readEntry(eventId);
+            if (!entry) {
+                continue;
+            }
+            if (!isEntryExpired(entry, entry.expiresUtc, nowMs)) {
+                activeIds.push(eventId);
+                continue;
+            }
+            const hydrated = hydrateCorrelationEntry(entry);
+            await this.tryExpire(eventId);
+            expired.push(hydrated);
+        }
+        if (activeIds.length !== pendingIds.length - expired.length) {
+            await this.writePendingIndexIds(activeIds);
+        }
+        return expired;
+    }
+    async incrementSourceOccurrences(trackingId) {
+        if (!this.client?.set || !this.client.get) {
+            return this.fallback.incrementSourceOccurrences(trackingId);
+        }
+        return this.incrementCounter(this.getSourceOccurrencesKey(trackingId));
+    }
+    async incrementDestinationOccurrences(trackingId) {
+        if (!this.client?.set || !this.client.get) {
+            return this.fallback.incrementDestinationOccurrences(trackingId);
+        }
+        return this.incrementCounter(this.getDestinationOccurrencesKey(trackingId));
+    }
+    async registerSource(trackingId, sourceTimestampUtc) {
+        const entry = normalizeCorrelationEntry({
+            trackingId,
+            eventId: generateCorrelationEventId(trackingId, sourceTimestampUtc),
+            sourceTimestampUtc,
+            destinationTimestampUtc: null,
+            producedUtc: sourceTimestampUtc,
+            payload: createTrackingPayload({})
+        });
+        await this.set(entry);
+        return entry;
+    }
+    async tryMatchDestination(trackingId, destinationTimestampUtc) {
+        if (!this.client?.set || !this.client.get || !this.client.del) {
+            const source = this.fallback.tryMatchDestination(trackingId, destinationTimestampUtc);
+            if (!source) {
+                return null;
+            }
+            if (source.eventId) {
+                this.fallbackExpiry.delete(source.eventId);
+            }
+            return hydrateCorrelationEntry(source);
+        }
+        const source = await this.get(trackingId);
+        if (!source) {
+            return null;
+        }
+        await this.delete(trackingId);
+        return hydrateCorrelationEntry({
+            ...source,
+            destinationTimestampUtc
+        });
+    }
+    async tryExpire(eventId) {
+        if (!this.client?.set || !this.client.get || !this.client.del) {
+            const expired = this.fallback.tryExpire(eventId);
+            if (expired) {
+                this.fallbackExpiry.delete(eventId);
+            }
+            return expired;
+        }
+        const entry = await this.readEntry(eventId);
+        if (!entry) {
+            return false;
+        }
+        await this.deleteEventKey(eventId);
+        await this.removePendingIndexId(eventId);
+        await this.removePendingQueueId(entry.trackingId, eventId);
+        return true;
+    }
+    async close() {
+        await this.client?.close?.();
+    }
+    trackFallbackExpiry(entry) {
+        if (!entry.eventId) {
+            return;
+        }
+        if (this.entryTtlMs > 0) {
+            this.fallbackExpiry.set(entry.eventId, this.now() + this.entryTtlMs);
+            return;
+        }
+        this.fallbackExpiry.delete(entry.eventId);
+    }
+    async incrementCounter(key) {
+        const raw = await this.client?.get?.(key);
+        const next = Number.parseInt(String(raw ?? "0"), 10) + 1;
+        await this.client?.set?.(key, String(next));
+        return next;
+    }
+    async readPendingIndexIds() {
+        const raw = await this.client?.get?.(this.pendingIndexKey);
+        if (!raw) {
+            return [];
+        }
+        return parseStringList(raw);
+    }
+    async writePendingIndexIds(ids) {
+        await this.client?.set?.(this.pendingIndexKey, JSON.stringify(uniqueStringList(ids)));
+    }
+    async appendPendingIndexId(eventId) {
+        const pending = await this.readPendingIndexIds();
+        pending.push(eventId);
+        await this.writePendingIndexIds(pending);
+    }
+    async removePendingIndexId(eventId) {
+        const pending = await this.readPendingIndexIds();
+        await this.writePendingIndexIds(pending.filter((value) => value !== eventId));
+    }
+    async readQueue(trackingId) {
+        const raw = await this.client?.get?.(this.getQueueKey(trackingId));
+        if (!raw) {
+            return [];
+        }
+        return parseStringList(raw);
+    }
+    async writeQueue(trackingId, ids) {
+        const queueKey = this.getQueueKey(trackingId);
+        if (ids.length === 0) {
+            await this.client?.del?.(queueKey);
+            return;
+        }
+        await this.client?.set?.(queueKey, JSON.stringify(ids));
+    }
+    async enqueuePendingId(trackingId, eventId) {
+        const queue = await this.readQueue(trackingId);
+        queue.push(eventId);
+        await this.writeQueue(trackingId, queue);
+    }
+    async removePendingQueueId(trackingId, eventId) {
+        const queue = await this.readQueue(trackingId);
+        await this.writeQueue(trackingId, queue.filter((value) => value !== eventId));
+    }
+    async readEntry(eventId) {
+        const raw = await this.client?.get?.(this.getEventKey(eventId));
+        if (!raw) {
+            return null;
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            return normalizeCorrelationEntry({
+                trackingId: String(parsed.trackingId ?? ""),
+                eventId: String(parsed.eventId ?? eventId),
+                sourceTimestampUtc: Number(parsed.sourceTimestampUtc ?? parsed.producedUtc ?? 0),
+                destinationTimestampUtc: parsed.destinationTimestampUtc == null ? null : Number(parsed.destinationTimestampUtc),
+                producedUtc: Number(parsed.producedUtc ?? parsed.sourceTimestampUtc ?? 0),
+                payload: parsed.payload ?? {}
+            }, parsed.expiresUtc);
+        }
+        catch {
+            return null;
+        }
+    }
+    async writeEntry(entry) {
+        await this.client?.set?.(this.getEventKey(entry.eventId ?? ""), JSON.stringify({
+            ...entry,
+            expiresUtc: this.entryTtlMs > 0 ? this.now() + this.entryTtlMs : null
+        }));
+    }
+    async deleteEventKey(eventId) {
+        await this.client?.del?.(this.getEventKey(eventId));
+    }
+    getQueueKey(trackingId) {
+        return `${this.prefix}:pending:queue:${encodeURIComponent(trackingId)}`;
+    }
+    getEventKey(eventId) {
+        return `${this.prefix}:pending:event:${eventId}`;
+    }
+    getSourceOccurrencesKey(trackingId) {
+        return `${this.prefix}:occ:src:${encodeURIComponent(trackingId)}`;
+    }
+    getDestinationOccurrencesKey(trackingId) {
+        return `${this.prefix}:occ:dst:${encodeURIComponent(trackingId)}`;
+    }
+}
+exports.RedisCorrelationStore = RedisCorrelationStore;
+class TrackingFieldSelector {
+    constructor(location, path) {
+        this.kind = normalizeTrackingFieldLocation(location);
+        this.path = String(path ?? "");
+    }
+    static parse(value) {
+        const normalized = (value ?? "").trim();
+        const [kindRaw, ...rest] = normalized.split(":");
+        const path = rest.join(":").trim();
+        if (!path) {
+            throw new Error("Tracking field expression is invalid. Use `header:<name>` or `json:$.<path>`.");
+        }
+        return new TrackingFieldSelector(kindRaw.trim(), path);
+    }
+    static Parse(value) {
+        return TrackingFieldSelector.parse(value);
+    }
+    static tryParse(value) {
+        try {
+            return {
+                success: true,
+                selector: TrackingFieldSelector.parse(value)
+            };
+        }
+        catch {
+            return {
+                success: false,
+                selector: null
+            };
+        }
+    }
+    static TryParse(value) {
+        return TrackingFieldSelector.tryParse(value);
+    }
+    get Location() {
+        return this.kind === "header" ? "Header" : "Json";
+    }
+    get Path() {
+        return this.path;
+    }
+    extract(payload) {
+        if (this.kind === "header") {
+            const headerName = this.path.toLowerCase();
+            const headers = payload.headers ?? {};
+            for (const [key, value] of Object.entries(headers)) {
+                const parsed = String(value ?? "").trim();
+                if (key.toLowerCase() === headerName && parsed) {
+                    return parsed;
+                }
+            }
+            return null;
+        }
+        const body = normalizeJsonBody(payload.body);
+        if (!body) {
+            return null;
+        }
+        const jsonPath = this.path.startsWith("$.") ? this.path.slice(2) : this.path;
+        const segments = jsonPath.split(".").filter(Boolean);
+        let current = body;
+        for (const segment of segments) {
+            current = readJsonPathSegment(current, segment);
+            if (current === undefined) {
+                return null;
+            }
+        }
+        if (current == null) {
+            return null;
+        }
+        return String(current);
+    }
+    toString() {
+        return `${this.kind}:${this.path}`;
+    }
+    ToString() {
+        return this.toString();
+    }
+}
+exports.TrackingFieldSelector = TrackingFieldSelector;
+function normalizeTrackingFieldLocation(location) {
+    const normalized = String(location ?? "").trim().toLowerCase();
+    if (normalized === "header" || normalized === "json") {
+        return normalized;
+    }
+    throw new Error("Tracking field location must be Header or Json.");
+}
+class CrossPlatformTrackingRuntime {
+    constructor(options) {
+        this.producedCount = 0;
+        this.consumedCount = 0;
+        this.matchedCount = 0;
+        this.timeoutCount = 0;
+        this.duplicateSourceCount = 0;
+        this.duplicateDestinationCount = 0;
+        this.totalLatencyMs = 0;
+        this.gathered = new Map();
+        this.sourceSelector = TrackingFieldSelector.parse(options.sourceTrackingField);
+        this.destinationSelector = TrackingFieldSelector.parse(options.destinationTrackingField ?? options.sourceTrackingField);
+        this.gatherSelector = options.destinationGatherByField
+            ? TrackingFieldSelector.parse(options.destinationGatherByField)
+            : null;
+        this.timeoutMs = Math.max(options.correlationTimeoutMs ?? 30000, 1);
+        this.timeoutCountsAsFailure = options.timeoutCountsAsFailure ?? true;
+        this.store = options.store ?? new InMemoryCorrelationStore();
+        this.plugins = options.plugins ?? [];
+    }
+    async onSourceProduced(payload, nowMs = Date.now()) {
+        const result = await this.onSourceProducedDetailed(payload, nowMs);
+        return result.trackingId || null;
+    }
+    async onSourceProducedDetailed(payload, nowMs = Date.now()) {
+        const result = {
+            trackingId: "",
+            eventId: "",
+            sourceTimestampUtc: nowMs,
+            duplicateSource: false
+        };
+        this.producedCount += 1;
+        const trackingId = this.sourceSelector.extract(payload);
+        if (!trackingId) {
+            return result;
+        }
+        result.trackingId = trackingId;
+        const sourceOccurrences = await this.store.incrementSourceOccurrences(trackingId);
+        if (sourceOccurrences > 1) {
+            this.duplicateSourceCount += 1;
+            result.duplicateSource = true;
+        }
+        const registration = await this.store.registerSource(trackingId, nowMs);
+        result.eventId = registration.eventId ?? "";
+        if (registration.eventId) {
+            await this.store.tryExpire(registration.eventId);
+        }
+        await this.store.set({
+            ...registration,
+            payload,
+            producedUtc: registration.producedUtc ?? nowMs,
+            sourceTimestampUtc: registration.sourceTimestampUtc ?? nowMs,
+            destinationTimestampUtc: null
+        });
+        for (const plugin of this.plugins) {
+            if (plugin.onProduced) {
+                await plugin.onProduced(trackingId, payload);
+            }
+        }
+        return result;
+    }
+    async onDestinationConsumed(payload, nowMs = Date.now()) {
+        const result = await this.onDestinationConsumedDetailed(payload, nowMs);
+        return result.matched;
+    }
+    async onDestinationConsumedDetailed(payload, nowMs = Date.now()) {
+        const result = {
+            trackingId: "",
+            eventId: "",
+            sourceTimestampUtc: 0,
+            destinationTimestampUtc: 0,
+            gatherKey: "__ungrouped__",
+            matched: false,
+            duplicateDestination: false,
+            latencyMs: 0,
+            message: ""
+        };
+        this.consumedCount += 1;
+        const trackingId = this.destinationSelector.extract(payload);
+        if (!trackingId) {
+            result.message = "Destination payload did not include a tracking id.";
+            return result;
+        }
+        result.trackingId = trackingId;
+        const destinationOccurrences = await this.store.incrementDestinationOccurrences(trackingId);
+        if (destinationOccurrences > 1) {
+            this.duplicateDestinationCount += 1;
+            result.duplicateDestination = true;
+        }
+        const source = await this.store.tryMatchDestination(trackingId, nowMs);
+        if (!source) {
+            result.message = "Destination tracking id had no source match.";
+            return result;
+        }
+        this.matchedCount += 1;
+        const latencyMs = Math.max(nowMs - (source.producedUtc ?? source.sourceTimestampUtc ?? nowMs), 0);
+        this.totalLatencyMs += latencyMs;
+        const gatherKey = this.resolveGatherKey(payload);
+        result.eventId = source.eventId ?? "";
+        result.sourceTimestampUtc = source.sourceTimestampUtc ?? source.producedUtc ?? 0;
+        result.destinationTimestampUtc = nowMs;
+        result.gatherKey = gatherKey;
+        result.matched = true;
+        result.latencyMs = latencyMs;
+        const row = this.gathered.get(gatherKey) ?? { total: 0, matched: 0, timedOut: 0 };
+        row.total += 1;
+        row.matched += 1;
+        this.gathered.set(gatherKey, row);
+        for (const plugin of this.plugins) {
+            if (plugin.onMatched) {
+                await plugin.onMatched(trackingId, source.payload, payload, latencyMs);
+            }
+        }
+        return result;
+    }
+    async sweepTimeouts(nowMs = Date.now(), batchSize) {
+        return (await this.sweepTimeoutEntries(nowMs, batchSize)).length;
+    }
+    async sweepTimeoutEntries(nowMs = Date.now(), batchSize) {
+        const maxBatch = Number.isFinite(batchSize ?? Number.NaN) && (batchSize ?? 0) > 0
+            ? Math.trunc(batchSize ?? 0)
+            : Number.POSITIVE_INFINITY;
+        const expiredEntries = [];
+        const seen = new Set();
+        const collected = await this.store.collectExpired(nowMs, Number.isFinite(maxBatch) ? maxBatch : 0);
+        for (const entry of collected) {
+            if (expiredEntries.length >= maxBatch) {
+                break;
+            }
+            const dedupeKey = entry.eventId?.trim() || `${entry.trackingId}:${entry.sourceTimestampUtc ?? entry.producedUtc}`;
+            if (!dedupeKey || seen.has(dedupeKey)) {
+                continue;
+            }
+            seen.add(dedupeKey);
+            expiredEntries.push(entry);
+        }
+        const entries = await this.store.all();
+        for (const entry of entries) {
+            if (expiredEntries.length >= maxBatch) {
+                break;
+            }
+            if (nowMs - entry.producedUtc < this.timeoutMs) {
+                continue;
+            }
+            if (entry.eventId && !(await this.store.tryExpire(entry.eventId))) {
+                await this.store.delete(entry.trackingId);
+            }
+            else if (!entry.eventId) {
+                await this.store.delete(entry.trackingId);
+            }
+            const dedupeKey = entry.eventId?.trim() || `${entry.trackingId}:${entry.sourceTimestampUtc ?? entry.producedUtc}`;
+            if (!dedupeKey || seen.has(dedupeKey)) {
+                continue;
+            }
+            seen.add(dedupeKey);
+            expiredEntries.push(entry);
+        }
+        for (const entry of expiredEntries) {
+            this.timeoutCount += 1;
+            const gatherKey = this.resolveGatherKey(entry.payload);
+            const row = this.gathered.get(gatherKey) ?? { total: 0, matched: 0, timedOut: 0 };
+            row.total += 1;
+            row.timedOut += 1;
+            this.gathered.set(gatherKey, row);
+            for (const plugin of this.plugins) {
+                if (plugin.onTimeout) {
+                    await plugin.onTimeout(entry.trackingId, entry.payload);
+                }
+            }
+        }
+        return expiredEntries;
+    }
+    async getStats() {
+        const inflight = (await this.store.all()).length;
+        return {
+            producedCount: this.producedCount,
+            consumedCount: this.consumedCount,
+            matchedCount: this.matchedCount,
+            timeoutCount: this.timeoutCount,
+            duplicateSourceCount: this.duplicateSourceCount,
+            duplicateDestinationCount: this.duplicateDestinationCount,
+            inflightCount: inflight,
+            averageLatencyMs: this.matchedCount > 0 ? this.totalLatencyMs / this.matchedCount : 0,
+            gathered: Object.fromEntries(this.gathered.entries())
+        };
+    }
+    resolveGatherKey(payload) {
+        if (!this.gatherSelector) {
+            return "__ungrouped__";
+        }
+        return this.gatherSelector.extract(payload) || "__unknown__";
+    }
+    isTimeoutCountedAsFailure() {
+        return this.timeoutCountsAsFailure;
+    }
+}
+exports.CrossPlatformTrackingRuntime = CrossPlatformTrackingRuntime;
+function normalizeJsonBody(body) {
+    if (body instanceof Uint8Array) {
+        return normalizeJsonBody(trackingBodyToUtf8(body));
+    }
+    if (body && typeof body === "object" && !Array.isArray(body)) {
+        return body;
+    }
+    if (typeof body !== "string" || !body.trim()) {
+        return null;
+    }
+    const direct = tryParseObject(body);
+    if (direct) {
+        return direct;
+    }
+    const relaxed = sanitizeLooseJson(body);
+    return tryParseObject(relaxed);
+}
+function normalizeTrackingBodyToBytes(body) {
+    return typeof body === "string"
+        ? new TextEncoder().encode(body)
+        : new Uint8Array(body);
+}
+function trackingBodyToUtf8(body) {
+    if (body instanceof Uint8Array) {
+        return new TextDecoder().decode(body);
+    }
+    if (typeof body === "string") {
+        return body;
+    }
+    if (body == null) {
+        return "";
+    }
+    try {
+        return JSON.stringify(body);
+    }
+    catch {
+        return String(body);
+    }
+}
+function createTrackingPayload(payload) {
+    return {
+        headers: { ...(payload.headers ?? {}) },
+        body: cloneTrackingBody(payload.body),
+        producedUtc: payload.producedUtc,
+        contentType: payload.contentType,
+        messagePayloadType: payload.messagePayloadType,
+        jsonSettings: cloneRecord(payload.jsonSettings),
+        jsonConvertSettings: cloneRecord(payload.jsonConvertSettings),
+        getBodyAsUtf8: () => trackingBodyToUtf8(payload.body)
+    };
+}
+function cloneTrackingBody(value) {
+    if (value instanceof Uint8Array) {
+        return new Uint8Array(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => cloneTrackingBody(entry));
+    }
+    if (value && typeof value === "object") {
+        return { ...value };
+    }
+    return value;
+}
+function cloneRecord(value) {
+    return value ? { ...value } : undefined;
+}
+function generateCorrelationEventId(trackingId, sourceTimestampUtc) {
+    return `${trackingId}:${sourceTimestampUtc}:${(0, node_crypto_1.randomUUID)()}`;
+}
+function normalizeCorrelationEntry(entry, expiresUtc) {
+    const trackingId = String(entry.trackingId ?? "").trim();
+    const producedUtc = Number(entry.producedUtc ?? entry.sourceTimestampUtc ?? 0);
+    const sourceTimestampUtc = Number(entry.sourceTimestampUtc ?? producedUtc);
+    const eventId = String(entry.eventId ?? generateCorrelationEventId(trackingId, sourceTimestampUtc));
+    return {
+        trackingId,
+        eventId,
+        sourceTimestampUtc,
+        destinationTimestampUtc: entry.destinationTimestampUtc == null ? null : Number(entry.destinationTimestampUtc),
+        producedUtc,
+        payload: createTrackingPayload(entry.payload ?? {}),
+        expiresUtc
+    };
+}
+function hydrateCorrelationEntry(entry) {
+    return {
+        trackingId: entry.trackingId,
+        eventId: entry.eventId,
+        sourceTimestampUtc: entry.sourceTimestampUtc,
+        destinationTimestampUtc: entry.destinationTimestampUtc ?? null,
+        producedUtc: entry.producedUtc,
+        payload: createTrackingPayload(entry.payload ?? {})
+    };
+}
+function isEntryExpired(entry, expiresUtc, nowMs) {
+    void entry;
+    return typeof expiresUtc === "number"
+        ? nowMs >= expiresUtc
+        : false;
+}
+function parseStringList(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed)) {
+            return [];
+        }
+        return parsed
+            .map((value) => String(value ?? "").trim())
+            .filter((value) => value.length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+function uniqueStringList(values) {
+    return [...new Set(values.filter((value) => value.trim().length > 0))];
+}
+function createRedisStoreClient(connectionString, database) {
+    const client = (0, redis_1.createClient)({
+        url: connectionString,
+        database: database >= 0 ? database : undefined
+    });
+    let connectPromise = null;
+    const ensureConnected = async () => {
+        if (client.isOpen) {
+            return client;
+        }
+        if (!connectPromise) {
+            connectPromise = client.connect().then(() => client);
+        }
+        return connectPromise;
+    };
+    return {
+        set: async (key, value) => {
+            const connected = await ensureConnected();
+            return connected.set(key, value);
+        },
+        get: async (key) => {
+            const connected = await ensureConnected();
+            return connected.get(key);
+        },
+        del: async (key) => {
+            const connected = await ensureConnected();
+            return connected.del(key);
+        },
+        keys: async (pattern) => {
+            const connected = await ensureConnected();
+            return connected.keys(pattern);
+        },
+        close: async () => {
+            if (client.isOpen) {
+                await client.quit();
+            }
+        }
+    };
+}
+function tryParseObject(value) {
+    try {
+        const parsed = JSON.parse(value);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+function sanitizeLooseJson(value) {
+    let normalized = value.trim();
+    // Accept commonly seen non-strict payloads from external systems.
+    normalized = normalized.replace(/,\s*([}\]])/g, "$1");
+    normalized = normalized.replace(/'([^']*)'/g, (_match, group) => `"${group.replace(/"/g, '\\"')}"`);
+    return normalized;
+}
+function readJsonPathSegment(current, segment) {
+    if (current == null) {
+        return undefined;
+    }
+    const token = segment.trim();
+    const indexed = token.match(/^([^\[\]]+)\[(\d+)\]$/);
+    if (indexed) {
+        const field = indexed[1];
+        const index = Number(indexed[2]);
+        if (!Number.isFinite(index)) {
+            return undefined;
+        }
+        if (!(current && typeof current === "object" && !Array.isArray(current))) {
+            return undefined;
+        }
+        const row = current[field];
+        if (!Array.isArray(row) || index < 0 || index >= row.length) {
+            return undefined;
+        }
+        return row[index];
+    }
+    if (Array.isArray(current)) {
+        const arrayIndex = Number(token);
+        if (!Number.isInteger(arrayIndex) || arrayIndex < 0 || arrayIndex >= current.length) {
+            return undefined;
+        }
+        return current[arrayIndex];
+    }
+    if (typeof current === "object") {
+        return current[token];
+    }
+    return undefined;
+}