@exortek/challenge 1.0.0 → 1.0.1

package/CHANGELOG.md

@@ -1,31 +1,34 @@
 # @exortek/challenge
 
+## 1.0.1
+
+### Patch Changes
+
+- 31223e4: Consolidate duplicated store internals into @exortek/shared utilities (redis-helpers, incr-store,
+  record-store). No public API changes.
+
+  apikey: fix Redis store race condition where a concurrent update() could silently un-revoke a key — revocations now
+  use a tombstone key that update() never touches.
+
+  apikey: fix memory store put() storing by reference instead of copying — now consistent with getById()'s copy-on-read
+  contract.
+
 ## 1.0.0
 
 ### Initial release
 
-- **`createChallenge(options)`** — issue an HMAC-signed challenge token
-  carrying `userId` / `method` / `step` / `nextStep` / `metadata` across
-  a multi-step auth flow. Optional `ipBinding` stamps the origin IP into
-  the payload; optional `singleUse` marks the token for one-shot
-  consumption via a caller-supplied store.
-- **`verifyChallenge(token, options)`** — HMAC-verify, expiry-check,
-  and optionally match `expectedUserId` / `expectedMethod` /
-  `expectedStep` / `expectedNextStep`, plus IP match when the token was
-  IP-bound. Returns `{ valid: true, payload }` on success or
-  `{ valid: false, reason }` on any expected failure; never throws on
-  bad tokens, only on programmer errors.
-- **Stores** — ships `memoryStore()` (single-node / dev, LRU + TTL
-  sweep) and `redisStore(client)` (cluster-safe, single Lua round-trip
-  per verify) under the `@exortek/challenge/stores` subpath. Any object
-  exposing `incr(key, ttlMs) → { count }` also works — e.g.
-  `@exortek/security`'s rate-limit stores.
-- **Token format:** `<prefix>.<base64url(payload)>.<base64url(hmac)>`
-  — deliberately not a JWT so the two token families cannot be confused
-  at a call site. Prefix defaults to `chall_v1`; callers can override
-  via `options.prefix` (e.g. `'server_challenge'`, `'myapp_v1'`) to
-  brand the wire format for their service. Must match
-  `/^[A-Za-z0-9_-]{1,32}$/`, and the same prefix must be used at create
-  and verify time.
-- **Errors:** stable `ErrorCode.INVALID_ARGUMENT` /
-  `ErrorCode.INVALID_SECRET` codes on the `ChallengeError` class.
+- **`createChallenge(options)`** — issue an HMAC-signed challenge token carrying `userId` / `method` / `step` /
+  `nextStep` / `metadata` across a multi-step auth flow. Optional `ipBinding` stamps the origin IP into the payload;
+  optional `singleUse` marks the token for one-shot consumption via a caller-supplied store.
+- **`verifyChallenge(token, options)`** — HMAC-verify, expiry-check, and optionally match `expectedUserId` /
+  `expectedMethod` / `expectedStep` / `expectedNextStep`, plus IP match when the token was IP-bound. Returns
+  `{ valid: true, payload }` on success or `{ valid: false, reason }` on any expected failure; never throws on bad
+  tokens, only on programmer errors.
+- **Stores** — ships `memoryStore()` (single-node / dev, LRU + TTL sweep) and `redisStore(client)` (cluster-safe, single
+  Lua round-trip per verify) under the `@exortek/challenge/stores` subpath. Any object exposing
+  `incr(key, ttlMs) → { count }` also works — e.g. `@exortek/security`'s rate-limit stores.
+- **Token format:** `<prefix>.<base64url(payload)>.<base64url(hmac)>` — deliberately not a JWT so the two token families
+  cannot be confused at a call site. Prefix defaults to `chall_v1`; callers can override via `options.prefix` (e.g.
+  `'server_challenge'`, `'myapp_v1'`) to brand the wire format for their service. Must match `/^[A-Za-z0-9_-]{1,32}$/`,
+  and the same prefix must be used at create and verify time.
+- **Errors:** stable `ErrorCode.INVALID_ARGUMENT` / `ErrorCode.INVALID_SECRET` codes on the `ChallengeError` class.

package/dist/errors.d.ts

