lacewing 1.0.0

package/dist/types/src/jwt/verify.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The one and only verification path (RFC 8725 §3.3).
+ *
+ * Order of operations, fail-fast, all-or-nothing:
+ *   1. structural parse (length cap, strict base64url, strict UTF-8)
+ *   2. header validation (allowlist, typ, kid hygiene, forbidden params)
+ *   3. key resolution from the profile's key source
+ *   4. signature verification
+ *   5. claims validation
+ *   6. custom claim validators
+ *   7. revocation check - last, so unauthenticated input can never
+ *      drive store lookups (LW-rev.3)
+ *
+ * There is no partial result and no decoded-but-unverified escape hatch
+ * here; that lives, loudly branded, in `util/unsafe-decode.ts`.
+ */
+import { type ExpectedJwtProfile, type VerifiedJwt } from "../types.js";
+/**
+ * Verify a token against a profile. The returned {@link VerifiedJwt} is
+ * the only way to obtain one - there is no backdoor.
+ *
+ * On any failure it throws a typed error ({@link JWTExpired},
+ * {@link AlgorithmNotAllowed}, {@link JWTClaimValidationFailed}, ...) and yields
+ * no partial result. There is no `decode()` and no `ignoreExpiration`.
+ *
+ * @example
+ * ```ts
+ * const profile = defineProfile({
+ *   typ: "at+jwt",
+ *   issuer: "https://auth.example.com",
+ *   audience: "https://api.example.com",
+ *   algorithms: ["EdDSA"],
+ *   keys: createRemoteJWKSet("https://auth.example.com/jwks"),
+ *   maxTokenAge: "10m",
+ * });
+ *
+ * const { payload } = await jwtVerify(token, profile); // every check passed
+ * ```
+ */
+export declare function jwtVerify(token: string, profile: ExpectedJwtProfile): Promise<VerifiedJwt>;
+//# sourceMappingURL=verify.d.ts.map

package/dist/types/src/jwt/verify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["../../../../src/jwt/verify.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAgBH,OAAO,EAEN,KAAK,kBAAkB,EAIvB,KAAK,WAAW,EAChB,MAAM,aAAa,CAAC;AAwBrB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,SAAS,CAC9B,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,kBAAkB,GACzB,OAAO,CAAC,WAAW,CAAC,CA+DtB"}

package/dist/types/src/key/encryption.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Encryption key import/generation (the JWE counterpart of `key/import.ts` and
+ * `key/generate.ts`). Every encryption key enters here and leaves bound to
+ * exactly one key-management algorithm, carried in the type. `EncryptJWT` and
+ * `jwtDecrypt` never accept a bare `CryptoKey`, so the binding cannot be
+ * bypassed - and a signing key can never be used to encrypt (different brand).
+ */
+import { type LacewingEncryptionKey, type StaticJWK } from "../types.js";
+/** JWK object, PEM string (PKCS#8 / SPKI), raw secret, or a CryptoKey. */
+export type EncryptionKeyMaterial = StaticJWK | string | Uint8Array | CryptoKey;
+export interface GenerateEncryptionKeyPairOptions {
+    extractable?: boolean;
+}
+/**
+ * Generate an asymmetric encryption key pair for `algorithm` (ECDH-ES* or
+ * RSA-OAEP-256). The recipient keeps the private key; senders encrypt to the
+ * public key.
+ */
+export declare function generateEncryptionKeyPair<const Alg extends string>(algorithm: Alg, options?: GenerateEncryptionKeyPairOptions): Promise<{
+    publicKey: LacewingEncryptionKey<Alg>;
+    privateKey: LacewingEncryptionKey<Alg>;
+}>;
+/** Generate a random symmetric key for an AES key-wrapping algorithm (A*KW / A*GCMKW). */
+export declare function generateEncryptionSecret<const Alg extends string>(algorithm: Alg): LacewingEncryptionKey<Alg>;
+/**
+ * Generate a random direct (`alg: "dir"`) key sized to a content-encryption
+ * algorithm. The key *is* the content-encryption key, so it is inseparable
+ * from its `enc`: a 32-byte key is for A256GCM/A128CBC-HS256, and so on.
+ */
+export declare function generateDirectKey<const Enc extends string>(enc: Enc): LacewingEncryptionKey<"dir">;
+/**
+ * Import encryption key material and bind it to `algorithm`. Throws
+ * {@link KeyTypeMismatch} when material and algorithm disagree, and
+ * {@link KeyImportFailed} for anything else.
+ */
+export declare function importEncryptionKey<const Alg extends string>(material: EncryptionKeyMaterial, algorithm: Alg): Promise<LacewingEncryptionKey<Alg>>;
+//# sourceMappingURL=encryption.d.ts.map

