@wildix/xbees-conversations-utils 2.0.1 → 4.0.2

package/dist-es/streamRateLimitHandlingProxy/generatedMethodNames.js

@@ -0,0 +1,317 @@
+export const STREAM_METHOD_NAMES = [
+    '_addChannelConfig',
+    '_buildWSPayload',
+    '_callClientListeners',
+    '_createImport',
+    '_createImportURL',
+    '_deleteUserMessageReference',
+    '_enrichAxiosOptions',
+    '_getConnectionID',
+    '_getImport',
+    '_getToken',
+    '_handleClientEvent',
+    '_handleUserEvent',
+    '_hasConnectionID',
+    '_isUsingServerAuth',
+    '_listImports',
+    '_logApiError',
+    '_logApiRequest',
+    '_logApiResponse',
+    '_muteStatus',
+    '_normalizeDate',
+    '_normalizeExpiration',
+    '_queryFlagReports',
+    '_queryFlags',
+    '_reviewFlagReport',
+    '_sayHi',
+    '_setToken',
+    '_setupConnection',
+    '_setUser',
+    '_startCleaning',
+    '_unblockMessage',
+    '_updateMemberWatcherReferences',
+    '_updateUserMessageReferences',
+    '_updateUserReferences',
+    '_validateAndGetMessageId',
+    'addDevice',
+    'banUser',
+    'channel',
+    'closeConnection',
+    'commitMessage',
+    'connect',
+    'connectAnonymousUser',
+    'connectUser',
+    'createAbortControllerForNextRequest',
+    'createBlockList',
+    'createCampaign',
+    'createChannelType',
+    'createCommand',
+    'createPermission',
+    'createRole',
+    'createSegment',
+    'createToken',
+    'deactivateUser',
+    'deactivateUsers',
+    'delete',
+    'deleteBlockList',
+    'deleteCampaign',
+    'deleteChannels',
+    'deleteChannelType',
+    'deleteCommand',
+    'deleteMessage',
+    'deletePermission',
+    'deletePushProvider',
+    'deleteRole',
+    'deleteSegment',
+    'deleteUser',
+    'deleteUsers',
+    'devToken',
+    'disconnect',
+    'disconnectUser',
+    'dispatchEvent',
+    'doAxiosRequest',
+    'enrichURL',
+    'errorFromResponse',
+    'exportChannel',
+    'exportChannels',
+    'exportUser',
+    'exportUsers',
+    'flagMessage',
+    'flagUser',
+    'get',
+    'getAppSettings',
+    'getAuthType',
+    'getBlockList',
+    'getCallToken',
+    'getChannelById',
+    'getChannelByMembers',
+    'getChannelType',
+    'getCommand',
+    'getDevices',
+    'getExportChannelStatus',
+    'getMessage',
+    'getPermission',
+    'getRateLimits',
+    'getTask',
+    'getUnreadCount',
+    'getUserAgent',
+    'handleEvent',
+    'handleResponse',
+    'hydrateActiveChannels',
+    'listBlockLists',
+    'listChannelTypes',
+    'listCommands',
+    'listPermissions',
+    'listPushProviders',
+    'listRoles',
+    'markAllRead',
+    'markChannelsRead',
+    'muteUser',
+    'off',
+    'on',
+    'openConnection',
+    'partialUpdateMessage',
+    'partialUpdateUser',
+    'partialUpdateUsers',
+    'patch',
+    'pinMessage',
+    'post',
+    'put',
+    'queryBannedUsers',
+    'queryCampaigns',
+    'queryChannels',
+    'queryMessageFlags',
+    'queryRecipients',
+    'querySegments',
+    'queryUsers',
+    'reactivateUser',
+    'reactivateUsers',
+    'recoverState',
+    'removeDevice',
+    'removeShadowBan',
+    'restoreUsers',
+    'resumeCampaign',
+    'revokeTokens',
+    'revokeUsersToken',
+    'revokeUserToken',
+    'scheduleCampaign',
+    'search',
+    'sendFile',
+    'sendUserCustomEvent',
+    'setAnonymousUser',
+    'setBaseURL',
+    'setGuestUser',
+    'setLocalDevice',
+    'setUser',
+    'setUserAgent',
+    'shadowBan',
+    'stopCampaign',
+    'sync',
+    'testCampaign',
+    'testPushSettings',
+    'testSQSSettings',
+    'translateMessage',
+    'unbanUser',
+    'unblockMessage',
+    'unflagMessage',
+    'unflagUser',
+    'unmuteUser',
+    'unpinMessage',
+    'updateAppSettings',
+    'updateBlockList',
+    'updateCampaign',
+    'updateChannelType',
+    'updateCommand',
+    'updateMessage',
+    'updatePermission',
+    'updateSegment',
+    'updateUser',
+    'updateUsers',
+    'upsertPushProvider',
+    'upsertUser',
+    'upsertUsers',
+    'userMuteStatus',
+    'verifyWebhook',
+];
+export const STREAM_SYNC_METHOD_NAMES = [
+    '_addChannelConfig',
+    '_buildWSPayload',
+    '_callClientListeners',
+    '_deleteUserMessageReference',
+    '_enrichAxiosOptions',
+    '_getConnectionID',
+    '_getToken',
+    '_handleClientEvent',
+    '_handleUserEvent',
+    '_hasConnectionID',
+    '_isUsingServerAuth',
+    '_logApiError',
+    '_logApiRequest',
+    '_logApiResponse',
+    '_muteStatus',
+    '_normalizeDate',
+    '_normalizeExpiration',
+    '_sayHi',
+    '_setUser',
+    '_startCleaning',
+    '_updateMemberWatcherReferences',
+    '_updateUserMessageReferences',
+    '_updateUserReferences',
+    '_validateAndGetMessageId',
+    'createAbortControllerForNextRequest',
+    'createToken',
+    'devToken',
+    'dispatchEvent',
+    'errorFromResponse',
+    'getAuthType',
+    'getUserAgent',
+    'handleEvent',
+    'handleResponse',
+    'off',
+    'on',
+    'setBaseURL',
+    'setLocalDevice',
+    'setUserAgent',
+    'userMuteStatus',
+    'verifyWebhook',
+];
+export const STREAM_CHANNEL_RESULT_METHOD_NAMES = [
+    'channel',
+    'getChannelById',
+    'getChannelByMembers',
+    'hydrateActiveChannels',
+    'queryChannels',
+];
+export const STREAM_SYNC_CHANNEL_RESULT_METHOD_NAMES = [
+    'channel',
+    'getChannelById',
+    'getChannelByMembers',
+    'hydrateActiveChannels',
+];
+export const CHANNEL_METHOD_NAMES = [
+    '_callChannelListeners',
+    '_channelURL',
+    '_checkInitialized',
+    '_countMessageAsUnread',
+    '_disconnect',
+    '_extendEventWithOwnReactions',
+    '_handleChannelEvent',
+    '_initializeState',
+    '_update',
+    'acceptInvite',
+    'addMembers',
+    'addModerators',
+    'assignRoles',
+    'banUser',
+    'clean',
+    'countUnread',
+    'countUnreadMentions',
+    'create',
+    'createCall',
+    'delete',
+    'deleteFile',
+    'deleteImage',
+    'deleteReaction',
+    'demoteModerators',
+    'disableSlowMode',
+    'enableSlowMode',
+    'getClient',
+    'getConfig',
+    'getMessagesById',
+    'getPinnedMessages',
+    'getReactions',
+    'getReplies',
+    'hide',
+    'inviteMembers',
+    'keystroke',
+    'lastMessage',
+    'lastRead',
+    'markRead',
+    'markUnread',
+    'mute',
+    'muteStatus',
+    'off',
+    'on',
+    'query',
+    'queryMembers',
+    'rejectInvite',
+    'removeMembers',
+    'removeShadowBan',
+    'search',
+    'sendAction',
+    'sendEvent',
+    'sendFile',
+    'sendImage',
+    'sendMessage',
+    'sendReaction',
+    'shadowBan',
+    'show',
+    'stopTyping',
+    'stopWatching',
+    'truncate',
+    'unbanUser',
+    'unmute',
+    'update',
+    'updatePartial',
+    'watch',
+];
+export const CHANNEL_SYNC_METHOD_NAMES = [
+    '_callChannelListeners',
+    '_channelURL',
+    '_checkInitialized',
+    '_countMessageAsUnread',
+    '_disconnect',
+    '_extendEventWithOwnReactions',
+    '_handleChannelEvent',
+    '_initializeState',
+    'clean',
+    'countUnread',
+    'countUnreadMentions',
+    'getConfig',
+    'lastMessage',
+    'lastRead',
+    'muteStatus',
+    'off',
+    'on',
+];
+export const CHANNEL_SYNC_PROXY_RESULT_METHOD_NAMES = ['getClient'];

