@lunora/ratelimit 0.0.0 → 1.0.0-alpha.10

package/dist/index.d.ts

@@ -0,0 +1,409 @@
+import { Middleware, Plugin } from '@lunora/server';
+import { Id } from '@lunora/values';
+import { LunoraError } from '@lunora/errors';
+/** Rate-limit algorithm. */
+type RateLimitKind = "fixed window" | "sliding window" | "token bucket";
+/** Why a request was denied. */
+type RateLimitReason = "deny" | "rate";
+/** Definition of a single named rate limit. */
+interface RateLimitConfig {
+  /**
+   * Maximum tokens that can accumulate (the rollover ceiling). Defaults to
+   * `rate`: for a token bucket that caps a burst at one period's worth of
+   * tokens, and for a fixed window it disables cross-window rollover. Ignored
+   * by sliding windows, which always cap at `rate` per `period`.
+   */
+  capacity?: number;
+  kind: RateLimitKind;
+  /** Window/refill period in milliseconds. */
+  period: number;
+  /** Tokens granted per `period`. */
+  rate: number;
+  /**
+   * Split a hot limit across N independent sub-buckets to avoid a single
+   * contended key/Durable Object. Each shard enforces `rate / shards` (and
+   * `capacity / shards`); a request is routed to a shard via a deterministic
+   * hash of `(name, key)`, so the same key always lands on the same shard and
+   * a single key's effective throughput is exactly `rate / shards`. Aggregate
+   * throughput across many distinct keys approaches `rate` as keys spread
+   * uniformly across shards. Reserve it for high-volume limits where
+   * contention bites; leave unset (one bucket) otherwise. Must be a positive
+   * integer — `1` is equivalent to unset.
+   */
+  shards?: number;
+  /**
+   * Phase offset in epoch milliseconds for windowed algorithms — windows
+   * align to `start + n * period`. Ignored by token buckets. Defaults to `0`.
+   */
+  start?: number;
+}
+/** A map of limit name to its config, used to construct a `RateLimiter`. */
+type RateLimitConfigMap<Names extends string = string> = Record<Names, RateLimitConfig>;
+/** Persisted accounting state for one `(name, key)` pair. */
+interface RateLimitValue {
+  /**
+   * Sliding window only: request count from the previous window, used to
+   * weight the current estimate. Unset for token-bucket / fixed-window.
+   */
+  prev?: number;
+  /**
+   * Token-bucket: timestamp of the last refill. Fixed/sliding window: start of
+   * the window the value belongs to.
+   */
+  ts: number;
+  /**
+   * Tokens available (token bucket), tokens remaining in the window (fixed
+   * window), or requests made in the current window (sliding window).
+   * Fractional for token buckets; negative when reserved ahead.
+   */
+  value: number;
+}
+/** Outcome of a `RateLimiter.limit` / `RateLimiter.check` call. */
+interface RateLimitStatus {
+  /** Whether the request is permitted. */
+  ok: boolean;
+  /** Why the request was denied. Absent when `ok`. */
+  reason?: RateLimitReason;
+  /** Milliseconds until the request would succeed. `0` when `ok` without reservation. */
+  retryAfter: number;
+}
+/** Per-call options for `RateLimiter.limit`. */
+interface RateLimitArgs {
+  /** Units to consume. Defaults to `1`. */
+  count?: number;
+  /** Sub-key isolating the limit (per user/team/IP). Omit for a global limit. */
+  key?: string;
+  /**
+   * Permit the request even when capacity is insufficient, reserving future
+   * capacity (the stored value goes negative). `retryAfter` then reports when
+   * the debt clears. Rejected only when `count` exceeds the bucket capacity.
+   */
+  reserve?: boolean;
+  /** Throw `RateLimitError` instead of returning a failing status. */
+  throws?: boolean;
+}
+/**
+ * Pluggable persistence. Reads and writes are keyed by an opaque storage key
+ * the limiter derives from the limit name and `key`. Implementations may be
+ * synchronous (in-memory) or asynchronous (SQLite/KV); the limiter awaits
+ * either.
+ */
+interface RateLimitStore {
+  delete: (storageKey: string) => Promise<void> | void;
+  get: (storageKey: string) => Promise<RateLimitValue | undefined> | RateLimitValue | undefined;
+  set: (storageKey: string, value: RateLimitValue) => Promise<void> | void;
+}
+/** Inputs to {@link evaluate}. */
+interface EvaluateOptions {
+  /** When `false`, compute status without consuming (a `check`). */
+  consume: boolean;
+  /** Units requested. */
+  count: number;
+  /** Current time in epoch milliseconds. */
+  now: number;
+  /** Permit a deficit by reserving future capacity (token bucket / within-window). */
+  reserve: boolean;
+}
+/** Result of evaluating a limit against its prior state. */
+interface EvaluateResult {
+  status: RateLimitStatus;
+  /** Next value to persist, or `undefined` when the call must not mutate state. */
+  value: RateLimitValue | undefined;
+}
+/**
+ * Project a limit's stored state forward to `now` without consuming: how many
+ * units could be admitted right now. Token bucket → the refilled token count;
+ * fixed window → tokens left in the current (possibly rolled-over) window;
+ * sliding window → `rate` minus the weighted estimate, floored at zero. Pure,
+ * like {@link evaluate}, and shares its per-algorithm projection helpers so the
+ * two never diverge. Backs `RateLimiter.getValue` so it reports a live figure
+ * rather than the last value that happened to be persisted.
+ */
+declare const availableAt: (config: RateLimitConfig, prior: RateLimitValue | undefined, now: number) => {
+  ts: number;
+  value: number;
+};
+/**
+ * Evaluate a request against a limit's prior state. Pure: it never reads a
+ * clock or persists — the caller supplies `now` and writes back `value` when
+ * it is not `undefined`.
+ */
+declare const evaluate: (config: RateLimitConfig, prior: RateLimitValue | undefined, options: EvaluateOptions) => EvaluateResult;
+interface RateLimiterOptions<Names extends string> {
+  config: RateLimitConfigMap<Names>;
+  /** Keys that are always denied, regardless of limit state. */
+  denyList?: Iterable<string>;
+  /**
+   * Optional key normalizer applied to every incoming `args.key` (the
+   * deny-list check, the storage key, and downstream shard selection all see
+   * the normalized form). Use for case-folding, trimming, or canonicalizing
+   * IPs/emails so equivalent inputs share a single bucket. The deny-list
+   * itself is consulted as-is; normalize the deny-list entries up front to
+   * match.
+   */
+  normalize?: (key: string) => string;
+  /** Clock injection for tests. Defaults to `Date.now`. */
+  now?: () => number;
+  /** Persistence. Defaults to a per-instance in-memory store. */
+  store?: RateLimitStore;
+}
+/**
+ * Enforces named rate limits over a pluggable store. Construct one per app with
+ * a config map; call {@link RateLimiter.limit} to consume and
+ * {@link RateLimiter.check} to peek. Framework-agnostic — the `@lunora/ratelimit`
+ * middleware wraps it for procedures.
+ */
+declare class RateLimiter<Names extends string = string> {
+  private readonly config;
+  private readonly denyList;
+  private readonly normalize;
+  private readonly now;
+  private readonly store;
+  constructor(options: RateLimiterOptions<Names>);
+  /** Peek at whether a request would be permitted without consuming. */
+  check(name: Names, args?: Omit<RateLimitArgs, "reserve" | "throws">): Promise<RateLimitStatus>;
+  /**
+   * Read the current config and the units admittable right now for a
+   * `(name, key)` pair. The value is projected forward to the current clock
+   * (token-bucket refill, fixed-window rollover, sliding-window decay), not
+   * the last persisted figure. For a sharded limit it reads only the single
+   * shard `limit()`/`run()` would route this key to — the sibling shards are
+   * never touched by this key, so summing them would over-report.
+   */
+  getValue(name: Names, args?: {
+    key?: string;
+  }): Promise<{
+    config: RateLimitConfig;
+    ts: number;
+    value: number;
+  }>;
+  /** Consume capacity. Returns the outcome, or throws when `args.throws` is set. */
+  limit(name: Names, args?: RateLimitArgs): Promise<RateLimitStatus>;
+  /** Clear accounting for a `(name, key)` pair (e.g. on successful login). */
+  reset(name: Names, args?: {
+    key?: string;
+  }): Promise<void>;
+  private resolve;
+  private run;
+}
+/**
+ * Either a fixed {@link RateLimiter} or a function that derives one from `ctx`
+ * — the latter lets a procedure bind a durable, ORM-backed limiter at call time
+ * (e.g. `(ctx) => new RateLimiter({ config, store: createDbStore({ db: ctx.db }) })`).
+ */
+type LimiterResolver<Context> = ((context: Context) => Promise<RateLimiter> | RateLimiter) | RateLimiter;
+interface RateLimitMiddlewareOptions<Context> {
+  /** Units to consume per call. Defaults to `1`. */
+  count?: number;
+  /**
+   * Behavior when the limiter itself throws (store unavailable, etc).
+   * Defaults to `false` (fail closed: deny the request with a 503). Set to
+   * `true` only when degraded availability is preferable to denying traffic
+   * — note that a failing limiter then permits every request through.
+   */
+  failOpen?: boolean;
+  /** Sub-key derived from `ctx` (per-user/IP). Omit for a global limit. */
+  key?: (context: Context) => string | undefined;
+  /** Override the error message thrown on rejection. */
+  message?: string;
+}
+/**
+ * Procedure middleware that enforces a named rate limit before the handler
+ * runs. Attach it with `.use()`. On rejection it throws a structural
+ * `LunoraError` (`TOO_MANY_REQUESTS`/429, or `FORBIDDEN`/403 for deny-list
+ * hits) carrying `retryAfter` in milliseconds — the runtime maps it to the
+ * matching RPC/HTTP status without any import of `@lunora/server` at runtime.
+ *
+ * **Failure policy:** if resolving or invoking the limiter throws for a genuine
+ * availability reason (e.g. the persistence store is unavailable), the
+ * middleware **fails closed by default**: it logs via `console.error` and
+ * rejects the request with `503`. This is the safer default for
+ * security-sensitive limits (auth, account creation). Pass `failOpen: true` to
+ * swallow the error and admit the request instead — appropriate only when
+ * degraded availability is preferable to refusal. Deterministic caller misuse
+ * (an unconfigured limit name, a non-positive count, or a count that exceeds
+ * capacity) throws an `INTERNAL` `LunoraError` that is re-thrown as-is under
+ * **both** policies — a config bug is never masked as a 503 or silently admitted.
+ */
+declare const rateLimit: <Context>(limiter: LimiterResolver<Context>, name: string, options?: RateLimitMiddlewareOptions<Context>) => Middleware<Context, Context>;
+/**
+ * In-memory store. State lives for the lifetime of the process (or, inside a
+ * Durable Object, the instance) — adequate for single-DO limits but not shared
+ * across instances. Use {@link createSqlStore} for durable per-DO state.
+ */
+declare const createMemoryStore: () => RateLimitStore;
+/**
+ * Minimal projection of `state.storage.sql` (workerd's `SqlStorage`, also
+ * satisfied by `node:sqlite`). Only the `exec` overload is required.
+ */
+interface SqlLike {
+  exec: <Row = Record<string, unknown>>(query: string, ...params: unknown[]) => {
+    toArray: () => Row[];
+  };
+}
+interface SqlStoreOptions {
+  sql: SqlLike;
+  /** Table name. Created if missing. Defaults to `_lunora_rate_limits`. */
+  table?: string;
+}
+/**
+ * SQLite-backed store for durable, per-DO rate-limit state. Persists each
+ * `(name, key)` pair as one row so limits survive hibernation and eviction.
+ *
+ * **Atomicity:** the store does not wrap individual operations in an explicit
+ * SQL transaction. Inside a Durable Object the DO's input gate serializes
+ * every RPC call against the storage, so the limiter's read-modify-write
+ * sequence runs to completion without interleaving — this is the same
+ * guarantee the surrounding `evaluate()` step depends on. **Outside a DO**
+ * (e.g. driving `createSqlStore` from a long-lived `node:sqlite` connection in
+ * tests or a custom host) the caller is responsible for serialization; the
+ * SQL surface used here (`exec`) is not a substitute for transactional
+ * isolation across concurrent invocations.
+ */
+declare const createSqlStore: (options: SqlStoreOptions) => RateLimitStore;
+/**
+ * The slice of an index-range builder the store uses. Mirrors `@lunora/server`'s
+ * `IndexRangeBuilder` field-for-field so the real `ctx.db` query builder is
+ * assignable; only `eq` is exercised.
+ */
+interface RateLimitDatabaseIndexRange {
+  eq: (field: string, value: unknown) => RateLimitDatabaseIndexRange;
+  gt: (field: string, value: unknown) => RateLimitDatabaseIndexRange;
+  gte: (field: string, value: unknown) => RateLimitDatabaseIndexRange;
+  lt: (field: string, value: unknown) => RateLimitDatabaseIndexRange;
+  lte: (field: string, value: unknown) => RateLimitDatabaseIndexRange;
+}
+/** The slice of a `ctx.db` table query the store relies on. */
+interface RateLimitDatabaseQuery {
+  first: () => Promise<Record<string, unknown> | null>;
+  withIndex: (indexName: string, range: (q: RateLimitDatabaseIndexRange) => RateLimitDatabaseIndexRange) => RateLimitDatabaseQuery;
+}
+/**
+ * The slice of the Lunora ORM writer (`ctx.db` on a mutation/action) the store
+ * needs. The real `DatabaseWriter` is structurally assignable, so pass `ctx.db`
+ * directly — declared here (rather than imported) to keep `@lunora/ratelimit`
+ * free of a runtime dependency on `@lunora/server`.
+ */
+interface RateLimitDatabase {
+  delete: <T extends string>(id: Id<T>) => Promise<void>;
+  insert: <T extends string>(table: T, document: Record<string, unknown>) => Promise<Id<T>>;
+  patch: <T extends string>(id: Id<T>, patch: Record<string, unknown>) => Promise<void>;
+  query: (table: string) => RateLimitDatabaseQuery;
+}
+interface DatabaseStoreOptions {
+  /** The Lunora ORM writer — `ctx.db` inside a mutation or action. */
+  db: RateLimitDatabase;
+  /** Index that resolves a row by its key column. Defaults to `by_key`. */
+  index?: string;
+  /** Column storing the opaque key. Defaults to `key`. */
+  keyField?: string;
+  /** Table holding one row per `(name, key)` pair. Defaults to `rateLimits`. */
+  table?: string;
+}
+/**
+ * Store backed by a Lunora table through `ctx.db`, for durable per-DO limits
+ * inside a procedure (the procedure context exposes no raw SQL). Declare a
+ * table with the key column and its index, e.g.
+ *
+ * ```ts
+ * rateLimits: defineTable({
+ *     key: v.string(),
+ *     ts: v.number(),
+ *     value: v.number(),
+ *     prev: v.optional(v.number()),
+ * }).index("by_key", ["key"])
+ * ```
+ *
+ * Each operation is a read-then-write; inside a mutation/action that pair runs
+ * under the DO's input gate, so it is atomic against concurrent calls.
+ */
+declare const createDatabaseStore: (options: DatabaseStoreOptions) => RateLimitStore;
+/**
+ * DB-backed rate-limit middleware sugar. Collapses the common
+ *
+ * ```ts
+ * rateLimit((ctx) => new RateLimiter({ config, store: createDbStore({ db: ctx.db }) }), name, opts)
+ * ```
+ *
+ * into `dbRateLimit(config, name, opts)`: it builds a per-call {@link RateLimiter}
+ * whose accounting lives in a Lunora table via `ctx.db` (so the bucket is durable
+ * on the DO the procedure runs on). Every query/mutation/action ctx exposes a
+ * compatible `db`, so it slots straight into a `.use(...)` chain.
+ *
+ * Pass `options.store` to point at a non-default backing table/index/key column
+ * (defaults: table `rateLimits`, index `by_key`, key column `key`); the rest of
+ * `options` (`key`, `count`, `failOpen`, `message`) is forwarded to
+ * {@link rateLimit} unchanged. When `config` is precisely typed, `name`
+ * autocompletes to its declared limit names.
+ *
+ * Re-exported as `dbRateLimit` from the package root.
+ *
+ * ```ts
+ * const limits = { send: { kind: "token bucket", period: 60_000, rate: 30 } } satisfies RateLimitConfigMap;
+ *
+ * export const send = mutation
+ *   .input({ text: v.string() })
+ *   .use(dbRateLimit(limits, "send", { key: (ctx) => ctx.auth.userId ?? "anonymous" }))
+ *   .mutation(async ({ ctx, args }) => ...);
+ * ```
+ */
+declare const databaseRateLimit: <Context extends {
+  db: RateLimitDatabase;
+}, Names extends string = string>(config: RateLimitConfigMap<Names>, name: Names, options?: RateLimitMiddlewareOptions<Context> & {
+  store?: Omit<DatabaseStoreOptions, "db">;
+}) => Middleware<Context, Context>;
+/**
+ * Thrown by `RateLimiter.limit` when called with `{ throws: true }`. A
+ * `LunoraError` subclass whose code/status track `status.reason`: a rate
+ * rejection is `TOO_MANY_REQUESTS`/429, a deny-list hit is `FORBIDDEN`/403 —
+ * the same mapping the middleware applies, so both entry points surface the
+ * identical wire code (a permanent deny is never a retryable 429). The
+ * middleware itself throws a bare structural `LunoraError`, so this is for
+ * direct callers that prefer exceptions. Keeps `reason`/`retryAfter`.
+ */
+declare class RateLimitError extends LunoraError {
+  readonly reason: RateLimitReason | undefined;
+  readonly retryAfter: number;
+  constructor(status: RateLimitStatus, message?: string);
+}
+/** Context shape the plugin middleware widens to: a `ratelimit` limiter on `ctx.api`. */
+interface RatelimitApiContext<Context> {
+  api: (Context extends {
+    api: infer A;
+  } ? A : Record<never, never>) & {
+    ratelimit: RateLimiter;
+  };
+}
+/**
+ * Package `@lunora/ratelimit` as a first-party {@link Plugin}, the dogfooded
+ * form of the plugin contract: instead of (or alongside) the enforcing
+ * `rateLimit(...)` middleware, this exposes the resolved {@link RateLimiter}
+ * under `ctx.api.ratelimit` so a handler can `limit()`/`check()`/`reset()`
+ * programmatically.
+ *
+ * Install the middleware with one `.use(...)` (or fold it in with
+ * `composePluginMiddleware([...])`):
+ *
+ * ```ts
+ * const limiter = new RateLimiter({ config: { send: { kind: "token bucket", rate: 5, period: 60_000, capacity: 5 } } });
+ * const c = initLunora.dataModel&lt;DataModel>().create();
+ * export const send = c.mutation
+ *     .use(ratelimitPlugin(limiter).middleware!)
+ *     .mutation(async ({ ctx, args }) => {
+ *         const status = await ctx.api.ratelimit.limit("send", { key: ctx.userId });
+ *         if (!status.ok) throw new Error("slow down");
+ *         // …
+ *     });
+ * ```
+ *
+ * The plugin ships no schema extension — the limiter's persistence is whatever
+ * store the resolved {@link RateLimiter} was built with — so it is a
+ * middleware-only plugin and is skipped by `installPlugins(...)`'s schema fold.
+ *
+ * Built as a plain {@link Plugin} literal (the key is the fixed string
+ * `"ratelimit"`, so the `definePlugin` validation adds nothing) — this keeps
+ * `@lunora/server` a type-only dependency of `@lunora/ratelimit`.
+ */
+declare const ratelimitPlugin: <Context = unknown>(limiter: LimiterResolver<Context>) => Plugin<Record<never, never>, Context, Context & RatelimitApiContext<Context>>;
+declare const VERSION = "0.0.0";
+export { type DatabaseStoreOptions as DbStoreOptions, type EvaluateOptions, type EvaluateResult, type LimiterResolver, type RateLimitArgs, type RateLimitConfig, type RateLimitConfigMap, type RateLimitDatabase as RateLimitDb, type RateLimitDatabaseIndexRange as RateLimitDbIndexRange, type RateLimitDatabaseQuery as RateLimitDbQuery, RateLimitError, type RateLimitKind, type RateLimitMiddlewareOptions, type RateLimitReason, type RateLimitStatus, type RateLimitStore, type RateLimitValue, RateLimiter, type RateLimiterOptions, type RatelimitApiContext, type SqlLike, type SqlStoreOptions, VERSION, availableAt, createDatabaseStore as createDbStore, createMemoryStore, createSqlStore, databaseRateLimit as dbRateLimit, evaluate, rateLimit, ratelimitPlugin };