package/dist/types/src/key/encryption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encryption.d.ts","sourceRoot":"","sources":["../../../../src/key/encryption.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAUH,OAAO,EAGN,KAAK,qBAAqB,EAC1B,KAAK,SAAS,EACd,MAAM,aAAa,CAAC;AAErB,0EAA0E;AAC1E,MAAM,MAAM,qBAAqB,GAAG,SAAS,GAAG,MAAM,GAAG,UAAU,GAAG,SAAS,CAAC;AAEhF,MAAM,WAAW,gCAAgC;IAChD,WAAW,CAAC,EAAE,OAAO,CAAC;CACtB;AAWD;;;;GAIG;AACH,wBAAsB,yBAAyB,CAAC,KAAK,CAAC,GAAG,SAAS,MAAM,EACvE,SAAS,EAAE,GAAG,EACd,OAAO,GAAE,gCAAqC,GAC5C,OAAO,CAAC;IAAE,SAAS,EAAE,qBAAqB,CAAC,GAAG,CAAC,CAAC;IAAC,UAAU,EAAE,qBAAqB,CAAC,GAAG,CAAC,CAAA;CAAE,CAAC,CAiB5F;AAED,0FAA0F;AAC1F,wBAAgB,wBAAwB,CAAC,KAAK,CAAC,GAAG,SAAS,MAAM,EAChE,SAAS,EAAE,GAAG,GACZ,qBAAqB,CAAC,GAAG,CAAC,CAO5B;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,CAAC,GAAG,SAAS,MAAM,EACzD,GAAG,EAAE,GAAG,GACN,qBAAqB,CAAC,KAAK,CAAC,CAM9B;AAsDD;;;;GAIG;AACH,wBAAsB,mBAAmB,CAAC,KAAK,CAAC,GAAG,SAAS,MAAM,EACjE,QAAQ,EAAE,qBAAqB,EAC/B,SAAS,EAAE,GAAG,GACZ,OAAO,CAAC,qBAAqB,CAAC,GAAG,CAAC,CAAC,CAarC"}

package/dist/types/src/key/export.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Key export to JWK / PEM. Only works on extractable keys - keys from
+ * `generateKeyPair` are non-extractable unless you asked otherwise.
+ */
+import type { LacewingKey, StaticJWK } from "../types.js";
+/** Export a key as a JWK, with its bound `alg` and `use: "sig"` set. */
+export declare function exportKeyJWK(key: LacewingKey): Promise<StaticJWK>;
+/** Export an asymmetric key as PEM (PKCS#8 for private, SPKI for public). */
+export declare function exportKeyPEM(key: LacewingKey): Promise<string>;
+//# sourceMappingURL=export.d.ts.map

package/dist/types/src/key/export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export.d.ts","sourceRoot":"","sources":["../../../../src/key/export.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE1D,wEAAwE;AACxE,wBAAsB,YAAY,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,CAAC,CAkBvE;AAED,6EAA6E;AAC7E,wBAAsB,YAAY,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAapE"}

package/dist/types/src/key/generate.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Key generation with safe defaults:
+ * asymmetric-first - EdDSA unless you say otherwise - and secrets that
+ * are always cryptographically random at the algorithm's minimum size.
+ */
+import { type LacewingKey } from "../types.js";
+export interface GenerateKeyPairOptions {
+    /**
+     * Whether the private key may be exported later (default false -
+     * non-extractable keys can't leak through `exportKey*`).
+     */
+    extractable?: boolean;
+}
+/**
+ * Generate an asymmetric key pair, bound to `algorithm` (default EdDSA).
+ */
+export declare function generateKeyPair<const Alg extends string = "EdDSA">(algorithm?: Alg, options?: GenerateKeyPairOptions): Promise<{
+    publicKey: LacewingKey<Alg>;
+    privateKey: LacewingKey<Alg>;
+}>;
+/**
+ * Generate a random HMAC secret at the algorithm's minimum size
+ * (default HS256 -> 256 bits). Always passes the entropy checks by
+ * construction.
+ */
+export declare function generateSecret<const Alg extends string = "HS256">(algorithm?: Alg): LacewingKey<Alg>;
+//# sourceMappingURL=generate.d.ts.map