package/dist-es/streamRateLimitHandlingProxy/helpers/RedisCooldown.js

@@ -0,0 +1,170 @@
+import { STREAM_RATE_LIMIT_COOLDOWN_KEY_PREFIX } from '../constants';
+export class RedisCooldown {
+    static resolveRedisKey(cooldownKey, options) {
+        const keyPrefix = options?.keyPrefix ?? STREAM_RATE_LIMIT_COOLDOWN_KEY_PREFIX;
+        return `${keyPrefix}${cooldownKey}`;
+    }
+    static async getRemainingMs(cooldownKey, context, options) {
+        const { redis, logger } = context;
+        try {
+            const ttlMs = await redis.pttl(RedisCooldown.resolveRedisKey(cooldownKey, options));
+            if (ttlMs > 0) {
+                return ttlMs;
+            }
+        }
+        catch (error) {
+            logger.warn('Failed to read stream rate-limit cooldown from Redis', {
+                cooldownKey,
+                error,
+            });
+        }
+        return 0;
+    }
+    static async setRemainingMs(cooldownKey, cooldownMs, context, options) {
+        if (cooldownMs <= 0) {
+            return;
+        }
+        const { redis, logger } = context;
+        const redisKey = RedisCooldown.resolveRedisKey(cooldownKey, options);
+        try {
+            await redis.eval(`
+        local key = KEYS[1]
+        local new_ttl = tonumber(ARGV[1])
+        local current_ttl = redis.call('PTTL', key)
+
+        if current_ttl == -2 then
+          redis.call('SET', key, '1', 'PX', new_ttl)
+          return 1
+        end
+
+        if current_ttl == -1 or current_ttl < new_ttl then
+          redis.call('PEXPIRE', key, new_ttl)
+          return 2
+        end
+
+        return 0
+      `, 1, redisKey, cooldownMs.toString());
+        }
+        catch (error) {
+            logger.warn('Failed to write stream rate-limit cooldown to Redis', {
+                cooldownKey,
+                cooldownMs,
+                error,
+            });
+        }
+    }
+    static async setRemainingMsExact(cooldownKey, cooldownMs, context, options) {
+        if (cooldownMs <= 0) {
+            return;
+        }
+        const { redis, logger } = context;
+        try {
+            await redis.set(RedisCooldown.resolveRedisKey(cooldownKey, options), '1', 'PX', cooldownMs);
+        }
+        catch (error) {
+            logger.warn('Failed to write exact stream rate-limit cooldown to Redis', {
+                cooldownKey,
+                cooldownMs,
+                error,
+            });
+        }
+    }
+    static async getValue(cooldownKey, context, options) {
+        const { redis, logger } = context;
+        try {
+            const value = await redis.get(RedisCooldown.resolveRedisKey(cooldownKey, options));
+            if (typeof value === 'string' && value.length > 0) {
+                return value;
+            }
+        }
+        catch (error) {
+            logger.warn('Failed to read stream rate-limit metadata from Redis', {
+                cooldownKey,
+                error,
+            });
+        }
+    }
+    static async setValueWithRemainingMs(cooldownKey, value, cooldownMs, context, options) {
+        if (value.length === 0 || cooldownMs <= 0) {
+            return;
+        }
+        const { redis, logger } = context;
+        try {
+            await redis.eval(`
+        local key = KEYS[1]
+        local value = ARGV[1]
+        local new_ttl = tonumber(ARGV[2])
+        local current_ttl = redis.call('PTTL', key)
+
+        if current_ttl == -2 then
+          redis.call('SET', key, value, 'PX', new_ttl)
+          return 1
+        end
+
+        if current_ttl == -1 or current_ttl < new_ttl then
+          redis.call('SET', key, value, 'PX', new_ttl)
+          return 2
+        end
+
+        redis.call('SET', key, value, 'KEEPTTL')
+        return 0
+      `, 1, RedisCooldown.resolveRedisKey(cooldownKey, options), value, cooldownMs.toString());
+        }
+        catch (error) {
+            logger.warn('Failed to write stream rate-limit metadata to Redis', {
+                cooldownKey,
+                cooldownMs,
+                error,
+            });
+        }
+    }
+    static async setRemainingMsWithValue(cooldownKey, valueKey, value, cooldownMs, context, options) {
+        if (value.length === 0 || cooldownMs <= 0) {
+            return;
+        }
+        const { redis, logger } = context;
+        const cooldownRedisKey = RedisCooldown.resolveRedisKey(cooldownKey, options);
+        const valueRedisKey = RedisCooldown.resolveRedisKey(valueKey, options);
+        try {
+            await redis.eval(`
+        local cooldown_key = KEYS[1]
+        local value_key = KEYS[2]
+        local value = ARGV[1]
+        local new_ttl = tonumber(ARGV[2])
+        local current_ttl = redis.call('PTTL', cooldown_key)
+        local final_ttl = new_ttl
+
+        if current_ttl == -2 then
+          redis.call('SET', cooldown_key, '1', 'PX', new_ttl)
+        elseif current_ttl == -1 or current_ttl < new_ttl then
+          redis.call('PEXPIRE', cooldown_key, new_ttl)
+        else
+          final_ttl = current_ttl
+        end
+
+        redis.call('SET', value_key, value, 'PX', final_ttl)
+        return final_ttl
+      `, 2, cooldownRedisKey, valueRedisKey, value, cooldownMs.toString());
+        }
+        catch (error) {
+            logger.warn('Failed to write stream rate-limit cooldown and metadata to Redis', {
+                cooldownKey,
+                valueKey,
+                cooldownMs,
+                error,
+            });
+        }
+    }
+    static async clear(cooldownKey, context, options) {
+        const { redis, logger } = context;
+        try {
+            await redis.del(RedisCooldown.resolveRedisKey(cooldownKey, options));
+        }
+        catch (error) {
+            logger.warn('Failed to clear stream rate-limit cooldown from Redis', {
+                cooldownKey,
+                error,
+            });
+        }
+    }
+}

