@kya-os/mcp-i-core 1.7.0 → 1.8.1

package/README.md

@@ -151,7 +151,7 @@ import { MCPIRuntimeBaseV2 } from '@kya-os/mcp-i-core';
 class MyPlatformRuntime extends MCPIRuntimeBaseV2 {
   constructor() {
     super({
-      cryptoProvider: new MyeCryptoProvider(),
+      cryptoProvider: new MyCryptoProvider(),
       identityProvider: new MyIdentityProvider(),
       storageProvider: new MyStorageProvider(),
       nonceCacheProvider: new MyNonceCacheProvider(),

package/dist/conformance/capability-verifier-adapter.d.ts

@@ -0,0 +1,66 @@
+/**
+ * CapabilityVerifier Adapter
+ *
+ * Adapts {@link verifyCapabilities} into the small, duck-typed verifier shape an
+ * entity-card consumer expects: given a list of capabilities and a verification
+ * context, return which capability names are `verified` (backed by a verified
+ * attestation) and which are `unverified` (self-declared or failed).
+ *
+ * The capability and verifier types are defined locally rather than imported
+ * from `@kya-os/mcp`: mcp-i-core pins `@kya-os/mcp@1.6.1`, which predates the
+ * entity-card export, so importing it would not resolve.
+ *
+ * Mapping:
+ *   - bare-string capability  → `unverified` (Level 1, self-declared)
+ *   - L2 object capability    → checked via {@link verifyCapabilities}; its
+ *     `valid` names become `verified`, its `invalid` names become `unverified`.
+ */
+import { type CapabilityVCSignatureVerifier } from './validate-level2.js';
+import type { DIDResolver } from '../delegation/vc-verifier.js';
+/**
+ * Duck-typed capability. A bare string is a Level 1 self-declared capability;
+ * an object with a `name` (and optional `attestations`) is a Level 2 attested
+ * capability.
+ */
+export type DuckTypedCapability = string | {
+    name: string;
+    attestations?: readonly unknown[];
+    [key: string]: unknown;
+};
+/** Context describing whose capabilities are being checked, and against whom. */
+export interface CapabilityVerificationContext {
+    /** The subject (agent) DID the capabilities are claimed for. */
+    subjectDid: string;
+    /** Issuer DIDs trusted to attest capabilities. */
+    trustedIssuers: readonly string[];
+}
+/** Partition of capability names by verification outcome. */
+export interface CapabilityVerificationResult {
+    /** Capability names backed by a verified attestation. */
+    verified: string[];
+    /** Capability names that are self-declared or failed verification. */
+    unverified: string[];
+}
+/** The duck-typed verifier returned by {@link createCapabilityVerifier}. */
+export type CapabilityVerifier = (capabilities: readonly DuckTypedCapability[], ctx: CapabilityVerificationContext) => Promise<CapabilityVerificationResult>;
+/** Options for {@link createCapabilityVerifier}. */
+export interface CreateCapabilityVerifierOptions {
+    /**
+     * Signature verifier for Level 2 attestations. Defaults to a VC-JWT verifier
+     * (see {@link createVcJwtSignatureVerifier}).
+     */
+    signatureVerifier?: CapabilityVCSignatureVerifier;
+    /**
+     * DID resolver for the default signature verifier. Ignored when a
+     * `signatureVerifier` is supplied.
+     */
+    didResolver?: DIDResolver;
+}
+/**
+ * Create a capability verifier.
+ *
+ * @param options - Optional signature-verifier / DID-resolver overrides.
+ * @returns A verifier mapping capabilities to `{ verified, unverified }`.
+ */
+export declare function createCapabilityVerifier(options?: CreateCapabilityVerifierOptions): CapabilityVerifier;
+//# sourceMappingURL=capability-verifier-adapter.d.ts.map

package/dist/conformance/capability-verifier-adapter.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * CapabilityVerifier Adapter
+ *
+ * Adapts {@link verifyCapabilities} into the small, duck-typed verifier shape an
+ * entity-card consumer expects: given a list of capabilities and a verification
+ * context, return which capability names are `verified` (backed by a verified
+ * attestation) and which are `unverified` (self-declared or failed).
+ *
+ * The capability and verifier types are defined locally rather than imported
+ * from `@kya-os/mcp`: mcp-i-core pins `@kya-os/mcp@1.6.1`, which predates the
+ * entity-card export, so importing it would not resolve.
+ *
+ * Mapping:
+ *   - bare-string capability  → `unverified` (Level 1, self-declared)
+ *   - L2 object capability    → checked via {@link verifyCapabilities}; its
+ *     `valid` names become `verified`, its `invalid` names become `unverified`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCapabilityVerifier = createCapabilityVerifier;
+const validate_level2_js_1 = require("./validate-level2.js");
+const vc_jwt_verifier_js_1 = require("./vc-jwt-verifier.js");
+/**
+ * Create a capability verifier.
+ *
+ * @param options - Optional signature-verifier / DID-resolver overrides.
+ * @returns A verifier mapping capabilities to `{ verified, unverified }`.
+ */
+function createCapabilityVerifier(options = {}) {
+    const signatureVerifier = options.signatureVerifier ??
+        (0, vc_jwt_verifier_js_1.createVcJwtSignatureVerifier)({ didResolver: options.didResolver });
+    return async (capabilities, ctx) => {
+        const list = Array.isArray(capabilities) ? capabilities : [];
+        const bareStrings = [];
+        const attested = [];
+        for (const capability of list) {
+            if (typeof capability === 'string') {
+                bareStrings.push(capability);
+            }
+            else {
+                attested.push(capability);
+            }
+        }
+        const result = await (0, validate_level2_js_1.verifyCapabilities)(attested, {
+            agentDid: ctx.subjectDid,
+            trustedIssuers: [...ctx.trustedIssuers],
+            signatureVerifier,
+        });
+        const verified = result.valid;
+        const verifiedSet = new Set(verified);
+        // A capability verified via its L2 attestation must not also appear as
+        // unverified — e.g. when the input mixes a bare-string and an attested
+        // object for the same name. Exclude already-verified names, and dedupe.
+        const unverified = Array.from(new Set([
+            ...bareStrings,
+            ...result.invalid.map((entry) => entry.capability),
+        ])).filter((name) => !verifiedSet.has(name));
+        return { verified, unverified };
+    };
+}
+//# sourceMappingURL=capability-verifier-adapter.js.map

package/dist/conformance/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * MCP-I Conformance Level helpers.
+ *
+ * See docs/conformance-levels for the spec page (introduced in
+ * modelcontextprotocol-identity#46).
+ */
+export { verifyCapabilities, validateLevel2, DEFAULT_TRUSTED_ISSUERS, type CapabilityName, type CapabilityAttestation, type CapabilityAttestationCredential, type Level2Capability, type ManifestCapabilities, type CapabilityVCSignatureVerifier, type CapabilityStatusListResolver, type ValidateLevel2Options, type ValidateLevel2Result, type InvalidCapability, } from './validate-level2.js';
+export { createVcJwtSignatureVerifier, createCombinedDidResolver, type VcJwtVerifierOptions, } from './vc-jwt-verifier.js';
+export { createCapabilityVerifier, type DuckTypedCapability, type CapabilityVerificationContext, type CapabilityVerificationResult, type CapabilityVerifier, type CreateCapabilityVerifierOptions, } from './capability-verifier-adapter.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/conformance/index.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * MCP-I Conformance Level helpers.
+ *
+ * See docs/conformance-levels for the spec page (introduced in
+ * modelcontextprotocol-identity#46).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCapabilityVerifier = exports.createCombinedDidResolver = exports.createVcJwtSignatureVerifier = exports.DEFAULT_TRUSTED_ISSUERS = exports.validateLevel2 = exports.verifyCapabilities = void 0;
+var validate_level2_js_1 = require("./validate-level2.js");
+Object.defineProperty(exports, "verifyCapabilities", { enumerable: true, get: function () { return validate_level2_js_1.verifyCapabilities; } });
+Object.defineProperty(exports, "validateLevel2", { enumerable: true, get: function () { return validate_level2_js_1.validateLevel2; } });
+Object.defineProperty(exports, "DEFAULT_TRUSTED_ISSUERS", { enumerable: true, get: function () { return validate_level2_js_1.DEFAULT_TRUSTED_ISSUERS; } });
+var vc_jwt_verifier_js_1 = require("./vc-jwt-verifier.js");
+Object.defineProperty(exports, "createVcJwtSignatureVerifier", { enumerable: true, get: function () { return vc_jwt_verifier_js_1.createVcJwtSignatureVerifier; } });
+Object.defineProperty(exports, "createCombinedDidResolver", { enumerable: true, get: function () { return vc_jwt_verifier_js_1.createCombinedDidResolver; } });
+var capability_verifier_adapter_js_1 = require("./capability-verifier-adapter.js");
+Object.defineProperty(exports, "createCapabilityVerifier", { enumerable: true, get: function () { return capability_verifier_adapter_js_1.createCapabilityVerifier; } });
+//# sourceMappingURL=index.js.map

package/dist/conformance/validate-level2.d.ts

@@ -0,0 +1,203 @@
+/**
+ * Level 2 Capability Attestation Validator
+ *
+ * Implements the Level 2 conformance behavior described in the MCP-I spec:
+ * https://github.com/modelcontextprotocol-identity/modelcontextprotocol-identity/pull/46
+ *
+ * For each declared capability in the agent manifest, verify at least one
+ * attached Verifiable Credential where ALL of the following hold:
+ *   - VC signature verifies (delegated to a platform-specific verifier)
+ *   - issuer DID is in the trusted issuer registry
+ *   - credentialSubject.id matches the agent DID
+ *   - credentialSubject.capability matches the declared capability name
+ *   - validUntil is in the future (and validFrom is in the past, when present)
+ *
+ * Revocation (StatusList2021) is OPTIONAL for v1 and not enforced here.
+ *
+ * Capabilities that fail validation are NOT thrown — they are returned in the
+ * `invalid` array along with the reasons, so callers can surface diagnostics
+ * to UI without a hard failure.
+ *
+ * The legacy Level 1 `string[]` form is accepted as input: every entry is
+ * returned under `valid` along with a global warning so callers can surface
+ * the missing attestation context.
+ */
+/**
+ * Default trusted issuer registry.
+ *
+ * Matches the spec default: `did:web:knowthat.ai`. Callers MAY substitute or
+ * extend this allowlist via {@link ValidateLevel2Options.trustedIssuers}.
+ */
+export declare const DEFAULT_TRUSTED_ISSUERS: readonly string[];
+/**
+ * Capability name as declared in the agent manifest (e.g. `payments.transfer`).
+ */
+export type CapabilityName = string;
+/**
+ * Minimal shape of a `CapabilityAttestationCredential` per the spec.
+ *
+ * Only the fields the validator inspects are typed strictly — additional
+ * fields (`@context`, `type`, `proof`, etc.) are passed through.
+ */
+export interface CapabilityAttestationCredential {
+    '@context'?: string | string[];
+    type?: string | string[];
+    issuer: string | {
+        id: string;
+    };
+    validFrom?: string;
+    validUntil?: string;
+    credentialSubject: {
+        id: string;
+        capability: string;
+        scope?: Record<string, unknown>;
+    };
+    proof?: unknown;
+    [key: string]: unknown;
+}
+/**
+ * Single attestation entry attached to a Level 2 capability.
+ *
+ * The `vc` field MAY be a compact JWT string (per the spec example) OR a
+ * pre-parsed credential object (convenient for tests and callers that have
+ * already decoded the JWT).
+ *
+ * `issuer` and `type` are OPTIONAL envelope metadata hints — they are
+ * informational only and play NO role in trust evaluation. The validator
+ * derives the authoritative issuer from `vc.issuer` (the signed credential
+ * itself), so a wrong or attacker-supplied envelope `issuer` cannot grant
+ * trust. If you need to record the credential type, prefer `vc.type` inside
+ * the VC, which is covered by the signature.
+ */
+export interface CapabilityAttestation {
+    vc: string | CapabilityAttestationCredential;
+    /**
+     * Optional metadata hint. NOT consulted during validation — `vc.issuer` is
+     * authoritative for the trusted-issuer check.
+     */
+    issuer?: string;
+    /**
+     * Optional metadata hint. NOT consulted during validation.
+     */
+    type?: string;
+}
+/**
+ * Level 2 capability entry.
+ */
+export interface Level2Capability {
+    name: CapabilityName;
+    attestations: CapabilityAttestation[];
+}
+/**
+ * Manifest capabilities — accepts either the legacy Level 1 string array or
+ * the Level 2 object array. Mixed entries within a single Level 2 array are
+ * tolerated (string entries are dropped with a per-capability warning).
+ */
+export type ManifestCapabilities = readonly CapabilityName[] | readonly (Level2Capability | CapabilityName)[];
+/**
+ * Pluggable signature verifier for capability attestations.
+ *
+ * Cryptographic verification (Ed25519, ES256, etc.) is platform-specific, so
+ * the validator delegates the signature check. Implementations should resolve
+ * the issuer DID, locate the verification method, and verify the proof.
+ *
+ * If no verifier is supplied, the validator emits a single global warning and
+ * treats every signature as valid — useful for development but unsafe in
+ * production. This mirrors `DelegationCredentialVerifier`'s behavior when no
+ * `signatureVerifier` is provided.
+ */
+export type CapabilityVCSignatureVerifier = (vc: CapabilityAttestationCredential, rawJwt: string | undefined) => Promise<{
+    valid: boolean;
+    reason?: string;
+}>;
+/**
+ * Reserved hook for StatusList2021-based revocation checks.
+ *
+ * Not invoked in v1. Reserved so callers can pass a resolver today and have
+ * it activate transparently once revocation enforcement lands.
+ */
+export type CapabilityStatusListResolver = (vc: CapabilityAttestationCredential) => Promise<{
+    revoked: boolean;
+    reason?: string;
+}>;
+/**
+ * Validator options.
+ */
+export interface ValidateLevel2Options {
+    /**
+     * The agent DID being validated. `credentialSubject.id` on each VC MUST
+     * match this exactly.
+     */
+    agentDid: string;
+    /**
+     * Trusted issuer DID allowlist. Defaults to {@link DEFAULT_TRUSTED_ISSUERS}.
+     * If supplied, replaces (does NOT merge with) the default — callers wanting
+     * to extend the default should spread it themselves.
+     */
+    trustedIssuers?: readonly string[];
+    /**
+     * Platform-specific signature verifier. If omitted, signatures are accepted
+     * unverified and a global warning is emitted.
+     */
+    signatureVerifier?: CapabilityVCSignatureVerifier;
+    /**
+     * StatusList2021 revocation hook. Reserved — not invoked in v1.
+     *
+     * TODO(v1.x): wire this into the per-attestation check loop once the
+     * StatusList2021 contract is finalized for capability attestations.
+     */
+    statusListResolver?: CapabilityStatusListResolver;
+    /**
+     * Clock injection for tests. Defaults to `new Date()`.
+     */
+    now?: () => Date;
+}
+/**
+ * Per-capability failure record.
+ */
+export interface InvalidCapability {
+    capability: CapabilityName;
+    reasons: string[];
+}
+/**
+ * Validator result.
+ *
+ * - `valid` lists the capability names that passed validation.
+ * - `invalid` lists the capabilities that were declared but failed, with the
+ *   accumulated reasons across every attached attestation.
+ * - `warnings` carries non-fatal diagnostics (e.g. "no signature verifier
+ *   provided", or Level 1 input).
+ */
+export interface ValidateLevel2Result {
+    valid: CapabilityName[];
+    invalid: InvalidCapability[];
+    warnings: string[];
+}
+/**
+ * Verify an MCP-I agent's declared capability attestations (Level 2).
+ *
+ * Named for the action it performs — verifying capability ATTESTATIONS — rather
+ * than the conformance level. {@link validateLevel2} remains exported as a
+ * non-breaking `@deprecated` alias.
+ *
+ * @example
+ * ```ts
+ * const result = await verifyCapabilities(manifest.capabilities, {
+ *   agentDid: 'did:web:securebank.example',
+ *   trustedIssuers: ['did:web:knowthat.ai'],
+ *   signatureVerifier: myEd25519Verifier,
+ * });
+ *
+ * console.log(result.valid);    // ['payments.transfer']
+ * console.log(result.invalid);  // [{ capability: 'accounts.read', reasons: [...] }]
+ * console.log(result.warnings); // []
+ * ```
+ */
+export declare function verifyCapabilities(capabilities: unknown, options: ValidateLevel2Options): Promise<ValidateLevel2Result>;
+/**
+ * @deprecated Renamed to {@link verifyCapabilities}. Retained as a non-breaking
+ * alias — the two are referentially identical. Prefer `verifyCapabilities` in
+ * new code; this alias will be removed in a future major.
+ */
+export declare const validateLevel2: typeof verifyCapabilities;
+//# sourceMappingURL=validate-level2.d.ts.map

package/dist/conformance/validate-level2.js

@@ -0,0 +1,294 @@
+"use strict";
+/**
+ * Level 2 Capability Attestation Validator
+ *
+ * Implements the Level 2 conformance behavior described in the MCP-I spec:
+ * https://github.com/modelcontextprotocol-identity/modelcontextprotocol-identity/pull/46
+ *
+ * For each declared capability in the agent manifest, verify at least one
+ * attached Verifiable Credential where ALL of the following hold:
+ *   - VC signature verifies (delegated to a platform-specific verifier)
+ *   - issuer DID is in the trusted issuer registry
+ *   - credentialSubject.id matches the agent DID
+ *   - credentialSubject.capability matches the declared capability name
+ *   - validUntil is in the future (and validFrom is in the past, when present)
+ *
+ * Revocation (StatusList2021) is OPTIONAL for v1 and not enforced here.
+ *
+ * Capabilities that fail validation are NOT thrown — they are returned in the
+ * `invalid` array along with the reasons, so callers can surface diagnostics
+ * to UI without a hard failure.
+ *
+ * The legacy Level 1 `string[]` form is accepted as input: every entry is
+ * returned under `valid` along with a global warning so callers can surface
+ * the missing attestation context.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateLevel2 = exports.DEFAULT_TRUSTED_ISSUERS = void 0;
+exports.verifyCapabilities = verifyCapabilities;
+const utils_js_1 = require("../delegation/utils.js");
+/**
+ * Default trusted issuer registry.
+ *
+ * Matches the spec default: `did:web:knowthat.ai`. Callers MAY substitute or
+ * extend this allowlist via {@link ValidateLevel2Options.trustedIssuers}.
+ */
+exports.DEFAULT_TRUSTED_ISSUERS = [
+    'did:web:knowthat.ai',
+];
+/**
+ * Verify an MCP-I agent's declared capability attestations (Level 2).
+ *
+ * Named for the action it performs — verifying capability ATTESTATIONS — rather
+ * than the conformance level. {@link validateLevel2} remains exported as a
+ * non-breaking `@deprecated` alias.
+ *
+ * @example
+ * ```ts
+ * const result = await verifyCapabilities(manifest.capabilities, {
+ *   agentDid: 'did:web:securebank.example',
+ *   trustedIssuers: ['did:web:knowthat.ai'],
+ *   signatureVerifier: myEd25519Verifier,
+ * });
+ *
+ * console.log(result.valid);    // ['payments.transfer']
+ * console.log(result.invalid);  // [{ capability: 'accounts.read', reasons: [...] }]
+ * console.log(result.warnings); // []
+ * ```
+ */
+async function verifyCapabilities(capabilities, options) {
+    const result = {
+        valid: [],
+        invalid: [],
+        warnings: [],
+    };
+    if (!Array.isArray(capabilities)) {
+        result.warnings.push('capabilities is not an array — no capabilities validated');
+        return result;
+    }
+    // Level 1 string[] passthrough: every entry is a bare capability name.
+    if (capabilities.length > 0 && capabilities.every((c) => typeof c === 'string')) {
+        result.valid.push(...capabilities);
+        result.warnings.push('Level 1 self-declared — no attestation verified');
+        return result;
+    }
+    const trustedIssuers = new Set(options.trustedIssuers ?? exports.DEFAULT_TRUSTED_ISSUERS);
+    const now = (options.now?.() ?? new Date()).getTime();
+    if (!options.signatureVerifier) {
+        result.warnings.push('No signatureVerifier provided — VC signatures accepted without cryptographic verification');
+    }
+    for (const entry of capabilities) {
+        // Mixed-array case: a bare string in a Level 2 array is unattested per
+        // spec ("MUST treat any capability supplied as a string … as unattested
+        // and therefore ignore it"). We surface it as invalid with a clear reason
+        // so callers can diagnose, rather than dropping silently.
+        if (typeof entry === 'string') {
+            result.invalid.push({
+                capability: entry,
+                reasons: ['capability declared as bare string with no attestations'],
+            });
+            continue;
+        }
+        if (!isLevel2Capability(entry)) {
+            // Entry has a name but malformed/missing attestations — report in invalid.
+            if (typeof entry === 'object' &&
+                entry !== null &&
+                typeof entry.name === 'string') {
+                result.invalid.push({
+                    capability: entry.name,
+                    reasons: ['capability has invalid or missing attestations array'],
+                });
+            }
+            else {
+                result.warnings.push(`Skipping capability entry of unrecognized shape: ${safeStringify(entry)}`);
+            }
+            continue;
+        }
+        const capabilityResult = await validateCapability(entry, {
+            agentDid: options.agentDid,
+            trustedIssuers,
+            now,
+            signatureVerifier: options.signatureVerifier,
+        });
+        if (capabilityResult.valid) {
+            result.valid.push(entry.name);
+        }
+        else {
+            result.invalid.push({
+                capability: entry.name,
+                reasons: capabilityResult.reasons,
+            });
+        }
+    }
+    return result;
+}
+/**
+ * @deprecated Renamed to {@link verifyCapabilities}. Retained as a non-breaking
+ * alias — the two are referentially identical. Prefer `verifyCapabilities` in
+ * new code; this alias will be removed in a future major.
+ */
+exports.validateLevel2 = verifyCapabilities;
+async function validateCapability(capability, ctx) {
+    const reasons = [];
+    if (!Array.isArray(capability.attestations) || capability.attestations.length === 0) {
+        return {
+            valid: false,
+            reasons: ['no attestations attached'],
+        };
+    }
+    for (let i = 0; i < capability.attestations.length; i++) {
+        const attestation = capability.attestations[i];
+        const attestationLabel = `attestation[${i}]`;
+        const parsed = decodeAttestationVC(attestation);
+        if (!parsed.ok) {
+            reasons.push(`${attestationLabel}: ${parsed.reason}`);
+            continue;
+        }
+        const { vc, rawJwt } = parsed;
+        const issuerDid = extractIssuerDid(vc);
+        if (!issuerDid) {
+            reasons.push(`${attestationLabel}: VC missing issuer`);
+            continue;
+        }
+        if (!ctx.trustedIssuers.has(issuerDid)) {
+            reasons.push(`${attestationLabel}: issuer ${issuerDid} not in trusted registry`);
+            continue;
+        }
+        if (vc.credentialSubject?.id !== ctx.agentDid) {
+            reasons.push(`${attestationLabel}: credentialSubject.id ${vc.credentialSubject?.id ?? '(missing)'} does not match agent DID ${ctx.agentDid}`);
+            continue;
+        }
+        if (vc.credentialSubject?.capability !== capability.name) {
+            reasons.push(`${attestationLabel}: credentialSubject.capability ${vc.credentialSubject?.capability ?? '(missing)'} does not match declared capability ${capability.name}`);
+            continue;
+        }
+        const validUntilMs = vc.validUntil ? Date.parse(vc.validUntil) : NaN;
+        if (!vc.validUntil || Number.isNaN(validUntilMs)) {
+            reasons.push(`${attestationLabel}: VC missing or unparseable validUntil`);
+            continue;
+        }
+        if (validUntilMs <= ctx.now) {
+            reasons.push(`${attestationLabel}: VC expired (validUntil ${vc.validUntil})`);
+            continue;
+        }
+        if (vc.validFrom) {
+            const validFromMs = Date.parse(vc.validFrom);
+            if (Number.isNaN(validFromMs)) {
+                reasons.push(`${attestationLabel}: unparseable validFrom`);
+                continue;
+            }
+            if (validFromMs > ctx.now) {
+                reasons.push(`${attestationLabel}: VC not yet valid (validFrom ${vc.validFrom})`);
+                continue;
+            }
+        }
+        if (ctx.signatureVerifier) {
+            let sig;
+            try {
+                sig = await ctx.signatureVerifier(vc, rawJwt);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                reasons.push(`${attestationLabel}: signature verifier threw: ${message}`);
+                continue;
+            }
+            if (!sig.valid) {
+                reasons.push(`${attestationLabel}: signature invalid${sig.reason ? ` (${sig.reason})` : ''}`);
+                continue;
+            }
+        }
+        // TODO(v1.x): when StatusList2021 hook lands, invoke
+        // ctx.statusListResolver here and reject revoked attestations. v1 skips
+        // revocation per the spec design doc.
+        return { valid: true, reasons: [] };
+    }
+    return { valid: false, reasons };
+}
+/**
+ * Decode an attestation `vc` field (string JWT or object) into a credential.
+ */
+function decodeAttestationVC(attestation) {
+    if (attestation === null || typeof attestation !== 'object') {
+        return { ok: false, reason: 'attestation entry is not an object' };
+    }
+    const vc = attestation.vc;
+    if (typeof vc === 'string') {
+        const parsed = (0, utils_js_1.parseVCJWT)(vc);
+        if (!parsed) {
+            return { ok: false, reason: 'VC JWT could not be parsed' };
+        }
+        const inner = parsed.payload.vc;
+        if (!inner || typeof inner !== 'object') {
+            return { ok: false, reason: 'VC JWT payload missing vc claim' };
+        }
+        // Per W3C VC-JWT spec §6.3: promote JWT-level iss→vc.issuer and
+        // sub→vc.credentialSubject.id when absent from the embedded vc object so
+        // that externally-issued spec-compliant JWTs are not falsely rejected.
+        const merged = { ...inner };
+        if (!merged.issuer && typeof parsed.payload.iss === 'string') {
+            merged.issuer = parsed.payload.iss;
+        }
+        if (typeof parsed.payload.sub === 'string' &&
+            merged.credentialSubject &&
+            typeof merged.credentialSubject === 'object' &&
+            !merged.credentialSubject.id) {
+            merged.credentialSubject = {
+                ...merged.credentialSubject,
+                id: parsed.payload.sub,
+            };
+        }
+        // Per W3C VC-JWT spec §6.3: also promote exp→validUntil and nbf→validFrom
+        // when absent from the embedded vc object, so externally-issued JWTs that
+        // carry validity only in the standard JWT claims are not falsely rejected.
+        // JWT exp/nbf are Unix seconds (NumericDate). Guard the conversion: an
+        // out-of-range claim yields an Invalid Date, which we leave unset (→ the VC
+        // fails closed at validation) rather than letting toISOString() throw a
+        // RangeError out of this otherwise-total decoder.
+        if (!merged.validUntil && typeof parsed.payload.exp === 'number') {
+            const d = new Date(parsed.payload.exp * 1000);
+            if (!Number.isNaN(d.getTime()))
+                merged.validUntil = d.toISOString();
+        }
+        if (!merged.validFrom && typeof parsed.payload.nbf === 'number') {
+            const d = new Date(parsed.payload.nbf * 1000);
+            if (!Number.isNaN(d.getTime()))
+                merged.validFrom = d.toISOString();
+        }
+        return {
+            ok: true,
+            vc: merged,
+            rawJwt: vc,
+        };
+    }
+    if (vc && typeof vc === 'object') {
+        return {
+            ok: true,
+            vc: vc,
+            rawJwt: undefined,
+        };
+    }
+    return { ok: false, reason: 'attestation.vc missing or invalid type' };
+}
+function extractIssuerDid(vc) {
+    if (typeof vc.issuer === 'string')
+        return vc.issuer;
+    if (vc.issuer && typeof vc.issuer === 'object' && typeof vc.issuer.id === 'string') {
+        return vc.issuer.id;
+    }
+    return undefined;
+}
+function isLevel2Capability(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        typeof value.name === 'string' &&
+        Array.isArray(value.attestations));
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+//# sourceMappingURL=validate-level2.js.map