package/dist/types/src/key/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../../src/key/generate.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,EAA6B,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AAE1E,MAAM,WAAW,sBAAsB;IACtC;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,KAAK,CAAC,GAAG,SAAS,MAAM,GAAG,OAAO,EACvE,SAAS,GAAE,GAAoB,EAC/B,OAAO,GAAE,sBAA2B,GAClC,OAAO,CAAC;IAAE,SAAS,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC;IAAC,UAAU,EAAE,WAAW,CAAC,GAAG,CAAC,CAAA;CAAE,CAAC,CAmBxE;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,CAAC,GAAG,SAAS,MAAM,GAAG,OAAO,EAChE,SAAS,GAAE,GAAoB,GAC7B,WAAW,CAAC,GAAG,CAAC,CAWlB"}

package/dist/types/src/key/import.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Key import with algorithm binding (RFC 8725 §3.1/§3.2/§3.5).
+ *
+ * Every key enters Lacewing through this module and leaves bound to
+ * exactly one algorithm, carried in the type system. Sign/verify never
+ * accept raw `CryptoKey`s, so the alg-to-key binding cannot be bypassed.
+ */
+import { type LacewingKey, type StaticJWK } from "../types.js";
+/** JWK object, PEM string (PKCS#8 / SPKI), raw secret, or a CryptoKey. */
+export type KeyMaterial = StaticJWK | string | Uint8Array | CryptoKey;
+/**
+ * Import key material and bind it to `algorithm`. The returned
+ * {@link LacewingKey} can only ever be used with that algorithm.
+ *
+ * Throws {@link KeyTypeMismatch} when material and algorithm disagree,
+ * {@link EntropyCheckFailed} for weak HMAC secrets, and
+ * {@link KeyImportFailed} for anything else that goes wrong.
+ */
+export declare function importKey<const Alg extends string>(material: KeyMaterial, algorithm: Alg): Promise<LacewingKey<Alg>>;
+//# sourceMappingURL=import.d.ts.map

package/dist/types/src/key/import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import.d.ts","sourceRoot":"","sources":["../../../../src/key/import.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAWH,OAAO,EAGN,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,MAAM,aAAa,CAAC;AAErB,0EAA0E;AAC1E,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,MAAM,GAAG,UAAU,GAAG,SAAS,CAAC;AAuHtE;;;;;;;GAOG;AACH,wBAAsB,SAAS,CAAC,KAAK,CAAC,GAAG,SAAS,MAAM,EACvD,QAAQ,EAAE,WAAW,EACrB,SAAS,EAAE,GAAG,GACZ,OAAO,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAoB3B"}

package/dist/types/src/legacy/rs256.d.ts

@@ -0,0 +1,11 @@
+/**
+ * LEGACY INTEROP - explicit opt-in only.
+ *
+ * `RS256` (RSASSA-PKCS1-v1_5) is not in Lacewing's default registry. This
+ * module is kept for backwards compatibility and re-exports the RS256 opt-in
+ * from {@link module:legacy/rsa}, where the rest of the `RS*` family lives.
+ * Calling {@link enableLegacyRS256} is the grep-loud marker code review looks
+ * for; prefer `PS256`/`EdDSA` everywhere you control both sides.
+ */
+export { enableLegacyRS256 } from "./rsa.js";
+//# sourceMappingURL=rs256.d.ts.map

package/dist/types/src/legacy/rs256.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rs256.d.ts","sourceRoot":"","sources":["../../../../src/legacy/rs256.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC"}

package/dist/types/src/legacy/rsa.d.ts