package/dist/index.mjs

@@ -0,0 +1,11 @@
+export { availableAt, evaluate } from './packem_shared/availableAt-DQcuVfSA.mjs';
+export { default as dbRateLimit } from './packem_shared/dbRateLimit-WTU-e0r6.mjs';
+export { default as RateLimitError } from './packem_shared/RateLimitError-CiLy3DsZ.mjs';
+export { rateLimit } from './packem_shared/rateLimit-BBdG9GFo.mjs';
+export { ratelimitPlugin } from './packem_shared/ratelimitPlugin-D5_-KV1T.mjs';
+export { RateLimiter } from './packem_shared/RateLimiter-rDCxu_Nx.mjs';
+export { createDbStore, createMemoryStore, createSqlStore } from './packem_shared/createDbStore-L1kD1g1n.mjs';
+
+const VERSION = "0.0.0";
+
+export { VERSION };

package/dist/packem_shared/RateLimitError-CiLy3DsZ.mjs

@@ -0,0 +1,21 @@
+import { LunoraError } from '@lunora/errors';
+import { STATUS_BY_REASON } from './rateLimit-BBdG9GFo.mjs';
+
+const describe = (status) => {
+  if (status.reason === "deny") {
+    return "request denied (deny list)";
+  }
+  return Number.isFinite(status.retryAfter) ? `rate limit exceeded; retry after ${String(Math.ceil(status.retryAfter))}ms` : "rate limit exceeded";
+};
+class RateLimitError extends LunoraError {
+  reason;
+  retryAfter;
+  constructor(status, message) {
+    const { code, status: httpStatus } = STATUS_BY_REASON[status.reason ?? "rate"];
+    super(code, message ?? describe(status), { name: "RateLimitError", status: httpStatus });
+    this.reason = status.reason;
+    this.retryAfter = status.retryAfter;
+  }
+}
+
+export { RateLimitError as default };