package/dist-es/streamRateLimitHandlingProxy/helpers/createRateLimitExceededException.js

@@ -0,0 +1,25 @@
+import { RateLimitExceededException } from '@wildix/xbees-conversations-client';
+import { DEFAULT_RETRY_AFTER_MS } from '../constants';
+const RETRY_AFTER_HEADER_PADDING_MS = 3000;
+function toPositiveMilliseconds(milliseconds) {
+    return Math.max(0, Math.ceil(milliseconds));
+}
+function toEpochSecondsFromNow(delayMs) {
+    return Math.ceil((Date.now() + toPositiveMilliseconds(delayMs)) / 1000);
+}
+export function createRateLimitExceededException(options = {}) {
+    const { rateLimit, message, operation, retryAfterMs = DEFAULT_RETRY_AFTER_MS } = options;
+    const defaultMessage = operation ? `Rate limit exceeded for ${operation}` : 'Rate limit exceeded';
+    const retryAfterFromResetMs = rateLimit?.reset != null ? rateLimit.reset - Date.now() : undefined;
+    const effectiveRetryAfterMs = retryAfterFromResetMs ?? retryAfterMs;
+    const retryAfterMilliseconds = toPositiveMilliseconds(effectiveRetryAfterMs);
+    const retryAfterEpochSeconds = toEpochSecondsFromNow(effectiveRetryAfterMs + RETRY_AFTER_HEADER_PADDING_MS);
+    return new RateLimitExceededException({
+        $metadata: {},
+        message: message || defaultMessage,
+        rateLimitRemaining: rateLimit?.remaining || 0,
+        retryAfter: retryAfterEpochSeconds,
+        rateLimit: rateLimit?.limit?.toString() || 'unknown',
+        rateLimitReset: retryAfterMilliseconds,
+    });
+}

