@commandkit/ratelimit 0.0.0-dev.20260317060555

package/dist/utils/config.js

@@ -0,0 +1,105 @@
+"use strict";
+/**
+ * Limiter config resolution.
+ *
+ * Applies defaults and merges overrides into concrete limiter settings
+ * used by the engine and plugin.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_LIMITER = void 0;
+exports.mergeLimiterConfigs = mergeLimiterConfigs;
+exports.resolveLimiterConfig = resolveLimiterConfig;
+exports.resolveLimiterConfigs = resolveLimiterConfigs;
+const time_1 = require("./time");
+const DEFAULT_MAX_REQUESTS = 10;
+const DEFAULT_INTERVAL_MS = 60000;
+const DEFAULT_ALGORITHM = 'fixed-window';
+const DEFAULT_SCOPE = 'user';
+/**
+ * Default limiter used when no explicit configuration is provided.
+ */
+exports.DEFAULT_LIMITER = {
+    maxRequests: DEFAULT_MAX_REQUESTS,
+    interval: DEFAULT_INTERVAL_MS,
+    algorithm: DEFAULT_ALGORITHM,
+    scope: DEFAULT_SCOPE,
+};
+/**
+ * Merge limiter configs; later values override earlier ones for layering.
+ *
+ * @param configs - Limiter configs ordered from lowest to highest priority.
+ * @returns Merged limiter config with later overrides applied.
+ */
+function mergeLimiterConfigs(...configs) {
+    return configs.reduce((acc, cfg) => ({ ...acc, ...(cfg ?? {}) }), {});
+}
+/**
+ * Resolve a limiter config for a single scope with defaults applied.
+ *
+ * @param config - Base limiter configuration.
+ * @param scope - Scope to resolve for the limiter.
+ * @returns Resolved limiter config with defaults and derived values.
+ */
+function resolveLimiterConfig(config, scope) {
+    const maxRequests = typeof config.maxRequests === 'number' && config.maxRequests > 0
+        ? config.maxRequests
+        : DEFAULT_MAX_REQUESTS;
+    const intervalMs = (0, time_1.clampAtLeast)((0, time_1.resolveDuration)(config.interval, DEFAULT_INTERVAL_MS), 1);
+    const algorithm = config.algorithm ?? DEFAULT_ALGORITHM;
+    const intervalSeconds = intervalMs / 1000;
+    const burst = typeof config.burst === 'number' && config.burst > 0
+        ? config.burst
+        : maxRequests;
+    const refillRate = typeof config.refillRate === 'number' && config.refillRate > 0
+        ? config.refillRate
+        : maxRequests / intervalSeconds;
+    const leakRate = typeof config.leakRate === 'number' && config.leakRate > 0
+        ? config.leakRate
+        : maxRequests / intervalSeconds;
+    return {
+        maxRequests,
+        intervalMs,
+        algorithm,
+        scope,
+        burst,
+        refillRate,
+        leakRate,
+        violations: config.violations,
+    };
+}
+/**
+ * Resolve a stable window id when one is missing.
+ *
+ * @param window - Window config entry.
+ * @param index - Index of the window in the config list.
+ * @returns Window id string.
+ */
+function resolveWindowId(window, index) {
+    if (window.id && window.id.trim())
+        return window.id;
+    /**
+     * Stable fallback IDs keep window identity deterministic for resets.
+     */
+    return `w${index + 1}`;
+}
+/**
+ * Resolve limiter configs for a scope across all configured windows.
+ *
+ * @param config - Base limiter configuration that may include windows.
+ * @param scope - Scope to resolve for the limiter.
+ * @returns Resolved limiter configs for each window (or a single config).
+ */
+function resolveLimiterConfigs(config, scope) {
+    const windows = config.windows;
+    if (!windows || windows.length === 0) {
+        return [resolveLimiterConfig(config, scope)];
+    }
+    const { windows: _windows, ...base } = config;
+    return windows.map((window, index) => {
+        const windowId = resolveWindowId(window, index);
+        const merged = { ...base, ...window };
+        const resolved = resolveLimiterConfig(merged, scope);
+        return windowId ? { ...resolved, windowId } : resolved;
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/keys.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Key construction helpers.
+ *
+ * Builds consistent storage keys for scopes and exemptions across
+ * message and interaction sources so limits remain comparable.
+ */
+import { Message } from 'discord.js';
+import type { Interaction } from 'discord.js';
+import type { Context } from 'commandkit';
+import type { LoadedCommand } from 'commandkit';
+import type { RateLimitExemptionScope, RateLimitKeyResolver, RateLimitScope } from '../types';
+/**
+ * Inputs for resolving a scope-based key from a command/source.
+ */
+export interface ResolveScopeKeyParams {
+    ctx: Context;
+    source: Interaction | Message;
+    command: LoadedCommand;
+    scope: RateLimitScope;
+    keyPrefix?: string;
+    keyResolver?: RateLimitKeyResolver;
+}
+/**
+ * Resolved key paired with its scope for aggregation.
+ */
+export interface ResolvedScopeKey {
+    scope: RateLimitScope;
+    key: string;
+}
+/**
+ * Extract role IDs from a message/interaction for role-based limits.
+ *
+ * @param source - Interaction or message to read role data from.
+ * @returns Array of role IDs for the source, or an empty array.
+ */
+export declare function getRoleIds(source: Interaction | Message): string[];
+/**
+ * Build a storage key for a temporary exemption entry.
+ *
+ * @param scope - Exemption scope to encode.
+ * @param id - Scope identifier (user, guild, role, etc.).
+ * @param keyPrefix - Optional prefix to prepend to the key.
+ * @returns Fully-qualified exemption storage key.
+ */
+export declare function buildExemptionKey(scope: RateLimitExemptionScope, id: string, keyPrefix?: string): string;
+/**
+ * Build a prefix for scanning exemption keys in storage.
+ *
+ * @param keyPrefix - Optional prefix to prepend to the key.
+ * @param scope - Optional exemption scope to narrow the prefix.
+ * @returns Prefix suitable for storage scans.
+ */
+export declare function buildExemptionPrefix(keyPrefix?: string, scope?: RateLimitExemptionScope): string;
+/**
+ * Parse an exemption key into scope and ID for listing.
+ *
+ * @param key - Exemption key to parse.
+ * @param keyPrefix - Optional prefix to strip before parsing.
+ * @returns Parsed scope/id pair or null when the key is invalid.
+ */
+export declare function parseExemptionKey(key: string, keyPrefix?: string): {
+    scope: RateLimitExemptionScope;
+    id: string;
+} | null;
+/**
+ * Resolve all exemption keys that could apply to a source.
+ *
+ * @param source - Interaction or message to resolve keys for.
+ * @param keyPrefix - Optional prefix to prepend to keys.
+ * @returns Exemption keys that should be checked for the source.
+ */
+export declare function resolveExemptionKeys(source: Interaction | Message, keyPrefix?: string): string[];
+/**
+ * Resolve the storage key for a single scope.
+ *
+ * @param params - Inputs required to resolve the scope key.
+ * @returns Resolved scope key or null when required identifiers are missing.
+ */
+export declare function resolveScopeKey({ ctx, source, command, scope, keyPrefix, keyResolver, }: ResolveScopeKeyParams): ResolvedScopeKey | null;
+/**
+ * Resolve keys for multiple scopes, dropping unresolvable ones.
+ *
+ * @param params - Inputs required to resolve all scope keys.
+ * @returns Array of resolved scope keys.
+ */
+export declare function resolveScopeKeys(params: Omit<ResolveScopeKeyParams, 'scope'> & {
+    scopes: RateLimitScope[];
+}): ResolvedScopeKey[];
+/**
+ * Build a prefix for resets by scope/identifier.
+ *
+ * @param scope - Scope to build the prefix for.
+ * @param keyPrefix - Optional prefix to prepend to the key.
+ * @param identifiers - Identifiers required for the scope.
+ * @returns Prefix string or null when identifiers are missing.
+ */
+export declare function buildScopePrefix(scope: RateLimitScope, keyPrefix: string | undefined, identifiers: {
+    userId?: string;
+    guildId?: string;
+    channelId?: string;
+    commandName?: string;
+}): string | null;

package/dist/utils/keys.js

@@ -0,0 +1,304 @@
+"use strict";
+/**
+ * Key construction helpers.
+ *
+ * Builds consistent storage keys for scopes and exemptions across
+ * message and interaction sources so limits remain comparable.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRoleIds = getRoleIds;
+exports.buildExemptionKey = buildExemptionKey;
+exports.buildExemptionPrefix = buildExemptionPrefix;
+exports.parseExemptionKey = parseExemptionKey;
+exports.resolveExemptionKeys = resolveExemptionKeys;
+exports.resolveScopeKey = resolveScopeKey;
+exports.resolveScopeKeys = resolveScopeKeys;
+exports.buildScopePrefix = buildScopePrefix;
+const discord_js_1 = require("discord.js");
+const types_1 = require("../types");
+const constants_1 = require("../constants");
+/**
+ * Apply an optional prefix to a storage key.
+ *
+ * @param prefix - Optional prefix to prepend.
+ * @param key - Base key to prefix.
+ * @returns Prefixed key.
+ */
+function applyPrefix(prefix, key) {
+    if (!prefix)
+        return key;
+    return `${prefix}${key}`;
+}
+/**
+ * Resolve a user id from a message or interaction.
+ *
+ * @param source - Interaction or message source.
+ * @returns User id or null when unavailable.
+ */
+function getUserId(source) {
+    if (source instanceof discord_js_1.Message)
+        return source.author.id;
+    return source.user?.id ?? null;
+}
+/**
+ * Resolve a guild id from a message or interaction.
+ *
+ * @param source - Interaction or message source.
+ * @returns Guild id or null when unavailable.
+ */
+function getGuildId(source) {
+    if (source instanceof discord_js_1.Message)
+        return source.guildId ?? null;
+    return source.guildId ?? null;
+}
+/**
+ * Resolve a channel id from a message or interaction.
+ *
+ * @param source - Interaction or message source.
+ * @returns Channel id or null when unavailable.
+ */
+function getChannelId(source) {
+    if (source instanceof discord_js_1.Message)
+        return source.channelId ?? null;
+    return source.channelId ?? null;
+}
+/**
+ * Resolve a parent category id from a channel object.
+ *
+ * @param channel - Channel object to inspect.
+ * @returns Parent id or null when unavailable.
+ */
+function getParentId(channel) {
+    if (!channel || typeof channel !== 'object')
+        return null;
+    if (!('parentId' in channel))
+        return null;
+    const parentId = channel.parentId;
+    return parentId ?? null;
+}
+/**
+ * Resolve a category id from a message or interaction.
+ *
+ * @param source - Interaction or message source.
+ * @returns Category id or null when unavailable.
+ */
+function getCategoryId(source) {
+    if (source instanceof discord_js_1.Message) {
+        return getParentId(source.channel);
+    }
+    return getParentId(source.channel);
+}
+/**
+ * Extract role IDs from a message/interaction for role-based limits.
+ *
+ * @param source - Interaction or message to read role data from.
+ * @returns Array of role IDs for the source, or an empty array.
+ */
+function getRoleIds(source) {
+    const roles = source.member?.roles;
+    if (!roles)
+        return [];
+    if (Array.isArray(roles))
+        return roles;
+    if ('cache' in roles) {
+        return roles.cache.map((role) => role.id);
+    }
+    return [];
+}
+/**
+ * Build a storage key for a temporary exemption entry.
+ *
+ * @param scope - Exemption scope to encode.
+ * @param id - Scope identifier (user, guild, role, etc.).
+ * @param keyPrefix - Optional prefix to prepend to the key.
+ * @returns Fully-qualified exemption storage key.
+ */
+function buildExemptionKey(scope, id, keyPrefix) {
+    const prefix = keyPrefix ?? '';
+    return applyPrefix(prefix, `${constants_1.DEFAULT_KEY_PREFIX}exempt:${scope}:${id}`);
+}
+/**
+ * Build a prefix for scanning exemption keys in storage.
+ *
+ * @param keyPrefix - Optional prefix to prepend to the key.
+ * @param scope - Optional exemption scope to narrow the prefix.
+ * @returns Prefix suitable for storage scans.
+ */
+function buildExemptionPrefix(keyPrefix, scope) {
+    const prefix = keyPrefix ?? '';
+    const base = `${constants_1.DEFAULT_KEY_PREFIX}exempt:`;
+    if (!scope)
+        return applyPrefix(prefix, base);
+    return applyPrefix(prefix, `${base}${scope}:`);
+}
+/**
+ * Parse an exemption key into scope and ID for listing.
+ *
+ * @param key - Exemption key to parse.
+ * @param keyPrefix - Optional prefix to strip before parsing.
+ * @returns Parsed scope/id pair or null when the key is invalid.
+ */
+function parseExemptionKey(key, keyPrefix) {
+    const prefix = keyPrefix ?? '';
+    const base = `${prefix}${constants_1.DEFAULT_KEY_PREFIX}exempt:`;
+    if (!key.startsWith(base))
+        return null;
+    const rest = key.slice(base.length);
+    const [scope, ...idParts] = rest.split(':');
+    if (!scope || idParts.length === 0)
+        return null;
+    if (!types_1.RATE_LIMIT_EXEMPTION_SCOPES.includes(scope)) {
+        return null;
+    }
+    return { scope: scope, id: idParts.join(':') };
+}
+/**
+ * Resolve all exemption keys that could apply to a source.
+ *
+ * @param source - Interaction or message to resolve keys for.
+ * @param keyPrefix - Optional prefix to prepend to keys.
+ * @returns Exemption keys that should be checked for the source.
+ */
+function resolveExemptionKeys(source, keyPrefix) {
+    const keys = [];
+    const userId = getUserId(source);
+    if (userId) {
+        keys.push(buildExemptionKey('user', userId, keyPrefix));
+    }
+    const guildId = getGuildId(source);
+    if (guildId) {
+        keys.push(buildExemptionKey('guild', guildId, keyPrefix));
+    }
+    const channelId = getChannelId(source);
+    if (channelId) {
+        keys.push(buildExemptionKey('channel', channelId, keyPrefix));
+    }
+    const categoryId = getCategoryId(source);
+    if (categoryId) {
+        keys.push(buildExemptionKey('category', categoryId, keyPrefix));
+    }
+    const roleIds = getRoleIds(source);
+    for (const roleId of roleIds) {
+        keys.push(buildExemptionKey('role', roleId, keyPrefix));
+    }
+    return keys;
+}
+/**
+ * Resolve the storage key for a single scope.
+ *
+ * @param params - Inputs required to resolve the scope key.
+ * @returns Resolved scope key or null when required identifiers are missing.
+ */
+function resolveScopeKey({ ctx, source, command, scope, keyPrefix, keyResolver, }) {
+    const prefix = keyPrefix ?? '';
+    const commandName = ctx.commandName || command.command.name;
+    switch (scope) {
+        case 'user': {
+            const userId = getUserId(source);
+            if (!userId)
+                return null;
+            return {
+                scope,
+                key: applyPrefix(prefix, `${constants_1.DEFAULT_KEY_PREFIX}user:${userId}:${commandName}`),
+            };
+        }
+        case 'guild': {
+            const guildId = getGuildId(source);
+            if (!guildId)
+                return null;
+            return {
+                scope,
+                key: applyPrefix(prefix, `${constants_1.DEFAULT_KEY_PREFIX}guild:${guildId}:${commandName}`),
+            };
+        }
+        case 'channel': {
+            const channelId = getChannelId(source);
+            if (!channelId)
+                return null;
+            return {
+                scope,
+                key: applyPrefix(prefix, `${constants_1.DEFAULT_KEY_PREFIX}channel:${channelId}:${commandName}`),
+            };
+        }
+        case 'global': {
+            return {
+                scope,
+                key: applyPrefix(prefix, `${constants_1.DEFAULT_KEY_PREFIX}global:${commandName}`),
+            };
+        }
+        case 'user-guild': {
+            const userId = getUserId(source);
+            const guildId = getGuildId(source);
+            if (!userId || !guildId)
+                return null;
+            return {
+                scope,
+                key: applyPrefix(prefix, `${constants_1.DEFAULT_KEY_PREFIX}user:${userId}:guild:${guildId}:${commandName}`),
+            };
+        }
+        case 'custom': {
+            if (!keyResolver)
+                return null;
+            const customKey = keyResolver(ctx, command, source);
+            if (!customKey)
+                return null;
+            return {
+                scope,
+                key: applyPrefix(prefix, customKey),
+            };
+        }
+        default:
+            return null;
+    }
+}
+/**
+ * Resolve keys for multiple scopes, dropping unresolvable ones.
+ *
+ * @param params - Inputs required to resolve all scope keys.
+ * @returns Array of resolved scope keys.
+ */
+function resolveScopeKeys(params) {
+    const results = [];
+    for (const scope of params.scopes) {
+        const resolved = resolveScopeKey({ ...params, scope });
+        if (resolved)
+            results.push(resolved);
+    }
+    return results;
+}
+/**
+ * Build a prefix for resets by scope/identifier.
+ *
+ * @param scope - Scope to build the prefix for.
+ * @param keyPrefix - Optional prefix to prepend to the key.
+ * @param identifiers - Identifiers required for the scope.
+ * @returns Prefix string or null when identifiers are missing.
+ */
+function buildScopePrefix(scope, keyPrefix, identifiers) {
+    const prefix = keyPrefix ?? '';
+    switch (scope) {
+        case 'user':
+            return identifiers.userId
+                ? applyPrefix(prefix, `${constants_1.DEFAULT_KEY_PREFIX}user:${identifiers.userId}:`)
+                : null;
+        case 'guild':
+            return identifiers.guildId
+                ? applyPrefix(prefix, `${constants_1.DEFAULT_KEY_PREFIX}guild:${identifiers.guildId}:`)
+                : null;
+        case 'channel':
+            return identifiers.channelId
+                ? applyPrefix(prefix, `${constants_1.DEFAULT_KEY_PREFIX}channel:${identifiers.channelId}:`)
+                : null;
+        case 'global':
+            return applyPrefix(prefix, `${constants_1.DEFAULT_KEY_PREFIX}global:`);
+        case 'user-guild':
+            return identifiers.userId && identifiers.guildId
+                ? applyPrefix(prefix, `${constants_1.DEFAULT_KEY_PREFIX}user:${identifiers.userId}:guild:${identifiers.guildId}:`)
+                : null;
+        case 'custom':
+            return null;
+        default:
+            return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"keys.js","sourceRoot":"","sources":["../../src/utils/keys.ts"],"names":[],"mappings":"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"}

package/dist/utils/locking.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Storage-scoped locking helpers.
+ *
+ * Serializes fallback storage operations per key to reduce same-process races.
+ */
+import type { RateLimitStorage } from '../types';
+type LockedFn<T> = () => Promise<T>;
+/**
+ * Serialize work for a storage key to avoid same-process conflicts.
+ *
+ * @param storage - Storage instance that owns the key.
+ * @param key - Storage key to lock on.
+ * @param fn - Async function to run under the lock.
+ * @returns Result of the locked function.
+ */
+export declare function withStorageKeyLock<T>(storage: RateLimitStorage, key: string, fn: LockedFn<T>): Promise<T>;
+export {};

package/dist/utils/locking.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * Storage-scoped locking helpers.
+ *
+ * Serializes fallback storage operations per key to reduce same-process races.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withStorageKeyLock = withStorageKeyLock;
+/**
+ * Queue-based mutex keyed by string identifiers.
+ */
+class KeyedMutex {
+    constructor() {
+        this.queues = new Map();
+    }
+    /**
+     * Run a function exclusively for the given key.
+     *
+     * @param key - Key to serialize on.
+     * @param fn - Async function to run under the lock.
+     * @returns Result of the locked function.
+     */
+    async run(key, fn) {
+        const previous = this.queues.get(key) ?? Promise.resolve();
+        let release;
+        const current = new Promise((resolve) => {
+            release = resolve;
+        });
+        const tail = previous.then(() => current);
+        this.queues.set(key, tail);
+        await previous;
+        try {
+            return await fn();
+        }
+        finally {
+            release();
+            if (this.queues.get(key) === tail) {
+                this.queues.delete(key);
+            }
+        }
+    }
+}
+const mutexByStorage = new WeakMap();
+/**
+ * Serialize work for a storage key to avoid same-process conflicts.
+ *
+ * @param storage - Storage instance that owns the key.
+ * @param key - Storage key to lock on.
+ * @param fn - Async function to run under the lock.
+ * @returns Result of the locked function.
+ */
+async function withStorageKeyLock(storage, key, fn) {
+    let mutex = mutexByStorage.get(storage);
+    if (!mutex) {
+        mutex = new KeyedMutex();
+        mutexByStorage.set(storage, mutex);
+    }
+    return mutex.run(key, fn);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9ja2luZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy9sb2NraW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7OztHQUlHOztBQWtESCxnREFXQztBQXZERDs7R0FFRztBQUNILE1BQU0sVUFBVTtJQUFoQjtRQUNtQixXQUFNLEdBQUcsSUFBSSxHQUFHLEVBQXlCLENBQUM7SUE0QjdELENBQUM7SUExQkM7Ozs7OztPQU1HO0lBQ0ksS0FBSyxDQUFDLEdBQUcsQ0FBSSxHQUFXLEVBQUUsRUFBZTtRQUM5QyxNQUFNLFFBQVEsR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsSUFBSSxPQUFPLENBQUMsT0FBTyxFQUFFLENBQUM7UUFDM0QsSUFBSSxPQUFtQixDQUFDO1FBQ3hCLE1BQU0sT0FBTyxHQUFHLElBQUksT0FBTyxDQUFPLENBQUMsT0FBTyxFQUFFLEVBQUU7WUFDNUMsT0FBTyxHQUFHLE9BQU8sQ0FBQztRQUNwQixDQUFDLENBQUMsQ0FBQztRQUNILE1BQU0sSUFBSSxHQUFHLFFBQVEsQ0FBQyxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDMUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsR0FBRyxFQUFFLElBQUksQ0FBQyxDQUFDO1FBRTNCLE1BQU0sUUFBUSxDQUFDO1FBQ2YsSUFBSSxDQUFDO1lBQ0gsT0FBTyxNQUFNLEVBQUUsRUFBRSxDQUFDO1FBQ3BCLENBQUM7Z0JBQVMsQ0FBQztZQUNULE9BQVEsRUFBRSxDQUFDO1lBQ1gsSUFBSSxJQUFJLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsS0FBSyxJQUFJLEVBQUUsQ0FBQztnQkFDbEMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUM7WUFDMUIsQ0FBQztRQUNILENBQUM7SUFDSCxDQUFDO0NBQ0Y7QUFFRCxNQUFNLGNBQWMsR0FBRyxJQUFJLE9BQU8sRUFBZ0MsQ0FBQztBQUVuRTs7Ozs7OztHQU9HO0FBQ0ksS0FBSyxVQUFVLGtCQUFrQixDQUN0QyxPQUF5QixFQUN6QixHQUFXLEVBQ1gsRUFBZTtJQUVmLElBQUksS0FBSyxHQUFHLGNBQWMsQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDeEMsSUFBSSxDQUFDLEtBQUssRUFBRSxDQUFDO1FBQ1gsS0FBSyxHQUFHLElBQUksVUFBVSxFQUFFLENBQUM7UUFDekIsY0FBYyxDQUFDLEdBQUcsQ0FBQyxPQUFPLEVBQUUsS0FBSyxDQUFDLENBQUM7SUFDckMsQ0FBQztJQUNELE9BQU8sS0FBSyxDQUFDLEdBQUcsQ0FBQyxHQUFHLEVBQUUsRUFBRSxDQUFDLENBQUM7QUFDNUIsQ0FBQyJ9

package/dist/utils/time.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Time helpers for rate limits.
+ *
+ * Converts user-friendly durations into milliseconds and clamps values
+ * so storage and algorithms always receive safe inputs.
+ */
+import type { DurationLike } from '../types';
+/**
+ * Resolve a duration input into milliseconds with a fallback.
+ *
+ * @param value - Duration input as ms or string.
+ * @param fallback - Fallback value used when parsing fails.
+ * @returns Parsed duration in milliseconds.
+ */
+export declare function resolveDuration(value: DurationLike | undefined, fallback: number): number;
+/**
+ * Clamp a number to a minimum value to avoid zero/negative windows.
+ *
+ * @param value - Value to clamp.
+ * @param min - Minimum allowed value.
+ * @returns The clamped value.
+ */
+export declare function clampAtLeast(value: number, min: number): number;