package/dist/packem_shared/RateLimiter-rDCxu_Nx.mjs

@@ -0,0 +1,121 @@
+import { LunoraError } from '@lunora/errors';
+import { availableAt, evaluate } from './availableAt-DQcuVfSA.mjs';
+import RateLimitError from './RateLimitError-CiLy3DsZ.mjs';
+import { createMemoryStore } from './createDbStore-L1kD1g1n.mjs';
+
+const storageKeyFor = (name, key) => key === void 0 ? encodeURIComponent(name) : `${encodeURIComponent(name)}:${encodeURIComponent(key)}`;
+const hashToShard = (storageKey, shards) => {
+  let hash = 0;
+  for (let index = 0; index < storageKey.length; index += 1) {
+    hash = hash * 31 + storageKey.charCodeAt(index) | 0;
+  }
+  return Math.abs(hash) % shards;
+};
+const perShardConfig = (config, shards) => shards > 1 ? { ...config, capacity: (config.capacity ?? config.rate) / shards, rate: config.rate / shards } : config;
+const shardKeysFor = (name, key, shards) => {
+  const base = storageKeyFor(name, key);
+  return shards > 1 ? Array.from({ length: shards }, (_, shard) => `${base}#${String(shard)}`) : [base];
+};
+const routeStorageKey = (name, key, shards) => {
+  const base = storageKeyFor(name, key);
+  return shards > 1 ? `${base}#${String(hashToShard(base, shards))}` : base;
+};
+class RateLimiter {
+  config;
+  denyList;
+  normalize;
+  now;
+  store;
+  constructor(options) {
+    this.config = options.config;
+    this.denyList = new Set(options.denyList);
+    this.normalize = options.normalize ?? ((key) => key);
+    this.now = options.now ?? Date.now;
+    this.store = options.store ?? createMemoryStore();
+    for (const [name, config] of Object.entries(this.config)) {
+      if (config.shards !== void 0 && (!Number.isInteger(config.shards) || config.shards < 1)) {
+        throw new LunoraError("INTERNAL", `rate limit "${name}": shards must be a positive integer`);
+      }
+      if (!Number.isFinite(config.period) || config.period <= 0) {
+        throw new LunoraError("INTERNAL", `rate limit "${name}": period must be a positive number`);
+      }
+      if (!Number.isFinite(config.rate) || config.rate <= 0) {
+        throw new LunoraError("INTERNAL", `rate limit "${name}": rate must be a positive number`);
+      }
+      if (config.capacity !== void 0 && (!Number.isFinite(config.capacity) || config.capacity < 0)) {
+        throw new LunoraError("INTERNAL", `rate limit "${name}": capacity must be a non-negative number`);
+      }
+    }
+  }
+  /** Peek at whether a request would be permitted without consuming. */
+  async check(name, args = {}) {
+    return this.run(name, args, false);
+  }
+  /**
+   * Read the current config and the units admittable right now for a
+   * `(name, key)` pair. The value is projected forward to the current clock
+   * (token-bucket refill, fixed-window rollover, sliding-window decay), not
+   * the last persisted figure. For a sharded limit it reads only the single
+   * shard `limit()`/`run()` would route this key to — the sibling shards are
+   * never touched by this key, so summing them would over-report.
+   */
+  async getValue(name, args = {}) {
+    const config = this.resolve(name);
+    const shards = config.shards ?? 1;
+    const now = this.now();
+    const normalizedKey = args.key === void 0 ? void 0 : this.normalize(args.key);
+    const storageKey = routeStorageKey(name, normalizedKey, shards);
+    const current = availableAt(perShardConfig(config, shards), await this.store.get(storageKey), now);
+    return { config, ts: current.ts, value: current.value };
+  }
+  /** Consume capacity. Returns the outcome, or throws when `args.throws` is set. */
+  async limit(name, args = {}) {
+    return this.run(name, args, true);
+  }
+  /** Clear accounting for a `(name, key)` pair (e.g. on successful login). */
+  async reset(name, args = {}) {
+    const shards = this.resolve(name).shards ?? 1;
+    const normalizedKey = args.key === void 0 ? void 0 : this.normalize(args.key);
+    await Promise.all(shardKeysFor(name, normalizedKey, shards).map((storageKey) => Promise.resolve(this.store.delete(storageKey))));
+  }
+  resolve(name) {
+    const config = this.config[name];
+    if (!config) {
+      throw new LunoraError("INTERNAL", `rate limit "${name}" is not configured`);
+    }
+    return config;
+  }
+  async run(name, args, consume) {
+    const config = this.resolve(name);
+    const normalizedKey = args.key === void 0 ? void 0 : this.normalize(args.key);
+    if (normalizedKey !== void 0 && (this.denyList.has(normalizedKey) || this.denyList.has(args.key))) {
+      const status2 = { ok: false, reason: "deny", retryAfter: Number.POSITIVE_INFINITY };
+      if (args.throws) {
+        throw new RateLimitError(status2);
+      }
+      return status2;
+    }
+    const count = args.count ?? 1;
+    if (!Number.isInteger(count) || count <= 0) {
+      throw new LunoraError("INTERNAL", `rate limit "${name}": count must be a positive integer`);
+    }
+    const shards = config.shards ?? 1;
+    const storageKey = routeStorageKey(name, normalizedKey, shards);
+    const prior = await this.store.get(storageKey);
+    const { status, value } = evaluate(perShardConfig(config, shards), prior, {
+      consume,
+      count,
+      now: this.now(),
+      reserve: args.reserve ?? false
+    });
+    if (value !== void 0) {
+      await this.store.set(storageKey, value);
+    }
+    if (!status.ok && args.throws) {
+      throw new RateLimitError(status);
+    }
+    return status;
+  }
+}
+
+export { RateLimiter };