@@ -1,14 +1,4 @@
-/**
- * Stable machine-readable codes for every programmer-error failure that
- * `@exortek/challenge` can raise. Branch on `code`, never on the
- * message. Note: expected verify failures (bad signature, expired,
- * mismatched claim) are NOT thrown — `verifyChallenge` returns
- * `{ valid: false, reason }` for those so a wrong or stale token is a
- * normal auth outcome, not an exception. Errors below fire only when
- * the caller configured something wrong.
- */
-import { BaseError } from '@exortek/shared/errors';
-export declare const ErrorCode: Readonly<{
+export const ErrorCode: Readonly<{
     INVALID_ARGUMENT: "INVALID_ARGUMENT";
     INVALID_SECRET: "INVALID_SECRET";
 }>;
@@ -17,10 +7,10 @@ export declare const ErrorCode: Readonly<{
  * `code` (from {@link ErrorCode}) and a `status` — the HTTP response
  * status a middleware layer would use when translating the error.
  */
-export declare class ChallengeError extends BaseError {
+export class ChallengeError extends BaseError {
     static statuses: {
         INVALID_ARGUMENT: number;
         INVALID_SECRET: number;
     };
-    static defaultStatus: number;
 }
+import { BaseError } from '@exortek/shared/errors';

package/dist/index.d.ts

@@ -1,130 +1,3 @@
-/**
- * `@exortek/challenge` — signed, single-use challenge tokens for
- * multi-step auth flows.
- *
- * A challenge is a small, HMAC-signed envelope that carries context
- * across a redirect or a follow-up request without a server-side
- * session: who is being challenged (`userId`), how they proved
- * themselves so far (`method`), what step of the flow they've cleared
- * (`step`), and any bespoke metadata the caller needs on the other
- * side. The token is stateless by default; single-use enforcement and
- * revocation are opt-in via a store the caller supplies.
- *
- * See the README for the full API and worked examples.
- */
-export { ChallengeError, ErrorCode } from './errors.js';
-export type ChallengeMethod = 'totp' | 'hotp' | 'email_otp' | 'sms_otp' | 'backup_code' | 'passkey' | 'magic_link' | 'password' | 'webauthn' | 'oauth' | 'oidc' | string;
-export type IncrStore = {
-    /**
-     *   Atomic increment-with-expiry. First call returns `{ count: 1 }` and
-     *   arms a TTL; subsequent calls before expiry return the incremented
-     *   count. Used as compare-and-set for single-use enforcement.
-     */
-    incr: (key: string, ttlMs: number) => Promise<{
-        count: number;
-    }>;
-};
-export type ChallengePayload = {
-    jti: string;
-    iat: number;
-    exp: number;
-    userId?: string;
-    method?: ChallengeMethod;
-    step?: string;
-    nextStep?: string;
-    /**
-     * Only set when `ipBinding: true`.
-     */
-    ip?: string;
-    /**
-     * Only set when `ua` supplied.
-     */
-    ua?: string;
-    meta?: Record<string, unknown>;
-};
-export type CreateChallengeOptions = {
-    /**
-     *   HMAC-SHA256 secret. **Must be at least 32 raw bytes.** A string is
-     *   interpreted as UTF-8 — for a hex or base64 secret, decode to
-     *   Buffer first.
-     */
-    secret: string | Buffer | Uint8Array;
-    userId?: string;
-    method?: ChallengeMethod;
-    step?: string;
-    nextStep?: string;
-    ip?: string;
-    ua?: string;
-    metadata?: Record<string, unknown>;
-    /**
-     * Duration string (`'5m'`) or ms integer.
-     */
-    expiresIn: string | number;
-    /**
-     * When true, the returned token can only be verified once — subsequent
-     * verifies with `consume: true` fail with `reason: 'replay'`. Requires
-     * `store` to be supplied.
-     */
-    singleUse?: boolean;
-    /**
-     * Any object exposing `incr(key, ttlMs) → { count }`. Compatible with
-     * `@exortek/security`'s rate-limit stores; also easy to wrap Redis.
-     */
-    store?: IncrStore;
-    /**
-     * When true, the caller-supplied `ip` is stamped into the payload and
-     * `verifyChallenge` will reject a request whose `ip` differs.
-     */
-    ipBinding?: boolean;
-    /**
-     * Wire-format prefix. Defaults to `'chall_v1'` — the value shipped
-     * with this package. Callers can override to brand the token
-     * family (e.g. `'server_challenge'`, `'myapp_v1'`); must match
-     * `/^[A-Za-z0-9_-]{1,32}$/`. The same prefix must be passed at
-     * verify time or verification returns `reason: 'malformed'`.
-     */
-    prefix?: string;
-    /**
-     * Override `Date.now()` for testing.
-     */
-    now?: number;
-};
-export type VerifyChallengeOptions = {
-    secret: string | Buffer | Uint8Array;
-    /**
-     * Enforce single-use. Requires `store` (typically the same one used
-     * at create time).
-     */
-    consume?: boolean;
-    store?: IncrStore;
-    expectedUserId?: string;
-    expectedMethod?: ChallengeMethod;
-    expectedStep?: string;
-    expectedNextStep?: string;
-    /**
-     * The current request's IP. Required to verify a token that was
-     * created with `ipBinding: true`; ignored otherwise.
-     */
-    ip?: string;
-    /**
-     * Wire-format prefix. Must match the value passed to
-     * `createChallenge` — a token minted with a different prefix will
-     * fail with `reason: 'malformed'`.
-     */
-    prefix?: string;
-    /**
-     * Override `Date.now()` for testing.
-     */
-    now?: number;
-};
-export type VerifyFailureReason = 'malformed' | 'bad_signature' | 'expired' | 'not_yet_valid' | 'user_mismatch' | 'method_mismatch' | 'step_mismatch' | 'next_step_mismatch' | 'ip_mismatch' | 'ip_missing' | 'replay' | 'store_unavailable';
-export type VerifyChallengeResult = {
-    valid: true;
-    payload: ChallengePayload;
-} | {
-    valid: false;
-    reason: VerifyFailureReason;
-};
 /**
  * @typedef {'totp' | 'hotp' | 'email_otp' | 'sms_otp' | 'backup_code'
  *   | 'passkey' | 'magic_link' | 'password' | 'webauthn' | 'oauth' | 'oidc'
@@ -229,7 +102,7 @@ export type VerifyChallengeResult = {
  * @param {CreateChallengeOptions} options
  * @returns {Promise<string>}
  */
-export declare function createChallenge(options: CreateChallengeOptions): Promise<string>;
+export function createChallenge(options: CreateChallengeOptions): Promise<string>;
 /**
  * Verify a challenge token. Returns `{ valid: true, payload }` on
  * success or `{ valid: false, reason }` on any expected failure. Only
@@ -249,4 +122,117 @@ export declare function createChallenge(options: CreateChallengeOptions): Promis
  * @param {VerifyChallengeOptions} options
  * @returns {Promise<VerifyChallengeResult>}
  */
-export declare function verifyChallenge(token: string, options: VerifyChallengeOptions): Promise<VerifyChallengeResult>;
+export function verifyChallenge(token: string, options: VerifyChallengeOptions): Promise<VerifyChallengeResult>;
+export type ChallengeMethod = "totp" | "hotp" | "email_otp" | "sms_otp" | "backup_code" | "passkey" | "magic_link" | "password" | "webauthn" | "oauth" | "oidc" | string;
+export type IncrStore = {
+    /**
+     *   Atomic increment-with-expiry. First call returns `{ count: 1 }` and
+     *   arms a TTL; subsequent calls before expiry return the incremented
+     *   count. Used as compare-and-set for single-use enforcement.
+     */
+    incr: (key: string, ttlMs: number) => Promise<{
+        count: number;
+    }>;
+};
+export type ChallengePayload = {
+    jti: string;
+    iat: number;
+    exp: number;
+    userId?: string | undefined;
+    method?: string | undefined;
+    step?: string | undefined;
+    nextStep?: string | undefined;
+    /**
+     * Only set when `ipBinding: true`.
+     */
+    ip?: string | undefined;
+    /**
+     * Only set when `ua` supplied.
+     */
+    ua?: string | undefined;
+    meta?: Record<string, unknown> | undefined;
+};
+export type CreateChallengeOptions = {
+    /**
+     *   HMAC-SHA256 secret. **Must be at least 32 raw bytes.** A string is
+     *   interpreted as UTF-8 — for a hex or base64 secret, decode to
+     *   Buffer first.
+     */
+    secret: string | Buffer | Uint8Array;
+    userId?: string | undefined;
+    method?: string | undefined;
+    step?: string | undefined;
+    nextStep?: string | undefined;
+    ip?: string | undefined;
+    ua?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    /**
+     * Duration string (`'5m'`) or ms integer.
+     */
+    expiresIn: string | number;
+    /**
+     * When true, the returned token can only be verified once — subsequent
+     * verifies with `consume: true` fail with `reason: 'replay'`. Requires
+     * `store` to be supplied.
+     */
+    singleUse?: boolean | undefined;
+    /**
+     * Any object exposing `incr(key, ttlMs) → { count }`. Compatible with
+     * `@exortek/security`'s rate-limit stores; also easy to wrap Redis.
+     */
+    store?: IncrStore | undefined;
+    /**
+     * When true, the caller-supplied `ip` is stamped into the payload and
+     * `verifyChallenge` will reject a request whose `ip` differs.
+     */
+    ipBinding?: boolean | undefined;
+    /**
+     * Wire-format prefix. Defaults to `'chall_v1'` — the value shipped
+     * with this package. Callers can override to brand the token
+     * family (e.g. `'server_challenge'`, `'myapp_v1'`); must match
+     * `/^[A-Za-z0-9_-]{1,32}$/`. The same prefix must be passed at
+     * verify time or verification returns `reason: 'malformed'`.
+     */
+    prefix?: string | undefined;
+    /**
+     * Override `Date.now()` for testing.
+     */
+    now?: number | undefined;
+};
+export type VerifyChallengeOptions = {
+    secret: string | Buffer | Uint8Array;
+    /**
+     * Enforce single-use. Requires `store` (typically the same one used
+     * at create time).
+     */
+    consume?: boolean | undefined;
+    store?: IncrStore | undefined;
+    expectedUserId?: string | undefined;
+    expectedMethod?: string | undefined;
+    expectedStep?: string | undefined;
+    expectedNextStep?: string | undefined;
+    /**
+     * The current request's IP. Required to verify a token that was
+     * created with `ipBinding: true`; ignored otherwise.
+     */
+    ip?: string | undefined;
+    /**
+     * Wire-format prefix. Must match the value passed to
+     * `createChallenge` — a token minted with a different prefix will
+     * fail with `reason: 'malformed'`.
+     */
+    prefix?: string | undefined;
+    /**
+     * Override `Date.now()` for testing.
+     */
+    now?: number | undefined;
+};
+export type VerifyFailureReason = "malformed" | "bad_signature" | "expired" | "not_yet_valid" | "user_mismatch" | "method_mismatch" | "step_mismatch" | "next_step_mismatch" | "ip_mismatch" | "ip_missing" | "replay" | "store_unavailable";
+export type VerifyChallengeResult = {
+    valid: true;
+    payload: ChallengePayload;
+} | {
+    valid: false;
+    reason: VerifyFailureReason;
+};
+export { ChallengeError, ErrorCode } from "./errors.js";

package/dist/internal/guards.d.ts

@@ -1,8 +1,5 @@
-/**
- * Argument guards bound to `ChallengeError` — the package-wide binding
- * of `@exortek/shared/asserts`. Import guards from here, never from the
- * shared module directly: every argument-shape failure must throw
- * `ChallengeError` with `ErrorCode.INVALID_ARGUMENT` so callers get one
- * error class for the whole package.
- */
-export declare const invalidArgument: (msg: string, extra?: import("@exortek/shared/asserts").WrapExtra) => Error, parse: (schema: import("@exortek/shared/asserts").ParseableSchema, input: unknown, path?: string) => unknown, assertObject: (value: unknown, name: string, opts?: import("@exortek/shared/asserts").AssertOptions) => void, assertNonEmptyString: (value: unknown, name: string, opts?: import("@exortek/shared/asserts").AssertOptions) => void, assertBytes: (value: unknown, name: string, opts?: import("@exortek/shared/asserts").AssertOptions) => void;
+export const invalidArgument: (msg: string, extra?: WrapExtra) => Error;
+export const parse: (schema: ParseableSchema, input: unknown, path?: string) => unknown;
+export const assertObject: (value: unknown, name: string, opts?: AssertOptions) => void;
+export const assertNonEmptyString: (value: unknown, name: string, opts?: AssertOptions) => void;
+export const assertBytes: (value: unknown, name: string, opts?: AssertOptions) => void;

package/dist/stores/index.d.ts

@@ -1,11 +1,5 @@
-/**
- * Store implementations shipped with `@exortek/challenge`. Any object
- * exposing the {@link IncrStore} shape works — these are provided as
- * a zero-config default (memory) and a cluster-safe default (Redis).
- * `@exortek/security`'s rate-limit stores are wire-compatible.
- */
-export { memoryStore } from './memory.js';
-export { redisStore } from './redis.js';
+export { memoryStore } from "./memory.js";
+export { redisStore } from "./redis.js";
 export type IncrStore = {
     /**
      *   Atomic increment-with-expiry. First call for a fresh key returns
@@ -18,11 +12,3 @@ export type IncrStore = {
         expiresAt?: number;
     }>;
 };
-/**
- * @typedef {object} IncrStore
- * @property {(key: string, ttlMs: number) => Promise<{ count: number, expiresAt?: number }>} incr
- *   Atomic increment-with-expiry. First call for a fresh key returns
- *   `{ count: 1 }` and arms a TTL of `ttlMs`; subsequent calls before
- *   expiry return the incremented count. `verifyChallenge` reads
- *   `count > 1` as "already consumed".
- */

package/dist/stores/memory.d.ts

@@ -1,40 +1,3 @@
-/**
- * In-process memory store for challenge single-use enforcement.
- *
- * Not cluster-safe: every worker has its own state, so a token accepted
- * on one worker could still be replayed on another. Use for dev,
- * single-node deploys, sticky-session behind an LB, and tests. For
- * multi-worker production, use {@link redisStore} or pass any object
- * exposing `incr(key, ttlMs) → { count }` (e.g.
- * `@exortek/security`'s rate-limit stores).
- *
- * Eviction: true LRU (least-recently-used). Every `incr` on an existing
- * key re-inserts it so it becomes the newest entry;
- * `map.keys().next().value` is then the least-recently-touched key and
- * is dropped when `maxKeys` is exceeded. This matters for the
- * replay-guard tombstone: a repeated verify attempt refreshes the
- * `count > 1` entry so it stays authoritative until its TTL expires.
- * FIFO would let an idle tombstone age out prematurely and a third
- * replay attempt could see a fresh counter.
- *
- * Textbook pattern, popularised in the JS community by projects like
- * `toad-cache` (MIT); no code copied, only the same ES2015
- * iteration-order guarantee.
- *
- * Expired entries are pruned lazily on read, plus a `setInterval` sweep
- * (unref'd so it never blocks process exit). The `maxKeys` cap
- * protects against unbounded growth if the caller forgets to clean up.
- */
-export type MemoryStoreOptions = {
-    /**
-     * Hard cap; oldest entry dropped when exceeded.
-     */
-    maxKeys?: number;
-    /**
-     * Interval for the background TTL sweep.
-     */
-    sweepMs?: number;
-};
 /**
  * @typedef {object} MemoryStoreOptions
  * @property {number} [maxKeys=10000]   Hard cap; oldest entry dropped when exceeded.
@@ -44,7 +7,17 @@ export type MemoryStoreOptions = {
  * @param {MemoryStoreOptions} [options]
  * @returns {import('./index.js').IncrStore & { _size: () => number, _stop: () => void }}
  */
-export declare function memoryStore(options?: MemoryStoreOptions): import('./index.js').IncrStore & {
+export function memoryStore(options?: MemoryStoreOptions): import("./index.js").IncrStore & {
     _size: () => number;
     _stop: () => void;
 };
+export type MemoryStoreOptions = {
+    /**
+     * Hard cap; oldest entry dropped when exceeded.
+     */
+    maxKeys?: number | undefined;
+    /**
+     * Interval for the background TTL sweep.
+     */
+    sweepMs?: number | undefined;
+};

package/dist/stores/redis.d.ts

@@ -1,24 +1,3 @@
-/**
- * Redis-backed store for challenge single-use enforcement.
- *
- * Cluster-safe: state lives in Redis, so a challenge accepted on one
- * worker cannot be replayed on another. Works with any client exposing
- * `eval(script, numkeys, ...args)` — verified against `ioredis`,
- * `node-redis` v4+, and `@upstash/redis` (HTTP client, runs on
- * Cloudflare Workers / Vercel Edge / Deno Deploy).
- *
- * Atomicity: `incr` runs a single Lua script that INCR's the key and
- * PEXPIRE's it only when the key is fresh (count === 1). The TTL
- * anchors to the first increment — exactly what single-use enforcement
- * needs (the tombstone lives as long as the token could still verify,
- * then rolls off).
- */
-export type RedisStoreOptions = {
-    /**
-     * Prepended to every key.
-     */
-    keyPrefix?: string;
-};
 /**
  * @typedef {object} RedisStoreOptions
  * @property {string} [keyPrefix='chall:']   Prepended to every key.
@@ -28,4 +7,10 @@ export type RedisStoreOptions = {
  * @param {RedisStoreOptions} [options]
  * @returns {import('./index.js').IncrStore}
  */
-export declare function redisStore(client: any, options?: RedisStoreOptions): import('./index.js').IncrStore;
+export function redisStore(client: any, options?: RedisStoreOptions): import("./index.js").IncrStore;
+export type RedisStoreOptions = {
+    /**
+     * Prepended to every key.
+     */
+    keyPrefix?: string | undefined;
+};

package/dist/stores.cjs

@@ -59,6 +59,194 @@ function isInteger(value) {
   return Number.isSafeInteger(value);
 }
 
+/**
+ * Duck-type guard for a Redis-compatible client. Every `@exortek/*`
+ * package that ships a Redis store (jwt blacklist, session store,
+ * security rate-limit) does the same "not null + required methods
+ * are functions" check up front so a missing dependency surfaces as
+ * a clean typed error instead of `TypeError: client.get is not a
+ * function` deep in a store operation.
+ *
+ * Callers pass their own `wrap` callback that throws their typed
+ * error class with the message — this file has no opinion on the
+ * error surface.
+ */
+
+/**
+ * @param {unknown} client
+ * @param {readonly string[]} methods  Method names that must be functions on the client.
+ * @param {(message: string) => never} wrap
+ *   Called with a diagnostic message when the check fails; must throw.
+ *   The caller's typed error class is emitted from inside this callback.
+ * @returns {void}
+ */
+function assertRedisClient(client, methods, wrap) {
+  if (!client || typeof client !== 'object') {
+    wrap('client is required — pass a Redis-compatible instance (ioredis / node-redis / @upstash/redis)');
+  }
+  const c = /** @type {Record<string, unknown>} */ (client);
+  for (const method of methods) {
+    if (typeof c[method] !== 'function') {
+      wrap(`client is missing '${method}()' — is this a Redis-compatible client?`);
+    }
+  }
+}
+
+/**
+ * Shared IncrStore — atomic TTL counter for replay guards and rate
+ * limiting. Memory and Redis factories.
+ *
+ * Interface: `incr(key, ttlMs) → { count, expiresAt }`.
+ * First call arms a TTL and returns `{ count: 1 }`; subsequent calls
+ * before expiry increment the counter.
+ *
+ * Consumers: `@exortek/challenge`, `@exortek/magic-link` (rate limiter).
+ */
+
+
+// Memory
+
+/**
+ * @typedef {object} MemoryIncrStoreOptions
+ * @property {number} [maxKeys=10000]  Hard cap; oldest entry dropped when exceeded.
+ * @property {number} [sweepMs=60000]  Interval for the background TTL sweep.
+ */
+
+/**
+ * @param {MemoryIncrStoreOptions} [options]
+ * @param {(msg: string) => never} [wrap]  Error factory for validation.
+ * @returns {{ incr: (key: string, ttlMs: number) => Promise<{ count: number, expiresAt: number }>, _size: () => number, _stop: () => void }}
+ */
+function createMemoryIncrStore(options = {}, wrap) {
+  const fail = wrap ?? (msg => { throw new TypeError(msg); });
+  const maxKeys = options.maxKeys ?? 10_000;
+  const sweepMs = options.sweepMs ?? 60_000;
+
+  if (!isInteger(maxKeys) || maxKeys < 1) {
+    fail(`memoryIncrStore.maxKeys must be a positive integer; got ${maxKeys}`);
+  }
+  if (!isInteger(sweepMs) || sweepMs < 1000) {
+    fail(`memoryIncrStore.sweepMs must be an integer >= 1000; got ${sweepMs}`);
+  }
+
+  /** @type {Map<string, { count: number, expiresAt: number }>} */
+  const map = new Map();
+  let timer = null;
+
+  function peekFresh(key) {
+    const entry = map.get(key);
+    if (!entry) {
+      return null;
+    }
+    if (entry.expiresAt <= Date.now()) {
+      map.delete(key);
+      return null;
+    }
+    return entry;
+  }
+
+  function sweep() {
+    const t = Date.now();
+    for (const [key, entry] of map) {
+      if (entry.expiresAt <= t) {
+        map.delete(key);
+      }
+    }
+  }
+
+  function scheduleSweeper() {
+    if (timer) {
+      return;
+    }
+    timer = setInterval(sweep, sweepMs);
+    if (isFunction(timer.unref)) {
+      timer.unref();
+    }
+  }
+
+  function evictIfFull() {
+    if (map.size < maxKeys) {
+      return;
+    }
+    const oldest = map.keys().next().value;
+    if (!isUndefined(oldest)) {
+      map.delete(oldest);
+    }
+  }
+
+  return {
+    async incr(key, ttlMs) {
+      scheduleSweeper();
+      const existing = peekFresh(key);
+      if (existing) {
+        existing.count += 1;
+        map.delete(key);
+        map.set(key, existing);
+        return { count: existing.count, expiresAt: existing.expiresAt };
+      }
+      evictIfFull();
+      const expiresAt = Date.now() + ttlMs;
+      map.set(key, { count: 1, expiresAt });
+      return { count: 1, expiresAt };
+    },
+
+    _size: () => map.size,
+    _stop: () => {
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+    },
+  };
+}
+
+// Redis
+
+const INCR_SCRIPT = `
+local key = KEYS[1]
+local ttl = tonumber(ARGV[1])
+local count = redis.call('INCR', key)
+local pttl
+if count == 1 then
+  redis.call('PEXPIRE', key, ttl)
+  pttl = ttl
+else
+  pttl = redis.call('PTTL', key)
+  if pttl < 0 then
+    redis.call('PEXPIRE', key, ttl)
+    pttl = ttl
+  end
+end
+return { count, pttl }
+`.trim();
+
+/**
+ * @typedef {object} RedisIncrStoreOptions
+ * @property {string} [keyPrefix='']  Prepended to every key.
+ */
+
+/**
+ * @param {object} client
+ * @param {RedisIncrStoreOptions} [options]
+ * @param {(msg: string) => never} [wrap]  Error factory for assertRedisClient.
+ * @returns {{ incr: (key: string, ttlMs: number) => Promise<{ count: number, expiresAt: number }> }}
+ */
+function createRedisIncrStore(client, options = {}, wrap) {
+  assertRedisClient(client, ['eval'], wrap ?? (msg => { throw new TypeError(msg); }));
+  const keyPrefix = options.keyPrefix ?? '';
+  const k = key => `${keyPrefix}${key}`;
+
+  return {
+    async incr(key, ttlMs) {
+      const raw = await client.eval(INCR_SCRIPT, 1, k(key), String(Math.max(1, Math.ceil(ttlMs))));
+      const arr = Array.isArray(raw) ? raw : [raw, ttlMs];
+      const count = Number(arr[0]);
+      const pttl = Number(arr[1]);
+      return { count, expiresAt: Date.now() + (Number.isFinite(pttl) && pttl > 0 ? pttl : ttlMs) };
+    },
+  };
+}
+
 /**
  * Imperative single-argument guard helpers — the everyday
  * `assertPositiveInt(x, 'name')` shape used at API boundaries.
@@ -524,121 +712,9 @@ const { invalidArgument} = defineGuards(
  * @returns {import('./index.js').IncrStore & { _size: () => number, _stop: () => void }}
  */
 function memoryStore(options = {}) {
-  const maxKeys = options.maxKeys ?? 10_000;
-  const sweepMs = options.sweepMs ?? 60_000;
-
-  if (!isInteger(maxKeys) || maxKeys < 1) {
-    throw invalidArgument(`memoryStore.options.maxKeys must be a positive integer; got ${maxKeys}`);
-  }
-  if (!isInteger(sweepMs) || sweepMs < 1000) {
-    throw invalidArgument(`memoryStore.options.sweepMs must be an integer >= 1000; got ${sweepMs}`);
-  }
-
-  /** @type {Map<string, { count: number, expiresAt: number }>} */
-  const map = new Map();
-  let timer = null;
-
-  function peekFresh(key) {
-    const entry = map.get(key);
-    if (!entry) {
-      return null;
-    }
-    if (entry.expiresAt <= Date.now()) {
-      map.delete(key);
-      return null;
-    }
-    return entry;
-  }
-
-  function sweep() {
-    const t = Date.now();
-    for (const [key, entry] of map) {
-      if (entry.expiresAt <= t) {
-        map.delete(key);
-      }
-    }
-  }
-
-  function scheduleSweeper() {
-    if (timer) {
-      return;
-    }
-    timer = setInterval(sweep, sweepMs);
-    if (isFunction(timer.unref)) {
-      timer.unref();
-    }
-  }
-
-  function evictIfFull() {
-    if (map.size < maxKeys) {
-      return;
-    }
-    const oldest = map.keys().next().value;
-    if (!isUndefined(oldest)) {
-      map.delete(oldest);
-    }
-  }
-
-  return {
-    async incr(key, ttlMs) {
-      scheduleSweeper();
-      const existing = peekFresh(key);
-      if (existing) {
-        existing.count += 1;
-        // Refresh LRU position on activity — the replay-guard tombstone
-        // must stay warm until its TTL fires, or a third replay attempt
-        // could see the entry evicted and get a fresh count.
-        map.delete(key);
-        map.set(key, existing);
-        return { count: existing.count, expiresAt: existing.expiresAt };
-      }
-      evictIfFull();
-      const expiresAt = Date.now() + ttlMs;
-      map.set(key, { count: 1, expiresAt });
-      return { count: 1, expiresAt };
-    },
-
-    _size: () => map.size,
-    _stop: () => {
-      if (timer) {
-        clearInterval(timer);
-        timer = null;
-      }
-    },
-  };
-}
-
-/**
- * Duck-type guard for a Redis-compatible client. Every `@exortek/*`
- * package that ships a Redis store (jwt blacklist, session store,
- * security rate-limit) does the same "not null + required methods
- * are functions" check up front so a missing dependency surfaces as
- * a clean typed error instead of `TypeError: client.get is not a
- * function` deep in a store operation.
- *
- * Callers pass their own `wrap` callback that throws their typed
- * error class with the message — this file has no opinion on the
- * error surface.
- */
-
-/**
- * @param {unknown} client
- * @param {readonly string[]} methods  Method names that must be functions on the client.
- * @param {(message: string) => never} wrap
- *   Called with a diagnostic message when the check fails; must throw.
- *   The caller's typed error class is emitted from inside this callback.
- * @returns {void}
- */
-function assertRedisClient(client, methods, wrap) {
-  if (!client || typeof client !== 'object') {
-    wrap('client is required — pass a Redis-compatible instance (ioredis / node-redis / @upstash/redis)');
-  }
-  const c = /** @type {Record<string, unknown>} */ (client);
-  for (const method of methods) {
-    if (typeof c[method] !== 'function') {
-      wrap(`client is missing '${method}()' — is this a Redis-compatible client?`);
-    }
-  }
+  return createMemoryIncrStore(options, msg => {
+    throw invalidArgument(msg);
+  });
 }
 
 /**
@@ -658,24 +734,6 @@ function assertRedisClient(client, methods, wrap) {
  */
 
 
-const INCR_SCRIPT = `
-local key = KEYS[1]
-local ttl = tonumber(ARGV[1])
-local count = redis.call('INCR', key)
-local pttl
-if count == 1 then
-  redis.call('PEXPIRE', key, ttl)
-  pttl = ttl
-else
-  pttl = redis.call('PTTL', key)
-  if pttl < 0 then
-    redis.call('PEXPIRE', key, ttl)
-    pttl = ttl
-  end
-end
-return { count, pttl }
-`.trim();
-
 /**
  * @typedef {object} RedisStoreOptions
  * @property {string} [keyPrefix='chall:']   Prepended to every key.
@@ -687,23 +745,9 @@ return { count, pttl }
  * @returns {import('./index.js').IncrStore}
  */
 function redisStore(client, options = {}) {
-  assertRedisClient(client, ['eval'], msg => {
+  return createRedisIncrStore(client, { keyPrefix: options.keyPrefix ?? 'chall:' }, msg => {
     throw invalidArgument(`redisStore.client: ${msg}`);
   });
-  const keyPrefix = options.keyPrefix ?? 'chall:';
-  const k = key => `${keyPrefix}${key}`;
-
-  return {
-    async incr(key, ttlMs) {
-      const raw = await client.eval(INCR_SCRIPT, 1, k(key), String(Math.max(1, Math.ceil(ttlMs))));
-      // ioredis returns [count, pttl] as numbers; node-redis v4 does too;
-      // Upstash HTTP driver returns strings. Coerce defensively.
-      const arr = Array.isArray(raw) ? raw : [raw, ttlMs];
-      const count = Number(arr[0]);
-      const pttl = Number(arr[1]);
-      return { count, expiresAt: Date.now() + (Number.isFinite(pttl) && pttl > 0 ? pttl : ttlMs) };
-    },
-  };
 }
 
 exports.memoryStore = memoryStore;

package/dist/stores.mjs

@@ -57,6 +57,194 @@ function isInteger(value) {
   return Number.isSafeInteger(value);
 }
 
+/**
+ * Duck-type guard for a Redis-compatible client. Every `@exortek/*`
+ * package that ships a Redis store (jwt blacklist, session store,
+ * security rate-limit) does the same "not null + required methods
+ * are functions" check up front so a missing dependency surfaces as
+ * a clean typed error instead of `TypeError: client.get is not a
+ * function` deep in a store operation.
+ *
+ * Callers pass their own `wrap` callback that throws their typed
+ * error class with the message — this file has no opinion on the
+ * error surface.
+ */
+
+/**
+ * @param {unknown} client
+ * @param {readonly string[]} methods  Method names that must be functions on the client.
+ * @param {(message: string) => never} wrap
+ *   Called with a diagnostic message when the check fails; must throw.
+ *   The caller's typed error class is emitted from inside this callback.
+ * @returns {void}
+ */
+function assertRedisClient(client, methods, wrap) {
+  if (!client || typeof client !== 'object') {
+    wrap('client is required — pass a Redis-compatible instance (ioredis / node-redis / @upstash/redis)');
+  }
+  const c = /** @type {Record<string, unknown>} */ (client);
+  for (const method of methods) {
+    if (typeof c[method] !== 'function') {
+      wrap(`client is missing '${method}()' — is this a Redis-compatible client?`);
+    }
+  }
+}
+
+/**
+ * Shared IncrStore — atomic TTL counter for replay guards and rate
+ * limiting. Memory and Redis factories.
+ *
+ * Interface: `incr(key, ttlMs) → { count, expiresAt }`.
+ * First call arms a TTL and returns `{ count: 1 }`; subsequent calls
+ * before expiry increment the counter.
+ *
+ * Consumers: `@exortek/challenge`, `@exortek/magic-link` (rate limiter).
+ */
+
+
+// Memory
+
+/**
+ * @typedef {object} MemoryIncrStoreOptions
+ * @property {number} [maxKeys=10000]  Hard cap; oldest entry dropped when exceeded.
+ * @property {number} [sweepMs=60000]  Interval for the background TTL sweep.
+ */
+
+/**
+ * @param {MemoryIncrStoreOptions} [options]
+ * @param {(msg: string) => never} [wrap]  Error factory for validation.
+ * @returns {{ incr: (key: string, ttlMs: number) => Promise<{ count: number, expiresAt: number }>, _size: () => number, _stop: () => void }}
+ */
+function createMemoryIncrStore(options = {}, wrap) {
+  const fail = wrap ?? (msg => { throw new TypeError(msg); });
+  const maxKeys = options.maxKeys ?? 10_000;
+  const sweepMs = options.sweepMs ?? 60_000;
+
+  if (!isInteger(maxKeys) || maxKeys < 1) {
+    fail(`memoryIncrStore.maxKeys must be a positive integer; got ${maxKeys}`);
+  }
+  if (!isInteger(sweepMs) || sweepMs < 1000) {
+    fail(`memoryIncrStore.sweepMs must be an integer >= 1000; got ${sweepMs}`);
+  }
+
+  /** @type {Map<string, { count: number, expiresAt: number }>} */
+  const map = new Map();
+  let timer = null;
+
+  function peekFresh(key) {
+    const entry = map.get(key);
+    if (!entry) {
+      return null;
+    }
+    if (entry.expiresAt <= Date.now()) {
+      map.delete(key);
+      return null;
+    }
+    return entry;
+  }
+
+  function sweep() {
+    const t = Date.now();
+    for (const [key, entry] of map) {
+      if (entry.expiresAt <= t) {
+        map.delete(key);
+      }
+    }
+  }
+
+  function scheduleSweeper() {
+    if (timer) {
+      return;
+    }
+    timer = setInterval(sweep, sweepMs);
+    if (isFunction(timer.unref)) {
+      timer.unref();
+    }
+  }
+
+  function evictIfFull() {
+    if (map.size < maxKeys) {
+      return;
+    }
+    const oldest = map.keys().next().value;
+    if (!isUndefined(oldest)) {
+      map.delete(oldest);
+    }
+  }
+
+  return {
+    async incr(key, ttlMs) {
+      scheduleSweeper();
+      const existing = peekFresh(key);
+      if (existing) {
+        existing.count += 1;
+        map.delete(key);
+        map.set(key, existing);
+        return { count: existing.count, expiresAt: existing.expiresAt };
+      }
+      evictIfFull();
+      const expiresAt = Date.now() + ttlMs;
+      map.set(key, { count: 1, expiresAt });
+      return { count: 1, expiresAt };
+    },
+
+    _size: () => map.size,
+    _stop: () => {
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+    },
+  };
+}
+
+// Redis
+
+const INCR_SCRIPT = `
+local key = KEYS[1]
+local ttl = tonumber(ARGV[1])
+local count = redis.call('INCR', key)
+local pttl
+if count == 1 then
+  redis.call('PEXPIRE', key, ttl)
+  pttl = ttl
+else
+  pttl = redis.call('PTTL', key)
+  if pttl < 0 then
+    redis.call('PEXPIRE', key, ttl)
+    pttl = ttl
+  end
+end
+return { count, pttl }
+`.trim();
+
+/**
+ * @typedef {object} RedisIncrStoreOptions
+ * @property {string} [keyPrefix='']  Prepended to every key.
+ */
+
+/**
+ * @param {object} client
+ * @param {RedisIncrStoreOptions} [options]
+ * @param {(msg: string) => never} [wrap]  Error factory for assertRedisClient.
+ * @returns {{ incr: (key: string, ttlMs: number) => Promise<{ count: number, expiresAt: number }> }}
+ */
+function createRedisIncrStore(client, options = {}, wrap) {
+  assertRedisClient(client, ['eval'], wrap ?? (msg => { throw new TypeError(msg); }));
+  const keyPrefix = options.keyPrefix ?? '';
+  const k = key => `${keyPrefix}${key}`;
+
+  return {
+    async incr(key, ttlMs) {
+      const raw = await client.eval(INCR_SCRIPT, 1, k(key), String(Math.max(1, Math.ceil(ttlMs))));
+      const arr = Array.isArray(raw) ? raw : [raw, ttlMs];
+      const count = Number(arr[0]);
+      const pttl = Number(arr[1]);
+      return { count, expiresAt: Date.now() + (Number.isFinite(pttl) && pttl > 0 ? pttl : ttlMs) };
+    },
+  };
+}
+
 /**
  * Imperative single-argument guard helpers — the everyday
  * `assertPositiveInt(x, 'name')` shape used at API boundaries.
@@ -522,121 +710,9 @@ const { invalidArgument} = defineGuards(
  * @returns {import('./index.js').IncrStore & { _size: () => number, _stop: () => void }}
  */
 function memoryStore(options = {}) {
-  const maxKeys = options.maxKeys ?? 10_000;
-  const sweepMs = options.sweepMs ?? 60_000;
-
-  if (!isInteger(maxKeys) || maxKeys < 1) {
-    throw invalidArgument(`memoryStore.options.maxKeys must be a positive integer; got ${maxKeys}`);
-  }
-  if (!isInteger(sweepMs) || sweepMs < 1000) {
-    throw invalidArgument(`memoryStore.options.sweepMs must be an integer >= 1000; got ${sweepMs}`);
-  }
-
-  /** @type {Map<string, { count: number, expiresAt: number }>} */
-  const map = new Map();
-  let timer = null;
-
-  function peekFresh(key) {
-    const entry = map.get(key);
-    if (!entry) {
-      return null;
-    }
-    if (entry.expiresAt <= Date.now()) {
-      map.delete(key);
-      return null;
-    }
-    return entry;
-  }
-
-  function sweep() {
-    const t = Date.now();
-    for (const [key, entry] of map) {
-      if (entry.expiresAt <= t) {
-        map.delete(key);
-      }
-    }
-  }
-
-  function scheduleSweeper() {
-    if (timer) {
-      return;
-    }
-    timer = setInterval(sweep, sweepMs);
-    if (isFunction(timer.unref)) {
-      timer.unref();
-    }
-  }
-
-  function evictIfFull() {
-    if (map.size < maxKeys) {
-      return;
-    }
-    const oldest = map.keys().next().value;
-    if (!isUndefined(oldest)) {
-      map.delete(oldest);
-    }
-  }
-
-  return {
-    async incr(key, ttlMs) {
-      scheduleSweeper();
-      const existing = peekFresh(key);
-      if (existing) {
-        existing.count += 1;
-        // Refresh LRU position on activity — the replay-guard tombstone
-        // must stay warm until its TTL fires, or a third replay attempt
-        // could see the entry evicted and get a fresh count.
-        map.delete(key);
-        map.set(key, existing);
-        return { count: existing.count, expiresAt: existing.expiresAt };
-      }
-      evictIfFull();
-      const expiresAt = Date.now() + ttlMs;
-      map.set(key, { count: 1, expiresAt });
-      return { count: 1, expiresAt };
-    },
-
-    _size: () => map.size,
-    _stop: () => {
-      if (timer) {
-        clearInterval(timer);
-        timer = null;
-      }
-    },
-  };
-}
-
-/**
- * Duck-type guard for a Redis-compatible client. Every `@exortek/*`
- * package that ships a Redis store (jwt blacklist, session store,
- * security rate-limit) does the same "not null + required methods
- * are functions" check up front so a missing dependency surfaces as
- * a clean typed error instead of `TypeError: client.get is not a
- * function` deep in a store operation.
- *
- * Callers pass their own `wrap` callback that throws their typed
- * error class with the message — this file has no opinion on the
- * error surface.
- */
-
-/**
- * @param {unknown} client
- * @param {readonly string[]} methods  Method names that must be functions on the client.
- * @param {(message: string) => never} wrap
- *   Called with a diagnostic message when the check fails; must throw.
- *   The caller's typed error class is emitted from inside this callback.
- * @returns {void}
- */
-function assertRedisClient(client, methods, wrap) {
-  if (!client || typeof client !== 'object') {
-    wrap('client is required — pass a Redis-compatible instance (ioredis / node-redis / @upstash/redis)');
-  }
-  const c = /** @type {Record<string, unknown>} */ (client);
-  for (const method of methods) {
-    if (typeof c[method] !== 'function') {
-      wrap(`client is missing '${method}()' — is this a Redis-compatible client?`);
-    }
-  }
+  return createMemoryIncrStore(options, msg => {
+    throw invalidArgument(msg);
+  });
 }
 
 /**
@@ -656,24 +732,6 @@ function assertRedisClient(client, methods, wrap) {
  */
 
 
-const INCR_SCRIPT = `
-local key = KEYS[1]
-local ttl = tonumber(ARGV[1])
-local count = redis.call('INCR', key)
-local pttl
-if count == 1 then
-  redis.call('PEXPIRE', key, ttl)
-  pttl = ttl
-else
-  pttl = redis.call('PTTL', key)
-  if pttl < 0 then
-    redis.call('PEXPIRE', key, ttl)
-    pttl = ttl
-  end
-end
-return { count, pttl }
-`.trim();
-
 /**
  * @typedef {object} RedisStoreOptions
  * @property {string} [keyPrefix='chall:']   Prepended to every key.
@@ -685,23 +743,9 @@ return { count, pttl }
  * @returns {import('./index.js').IncrStore}
  */
 function redisStore(client, options = {}) {
-  assertRedisClient(client, ['eval'], msg => {
+  return createRedisIncrStore(client, { keyPrefix: options.keyPrefix ?? 'chall:' }, msg => {
     throw invalidArgument(`redisStore.client: ${msg}`);
   });
-  const keyPrefix = options.keyPrefix ?? 'chall:';
-  const k = key => `${keyPrefix}${key}`;
-
-  return {
-    async incr(key, ttlMs) {
-      const raw = await client.eval(INCR_SCRIPT, 1, k(key), String(Math.max(1, Math.ceil(ttlMs))));
-      // ioredis returns [count, pttl] as numbers; node-redis v4 does too;
-      // Upstash HTTP driver returns strings. Coerce defensively.
-      const arr = Array.isArray(raw) ? raw : [raw, ttlMs];
-      const count = Number(arr[0]);
-      const pttl = Number(arr[1]);
-      return { count, expiresAt: Date.now() + (Number.isFinite(pttl) && pttl > 0 ? pttl : ttlMs) };
-    },
-  };
 }
 
 export { memoryStore, redisStore };

package/dist/token.d.ts

@@ -1,23 +1,3 @@
-/**
- * Token codec for `@exortek/challenge`.
- *
- * Format:
- *
- *     <prefix>.<base64url(JSON payload)>.<base64url(HMAC-SHA256 tag)>
- *
- * The default prefix is {@link DEFAULT_PREFIX} (`chall_v1`) — deliberately
- * unlike a JWT so the two token families cannot be confused at a call
- * site. Callers may override it (e.g. `'server_challenge'`,
- * `'myapp_v1'`) to brand the wire format for a specific service; the
- * same prefix must be used at create and verify time, or verification
- * returns `reason: 'malformed'`.
- *
- * HMAC covers `<prefix>.<b64u payload>` — the same string the caller
- * received minus the trailing tag. Any change to prefix or payload
- * invalidates the signature; a token minted with one prefix cannot be
- * accepted under another even by the same secret.
- */
-export declare const DEFAULT_PREFIX = "chall_v1";
 /**
  * Assert a prefix is well-shaped. Throws via the caller's `invalidArg`
  * function so `createChallenge` / `verifyChallenge` can raise
@@ -29,7 +9,7 @@ export declare const DEFAULT_PREFIX = "chall_v1";
  * @param {(msg: string) => Error} invalidArg
  * @returns {string}
  */
-export declare function assertPrefix(prefix: string, name: string, invalidArg: (msg: string) => Error): string;
+export function assertPrefix(prefix: string, name: string, invalidArg: (msg: string) => Error): string;
 /**
  * Random ID for the token's `jti` claim — 128 bits of entropy, encoded
  * as 22 base64url characters. Used as the store key for single-use
@@ -37,7 +17,7 @@ export declare function assertPrefix(prefix: string, name: string, invalidArg: (
  *
  * @returns {string}
  */
-export declare function newJti(): string;
+export function newJti(): string;
 /**
  * Sign a payload with `secret` and return the compact token string.
  *
@@ -46,7 +26,7 @@ export declare function newJti(): string;
  * @param {string} [prefix]   Wire prefix; defaults to {@link DEFAULT_PREFIX}.
  * @returns {string}
  */
-export declare function sign(payload: object, secret: Buffer, prefix?: string): string;
+export function sign(payload: object, secret: Buffer, prefix?: string): string;
 /**
  * Parse + HMAC-verify a token. Returns the decoded payload on success,
  * or a reason string on any failure. Never throws on user-input
@@ -57,8 +37,9 @@ export declare function sign(payload: object, secret: Buffer, prefix?: string):
  * @param {string} [prefix]   Expected prefix; defaults to {@link DEFAULT_PREFIX}.
  * @returns {{ payload: object } | { reason: 'malformed' | 'bad_signature' }}
  */
-export declare function decode(token: string, secret: Buffer, prefix?: string): {
+export function decode(token: string, secret: Buffer, prefix?: string): {
     payload: object;
 } | {
-    reason: 'malformed' | 'bad_signature';
+    reason: "malformed" | "bad_signature";
 };
+export const DEFAULT_PREFIX: "chall_v1";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exortek/challenge",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Signed, single-use challenge tokens for multi-step auth flows on Node.js — carries userId / method / step / metadata across a redirect or a second request without a server-side session; HMAC-signed, expiring, optional IP-binding, single-use enforcement via any @exortek/security store.",
   "type": "module",
   "sideEffects": false,