@@ -0,0 +1,25 @@
+/**
+ * LEGACY INTEROP - explicit opt-in only.
+ *
+ * The `RS*` family (RSASSA-PKCS1-v1_5) is not in Lacewing's default registry:
+ * PKCS#1 v1.5 signatures are the deprecated ancestor of RSA-PSS and only
+ * belong in systems that must interoperate with issuers that cannot emit
+ * `PS256`/`EdDSA`. Each `enable...` call is the grep-loud marker code review
+ * looks for; prefer `PS256`/`EdDSA` everywhere you control both sides.
+ *
+ * `none` can never enter through this door - `registerLegacyAlgorithm` refuses
+ * it - and neither can any algorithm not on this curated legacy list.
+ */
+/** Register legacy `RS256`. After this, importKey/profiles/JWKS accept it. */
+export declare function enableLegacyRS256(): void;
+/** Register legacy `RS384`. Prefer `PS384`/`EdDSA` where you control both sides. */
+export declare function enableLegacyRS384(): void;
+/** Register legacy `RS512`. Prefer `PS512`/`EdDSA` where you control both sides. */
+export declare function enableLegacyRS512(): void;
+/**
+ * Register the whole legacy `RS256`/`RS384`/`RS512` family at once, for
+ * interop with an issuer that may rotate across hash sizes. Still an explicit,
+ * grep-loud opt-in - do not call it "just in case".
+ */
+export declare function enableLegacyRSA(): void;
+//# sourceMappingURL=rsa.d.ts.map

package/dist/types/src/legacy/rsa.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rsa.d.ts","sourceRoot":"","sources":["../../../../src/legacy/rsa.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAMH,8EAA8E;AAC9E,wBAAgB,iBAAiB,IAAI,IAAI,CAExC;AAED,oFAAoF;AACpF,wBAAgB,iBAAiB,IAAI,IAAI,CAExC;AAED,oFAAoF;AACpF,wBAAgB,iBAAiB,IAAI,IAAI,CAExC;AAED;;;;GAIG;AACH,wBAAgB,eAAe,IAAI,IAAI,CAItC"}

package/dist/types/src/lib/algorithms.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The algorithm registry - single source of truth for which algorithms
+ * exist and which key types they pair with (RFC 8725 §3.1/§3.2).
+ *
+ * `none`, `RSA1_5` and `RS*` are simply absent. Adding an algorithm is a
+ * one-entry change here (cryptographic agility, §3.2.4). Legacy interop
+ * algorithms can only enter through `registerLegacyAlgorithm`, which is
+ * reachable exclusively via the explicit `legacy/` imports.
+ */
+import { type ValidAlg } from "../types.js";
+export interface AlgorithmInfo {
+    /** JOSE algorithm identifier, e.g. "EdDSA". */
+    readonly name: string;
+    /** JWK key type this algorithm pairs with. */
+    readonly kty: "OKP" | "EC" | "RSA" | "oct";
+    /** Named curve for EC/OKP algorithms. */
+    readonly crv?: string;
+    /** Minimum key size in bits (secret length for `oct`, modulus for RSA). */
+    readonly minKeyBits: number;
+}
+/** Type guard: is this exact string an allowed algorithm? Case sensitive. */
+export declare function isValidAlgorithm(alg: string): boolean;
+/** Look up an algorithm's properties, or throw {@link AlgorithmNotAllowed}. */
+export declare function getAlgorithmProperties(alg: string): AlgorithmInfo;
+/** Validate against the registry and brand the string as {@link ValidAlg}. */
+export declare function toValidAlg(alg: string): ValidAlg;
+/** Currently registered algorithm names (core + any enabled legacy). */
+export declare function listAlgorithms(): string[];
+/**
+ * Internal - only the `legacy/` modules call this. Registers an interop
+ * algorithm so it becomes importable/verifiable. Never accepts `none`.
+ */
+export declare function registerLegacyAlgorithm(info: AlgorithmInfo): void;
+//# sourceMappingURL=algorithms.d.ts.map