package/dist-es/streamRateLimitHandlingProxy/helpers/executeWithRateLimitHandling.js

@@ -0,0 +1,148 @@
+import { BUDGET_COOLDOWN_SLEEP_CHUNK_MS, BUDGET_DELAY_MAX_MS, DEFAULT_JITTER_MS, DEFAULT_RETRY_AFTER_MS, RETRY_AFTER_BUFFER_MS, STREAM_BUDGET_COOLDOWN_KEY, STREAM_BUDGET_COOLDOWN_KEY_PREFIX, STREAM_RATE_LIMIT_COOLDOWN_KEY_PREFIX, STREAM_RATE_LIMIT_METADATA_KEY_SUFFIX, STREAM_RATE_LIMIT_SOFT_COOLDOWN_KEY, } from '../constants';
+import { createRateLimitExceededException } from './createRateLimitExceededException';
+import { processStreamRateLimitException } from './processStreamRateLimitException';
+import { parseRateLimitSnapshot, serializeRateLimitSnapshot } from './rateLimitSnapshot';
+import { RedisCooldown } from './RedisCooldown';
+import sleep from './sleep';
+function calculateRateLimitDelayMs(error, maxDelayMs) {
+    const retryAfterMs = typeof error.rateLimitReset === 'number' && error.rateLimitReset > 0 ? error.rateLimitReset : 0;
+    const hasServerRetryAfter = retryAfterMs > 0;
+    const baseDelayMs = hasServerRetryAfter ? retryAfterMs + RETRY_AFTER_BUFFER_MS : DEFAULT_RETRY_AFTER_MS;
+    const jitterMs = Math.floor(Math.random() * DEFAULT_JITTER_MS);
+    const computedDelayMs = baseDelayMs + jitterMs;
+    if (hasServerRetryAfter) {
+        return computedDelayMs;
+    }
+    return Math.min(maxDelayMs, computedDelayMs);
+}
+function getRateLimitMetadataKey(operation) {
+    return `${operation}${STREAM_RATE_LIMIT_METADATA_KEY_SUFFIX}`;
+}
+function toCooldownRateLimit(snapshot, cooldownMs) {
+    return {
+        limit: snapshot.limit,
+        remaining: snapshot.remaining,
+        reset: Math.max(snapshot.reset, Date.now() + cooldownMs),
+    };
+}
+function toRateLimitSnapshot(error) {
+    const limit = Number(error.rateLimit);
+    const remaining = error.rateLimitRemaining;
+    const resetMs = error.rateLimitReset;
+    if (!Number.isFinite(limit) ||
+        typeof remaining !== 'number' ||
+        !Number.isFinite(remaining) ||
+        typeof resetMs !== 'number' ||
+        !Number.isFinite(resetMs) ||
+        resetMs <= 0) {
+        return;
+    }
+    return {
+        limit,
+        remaining,
+        reset: Date.now() + resetMs,
+    };
+}
+async function throwIfOperationCooldownActive(operation, context) {
+    const { logger, redis } = context;
+    const cooldownMs = await RedisCooldown.getRemainingMs(operation, { redis, logger });
+    if (cooldownMs <= 0) {
+        return;
+    }
+    const rateLimitSnapshot = parseRateLimitSnapshot(await RedisCooldown.getValue(getRateLimitMetadataKey(operation), { redis, logger }));
+    logger.warn('Skipping stream request due to active rate-limit cooldown', {
+        operation,
+        cooldown: cooldownMs,
+        rateLimitSnapshot,
+    });
+    throw createRateLimitExceededException({
+        operation,
+        retryAfterMs: cooldownMs,
+        rateLimit: rateLimitSnapshot ? toCooldownRateLimit(rateLimitSnapshot, cooldownMs) : undefined,
+    });
+}
+export async function executeWithRateLimitHandling(execute, operation, context, options) {
+    const { logger, redis } = context;
+    const { enableCooldown, maxAttempts, maxDelayMs, maxRetryableDelayMs } = options;
+    let attempt = 1;
+    if (enableCooldown) {
+        await throwIfOperationCooldownActive(operation, { logger, redis });
+        let waitedForSharedCooldown = false;
+        const softCooldownMs = await RedisCooldown.getRemainingMs(STREAM_RATE_LIMIT_SOFT_COOLDOWN_KEY, { redis, logger }, { keyPrefix: STREAM_RATE_LIMIT_COOLDOWN_KEY_PREFIX });
+        if (softCooldownMs > 0) {
+            logger.info('Delaying stream request due to active soft rate-limit cooldown', {
+                operation,
+                cooldown: softCooldownMs,
+            });
+            await sleep(softCooldownMs);
+            waitedForSharedCooldown = true;
+        }
+        const budgetCooldownMs = await RedisCooldown.getRemainingMs(STREAM_BUDGET_COOLDOWN_KEY, { redis, logger }, { keyPrefix: STREAM_BUDGET_COOLDOWN_KEY_PREFIX });
+        if (budgetCooldownMs > 0) {
+            logger.warn('Delaying stream request due to active budget cooldown', {
+                operation,
+                cooldown: budgetCooldownMs,
+            });
+            let totalBudgetWaitMs = 0;
+            for (;;) {
+                const waitMs = await RedisCooldown.getRemainingMs(STREAM_BUDGET_COOLDOWN_KEY, { redis, logger }, { keyPrefix: STREAM_BUDGET_COOLDOWN_KEY_PREFIX });
+                if (waitMs <= 0 || totalBudgetWaitMs >= BUDGET_DELAY_MAX_MS) {
+                    break;
+                }
+                const chunkMs = Math.min(waitMs, BUDGET_COOLDOWN_SLEEP_CHUNK_MS, BUDGET_DELAY_MAX_MS - totalBudgetWaitMs);
+                await sleep(chunkMs);
+                totalBudgetWaitMs += chunkMs;
+                waitedForSharedCooldown = true;
+            }
+        }
+        if (waitedForSharedCooldown) {
+            await throwIfOperationCooldownActive(operation, { logger, redis });
+        }
+    }
+    for (;;) {
+        try {
+            return await execute();
+        }
+        catch (error) {
+            const rateLimitError = processStreamRateLimitException(error, logger);
+            if (!rateLimitError) {
+                throw error;
+            }
+            const retryAfterMs = calculateRateLimitDelayMs(rateLimitError, maxDelayMs);
+            if (enableCooldown) {
+                const rateLimitSnapshot = toRateLimitSnapshot(rateLimitError);
+                if (rateLimitSnapshot) {
+                    await RedisCooldown.setRemainingMsWithValue(operation, getRateLimitMetadataKey(operation), serializeRateLimitSnapshot(rateLimitSnapshot), retryAfterMs, { redis, logger });
+                }
+                else {
+                    await RedisCooldown.setRemainingMs(operation, retryAfterMs, { redis, logger });
+                }
+            }
+            if (attempt < maxAttempts && retryAfterMs <= maxRetryableDelayMs) {
+                logger.warn('Retrying stream request after rate limit', {
+                    operation,
+                    attempt,
+                    maxAttempts,
+                    retryAfterMs,
+                    rateLimit: rateLimitError.rateLimit,
+                    rateLimitRemaining: rateLimitError.rateLimitRemaining,
+                    rateLimitReset: rateLimitError.rateLimitReset,
+                });
+                await sleep(retryAfterMs);
+                attempt++;
+                continue;
+            }
+            logger.warn('Propagating stream rate limit w/o retry', {
+                operation,
+                attempt,
+                maxAttempts,
+                retryAfterMs,
+                maxRetryableDelayMs,
+                rateLimit: rateLimitError.rateLimit,
+                rateLimitRemaining: rateLimitError.rateLimitRemaining,
+                rateLimitReset: rateLimitError.rateLimitReset,
+            });
+            throw rateLimitError;
+        }
+    }
+}