package/dist/packem_shared/availableAt-DQcuVfSA.mjs

@@ -0,0 +1,114 @@
+import { LunoraError } from '@lunora/errors';
+
+const capacityOf = (config) => config.capacity ?? config.rate;
+const projectTokenBucket = (config, prior, now) => {
+  const capacity = capacityOf(config);
+  const ratePerMs = config.rate / config.period;
+  const base = prior ?? { ts: now, value: capacity };
+  const elapsed = Math.max(0, now - base.ts);
+  return { available: Math.min(capacity, base.value + elapsed * ratePerMs), capacity, ratePerMs };
+};
+const projectFixedWindow = (config, prior, now) => {
+  const start = config.start ?? 0;
+  const windowStart = start + Math.floor((now - start) / config.period) * config.period;
+  if (!prior || prior.ts < windowStart) {
+    let carry = 0;
+    if (prior && (prior.value < 0 || config.capacity !== void 0)) {
+      carry = prior.value;
+    }
+    return { ts: windowStart, value: Math.min(capacityOf(config), carry + config.rate) };
+  }
+  return { ts: prior.ts, value: prior.value };
+};
+const projectSlidingWindow = (config, prior, now) => {
+  const start = config.start ?? 0;
+  const windowStart = start + Math.floor((now - start) / config.period) * config.period;
+  const elapsed = now - windowStart;
+  const weight = (config.period - elapsed) / config.period;
+  let previousCount = 0;
+  let currentCount = 0;
+  if (prior?.ts === windowStart) {
+    previousCount = prior.prev ?? 0;
+    currentCount = prior.value;
+  } else if (prior?.ts === windowStart - config.period) {
+    previousCount = prior.value;
+  }
+  return { currentCount, elapsed, previousCount, weight, windowStart };
+};
+const tokenBucket = (config, prior, options) => {
+  const { available, capacity, ratePerMs } = projectTokenBucket(config, prior, options.now);
+  if (available >= options.count) {
+    const value = { ts: options.now, value: available - options.count };
+    return { status: { ok: true, retryAfter: 0 }, value: options.consume ? value : void 0 };
+  }
+  const deficit = options.count - available;
+  const retryAfter = Math.ceil(deficit / ratePerMs);
+  if (options.consume && options.reserve && options.count <= capacity) {
+    return { status: { ok: true, retryAfter }, value: { ts: options.now, value: available - options.count } };
+  }
+  if (options.count > capacity) {
+    throw new LunoraError("INTERNAL", `@lunora/ratelimit: requested count ${String(options.count)} exceeds the limiter capacity ${String(capacity)}`);
+  }
+  return { status: { ok: false, reason: "rate", retryAfter }, value: void 0 };
+};
+const fixedWindow = (config, prior, options) => {
+  const capacity = capacityOf(config);
+  const base = projectFixedWindow(config, prior, options.now);
+  if (base.value >= options.count) {
+    const value = { ts: base.ts, value: base.value - options.count };
+    return { status: { ok: true, retryAfter: 0 }, value: options.consume ? value : void 0 };
+  }
+  const retryAfter = base.ts + config.period - options.now;
+  if (options.consume && options.reserve && options.count <= capacity) {
+    return { status: { ok: true, retryAfter }, value: { ts: base.ts, value: base.value - options.count } };
+  }
+  if (options.count > capacity) {
+    throw new LunoraError("INTERNAL", `@lunora/ratelimit: requested count ${String(options.count)} exceeds the limiter capacity ${String(capacity)}`);
+  }
+  return { status: { ok: false, reason: "rate", retryAfter }, value: void 0 };
+};
+const slidingWindow = (config, prior, options) => {
+  const limit = config.rate;
+  const { period } = config;
+  const { currentCount, elapsed, previousCount, weight, windowStart } = projectSlidingWindow(config, prior, options.now);
+  const estimated = previousCount * weight + currentCount;
+  const admit = estimated + options.count <= limit;
+  const retryAfter = () => {
+    const headroomNow = limit - currentCount - options.count;
+    if (previousCount > 0 && headroomNow >= 0) {
+      return Math.ceil(period - elapsed - headroomNow * period / previousCount);
+    }
+    const headroomNext = limit - options.count;
+    const intoNext = currentCount > 0 ? Math.max(0, period - headroomNext * period / currentCount) : 0;
+    return Math.ceil(period - elapsed + intoNext);
+  };
+  if (admit || options.consume && options.reserve && options.count <= limit) {
+    const value = { prev: previousCount, ts: windowStart, value: currentCount + options.count };
+    return { status: { ok: true, retryAfter: admit ? 0 : retryAfter() }, value: options.consume ? value : void 0 };
+  }
+  if (options.count > limit) {
+    throw new LunoraError("INTERNAL", `@lunora/ratelimit: requested count ${String(options.count)} exceeds the limiter capacity ${String(limit)}`);
+  }
+  return { status: { ok: false, reason: "rate", retryAfter: retryAfter() }, value: void 0 };
+};
+const availableAt = (config, prior, now) => {
+  if (config.kind === "token bucket") {
+    return { ts: now, value: projectTokenBucket(config, prior, now).available };
+  }
+  if (config.kind === "sliding window") {
+    const { currentCount, previousCount, weight, windowStart } = projectSlidingWindow(config, prior, now);
+    return { ts: windowStart, value: Math.max(0, config.rate - (previousCount * weight + currentCount)) };
+  }
+  return projectFixedWindow(config, prior, now);
+};
+const evaluate = (config, prior, options) => {
+  if (config.kind === "token bucket") {
+    return tokenBucket(config, prior, options);
+  }
+  if (config.kind === "sliding window") {
+    return slidingWindow(config, prior, options);
+  }
+  return fixedWindow(config, prior, options);
+};
+
+export { availableAt, evaluate };