package/dist/types/src/lib/algorithms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"algorithms.d.ts","sourceRoot":"","sources":["../../../../src/lib/algorithms.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAAU,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEpD,MAAM,WAAW,aAAa;IAC7B,+CAA+C;IAC/C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,8CAA8C;IAC9C,QAAQ,CAAC,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,KAAK,GAAG,KAAK,CAAC;IAC3C,yCAAyC;IACzC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,2EAA2E;IAC3E,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC5B;AAoBD,6EAA6E;AAC7E,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAErD;AAED,+EAA+E;AAC/E,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa,CAOjE;AAED,8EAA8E;AAC9E,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CAGhD;AAED,wEAAwE;AACxE,wBAAgB,cAAc,IAAI,MAAM,EAAE,CAEzC;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI,CAOjE"}

package/dist/types/src/lib/base64url.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Strict base64url (RFC 7515 §2: no padding, no whitespace, no URL-unsafe
+ * characters). Non-canonical encodings are rejected to close parser
+ * differentials between Lacewing and other JWT consumers.
+ */
+export declare function encodeBase64url(bytes: Uint8Array): string;
+export declare function decodeBase64url(encoded: string): Uint8Array;
+//# sourceMappingURL=base64url.d.ts.map

package/dist/types/src/lib/base64url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base64url.d.ts","sourceRoot":"","sources":["../../../../src/lib/base64url.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAOH,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAEzD;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,CAe3D"}

package/dist/types/src/lib/claims.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Claims validation engine (RFC 8725 §3.8/§3.9).
+ *
+ * One pass, fail-fast, all-or-nothing. Rejection messages never echo
+ * untrusted token content (log-injection hygiene, §3.10) - errors name
+ * the claim, not its value.
+ */
+import type { ClaimsPolicy } from "../types.js";
+export type { ValidateClaim } from "../types.js";
+/**
+ * Validate a decoded payload against a profile. Only called after the
+ * signature has been verified. `nowSeconds` is injectable for tests.
+ */
+export declare function validateClaims(payload: Record<string, unknown>, profile: ClaimsPolicy, nowSeconds?: number): Promise<void>;
+//# sourceMappingURL=claims.d.ts.map

package/dist/types/src/lib/claims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claims.d.ts","sourceRoot":"","sources":["../../../../src/lib/claims.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAOH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAuChD,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD;;;GAGG;AACH,wBAAsB,cAAc,CACnC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,OAAO,EAAE,YAAY,EACrB,UAAU,GAAE,MAAsC,GAChD,OAAO,CAAC,IAAI,CAAC,CA4Ef"}

package/dist/types/src/lib/duration.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Human-friendly duration parsing: public APIs accept `900` (seconds) or
+ * `"15m"`; everything internal works in branded {@link DurationSeconds}.
+ */
+import { type DurationSeconds } from "../types.js";
+export declare function parseDuration(value: number | string): DurationSeconds;
+//# sourceMappingURL=duration.d.ts.map

package/dist/types/src/lib/duration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duration.d.ts","sourceRoot":"","sources":["../../../../src/lib/duration.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAa,KAAK,eAAe,EAAE,MAAM,aAAa,CAAC;AAW9D,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,eAAe,CAYrE"}

package/dist/types/src/lib/entropy.d.ts

@@ -0,0 +1,21 @@
+/**
+ * HMAC secret strength checks (RFC 8725 §3.5).
+ *
+ * Two gates at import time:
+ *  1. Minimum length per algorithm (RFC 7518: >= hash output size).
+ *  2. A heuristic that rejects password-looking strings - the classic
+ *     `secret: "my-secret"` misuse - even when they are long enough.
+ */
+/**
+ * Heuristic: does this byte sequence look like a human-chosen password
+ * rather than a random key? Only printable-ASCII inputs are suspected -
+ * raw random bytes virtually never stay inside that range.
+ */
+export declare function isPasswordLike(bytes: Uint8Array): boolean;
+/**
+ * Validate an HMAC secret for the given HS* algorithm.
+ * Throws {@link EntropyCheckFailed} when the secret is too short or
+ * looks like a password.
+ */
+export declare function validateHMACSecret(secret: Uint8Array, algorithmName: string): void;
+//# sourceMappingURL=entropy.d.ts.map

package/dist/types/src/lib/entropy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entropy.d.ts","sourceRoot":"","sources":["../../../../src/lib/entropy.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AA+BH;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAYzD;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,GAAG,IAAI,CAelF"}