package/dist-es/streamRateLimitHandlingProxy/helpers/headerUtils.js

@@ -0,0 +1,42 @@
+const EPOCH_SECONDS_PAST_SKEW_SECONDS = 60;
+const EPOCH_SECONDS_FUTURE_SKEW_SECONDS = 24 * 60 * 60;
+export function getHeaderCaseInsensitive(headers, key) {
+    if (!headers) {
+        return;
+    }
+    const direct = headers[key];
+    if (direct !== undefined) {
+        return direct;
+    }
+    const normalizedKey = key.toLowerCase();
+    for (const [headerKey, headerValue] of Object.entries(headers)) {
+        if (headerKey.toLowerCase() === normalizedKey) {
+            return headerValue;
+        }
+    }
+}
+export function parseHeaderNumber(headers, key) {
+    const raw = getHeaderCaseInsensitive(headers, key);
+    if (typeof raw === 'number' && Number.isFinite(raw)) {
+        return raw;
+    }
+    if (typeof raw === 'string') {
+        const parsed = Number(raw);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+}
+export function normalizeResetToEpochMs(reset) {
+    const nowMs = Date.now();
+    if (!Number.isFinite(reset)) {
+        return nowMs;
+    }
+    if (reset >= 10000000000)
+        return Math.round(reset);
+    const nowSeconds = nowMs / 1000;
+    const looksLikeEpochSeconds = reset >= nowSeconds - EPOCH_SECONDS_PAST_SKEW_SECONDS && reset <= nowSeconds + EPOCH_SECONDS_FUTURE_SKEW_SECONDS;
+    if (looksLikeEpochSeconds)
+        return Math.round(reset * 1000);
+    return nowMs + Math.round(reset * 1000);
+}