ubid-common 0.1.0

package/dist/schemas/SdJwtVcTypeMetadataSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SdJwtVcTypeMetadataSchema.d.ts","sourceRoot":"","sources":["../../src/schemas/SdJwtVcTypeMetadataSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,+DAA+D;AAC/D,eAAO,MAAM,eAAe,aAAoB,CAAC;AAEjD,eAAO,MAAM,GAAG,aAAmB,CAAC;AAEpC,eAAO,MAAM,SAAS,aAAoB,CAAC;AAE3C,yEAAyE;AACzE,eAAO,MAAM,SAAS,6EAEV,CAAC;AAEb,kDAAkD;AAClD,eAAO,MAAM,KAAK,aAA+C,CAAC;AAElE,sDAAsD;AACtD,eAAO,MAAM,YAAY;;;;;;;;;;;;EAIvB,CAAC;AAEH,6DAA6D;AAC7D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQ1B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;EAOjC,CAAC;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAI3B,CAAC;AAoBH,6DAA6D;AAC7D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK3B,CAAC;AAEH,6DAA6D;AAC7D,eAAO,MAAM,iBAAiB;;;;;;;;;;;;EAI5B,CAAC;AAEH,oDAAoD;AACpD,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM7B,CAAC;AAEH,wDAAwD;AACxD,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6BtB,CAAC;AAEJ,2CAA2C;AAC3C,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AACxD,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AACpE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAChE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAClE,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAClD,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/dist/schemas/SdJwtVcTypeMetadataSchema.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeMetadata = exports.ClaimMetadataEntry = exports.ClaimDisplayEntry = exports.TypeDisplayEntry = exports.SvgTemplateEntry = exports.SvgTemplateProperties = exports.RenderingSimple = exports.LogoMetadata = exports.SvgId = exports.ClaimPath = exports.LocaleTag = exports.Uri = exports.IntegrityString = void 0;
+const zod_1 = require("zod");
+/** Integrity string per W3C SRI, e.g., "sha256-<base64url>" */
+exports.IntegrityString = zod_1.z.string().min(1);
+exports.Uri = zod_1.z.string().url();
+exports.LocaleTag = zod_1.z.string().min(1);
+/** Claim path per §9.1: array of string | null | non-negative integer */
+exports.ClaimPath = zod_1.z.array(zod_1.z.union([zod_1.z.string(), zod_1.z.null(), zod_1.z.number().int().nonnegative()])).nonempty();
+/** svg_id: [A-Za-z_][A-Za-z0-9_]* per §8.1.2.2 */
+exports.SvgId = zod_1.z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/);
+/** ---------- §8.1.1 "simple" rendering ---------- */
+exports.LogoMetadata = zod_1.z.object({
+    uri: exports.Uri, // REQUIRED
+    ["uri#integrity"]: exports.IntegrityString.optional(),
+    alt_text: zod_1.z.string().optional(),
+});
+/** ---------- §8.1.2 "svg_templates" rendering ---------- */
+exports.RenderingSimple = zod_1.z.object({
+    logo: exports.LogoMetadata.optional(),
+    background_image: zod_1.z.object({
+        uri: exports.Uri,
+        ["uri#integrity"]: exports.IntegrityString.optional(),
+    }).optional(),
+    background_color: zod_1.z.string().optional(), // CSS color; keep as string
+    text_color: zod_1.z.string().optional(), // CSS color; keep as string
+});
+exports.SvgTemplateProperties = zod_1.z.object({
+    orientation: zod_1.z.enum(["portrait", "landscape"]).optional(),
+    color_scheme: zod_1.z.enum(["light", "dark"]).optional(),
+    contrast: zod_1.z.enum(["normal", "high"]).optional(),
+}).refine((o) => o.orientation !== undefined || o.color_scheme !== undefined || o.contrast !== undefined, { message: "svg_template.properties must contain at least one of orientation, color_scheme, contrast" });
+exports.SvgTemplateEntry = zod_1.z.object({
+    uri: exports.Uri, // REQUIRED
+    ["uri#integrity"]: exports.IntegrityString.optional(),
+    properties: exports.SvgTemplateProperties.optional(), // REQUIRED if >1 template; enforced at array level
+});
+const Rendering = zod_1.z.object({
+    simple: exports.RenderingSimple.optional(),
+    svg_templates: zod_1.z.array(exports.SvgTemplateEntry).optional(), // optional here
+}).superRefine((val, ctx) => {
+    const arr = val.svg_templates;
+    if (arr && arr.length > 1) {
+        arr.forEach((t, i) => {
+            if (!t.properties) {
+                ctx.addIssue({
+                    code: zod_1.z.ZodIssueCode.custom,
+                    message: `rendering.svg_templates[${i}].properties is required when more than one template is present`,
+                    path: ["svg_templates", i, "properties"],
+                });
+            }
+        });
+    }
+});
+/** ---------- §8 Display metadata for the TYPE ---------- */
+exports.TypeDisplayEntry = zod_1.z.object({
+    locale: exports.LocaleTag, // REQUIRED
+    name: zod_1.z.string().min(1), // REQUIRED
+    description: zod_1.z.string().optional(),
+    rendering: Rendering.optional(),
+});
+/** ---------- §9.2 Display metadata for CLAIMS ---------- */
+exports.ClaimDisplayEntry = zod_1.z.object({
+    locale: exports.LocaleTag, // REQUIRED
+    label: zod_1.z.string().min(1), // REQUIRED
+    description: zod_1.z.string().optional(),
+});
+/** ---------- §9 Claim metadata entry ---------- */
+exports.ClaimMetadataEntry = zod_1.z.object({
+    path: exports.ClaimPath, // REQUIRED
+    display: zod_1.z.array(exports.ClaimDisplayEntry).optional(), // §9.2
+    mandatory: zod_1.z.boolean().optional(), // §9.3 d12
+    sd: zod_1.z.enum(["always", "allowed", "never"]).optional(), // §9.3 (default "allowed")
+    svg_id: exports.SvgId.optional(), // §8.1.2.2
+});
+/** ---------- §6.2 Type Metadata Document ---------- */
+exports.TypeMetadata = zod_1.z.object({
+    vct: zod_1.z.string(),
+    name: zod_1.z.string().optional(),
+    description: zod_1.z.string().optional(),
+    extends: zod_1.z.string().optional(),
+    ["extends#integrity"]: exports.IntegrityString.optional(),
+    display: zod_1.z.array(exports.TypeDisplayEntry).optional(), // §8
+    claims: zod_1.z.array(exports.ClaimMetadataEntry).optional(), // §9
+    // §7 integrity for the vct reference when used
+    ["vct#integrity"]: exports.IntegrityString.optional(),
+})
+    .strip() // remove unknown fields but don't error
+    .superRefine((val, ctx) => {
+    const ids = new Set();
+    val.claims?.forEach((c, i) => {
+        if (c.svg_id) {
+            if (ids.has(c.svg_id)) {
+                ctx.addIssue({
+                    code: zod_1.z.ZodIssueCode.custom,
+                    message: `svg_id "${c.svg_id}" must be unique within the type metadata`,
+                    path: ["claims", i, "svg_id"],
+                });
+            }
+            ids.add(c.svg_id);
+        }
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/schemas/index.d.ts

@@ -0,0 +1,6 @@
+export * from './CredentialConfigurationSupportedSchema';
+export * from './CredentialOfferSchema';
+export * from './OpenidAuthorizationServerMetadataSchema';
+export * from './OpenidCredentialIssuerMetadataSchema';
+export * from './SdJwtVcPayloadSchema';
+//# sourceMappingURL=index.d.ts.map

package/dist/schemas/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"AAAA,cAAc,0CAA0C,CAAC;AACzD,cAAc,yBAAyB,CAAC;AACxC,cAAc,2CAA2C,CAAC;AAC1D,cAAc,wCAAwC,CAAC;AACvD,cAAc,wBAAwB,CAAC"}

package/dist/schemas/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./CredentialConfigurationSupportedSchema"), exports);
+__exportStar(require("./CredentialOfferSchema"), exports);
+__exportStar(require("./OpenidAuthorizationServerMetadataSchema"), exports);
+__exportStar(require("./OpenidCredentialIssuerMetadataSchema"), exports);
+__exportStar(require("./SdJwtVcPayloadSchema"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2NoZW1hcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsMkVBQXlEO0FBQ3pELDBEQUF3QztBQUN4Qyw0RUFBMEQ7QUFDMUQseUVBQXVEO0FBQ3ZELHlEQUF1QyJ9

package/dist/status/TokenStatusListVerifier.d.ts

@@ -0,0 +1,41 @@
+import { TokenStatusListVerificationError } from "../error";
+import { CredentialStatus, HttpClient, PublicKeyResolverEngineI } from "../interfaces";
+import { Result } from "../types";
+import { TrustRegistry } from "../trust/TrustRegistry";
+export interface TokenStatusListVerificationResult {
+    status: CredentialStatus;
+    statusValue: number;
+    index: number;
+    bits: number;
+    uri: string;
+    issuer: string;
+    issuedAt: number;
+    expiresAt: number;
+    ttl: number;
+    kid: string;
+}
+export interface TokenStatusListVerifierI {
+    verify(args: {
+        credentialIssuer: string;
+        status: unknown;
+        forceRefresh?: boolean;
+    }): Promise<Result<TokenStatusListVerificationResult, TokenStatusListVerificationError>>;
+    clearCache(uri?: string): void;
+}
+export interface TokenStatusListVerifierOptions {
+    trustRegistry: TrustRegistry;
+    pkResolverEngine: PublicKeyResolverEngineI;
+    httpClient: HttpClient;
+    allowedBits?: readonly (1 | 2 | 4 | 8)[];
+    clockToleranceSeconds?: number;
+    requestTimeoutMs?: number;
+    maxResponseBytes?: number;
+    maxCompressedBytes?: number;
+    maxDecompressedBytes?: number;
+    maxTtlSeconds?: number;
+    requireExpiration?: boolean;
+    requireTtl?: boolean;
+    now?: () => Date;
+}
+export declare function TokenStatusListVerifier(options: TokenStatusListVerifierOptions): TokenStatusListVerifierI;
+//# sourceMappingURL=TokenStatusListVerifier.d.ts.map

package/dist/status/TokenStatusListVerifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TokenStatusListVerifier.d.ts","sourceRoot":"","sources":["../../src/status/TokenStatusListVerifier.ts"],"names":[],"mappings":"AAEA,OAAO,EACN,gCAAgC,EAChC,MAAM,UAAU,CAAC;AAClB,OAAO,EACN,gBAAgB,EAChB,UAAU,EACV,wBAAwB,EACxB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,aAAa,EAAsB,MAAM,wBAAwB,CAAC;AAG3E,MAAM,WAAW,iCAAiC;IACjD,MAAM,EAAE,gBAAgB,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,wBAAwB;IACxC,MAAM,CAAC,IAAI,EAAE;QACZ,gBAAgB,EAAE,MAAM,CAAC;QACzB,MAAM,EAAE,OAAO,CAAC;QAChB,YAAY,CAAC,EAAE,OAAO,CAAC;KACvB,GAAG,OAAO,CAAC,MAAM,CAAC,iCAAiC,EAAE,gCAAgC,CAAC,CAAC,CAAC;IACzF,UAAU,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED,MAAM,WAAW,8BAA8B;IAC9C,aAAa,EAAE,aAAa,CAAC;IAC7B,gBAAgB,EAAE,wBAAwB,CAAC;IAC3C,UAAU,EAAE,UAAU,CAAC;IACvB,WAAW,CAAC,EAAE,SAAS,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;IACzC,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;CACjB;AAqKD,wBAAgB,uBAAuB,CACtC,OAAO,EAAE,8BAA8B,GACrC,wBAAwB,CAgU1B"}

package/dist/status/TokenStatusListVerifier.js

@@ -0,0 +1,410 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenStatusListVerifier = TokenStatusListVerifier;
+const jose_1 = require("jose");
+const pako_1 = require("pako");
+const error_1 = require("../error");
+const util_1 = require("../utils/util");
+const DEFAULT_REQUEST_TIMEOUT_MS = 5_000;
+const DEFAULT_MAX_RESPONSE_BYTES = 256 * 1024;
+const DEFAULT_MAX_COMPRESSED_BYTES = 128 * 1024;
+const DEFAULT_MAX_DECOMPRESSED_BYTES = 512 * 1024;
+const DEFAULT_MAX_TTL_SECONDS = 86_400;
+const COMPACT_JWT = /^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/;
+const BASE64URL = /^[A-Za-z0-9_-]+$/;
+function failure(error) {
+    return { success: false, error };
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonNegativeInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function isPositiveInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+function normalizeStatusUri(value) {
+    try {
+        const url = new URL(value);
+        if (url.protocol !== "https:" ||
+            url.username ||
+            url.password ||
+            url.hash) {
+            return undefined;
+        }
+        return url.href;
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseReference(status) {
+    if (!isObject(status) || !isObject(status.status_list))
+        return undefined;
+    const idx = status.status_list.idx;
+    const uri = status.status_list.uri;
+    if (!isNonNegativeInteger(idx) || typeof uri !== "string")
+        return undefined;
+    const normalizedUri = normalizeStatusUri(uri);
+    if (!normalizedUri)
+        return undefined;
+    return { idx, uri: normalizedUri };
+}
+function responseText(data) {
+    if (typeof data === "string")
+        return data.trim();
+    if (data instanceof Uint8Array) {
+        try {
+            return new TextDecoder("utf-8", { fatal: true }).decode(data).trim();
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return undefined;
+}
+function headerValue(headers, name) {
+    const expected = name.toLowerCase();
+    for (const [key, value] of Object.entries(headers ?? {})) {
+        if (key.toLowerCase() === expected && typeof value === "string") {
+            return value;
+        }
+    }
+    return undefined;
+}
+function statusName(value) {
+    if (value === 0)
+        return "valid";
+    if (value === 1)
+        return "revoked";
+    if (value === 2)
+        return "suspended";
+    return "application-specific";
+}
+function inflateBounded(compressed, maxDecompressedBytes) {
+    const chunks = [];
+    let size = 0;
+    try {
+        const inflater = new pako_1.Inflate({
+            chunkSize: Math.min(16 * 1024, maxDecompressedBytes + 1),
+        });
+        inflater.onData = (chunk) => {
+            size += chunk.byteLength;
+            if (size > maxDecompressedBytes) {
+                throw new RangeError("Token Status List exceeds the decompression limit");
+            }
+            chunks.push(new Uint8Array(chunk));
+        };
+        const completed = inflater.push(compressed, true);
+        if (!completed || inflater.err) {
+            return failure(error_1.TokenStatusListVerificationError.DecompressionFailed);
+        }
+    }
+    catch (error) {
+        if (error instanceof RangeError) {
+            return failure(error_1.TokenStatusListVerificationError.DecompressedListTooLarge);
+        }
+        return failure(error_1.TokenStatusListVerificationError.DecompressionFailed);
+    }
+    const output = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+        output.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return { success: true, value: output };
+}
+function validateOptions(options) {
+    const allowedBits = options.allowedBits ?? [2];
+    const values = [
+        options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS,
+        options.maxResponseBytes ?? DEFAULT_MAX_RESPONSE_BYTES,
+        options.maxCompressedBytes ?? DEFAULT_MAX_COMPRESSED_BYTES,
+        options.maxDecompressedBytes ?? DEFAULT_MAX_DECOMPRESSED_BYTES,
+        options.maxTtlSeconds ?? DEFAULT_MAX_TTL_SECONDS,
+    ];
+    if (allowedBits.length === 0 ||
+        new Set(allowedBits).size !== allowedBits.length ||
+        allowedBits.some((bits) => ![1, 2, 4, 8].includes(bits)) ||
+        values.some((value) => !Number.isSafeInteger(value) || value <= 0) ||
+        !Number.isSafeInteger(options.clockToleranceSeconds ?? 0) ||
+        (options.clockToleranceSeconds ?? 0) < 0) {
+        throw new TypeError("TokenStatusListVerifier options are invalid");
+    }
+    return Object.freeze([...allowedBits]);
+}
+function TokenStatusListVerifier(options) {
+    const allowedBits = validateOptions(options);
+    const requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+    const maxResponseBytes = options.maxResponseBytes ?? DEFAULT_MAX_RESPONSE_BYTES;
+    const maxCompressedBytes = options.maxCompressedBytes ?? DEFAULT_MAX_COMPRESSED_BYTES;
+    const maxDecompressedBytes = options.maxDecompressedBytes ?? DEFAULT_MAX_DECOMPRESSED_BYTES;
+    const maxTtlSeconds = options.maxTtlSeconds ?? DEFAULT_MAX_TTL_SECONDS;
+    const clockToleranceSeconds = options.clockToleranceSeconds ?? 0;
+    const requireExpiration = options.requireExpiration ?? true;
+    const requireTtl = options.requireTtl ?? true;
+    const now = options.now ?? (() => new Date());
+    const cache = new Map();
+    const inflight = new Map();
+    function cacheKey(credentialIssuer, uri) {
+        return `${credentialIssuer}\n${uri}`;
+    }
+    function trustedReference(credentialIssuer, status) {
+        const entry = options.trustRegistry.get(credentialIssuer);
+        const reference = parseReference(status);
+        if (!entry || !reference) {
+            return failure(error_1.TokenStatusListVerificationError.InvalidReference);
+        }
+        if (!entry.statusListUris ||
+            !entry.statusListUris.includes(reference.uri)) {
+            return failure(error_1.TokenStatusListVerificationError.StatusListUriNotTrusted);
+        }
+        const statusIssuer = entry.statusListIssuer ?? entry.issuer;
+        const statusIssuerEntry = options.trustRegistry.get(statusIssuer);
+        if (!statusIssuerEntry?.algorithms["status-list"]?.length) {
+            return failure(error_1.TokenStatusListVerificationError.StatusListUriNotTrusted);
+        }
+        return {
+            success: true,
+            value: { entry, reference, statusIssuer },
+        };
+    }
+    async function fetchAndVerify(reference, statusIssuer) {
+        const currentDate = now();
+        const currentSeconds = Math.floor(currentDate.getTime() / 1000);
+        const requestUrl = new URL(reference.uri);
+        requestUrl.searchParams.set("time", String(currentSeconds));
+        let response;
+        try {
+            response = await options.httpClient.get(requestUrl.href, { Accept: "application/statuslist+jwt" }, {
+                useCache: false,
+                timeout: requestTimeoutMs,
+                maxRedirects: 0,
+                maxContentLength: maxResponseBytes,
+                maxBodyLength: maxResponseBytes,
+                responseType: "text",
+            });
+        }
+        catch {
+            return failure(error_1.TokenStatusListVerificationError.FetchFailed);
+        }
+        if (!response || response.status < 200 || response.status >= 300) {
+            return failure(error_1.TokenStatusListVerificationError.FetchFailed);
+        }
+        const contentType = headerValue(response.headers, "content-type");
+        if (!contentType ||
+            contentType.split(";", 1)[0].trim().toLowerCase() !==
+                "application/statuslist+jwt") {
+            return failure(error_1.TokenStatusListVerificationError.InvalidResponse);
+        }
+        const token = responseText(response.data);
+        if (!token) {
+            return failure(error_1.TokenStatusListVerificationError.InvalidResponse);
+        }
+        if (new TextEncoder().encode(token).byteLength > maxResponseBytes) {
+            return failure(error_1.TokenStatusListVerificationError.ResponseTooLarge);
+        }
+        if (!COMPACT_JWT.test(token)) {
+            return failure(error_1.TokenStatusListVerificationError.InvalidResponse);
+        }
+        let header;
+        let unverifiedPayload;
+        try {
+            header = (0, jose_1.decodeProtectedHeader)(token);
+            unverifiedPayload = (0, jose_1.decodeJwt)(token);
+        }
+        catch {
+            return failure(error_1.TokenStatusListVerificationError.InvalidResponse);
+        }
+        if (header.typ !== "statuslist+jwt" ||
+            typeof header.alg !== "string" ||
+            !header.alg ||
+            header.alg === "none" ||
+            typeof header.kid !== "string" ||
+            !header.kid ||
+            header.b64 !== undefined ||
+            header.jku !== undefined ||
+            header.x5u !== undefined ||
+            header.jwk !== undefined ||
+            header.x5c !== undefined ||
+            (header.crit !== undefined &&
+                (!Array.isArray(header.crit) || header.crit.length > 0))) {
+            return failure(error_1.TokenStatusListVerificationError.InvalidHeader);
+        }
+        if (unverifiedPayload.iss !== statusIssuer ||
+            unverifiedPayload.sub !== reference.uri) {
+            return failure(error_1.TokenStatusListVerificationError.InvalidPayload);
+        }
+        const keyResult = await options.pkResolverEngine.resolve({
+            identifier: statusIssuer,
+            kid: header.kid,
+            alg: header.alg,
+            tokenType: "status-list",
+        });
+        if (!keyResult.success) {
+            return failure(error_1.TokenStatusListVerificationError.CannotResolveSigningKey);
+        }
+        let key;
+        try {
+            key = await (0, jose_1.importJWK)(keyResult.value.jwk, header.alg);
+        }
+        catch {
+            return failure(error_1.TokenStatusListVerificationError.CannotImportSigningKey);
+        }
+        let payload;
+        try {
+            const verified = await (0, jose_1.jwtVerify)(token, key, {
+                algorithms: [header.alg],
+                issuer: statusIssuer,
+                subject: reference.uri,
+                clockTolerance: clockToleranceSeconds,
+                currentDate,
+            });
+            payload = verified.payload;
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                (error.name === "JWTExpired" ||
+                    error.name === "JWTClaimValidationFailed")) {
+                return failure(error_1.TokenStatusListVerificationError.ExpiredStatusList);
+            }
+            return failure(error_1.TokenStatusListVerificationError.InvalidSignature);
+        }
+        const issuedAt = payload.iat;
+        const expiresAt = payload.exp;
+        const ttl = payload.ttl;
+        const statusList = payload.status_list;
+        if (!isNonNegativeInteger(issuedAt) ||
+            (requireExpiration && !isNonNegativeInteger(expiresAt)) ||
+            (expiresAt !== undefined && !isNonNegativeInteger(expiresAt)) ||
+            (requireTtl && !isPositiveInteger(ttl)) ||
+            (ttl !== undefined && !isPositiveInteger(ttl)) ||
+            (typeof ttl === "number" && ttl > maxTtlSeconds) ||
+            !isObject(statusList) ||
+            !allowedBits.includes(statusList.bits) ||
+            typeof statusList.lst !== "string" ||
+            !BASE64URL.test(statusList.lst)) {
+            return failure(error_1.TokenStatusListVerificationError.InvalidPayload);
+        }
+        if (issuedAt > currentSeconds + clockToleranceSeconds ||
+            (typeof expiresAt === "number" &&
+                (expiresAt <= currentSeconds - clockToleranceSeconds ||
+                    issuedAt >= expiresAt))) {
+            return failure(error_1.TokenStatusListVerificationError.ExpiredStatusList);
+        }
+        let compressed;
+        try {
+            compressed = (0, util_1.fromBase64Url)(statusList.lst);
+        }
+        catch {
+            return failure(error_1.TokenStatusListVerificationError.InvalidPayload);
+        }
+        if (compressed.byteLength === 0 ||
+            compressed.byteLength > maxCompressedBytes) {
+            return failure(error_1.TokenStatusListVerificationError.ResponseTooLarge);
+        }
+        const inflated = inflateBounded(compressed, maxDecompressedBytes);
+        if (!inflated.success)
+            return inflated;
+        if (inflated.value.byteLength === 0) {
+            return failure(error_1.TokenStatusListVerificationError.InvalidPayload);
+        }
+        const effectiveExpiresAt = typeof expiresAt === "number"
+            ? expiresAt
+            : currentSeconds + (typeof ttl === "number" ? ttl : 0);
+        const advertisedTtl = typeof ttl === "number"
+            ? ttl
+            : Math.max(0, effectiveExpiresAt - currentSeconds);
+        const effectiveTtl = Math.min(advertisedTtl, maxTtlSeconds);
+        const cacheUntil = Math.min(currentDate.getTime() + effectiveTtl * 1000, effectiveExpiresAt * 1000);
+        return {
+            success: true,
+            value: {
+                bytes: inflated.value,
+                bits: statusList.bits,
+                uri: reference.uri,
+                issuer: statusIssuer,
+                issuedAt,
+                expiresAt: effectiveExpiresAt,
+                ttl: effectiveTtl,
+                kid: header.kid,
+                cacheUntil,
+            },
+        };
+    }
+    async function statusList(credentialIssuer, reference, statusIssuer, forceRefresh) {
+        const key = cacheKey(credentialIssuer, reference.uri);
+        const cached = cache.get(key);
+        if (!forceRefresh && cached && cached.value.cacheUntil > now().getTime()) {
+            return { success: true, value: cached.value };
+        }
+        if (!forceRefresh) {
+            const pending = inflight.get(key);
+            if (pending)
+                return pending;
+        }
+        const pending = fetchAndVerify(reference, statusIssuer);
+        if (!forceRefresh)
+            inflight.set(key, pending);
+        try {
+            const result = await pending;
+            if (result.success)
+                cache.set(key, { value: result.value });
+            return result;
+        }
+        finally {
+            if (!forceRefresh)
+                inflight.delete(key);
+        }
+    }
+    return {
+        async verify({ credentialIssuer, status, forceRefresh = false }) {
+            const trusted = trustedReference(credentialIssuer, status);
+            if (!trusted.success)
+                return trusted;
+            const { reference, statusIssuer } = trusted.value;
+            const list = await statusList(credentialIssuer, reference, statusIssuer, forceRefresh);
+            if (!list.success)
+                return list;
+            const bitOffset = reference.idx * list.value.bits;
+            if (!Number.isSafeInteger(bitOffset)) {
+                return failure(error_1.TokenStatusListVerificationError.IndexOutOfRange);
+            }
+            const byteIndex = Math.floor(bitOffset / 8);
+            if (byteIndex >= list.value.bytes.byteLength) {
+                return failure(error_1.TokenStatusListVerificationError.IndexOutOfRange);
+            }
+            const shift = bitOffset % 8;
+            const mask = (1 << list.value.bits) - 1;
+            const statusValue = (list.value.bytes[byteIndex] >> shift) & mask;
+            return {
+                success: true,
+                value: {
+                    status: statusName(statusValue),
+                    statusValue,
+                    index: reference.idx,
+                    bits: list.value.bits,
+                    uri: list.value.uri,
+                    issuer: list.value.issuer,
+                    issuedAt: list.value.issuedAt,
+                    expiresAt: list.value.expiresAt,
+                    ttl: list.value.ttl,
+                    kid: list.value.kid,
+                },
+            };
+        },
+        clearCache(uri) {
+            if (uri === undefined) {
+                cache.clear();
+                return;
+            }
+            const normalized = normalizeStatusUri(uri);
+            for (const key of cache.keys()) {
+                if (normalized && key.endsWith(`\n${normalized}`))
+                    cache.delete(key);
+            }
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"TokenStatusListVerifier.js","sourceRoot":"","sources":["../../src/status/TokenStatusListVerifier.ts"],"names":[],"mappings":"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"}