package/dist/types/src/lib/headers.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Header parsing and hardening (RFC 8725 §3.1/§3.2/§3.6/§3.10/§3.11).
+ *
+ * Header values are untrusted input: `kid` is length-capped and
+ * character-whitelisted before any lookup, `jku`/`x5u`/`jwk`/`x5c` are
+ * never honored, `zip` is rejected outright, and `crit` is rejected
+ * because Lacewing supports no header extensions.
+ */
+import { type ExpectedJwtProfile, type JwtHeader } from "../types.js";
+/**
+ * Sanitize an untrusted `kid` before it is used for key lookup (§3.10):
+ * bounded length, conservative charset.
+ */
+export declare function sanitizeKid(kid: unknown): string;
+/** Compare `typ` values per RFC 9068: optional media-type prefix, case-insensitive. */
+export declare function normalizeTyp(typ: string): string;
+/** Validate a decoded (but unverified) header object against a profile. */
+export declare function validateHeader(raw: unknown, profile: ExpectedJwtProfile): JwtHeader;
+//# sourceMappingURL=headers.d.ts.map

package/dist/types/src/lib/headers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"headers.d.ts","sourceRoot":"","sources":["../../../../src/lib/headers.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,EAAU,KAAK,kBAAkB,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAS9E;;;GAGG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAUhD;AAED,uFAAuF;AACvF,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAGhD;AAED,2EAA2E;AAC3E,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,kBAAkB,GAAG,SAAS,CA0CnF"}

package/dist/types/src/lib/invariants.d.ts

@@ -0,0 +1,6 @@
+/** Internal assertion helpers. */
+/** Throw if `condition` is false. For states that must be impossible. */
+export declare function invariant(condition: unknown, message: string): asserts condition;
+/** Exhaustiveness check for switch statements. */
+export declare function assertNever(value: never): never;
+//# sourceMappingURL=invariants.d.ts.map

package/dist/types/src/lib/invariants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invariants.d.ts","sourceRoot":"","sources":["../../../../src/lib/invariants.ts"],"names":[],"mappings":"AAAA,kCAAkC;AAElC,yEAAyE;AACzE,wBAAgB,SAAS,CAAC,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAIhF;AAED,kDAAkD;AAClD,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAE/C"}

package/dist/types/src/lib/json.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Strict JSON object parsing for token segments (RFC 8725 §3.7 strictness).
+ *
+ * `JSON.parse` silently keeps the *last* value when a member name is
+ * duplicated. That is a parser differential: an attacker crafts a header or
+ * payload where Lacewing and another consumer disagree about, say, which
+ * `alg` or `aud` is authoritative. RFC 8259 §4 says names SHOULD be unique
+ * and that behavior is otherwise unpredictable - Lacewing treats a duplicate
+ * key at any nesting level as malformed and rejects the token.
+ *
+ * The scan runs only after `JSON.parse` has confirmed the text is
+ * well-formed, so it can assume valid JSON and stay small.
+ */
+/**
+ * Throw {@link JWTInvalid} if `text` (already known to be valid JSON) contains
+ * a duplicated member name in any object at any depth.
+ */
+export declare function assertNoDuplicateKeys(text: string, what: string): void;
+/**
+ * Decode a token segment's UTF-8 text into a JSON object, rejecting anything
+ * that is not a plain object and any duplicate member names.
+ */
+export declare function parseJsonObject(text: string, what: string): Record<string, unknown>;
+//# sourceMappingURL=json.d.ts.map

package/dist/types/src/lib/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../../../src/lib/json.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAiEH;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CA8CtE;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAanF"}

package/dist/types/src/lib/jwe_algorithms.d.ts

