@wildix/xbees-conversations-utils 1.3.1 → 2.0.1

package/dist-es/streamRateLimitHandlingProxy/generatedMethodNames.js

@@ -1,317 +0,0 @@
-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

@@ -1,170 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,148 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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);
-}