kitcn 0.23.0 → 0.25.0

package/dist/{query-context-BzihIpnM.js → query-context-DOm5Xm3H.js}

@@ -1,406 +1,5 @@
 import { compareValues, convexToJson, jsonToConvex } from "convex/values";
 
-//#region src/orm/filter-expression.ts
-/**
-* Unique symbol for FilterExpression brand
-* Prevents structural typing - only expressions created by factory functions are valid
-*/
-const FilterExpressionBrand = Symbol("FilterExpression");
-/**
-* Create a field reference
-* Used internally by operator functions
-*/
-function fieldRef(fieldName) {
-	return {
-		__brand: "FieldReference",
-		fieldName
-	};
-}
-/**
-* Type guard for FieldReference
-*/
-function isFieldReference(value) {
-	return value && typeof value === "object" && value.__brand === "FieldReference";
-}
-/**
-* The pattern is the same for every row of a scan while the value is not, so
-* only the value genuinely has to be split per call. A small bounded cache
-* keeps the split pattern across rows without unbounded growth on
-* caller-supplied patterns; a query with a handful of LIKE filters still hits
-* on every row.
-*/
-const LIKE_PATTERN_CACHE_MAX = 16;
-const likePatternCache = /* @__PURE__ */ new Map();
-function likePatternCodePoints(pattern, caseInsensitive) {
-	const key = caseInsensitive ? `i:${pattern}` : `s:${pattern}`;
-	const cached = likePatternCache.get(key);
-	if (cached) return cached;
-	const source = Array.from(caseInsensitive ? pattern.toLowerCase() : pattern);
-	if (likePatternCache.size >= LIKE_PATTERN_CACHE_MAX) for (const oldest of likePatternCache.keys()) {
-		likePatternCache.delete(oldest);
-		break;
-	}
-	likePatternCache.set(key, source);
-	return source;
-}
-/**
-* SQL `LIKE` semantics: `%` matches any run of characters, `_` matches exactly
-* one, everything else is literal. Wildcards work anywhere in the pattern, not
-* only at the ends.
-*
-* Matched with a single-backtrack scan rather than a compiled regex. A pattern
-* is caller data — anything interpolated into `` `%${query}%` `` reaches here —
-* and translating `%` to a regex quantifier makes `'%%%%%z'` backtrack
-* exponentially, which would burn the whole Convex function CPU budget on one
-* row. This scan remembers only the most recent `%`, so the worst case is
-* O(value * pattern) with no catastrophic case at all.
-*/
-function matchLikePattern(value, pattern, caseInsensitive) {
-	const target = Array.from(caseInsensitive ? value.toLowerCase() : value);
-	const source = likePatternCodePoints(pattern, caseInsensitive);
-	let valueIndex = 0;
-	let patternIndex = 0;
-	let wildcardPatternIndex = -1;
-	let wildcardValueIndex = 0;
-	while (valueIndex < target.length) {
-		const patternChar = patternIndex < source.length ? source[patternIndex] : void 0;
-		if (patternChar === "_" || patternChar === target[valueIndex]) {
-			valueIndex += 1;
-			patternIndex += 1;
-		} else if (patternChar === "%") {
-			wildcardPatternIndex = patternIndex;
-			wildcardValueIndex = valueIndex;
-			patternIndex += 1;
-		} else if (wildcardPatternIndex === -1) return false;
-		else {
-			wildcardValueIndex += 1;
-			valueIndex = wildcardValueIndex;
-			patternIndex = wildcardPatternIndex + 1;
-		}
-	}
-	while (patternIndex < source.length && source[patternIndex] === "%") patternIndex += 1;
-	return patternIndex === source.length;
-}
-/**
-* Structural equality matching Convex's own `q.eq`. Arrays, objects and bytes
-* are compared by content: reference identity would make every `eq`/`in` filter
-* on a `custom(v.array(...))` / `custom(v.object(...))` column match nothing.
-*/
-function filterValuesEqual(a, b) {
-	if (a === b) return true;
-	if (a === null || b === null || typeof a !== "object" || typeof b !== "object") return false;
-	if (Array.isArray(a) || Array.isArray(b)) {
-		if (!(Array.isArray(a) && Array.isArray(b)) || a.length !== b.length) return false;
-		return a.every((item, index) => filterValuesEqual(item, b[index]));
-	}
-	if (a instanceof ArrayBuffer || b instanceof ArrayBuffer) {
-		if (!(a instanceof ArrayBuffer && b instanceof ArrayBuffer) || a.byteLength !== b.byteLength) return false;
-		const left = new Uint8Array(a);
-		const right = new Uint8Array(b);
-		return left.every((byte, index) => byte === right[index]);
-	}
-	const aKeys = Object.keys(a);
-	const bKeys = Object.keys(b);
-	if (aKeys.length !== bKeys.length) return false;
-	return aKeys.every((key) => Object.hasOwn(b, key) && filterValuesEqual(a[key], b[key]));
-}
-/** `inArray`/`notInArray` membership using {@link filterValuesEqual}. */
-function filterValueInList(value, list) {
-	return list.some((candidate) => filterValuesEqual(candidate, value));
-}
-/**
-* Create a column wrapper
-* Used internally by query builder's _createColumnProxies
-*/
-function column(builder, columnName) {
-	return {
-		builder,
-		columnName
-	};
-}
-function resolveColumn(col) {
-	if (col && typeof col === "object" && "columnName" in col) return col;
-	if (isFieldReference(col)) return {
-		builder: col,
-		columnName: col.fieldName
-	};
-	const builder = col;
-	const columnName = builder?.config?.name;
-	if (!columnName) throw new Error("Column builder is missing a column name");
-	return column(builder, columnName);
-}
-/**
-* Internal binary expression implementation
-* Private class - only accessible via factory functions
-*/
-var BinaryExpressionImpl = class {
-	[FilterExpressionBrand] = true;
-	type = "binary";
-	constructor(operator, operands) {
-		this.operator = operator;
-		this.operands = operands;
-	}
-	accept(visitor) {
-		return visitor.visitBinary(this);
-	}
-};
-/**
-* Internal logical expression implementation
-* Private class - only accessible via factory functions
-*/
-var LogicalExpressionImpl = class {
-	[FilterExpressionBrand] = true;
-	type = "logical";
-	constructor(operator, operands) {
-		this.operator = operator;
-		this.operands = operands;
-	}
-	accept(visitor) {
-		return visitor.visitLogical(this);
-	}
-};
-/**
-* Internal unary expression implementation
-* Private class - only accessible via factory functions
-*/
-var UnaryExpressionImpl = class {
-	[FilterExpressionBrand] = true;
-	type = "unary";
-	constructor(operator, operands) {
-		this.operator = operator;
-		this.operands = operands;
-	}
-	accept(visitor) {
-		return visitor.visitUnary(this);
-	}
-};
-/**
-* Equality operator: field == value
-*
-* @example
-* const filter = eq(cols.name, 'Alice');
-*/
-function eq(col, value) {
-	return new BinaryExpressionImpl("eq", [fieldRef(resolveColumn(col).columnName), value]);
-}
-/**
-* Not equal operator: field != value
-*/
-function ne(col, value) {
-	return new BinaryExpressionImpl("ne", [fieldRef(resolveColumn(col).columnName), value]);
-}
-/**
-* Greater than operator: field > value
-*/
-function gt(col, value) {
-	return new BinaryExpressionImpl("gt", [fieldRef(resolveColumn(col).columnName), value]);
-}
-/**
-* Greater than or equal operator: field >= value
-*/
-function gte(col, value) {
-	return new BinaryExpressionImpl("gte", [fieldRef(resolveColumn(col).columnName), value]);
-}
-/**
-* Less than operator: field < value
-*/
-function lt(col, value) {
-	return new BinaryExpressionImpl("lt", [fieldRef(resolveColumn(col).columnName), value]);
-}
-/**
-* Less than or equal operator: field <= value
-*/
-function lte(col, value) {
-	return new BinaryExpressionImpl("lte", [fieldRef(resolveColumn(col).columnName), value]);
-}
-/**
-* Between operator: field BETWEEN min AND max (inclusive)
-*
-* Sugar for and(gte(field, min), lte(field, max)).
-*/
-function between(col, min, max) {
-	return and(gte(col, min), lte(col, max));
-}
-/**
-* Not between operator: field < min OR field > max
-*
-* Sugar for or(lt(field, min), gt(field, max)).
-*/
-function notBetween(col, min, max) {
-	return or(lt(col, min), gt(col, max));
-}
-/**
-* LIKE operator: SQL-style pattern matching with % wildcards
-* Note: Implemented as post-filter (Convex has no native LIKE)
-*
-* @example
-* const users = await db.query.users.findMany({
-*   where: like(users.name, '%alice%'),
-* });
-*/
-function like(col, pattern) {
-	return new BinaryExpressionImpl("like", [fieldRef(resolveColumn(col).columnName), pattern]);
-}
-/**
-* ILIKE operator: Case-insensitive LIKE
-* Note: Implemented as post-filter (Convex has no native LIKE)
-*
-* @example
-* const users = await db.query.users.findMany({
-*   where: ilike(users.name, '%ALICE%'),
-* });
-*/
-function ilike(col, pattern) {
-	return new BinaryExpressionImpl("ilike", [fieldRef(resolveColumn(col).columnName), pattern]);
-}
-/**
-* NOT LIKE operator: Negated LIKE pattern
-*/
-function notLike(col, pattern) {
-	return new BinaryExpressionImpl("notLike", [fieldRef(resolveColumn(col).columnName), pattern]);
-}
-/**
-* NOT ILIKE operator: Negated case-insensitive LIKE
-*/
-function notIlike(col, pattern) {
-	return new BinaryExpressionImpl("notIlike", [fieldRef(resolveColumn(col).columnName), pattern]);
-}
-/**
-* startsWith operator: Check if string starts with prefix
-* Optimized for prefix matching
-*
-* @example
-* const users = await db.query.users.findMany({
-*   where: startsWith(users.email, 'admin@'),
-* });
-*/
-function startsWith(col, prefix) {
-	return new BinaryExpressionImpl("startsWith", [fieldRef(resolveColumn(col).columnName), prefix]);
-}
-/**
-* endsWith operator: Check if string ends with suffix
-*
-* @example
-* const users = await db.query.users.findMany({
-*   where: endsWith(users.email, '@example.com'),
-* });
-*/
-function endsWith(col, suffix) {
-	return new BinaryExpressionImpl("endsWith", [fieldRef(resolveColumn(col).columnName), suffix]);
-}
-/**
-* contains operator: Check if string contains substring
-* Can use search index for optimization when available
-*
-* @example
-* const posts = await db.query.posts.findMany({
-*   where: contains(posts.title, 'javascript'),
-* });
-*/
-function contains(col, substring) {
-	return new BinaryExpressionImpl("contains", [fieldRef(resolveColumn(col).columnName), substring]);
-}
-/**
-* Logical AND: all expressions must be true
-* Filters out undefined expressions (following Drizzle pattern)
-*
-* @example
-* const filter = and(
-*   eq(fieldRef('age'), 25),
-*   eq(fieldRef('name'), 'Alice')
-* );
-*/
-function and(...expressions) {
-	const defined = expressions.filter((expr) => expr !== void 0);
-	if (defined.length === 0) return;
-	if (defined.length === 1) return defined[0];
-	return new LogicalExpressionImpl("and", defined);
-}
-/**
-* Logical OR: at least one expression must be true
-* Filters out undefined expressions (following Drizzle pattern)
-*
-* @example
-* const filter = or(
-*   eq(fieldRef('status'), 'active'),
-*   eq(fieldRef('status'), 'pending')
-* );
-*/
-function or(...expressions) {
-	const defined = expressions.filter((expr) => expr !== void 0);
-	if (defined.length === 0) return;
-	if (defined.length === 1) return defined[0];
-	return new LogicalExpressionImpl("or", defined);
-}
-/**
-* Logical NOT: negates expression
-*
-* @example
-* const filter = not(eq(fieldRef('isDeleted'), true));
-*/
-function not(expression) {
-	return new UnaryExpressionImpl("not", [expression]);
-}
-/**
-* Array membership operator: field IN array
-*
-* @example
-* const filter = inArray(cols.status, ['active', 'pending']);
-*/
-function inArray(col, values) {
-	return new BinaryExpressionImpl("inArray", [fieldRef(resolveColumn(col).columnName), values]);
-}
-/**
-* Array exclusion operator: field NOT IN array
-* Validates array is non-empty at construction time
-*
-* @example
-* const filter = notInArray(cols.role, ['admin', 'moderator']);
-*/
-function notInArray(col, values) {
-	if (!Array.isArray(values) || values.length === 0) throw new Error("notInArray requires a non-empty array of values");
-	return new BinaryExpressionImpl("notInArray", [fieldRef(resolveColumn(col).columnName), values]);
-}
-/**
-* Array contains operator: field @> array
-*/
-function arrayContains(col, values) {
-	return new BinaryExpressionImpl("arrayContains", [fieldRef(resolveColumn(col).columnName), values]);
-}
-/**
-* Array contained operator: field <@ array
-*/
-function arrayContained(col, values) {
-	return new BinaryExpressionImpl("arrayContained", [fieldRef(resolveColumn(col).columnName), values]);
-}
-/**
-* Array overlaps operator: field && array
-*/
-function arrayOverlaps(col, values) {
-	return new BinaryExpressionImpl("arrayOverlaps", [fieldRef(resolveColumn(col).columnName), values]);
-}
-/**
-* Null check operator: field IS NULL
-* Type validation: Only works with nullable fields
-*
-* @example
-* const filter = isNull(cols.deletedAt);
-*/
-function isNull(col) {
-	return new UnaryExpressionImpl("isNull", [fieldRef(resolveColumn(col).columnName)]);
-}
-/**
-* Not null check operator: field IS NOT NULL
-* Type validation: Only works with nullable fields
-*
-* @example
-* const filter = isNotNull(cols.deletedAt);
-*/
-function isNotNull(col) {
-	return new UnaryExpressionImpl("isNotNull", [fieldRef(resolveColumn(col).columnName)]);
-}
-
-//#endregion
 //#region src/orm/unset-token.ts
 const unsetToken = Symbol.for("kitcn/orm/unsetToken");
 function isUnsetToken(value) {
@@ -1743,4 +1342,4 @@ async function getByIdWithOrmQueryFallback(ctx, tableName, id) {
 }
 
 //#endregion
-export { like as A, or as B, gt as C, isFieldReference as D, inArray as E, not as F, notBetween as I, notIlike as L, lte as M, matchLikePattern as N, isNotNull as O, ne as P, notInArray as R, filterValuesEqual as S, ilike as T, startsWith as V, contains as _, indexKeyWithinBounds as a, fieldRef as b, streamIndexRange as c, and as d, arrayContained as f, column as g, between as h, getIndexFields as i, lt as j, isNull as k, isUnsetToken as l, arrayOverlaps as m, EmptyStream as n, mergedStream as o, arrayContains as p, QueryStream as r, stream as s, getByIdWithOrmQueryFallback as t, unsetToken as u, endsWith as v, gte as w, filterValueInList as x, eq as y, notLike as z };
+export { indexKeyWithinBounds as a, streamIndexRange as c, getIndexFields as i, isUnsetToken as l, EmptyStream as n, mergedStream as o, QueryStream as r, stream as s, getByIdWithOrmQueryFallback as t, unsetToken as u };

package/dist/{query-options-C_eBSIXG.js → query-options-DUiOj01a.js}

@@ -1,6 +1,38 @@
 import { getFunctionName } from "convex/server";
 
 //#region src/crpc/http-types.ts
+/**
+* Build the exact cache key for an HTTP route.
+*
+* Missing args normalize to `{}` so the RSC prefetch, the browser observer, and
+* a hand-written `getQueryData` call all hash to the same key. Every producer
+* of an `httpQuery` cache key goes through here.
+*/
+function buildHttpQueryKey(routeKey, args) {
+	return [
+		"httpQuery",
+		routeKey,
+		args ?? {}
+	];
+}
+/**
+* Build the route-wide prefix key.
+*
+* Filters match on prefix, so this matches every args variant of the route.
+* Not a cache key: nothing is ever stored under it.
+*/
+function buildHttpQueryPrefixKey(routeKey) {
+	return ["httpQuery", routeKey];
+}
+/**
+* Freshness window for `crpc.http.*` routes, in milliseconds.
+*
+* HTTP routes are a pull model with no push channel, so hydrated data needs a
+* real freshness window or the browser refetches it on mount. The RSC
+* QueryClient reads the same constant, so the server dedupe window and the
+* client freshness window cannot drift apart.
+*/
+const HTTP_DEFAULT_STALE_TIME = 3e4;
 /** HTTP client error */
 var HttpClientError = class extends Error {
 	name = "HttpClientError";
@@ -244,4 +276,4 @@ function convexInfiniteQueryOptions(funcRef, args, opts = {}, meta) {
 }
 
 //#endregion
-export { buildSearchParams as a, HttpClientError as c, RESERVED_KEYS as i, isHttpClientError as l, convexInfiniteQueryOptions as n, executeHttpRequest as o, convexQuery as r, replaceUrlParam as s, convexAction as t };
+export { buildSearchParams as a, HTTP_DEFAULT_STALE_TIME as c, buildHttpQueryPrefixKey as d, isHttpClientError as f, RESERVED_KEYS as i, HttpClientError as l, convexInfiniteQueryOptions as n, executeHttpRequest as o, convexQuery as r, replaceUrlParam as s, convexAction as t, buildHttpQueryKey as u };

package/dist/ratelimit/index.d.ts

@@ -1,5 +1,5 @@
-import { o as MiddlewareBuilder } from "../types-CnTpHR1F.js";
-import { t as Plugin } from "../middleware-Br5zubu7.js";
+import { o as MiddlewareBuilder } from "../types-eNzQmbqM.js";
+import { t as Plugin } from "../middleware-CE_MC6Gi.js";
 import * as convex_server0 from "convex/server";
 
 //#region src/ratelimit/duration.d.ts
@@ -127,6 +127,7 @@ type ConvexQueryBuilder = {
   withIndex: (name: any, cb: any) => {
     unique: () => Promise<any>;
     collect: () => Promise<any[]>;
+    take: (limit: number) => Promise<any[]>;
   };
 };
 type ConvexRatelimitDbReader = {
@@ -176,17 +177,36 @@ declare function calculateRatelimit(state: RatelimitState | null, algorithm: Res
  */
 declare function snapshotToState(snapshot: RatelimitSnapshot): RatelimitState;
 //#endregion
+//#region src/ratelimit/maintenance.d.ts
+type CleanupRatelimitStateOptions = {
+  before: number;
+  limit?: number;
+};
+type CleanupRatelimitStateResult = {
+  deleted: number;
+  hasMore: boolean;
+};
+/** Deletes one on-demand batch of state older than the caller-owned cutoff. */
+declare function cleanupRatelimitState(db: ConvexRatelimitDbWriter, options: CleanupRatelimitStateOptions): Promise<CleanupRatelimitStateResult>;
+//#endregion
 //#region src/ratelimit/plugin.d.ts
 type MaybePromise<T> = T | Promise<T>;
 type RatelimitBuckets = Record<string, Record<string, ResolvedAlgorithm>>;
 type BucketName<TBuckets extends RatelimitBuckets> = Extract<keyof TBuckets, string>;
 type TierName<TBuckets extends RatelimitBuckets> = Extract<keyof TBuckets[BucketName<TBuckets>], string>;
-type RatelimitResolvedArgs<TCtx, TMeta extends object, TUser, TBuckets extends RatelimitBuckets> = {
+/** What is known before request signals are resolved. */
+type RatelimitRequestArgs<TCtx, TMeta extends object, TUser, TBuckets extends RatelimitBuckets> = {
   ctx: TCtx;
   meta: TMeta;
   user: TUser;
   bucket: BucketName<TBuckets>;
   tier: TierName<TBuckets>;
+};
+/** Signals are resolved once per request and reused as the identifier input. */
+type RatelimitIdentifierArgs<TCtx, TMeta extends object, TUser, TBuckets extends RatelimitBuckets> = RatelimitRequestArgs<TCtx, TMeta, TUser, TBuckets> & {
+  signals: LimitRequest | undefined;
+};
+type RatelimitResolvedArgs<TCtx, TMeta extends object, TUser, TBuckets extends RatelimitBuckets> = RatelimitIdentifierArgs<TCtx, TMeta, TUser, TBuckets> & {
   identifier: string;
 };
 type RatelimitPluginOptions<TCtx = unknown, TMeta extends object = object, TUser = unknown, TBuckets extends RatelimitBuckets = RatelimitBuckets> = {
@@ -199,18 +219,34 @@ type RatelimitPluginOptions<TCtx = unknown, TMeta extends object = object, TUser
     ctx: TCtx;
     meta: TMeta;
   }) => MaybePromise<TUser>;
-  getIdentifier: (args: {
-    ctx: TCtx;
-    meta: TMeta;
-    user: TUser;
-    bucket: BucketName<TBuckets>;
-  }) => MaybePromise<string>;
   getTier: (user: TUser) => MaybePromise<TierName<TBuckets>>;
-  getSignals: (args: RatelimitResolvedArgs<TCtx, TMeta, TUser, TBuckets>) => MaybePromise<LimitRequest | undefined>;
+  /**
+   * Resolved once per request, before `getIdentifier`, and reused for the limit
+   * call. Read request metadata here rather than in `getIdentifier`, so a
+   * guarded mutation pays at most one `ctx.meta.getRequestMetadata()` syscall.
+   */
+  getSignals: (args: RatelimitRequestArgs<TCtx, TMeta, TUser, TBuckets>) => MaybePromise<LimitRequest | undefined>;
+  /**
+   * The rate-limit partition key. Everything sharing a value shares one budget
+   * and one `ratelimitState` document, so key unauthenticated traffic by
+   * `signals.ip` rather than a constant.
+   */
+  getIdentifier: (args: RatelimitIdentifierArgs<TCtx, TMeta, TUser, TBuckets>) => MaybePromise<string>;
   prefix?: string | ((args: RatelimitResolvedArgs<TCtx, TMeta, TUser, TBuckets>) => MaybePromise<string>);
   failureMode?: 'closed' | 'open';
   enableProtection?: boolean;
   denyListThreshold?: number;
+  denyList?: RatelimitConfig['denyList'];
+  dynamicLimits?: boolean;
+  timeout?: number;
+  /**
+   * Block cache backing store. The plugin builds one `Ratelimit` per guarded
+   * mutation, so the default per-instance cache never outlives a request. Pass
+   * a longer-lived `Map` only if you accept that a stale block can deny a
+   * request a refilled shard could have served, and that a mutation replayed
+   * after an OCC conflict can observe entries its first attempt wrote.
+   */
+  ephemeralCache?: RatelimitConfig['ephemeralCache'];
   message?: string | ((args: RatelimitResolvedArgs<TCtx, TMeta, TUser, TBuckets>) => MaybePromise<string>);
 };
 type AnyRatelimitPluginOptions = RatelimitPluginOptions<any, any, any, any>;
@@ -285,4 +321,4 @@ declare const HOUR: number;
 declare const DAY: number;
 declare const WEEK: number;
 //#endregion
-export { type CheckRequest, type ConvexQueryBuilder, type ConvexRatelimitDbReader, type ConvexRatelimitDbWriter, DAY, type Duration, type DurationString, type DurationUnit, type DynamicLimitResponse, type EvaluationResult, type FixedWindowAlgorithm, HOUR, type HookAPIOptions, type HookCheckValue, type LimitRequest, MINUTE, RATE_LIMIT_DYNAMIC_TABLE, RATE_LIMIT_HIT_TABLE, RATE_LIMIT_STATE_TABLE, Ratelimit, type RatelimitConfig, RatelimitPlugin, type RatelimitPluginOptions, type RatelimitReason, type RatelimitResponse, type RatelimitRow, type RatelimitShardState, type RatelimitSnapshot, type RatelimitState, type RatelimitStoredState, type RemainingResponse, type ResolvedAlgorithm, SECOND, type SlidingWindowAlgorithm, type TokenBucketAlgorithm, WEEK, applyDynamicLimit, calculateRatelimit, fixedWindow, slidingWindow, snapshotToState, toMs, tokenBucket };
+export { type CheckRequest, type CleanupRatelimitStateOptions, type CleanupRatelimitStateResult, type ConvexQueryBuilder, type ConvexRatelimitDbReader, type ConvexRatelimitDbWriter, DAY, type Duration, type DurationString, type DurationUnit, type DynamicLimitResponse, type EvaluationResult, type FixedWindowAlgorithm, HOUR, type HookAPIOptions, type HookCheckValue, type LimitRequest, MINUTE, RATE_LIMIT_DYNAMIC_TABLE, RATE_LIMIT_HIT_TABLE, RATE_LIMIT_STATE_TABLE, Ratelimit, type RatelimitConfig, RatelimitPlugin, type RatelimitPluginOptions, type RatelimitReason, type RatelimitResponse, type RatelimitRow, type RatelimitShardState, type RatelimitSnapshot, type RatelimitState, type RatelimitStoredState, type RemainingResponse, type ResolvedAlgorithm, SECOND, type SlidingWindowAlgorithm, type TokenBucketAlgorithm, WEEK, applyDynamicLimit, calculateRatelimit, cleanupRatelimitState, fixedWindow, slidingWindow, snapshotToState, toMs, tokenBucket };