@@ -0,0 +1,46 @@
+/**
+ * The JWE algorithm registry (encrypted JWTs). Two axes, both curated:
+ *
+ *  - key management (`alg`): how the content-encryption key is agreed/wrapped.
+ *  - content encryption (`enc`): the AEAD that actually encrypts the payload.
+ *
+ * Deliberately absent, exactly as on the JWS side: `none`, `RSA1_5`
+ * (Bleichenbacher - CVE-2023-... class), `RSA-OAEP` with SHA-1, and the `PBES2*`
+ * password-based algorithms (Lacewing does not do human-memorable secrets).
+ * As with JWS, the token header never chooses - the decryption profile does.
+ *
+ * Portability note: the `A192*` entries work on Node >= 24 (the engine floor)
+ * but 192-bit AES is not implemented by browser WebCrypto and some edge
+ * runtimes. Documented in the README; prefer `A128*`/`A256*` for tokens that
+ * must be decrypted outside Node.
+ */
+import { type ValidAlg } from "../types.js";
+export interface JweKeyManagementInfo {
+    readonly name: string;
+    /** Family: direct key, AES key-wrap, ECDH-ES (opt. wrap), or RSA-OAEP-256. */
+    readonly kind: "dir" | "aeskw" | "ecdh" | "rsa";
+    /** JWK key type the recipient key must have. */
+    readonly kty: "EC" | "RSA" | "oct";
+    /** Symmetric secret size in bytes (aeskw only). */
+    readonly secretBytes?: number;
+    /** Minimum RSA modulus in bits (rsa only). */
+    readonly minKeyBits?: number;
+}
+export interface JweContentEncryptionInfo {
+    readonly name: string;
+    /** Content-encryption key size in bytes - the size a `dir` key must be. */
+    readonly cekBytes: number;
+}
+export declare function isValidKeyManagementAlgorithm(alg: string): boolean;
+export declare function isValidContentEncryptionAlgorithm(enc: string): boolean;
+/** Look up a key-management algorithm, or throw {@link AlgorithmNotAllowed}. */
+export declare function getKeyManagementProperties(alg: string): JweKeyManagementInfo;
+/** Look up a content-encryption algorithm, or throw {@link AlgorithmNotAllowed}. */
+export declare function getContentEncryptionProperties(enc: string): JweContentEncryptionInfo;
+/** Validate against the registry and brand the key-management alg. */
+export declare function toValidKeyManagementAlg(alg: string): ValidAlg;
+/** Validate against the registry and brand the content-encryption alg. */
+export declare function toValidContentEncryptionAlg(enc: string): ValidAlg;
+export declare function listKeyManagementAlgorithms(): string[];
+export declare function listContentEncryptionAlgorithms(): string[];
+//# sourceMappingURL=jwe_algorithms.d.ts.map

package/dist/types/src/lib/jwe_algorithms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jwe_algorithms.d.ts","sourceRoot":"","sources":["../../../../src/lib/jwe_algorithms.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EAAU,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEpD,MAAM,WAAW,oBAAoB;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,8EAA8E;IAC9E,QAAQ,CAAC,IAAI,EAAE,KAAK,GAAG,OAAO,GAAG,MAAM,GAAG,KAAK,CAAC;IAChD,gDAAgD;IAChD,QAAQ,CAAC,GAAG,EAAE,IAAI,GAAG,KAAK,GAAG,KAAK,CAAC;IACnC,mDAAmD;IACnD,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,8CAA8C;IAC9C,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,wBAAwB;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,2EAA2E;IAC3E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC1B;AA6BD,wBAAgB,6BAA6B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAElE;AAED,wBAAgB,iCAAiC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAEtE;AAED,gFAAgF;AAChF,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,MAAM,GAAG,oBAAoB,CAM5E;AAED,oFAAoF;AACpF,wBAAgB,8BAA8B,CAAC,GAAG,EAAE,MAAM,GAAG,wBAAwB,CAMpF;AAED,sEAAsE;AACtE,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CAG7D;AAED,0EAA0E;AAC1E,wBAAgB,2BAA2B,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CAGjE;AAED,wBAAgB,2BAA2B,IAAI,MAAM,EAAE,CAEtD;AAED,wBAAgB,+BAA+B,IAAI,MAAM,EAAE,CAE1D"}

package/dist/types/src/lib/payload_hygiene.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Sign-time payload hygiene scanner (LW-payload).
+ *
+ * JWS payloads are base64url-encoded **plaintext** - encoding, not
+ * encryption. Two tiers, applied recursively so nesting offers no blind
+ * spots:
+ *  - claim *names* matching a deny-heuristic (`password`, `secret`, ...)
+ *  - claim *values* matching high-confidence secret patterns (Luhn-valid
+ *    card numbers, PEM private-key blocks, other JWTs)
+ *
+ * False positives are waived per top-level claim via the grep-loud
+ * `SignJWT.unsafeAllowClaim(name)`.
+ */
+/**
+ * Scan a payload about to be signed. Throws {@link PayloadHygieneViolation}
+ * naming the offending claim (never echoing its value). Claims listed in
+ * `allowedClaims` are skipped entirely, subtree included.
+ */
+export declare function scanPayloadForSensitiveData(payload: Record<string, unknown>, allowedClaims?: ReadonlySet<string>): void;
+//# sourceMappingURL=payload_hygiene.d.ts.map

package/dist/types/src/lib/payload_hygiene.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payload_hygiene.d.ts","sourceRoot":"","sources":["../../../../src/lib/payload_hygiene.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAwGH;;;;GAIG;AACH,wBAAgB,2BAA2B,CAC1C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,aAAa,GAAE,WAAW,CAAC,MAAM,CAAa,GAC5C,IAAI,CAgBN"}

package/dist/types/src/lib/utf8.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Strict UTF-8 encode/decode (RFC 8725 §3.7). Malformed sequences reject
+ * the token - no replacement characters, no silently stripped BOM.
+ */
+export declare function encodeUTF8(text: string): Uint8Array;
+export declare function decodeUTF8(bytes: Uint8Array): string;
+//# sourceMappingURL=utf8.d.ts.map

package/dist/types/src/lib/utf8.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utf8.d.ts","sourceRoot":"","sources":["../../../../src/lib/utf8.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAcH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAKnD;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAMpD"}

package/dist/types/src/revocation/memory.d.ts

@@ -0,0 +1,22 @@
+/**
+ * In-memory {@link RevocationStore}.
+ *
+ * Entries evict once the revoked token's `exp` passes: a revocation only
+ * needs to outlive the token it revokes. Suitable for single-process
+ * deployments and tests; multi-instance services want a shared backend
+ * (Redis/DB) implementing the same interface.
+ */
+import type { RevocationStore, TokenRevocationContext } from "../types.js";
+export declare class MemoryRevocationStore implements RevocationStore {
+    #private;
+    /**
+     * Revoke a token by its `jti`. `expiresAt` is the token's `exp`
+     * (unix seconds or Date) - the entry is dropped after that moment.
+     */
+    revoke(jti: string, expiresAt: number | Date): void;
+    isRevoked(context: TokenRevocationContext): Promise<boolean>;
+    isAnyRevoked(contexts: TokenRevocationContext[]): Promise<boolean[]>;
+    /** Number of live revocations (expired entries may linger until a sweep). */
+    get size(): number;
+}
+//# sourceMappingURL=memory.d.ts.map

package/dist/types/src/revocation/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../../../src/revocation/memory.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAI3E,qBAAa,qBAAsB,YAAW,eAAe;;IAK5D;;;OAGG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;IAa7C,SAAS,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,OAAO,CAAC;IAgB5D,YAAY,CAAC,QAAQ,EAAE,sBAAsB,EAAE,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;IAI1E,6EAA6E;IAC7E,IAAI,IAAI,IAAI,MAAM,CAEjB;CAkBD"}

package/dist/types/src/revocation/store.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Revocation contract.
+ *
+ * A {@link RevocationStore} answers "has this token been revoked?" and is
+ * consulted by `jwtVerify` *only after* signature and claims checks pass
+ * (LW-rev.3), so unauthenticated input can never drive store lookups.
+ * Store errors fail closed (LW-rev.4).
+ *
+ * The interface is shaped for async backends (Redis, a database): see
+ * `MemoryRevocationStore` for the reference implementation and the
+ * eviction contract - a revocation only needs to outlive its token.
+ */
+import type { TokenRevocationContext } from "../types.js";
+export type { RevocationStore, TokenRevocationContext } from "../types.js";
+/** Extract the revocation-relevant slice of a verified payload. */
+export declare function buildRevocationContext(payload: Record<string, unknown>): TokenRevocationContext;
+//# sourceMappingURL=store.d.ts.map

package/dist/types/src/revocation/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../../src/revocation/store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAc,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAEtE,YAAY,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAE3E,mEAAmE;AACnE,wBAAgB,sBAAsB,CACrC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,sBAAsB,CAOxB"}