@learncard/openid4vc-plugin 0.0.1

package/dist/plugin.d.ts

@@ -0,0 +1,12 @@
+import { OpenID4VCDependentLearnCard, OpenID4VCPlugin, OpenID4VCPluginConfig } from './types';
+/**
+ * Create the OpenID4VC holder plugin.
+ *
+ * Current scope (Slice 1): Credential Offer URI parsing + by-reference
+ * resolution. Subsequent slices will add token exchange, credential request,
+ * OID4VP Authorization Request handling, and SIOPv2 ID tokens.
+ *
+ * @group Plugins
+ */
+export declare const getOpenID4VCPlugin: (_learnCard: OpenID4VCDependentLearnCard, config?: OpenID4VCPluginConfig) => OpenID4VCPlugin;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAEA,OAAO,EACH,2BAA2B,EAC3B,eAAe,EACf,qBAAqB,EACxB,MAAM,SAAS,CAAC;AAkDjB;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,eACf,2BAA2B,WAC/B,qBAAqB,KAC9B,eAkYF,CAAC"}

package/dist/siop/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * SIOPv2 (Self-Issued OpenID Provider v2) surface.
+ *
+ * Currently scoped to **holder-side ID token issuance** used by OID4VP
+ * combined flows (`response_type=vp_token id_token`). SIOPv2-only
+ * flows (no VP at all, just an id_token) reuse the same module — the
+ * wallet just wouldn't call `buildPresentation` beforehand.
+ */
+export { signIdToken, SiopSignError, responseTypeSet, requiresIdToken, } from './sign';
+export type { SignIdTokenOptions, SignIdTokenHelpers, SignIdTokenResult, SiopSignErrorCode, } from './sign';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/siop/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EACH,WAAW,EACX,aAAa,EACb,eAAe,EACf,eAAe,GAClB,MAAM,QAAQ,CAAC;AAEhB,YAAY,EACR,kBAAkB,EAClB,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,GACpB,MAAM,QAAQ,CAAC"}

package/dist/siop/sign.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Slice 8 — **SIOPv2 ID token signing**.
+ *
+ * OpenID for Verifiable Presentations combined flows
+ * (`response_type=vp_token id_token`) require the wallet to return a
+ * Self-Issued OpenID Provider v2 (SIOPv2) ID token alongside the VP
+ * token. The ID token proves the holder controls the DID the VP was
+ * bound to.
+ *
+ * This module builds + signs the ID token per §9 of the SIOPv2 spec:
+ *   - `iss` = the holder DID (or `https://self-issued.me/v2` when the
+ *      spec-reserved form is requested; we default to the DID because
+ *      that's what every real verifier expects).
+ *   - `sub` = the holder DID.
+ *   - `aud` = verifier's `client_id` (from the Authorization Request).
+ *   - `nonce` = verifier's nonce.
+ *   - `iat` / `exp` = now / now+5min.
+ *
+ * Purely dependency-injected: the signer is the same
+ * {@link ProofJwtSigner} shape used by VCI proof-of-possession and VP
+ * signing. Plugin wires in the Ed25519 signer built from the host
+ * LearnCard's keypair.
+ */
+import { ProofJwtSigner } from '../vci/types';
+export interface SignIdTokenOptions {
+    /** Holder DID — becomes both `iss` and `sub`. */
+    holder: string;
+    /** Verifier's `client_id` — becomes `aud`. */
+    audience: string;
+    /** Verifier's `nonce` — must match between vp_token and id_token. */
+    nonce: string;
+    /**
+     * Optional. When the verifier's Authorization Request requested a
+     * `_vp_token` hash binding, the caller can pre-compute it and
+     * pass it here. We just stamp the claim unchanged — calculation
+     * of the JWT-VP hash belongs in the caller.
+     */
+    vpTokenHash?: string;
+    /** Override `iat` for deterministic tests. Defaults to `Math.floor(Date.now() / 1000)`. */
+    iat?: number;
+    /**
+     * Override token lifetime in seconds. Defaults to 300 (5 min) —
+     * enough for the verifier to receive and validate before expiry
+     * even over slow networks, short enough that a leaked token
+     * won't linger.
+     */
+    lifetimeSeconds?: number;
+    /**
+     * SIOPv2 §9 allows `iss` to be either the holder DID or the
+     * reserved value `https://self-issued.me/v2`. Default: holder DID
+     * (matches what EUDI + Sphereon + walt.id all expect). Flip to
+     * `'self-issued.me'` for spec-purity test cases.
+     */
+    issuerMode?: 'did' | 'self-issued.me';
+}
+export interface SignIdTokenHelpers {
+    signer: ProofJwtSigner;
+}
+export interface SignIdTokenResult {
+    /** Compact JWS suitable for submission as the `id_token` form field. */
+    idToken: string;
+}
+export type SiopSignErrorCode = 'invalid_input' | 'missing_signer' | 'id_token_sign_failed';
+export declare class SiopSignError extends Error {
+    readonly code: SiopSignErrorCode;
+    constructor(code: SiopSignErrorCode, message: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Build + sign a SIOPv2 ID token. See module doc for claim shape.
+ *
+ * Typed `SiopSignError`s on every failure so UIs can surface
+ * "couldn't prove holder identity" distinctly from "verifier
+ * rejected the VP".
+ */
+export declare const signIdToken: (options: SignIdTokenOptions, helpers: SignIdTokenHelpers) => Promise<SignIdTokenResult>;
+/**
+ * Parse a space-separated `response_type` value into a set. Handy for
+ * plugin consumers that need to decide whether to emit an id_token:
+ *
+ *   responseTypeSet(req.response_type).has('id_token')
+ */
+export declare const responseTypeSet: (value: string | undefined) => Set<string>;
+/**
+ * Convenience predicate mirroring OID4VP spec intent:
+ *   - `vp_token` alone → VP only.
+ *   - `id_token` alone → SIOPv2 identity only, no VP.
+ *   - `vp_token id_token` → combined flow, both.
+ */
+export declare const requiresIdToken: (responseType: string | undefined) => boolean;
+//# sourceMappingURL=sign.d.ts.map

package/dist/siop/sign.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sign.d.ts","sourceRoot":"","sources":["../../src/siop/sign.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAM9C,MAAM,WAAW,kBAAkB;IAC/B,iDAAiD;IACjD,MAAM,EAAE,MAAM,CAAC;IAEf,8CAA8C;IAC9C,QAAQ,EAAE,MAAM,CAAC;IAEjB,qEAAqE;IACrE,KAAK,EAAE,MAAM,CAAC;IAEd;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,2FAA2F;IAC3F,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb;;;;;OAKG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,KAAK,GAAG,gBAAgB,CAAC;CACzC;AAED,MAAM,WAAW,kBAAkB;IAC/B,MAAM,EAAE,cAAc,CAAC;CAC1B;AAED,MAAM,WAAW,iBAAiB;IAC9B,wEAAwE;IACxE,OAAO,EAAE,MAAM,CAAC;CACnB;AAMD,MAAM,MAAM,iBAAiB,GACvB,eAAe,GACf,gBAAgB,GAChB,sBAAsB,CAAC;AAE7B,qBAAa,aAAc,SAAQ,KAAK;IACpC,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;gBAG7B,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE;CASpC;AAMD;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,YACX,kBAAkB,WAClB,kBAAkB,KAC5B,OAAO,CAAC,iBAAiB,CAuC3B,CAAC;AA2CF;;;;;GAKG;AACH,eAAO,MAAM,eAAe,UAAW,MAAM,GAAG,SAAS,KAAG,GAAG,CAAC,MAAM,CAGrE,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,eAAe,iBAAkB,MAAM,GAAG,SAAS,KAAG,OAClB,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,359 @@
+import { Plugin, LearnCard } from '@learncard/core';
+import { UnsignedVC, VC, UnsignedVP, VP } from '@learncard/types';
+import { ProofOptions } from '@learncard/didkit-plugin';
+import { CredentialOffer, ParsedCredentialOfferUri } from './offer/types';
+import { AcceptCredentialOfferOptions, AcceptedCredentialResult } from './vci/types';
+import { AuthCodeFlowHandle, BeginAuthCodeFlowResult } from './vci/auth-code';
+import { StoreAcceptedCredentialsOptions, StoreAcceptedCredentialsResult } from './vci/store';
+import { AuthorizationRequest, ParsedAuthorizationRequest } from './vp/types';
+import { CandidateCredential, PresentationSubmission, SelectionResult } from './vp/select';
+import { ChosenCredential, PreparedPresentation, VpFormat } from './vp/present';
+import { SignPresentationResult } from './vp/sign';
+import { SubmitPresentationResult } from './vp/submit';
+import { DidResolver } from './vp/request-object';
+import { SignIdTokenResult } from './siop/sign';
+import { ProofJwtSigner } from './vci/types';
+import type { DcqlChosenCredential, BuiltDcqlPresentation } from './dcql/build';
+import type { DcqlSelectionResult } from './dcql/select';
+import type { DcqlSignedPresentation } from './dcql/respond';
+/**
+ * A holder pick for either the PEX or DCQL pipeline.
+ *
+ * The plugin auto-routes based on which query language the verifier's
+ * Authorization Request carried:
+ *
+ * - PEX (`request.presentation_definition` set) → entries MUST use
+ *   {@link ChosenCredential} (with `descriptorId`).
+ * - DCQL (`request.dcql_query` set) → entries MUST use
+ *   {@link DcqlChosenCredential} (with `credentialQueryId`).
+ *
+ * Mixing shapes within a single call is rejected with a typed error
+ * — every entry must match the request's query language.
+ */
+export type ChosenForPresentation = ChosenCredential | DcqlChosenCredential;
+/**
+ * Methods the host LearnCard must provide for the OpenID4VC plugin to work.
+ *
+ * We lean on the existing VC plugin for credential signing (needed for
+ * proof-of-possession JWTs and, eventually, VP token construction) and on
+ * the `id` plane for keypair/DID access.
+ */
+export type OpenID4VCPluginDependentMethods = {
+    issueCredential: (credential: UnsignedVC, signingOptions?: Partial<ProofOptions>) => Promise<VC>;
+    issuePresentation: (presentation: UnsignedVP, signingOptions?: Partial<ProofOptions>) => Promise<VP>;
+    didToVerificationMethod: (did: string) => Promise<string>;
+};
+/** Public surface of the OpenID4VC plugin. */
+export type OpenID4VCPluginMethods = {
+    /**
+     * Parse an OpenID4VCI Credential Offer URI. Does not hit the network.
+     *
+     * Returns a discriminated union so callers can decide whether to resolve
+     * a by-reference offer themselves or delegate to {@link resolveCredentialOffer}.
+     */
+    parseCredentialOffer: (input: string) => ParsedCredentialOfferUri;
+    /**
+     * Parse a Credential Offer URI and, if it's by-reference, fetch and
+     * normalize the underlying offer. Returns the normalized Draft 13 offer.
+     */
+    resolveCredentialOffer: (input: string) => Promise<CredentialOffer>;
+    /**
+     * Drive the pre-authorized_code flow end-to-end for a credential offer
+     * and return the raw issued credentials. Accepts either a Credential
+     * Offer URI (which will be parsed + resolved) or an already-parsed offer.
+     *
+     * The plugin auto-builds an Ed25519 proof-of-possession signer from the
+     * host LearnCard's keypair. Callers using other key types (HSM, secp256k1)
+     * should supply their own `options.signer`.
+     *
+     * Storage of the returned credentials is the caller's responsibility.
+     * Use {@link acceptAndStoreCredentialOffer} for the turnkey "accept and
+     * persist to the wallet" flow.
+     */
+    acceptCredentialOffer: (input: string | CredentialOffer, options?: AcceptCredentialOfferOptions) => Promise<AcceptedCredentialResult>;
+    /**
+     * Accept a Credential Offer **and** persist the resulting credentials
+     * to the wallet's store + index planes, so they appear in the UI.
+     *
+     * Internally: runs {@link acceptCredentialOffer}, then normalizes each
+     * issued credential into a W3C VC (JWT → VC per VCDM §6.3.1), uploads
+     * to `learnCard.store.LearnCloud.uploadEncrypted` by default, and adds
+     * an index record so the wallet's credential list picks it up.
+     *
+     * Per-credential failures are surfaced in the `failures` array rather
+     * than aborting the batch — one bad credential in an offer shouldn't
+     * discard the rest.
+     */
+    acceptAndStoreCredentialOffer: (input: string | CredentialOffer, options?: AcceptCredentialOfferOptions & StoreAcceptedCredentialsOptions) => Promise<AcceptedCredentialResult & StoreAcceptedCredentialsResult>;
+    /**
+     * Slice 4 — phase 1 of the OID4VCI **authorization_code** flow.
+     *
+     * Resolves issuer + AS metadata, generates PKCE, and builds the
+     * `authorization_endpoint` URL the wallet should open in a
+     * user-agent. Returns an opaque `flowHandle` the wallet persists
+     * until the redirect callback fires.
+     *
+     * This method is purely preparation — no codes are exchanged, no
+     * credentials requested. The actual credential issuance happens
+     * in {@link completeCredentialOfferAuthCode} once the redirect
+     * delivers a `code`.
+     */
+    beginCredentialOfferAuthCode: (input: string | CredentialOffer, options: {
+        /** Wallet's OAuth 2.0 redirect_uri for the callback. Required. */
+        redirectUri: string;
+        /** Wallet's OAuth client_id. Required by most authorization servers. */
+        clientId: string;
+        /** Optional subset of credential_configuration_ids. Default: all. */
+        configurationIds?: string[];
+        /** Optional OAuth scope. */
+        scope?: string;
+    }) => Promise<BeginAuthCodeFlowResult>;
+    /**
+     * Slice 4 — phase 2 of the OID4VCI **authorization_code** flow.
+     *
+     * Takes the `code` (and `state`) delivered on the redirect
+     * callback, the `flowHandle` persisted from
+     * {@link beginCredentialOfferAuthCode}, and:
+     *   - Exchanges the code for an access token (PKCE verifier sent).
+     *   - Builds a proof-of-possession JWT via the host signer.
+     *   - POSTs the credential request + returns the issued VC(s).
+     */
+    completeCredentialOfferAuthCode: (options: {
+        flowHandle: AuthCodeFlowHandle;
+        code: string;
+        state?: string;
+        signer?: AcceptCredentialOfferOptions['signer'];
+    }) => Promise<AcceptedCredentialResult>;
+    /**
+     * Parse an OpenID4VP Authorization Request URI. Does not hit the
+     * network. Returns a discriminated union so callers can detect
+     * signed Request Objects (`request` / `request_uri`) — those require
+     * JWS verification via Slice 7.
+     *
+     * @see resolveAuthorizationRequest for the one-shot version that
+     * also fetches `presentation_definition_uri` when present.
+     */
+    parseAuthorizationRequest: (input: string) => ParsedAuthorizationRequest;
+    /**
+     * End-to-end: parse the Authorization Request URI and, if it's a
+     * by-value request with an out-of-band `presentation_definition_uri`,
+     * fetch and inline the PD. Returns a fully resolved
+     * {@link AuthorizationRequest} ready for PEX matching.
+     *
+     * Throws `VpError` with code `request_object_not_supported` when
+     * the URI points at a signed Request Object (Slice 7 surface).
+     */
+    resolveAuthorizationRequest: (input: string) => Promise<AuthorizationRequest>;
+    /**
+     * The main OID4VP entry point for wallet UIs: resolve the verifier's
+     * Authorization Request, match every `input_descriptor` in its
+     * Presentation Definition against the holder's candidate credentials,
+     * and return a preview object carrying:
+     *
+     *   - The resolved {@link AuthorizationRequest} (for UI to show
+     *     verifier identity, purpose, etc.).
+     *   - A {@link SelectionResult} with per-descriptor candidate lists
+     *     so the UI can render selection rows and disable "Share" up
+     *     front when `canSatisfy === false`.
+     *
+     * This method is read-only — it never signs, never POSTs, and never
+     * touches the holder's private keys. Actual vp_token construction
+     * + `direct_post` submission happens in Slice 7.
+     *
+     * Match the holder's candidate pool against either the
+     * verifier's PEX `presentation_definition` or DCQL `dcql_query`,
+     * whichever the request carries.
+     *
+     * The returned object exposes BOTH `selection` (PEX) and
+     * `dcqlSelection` (DCQL) fields; exactly one is populated, mirroring
+     * which query language the request used. Callers can either:
+     *  - branch on `request.dcql_query` first (preferred), or
+     *  - branch on which selection field is defined.
+     *
+     * @param input        Authorization Request URI, or an already-parsed request.
+     * @param credentials  Wallet's candidate pool (same shape used by both routes).
+     */
+    prepareVerifiablePresentation: (input: string | AuthorizationRequest, credentials: CandidateCredential[]) => Promise<{
+        request: AuthorizationRequest;
+        /** Populated when the verifier sent PEX. Undefined for DCQL requests. */
+        selection?: SelectionResult;
+        /** Populated when the verifier sent DCQL. Undefined for PEX requests. */
+        dcqlSelection?: DcqlSelectionResult;
+    }>;
+    /**
+     * Slice 7a — build an unsigned Verifiable Presentation + DIF PEX
+     * Presentation Submission from the user's per-descriptor picks.
+     *
+     * Pure / synchronous w.r.t. cryptography: this method never touches
+     * the holder's private keys, so UIs can call it to show a preview
+     * of exactly what will be submitted before the user consents to
+     * sign.
+     *
+     * @param input    The verifier's Authorization Request (or URI that
+     *   will be re-resolved for convenience).
+     * @param chosen   One {@link ChosenCredential} per input_descriptor
+     *   the user picked. Order determines `verifiableCredential[i]`
+     *   slots in the VP and the corresponding `descriptor_map` entries.
+     * @param options  `holder` defaults to `learnCard.id.did()`;
+     *   `envelopeFormat` is inferred from `pd.format` + the inner
+     *   credential formats when omitted.
+     */
+    buildPresentation: (input: string | AuthorizationRequest, chosen: ChosenCredential[], options?: {
+        holder?: string;
+        envelopeFormat?: VpFormat;
+    }) => Promise<{
+        request: AuthorizationRequest;
+        prepared: PreparedPresentation;
+    }>;
+    /**
+     * Slice 7b — sign a prepared VP into a submittable `vp_token`.
+     *
+     * For `jwt_vp_json` envelopes: builds a VCDM §6.3.1 JWT-VP with
+     * `iss`/`sub` = holder, `aud` = verifier `client_id`, `nonce` =
+     * verifier nonce, and signs with an Ed25519 signer derived from
+     * the host's primary keypair (unless overridden via `options.signer`).
+     *
+     * For `ldp_vp` envelopes: delegates to
+     * `learnCard.invoke.issuePresentation`, passing `domain = client_id`
+     * and `challenge = nonce` so the resulting Linked-Data proof binds
+     * to the verifier's replay-resistant context.
+     */
+    signPresentation: (input: string | AuthorizationRequest, prepared: PreparedPresentation, options?: {
+        /** Override the JWT signer (for HSM/secp256k1/etc. backends). */
+        signer?: ProofJwtSigner;
+        /** Override holder DID. Defaults to `prepared.unsignedVp.holder` or `learnCard.id.did()`. */
+        holder?: string;
+    }) => Promise<SignPresentationResult>;
+    /**
+     * Slice 7c — POST the signed `vp_token` + `presentation_submission`
+     * to the verifier's `response_uri` per OID4VP §8 (direct_post).
+     * Pass `idToken` to include a SIOPv2 id_token alongside the VP
+     * (required when `response_type=vp_token id_token`). `state` is
+     * echoed back when the verifier included one.
+     */
+    submitPresentation: (input: string | AuthorizationRequest, signed: SignPresentationResult, submission: PresentationSubmission, options?: {
+        idToken?: string;
+    }) => Promise<SubmitPresentationResult>;
+    /**
+     * Slice 8 — sign a SIOPv2 ID token proving holder control of
+     * their DID. Used on its own for SIOPv2-only flows
+     * (`response_type=id_token`), or bundled into `presentCredentials`
+     * for combined `vp_token id_token` flows.
+     */
+    signIdToken: (input: string | AuthorizationRequest, options?: {
+        holder?: string;
+        signer?: ProofJwtSigner;
+        lifetimeSeconds?: number;
+        issuerMode?: 'did' | 'self-issued.me';
+        vpTokenHash?: string;
+    }) => Promise<SignIdTokenResult>;
+    /**
+     * End-to-end convenience: resolve the verifier's request, build +
+     * sign the VP around the user's picks, and POST it. Returns every
+     * intermediate stage so UIs can surface per-step progress or errors.
+     *
+     * When the verifier's `response_type` includes `id_token`, a
+     * SIOPv2 id_token is also signed and included in the direct_post
+     * submission. The returned `signedIdToken` is populated on those
+     * flows; on pure `vp_token` flows it's undefined.
+     *
+     * Typed error codes bubble up from each stage (`BuildPresentationError`,
+     * `VpSignError`, `SiopSignError`, `VpSubmitError`) — wrap this in
+     * a `try/catch` to distinguish "we couldn't build the VP" from
+     * "the verifier rejected it" in the UI.
+     */
+    presentCredentials: (input: string | AuthorizationRequest, chosen: ChosenForPresentation[], options?: {
+        holder?: string;
+        envelopeFormat?: VpFormat;
+        signer?: ProofJwtSigner;
+    }) => Promise<{
+        request: AuthorizationRequest;
+        /**
+         * PEX flow output: the unsigned VP + DIF PEX presentation_submission
+         * built before signing. Populated only when the request carried
+         * `presentation_definition`.
+         */
+        prepared?: PreparedPresentation;
+        /**
+         * PEX flow output: the signed PEX `vp_token`. Populated only when
+         * the request carried `presentation_definition`.
+         */
+        signed?: SignPresentationResult;
+        /** SIOPv2 id_token (both PEX and DCQL flows route through this). */
+        signedIdToken?: SignIdTokenResult;
+        /**
+         * DCQL flow output: per-credential-query unsigned VPs.
+         * Populated only when the request carried `dcql_query`.
+         */
+        dcqlBuilt?: BuiltDcqlPresentation[];
+        /**
+         * DCQL flow output: per-credential-query signed presentations.
+         * Populated only when the request carried `dcql_query`.
+         */
+        dcqlSigned?: DcqlSignedPresentation[];
+        /**
+         * DCQL flow output: the assembled `vp_token` object (keys =
+         * credential_query_id, values = signed presentations).
+         * Populated only when the request carried `dcql_query`.
+         */
+        dcqlVpToken?: Record<string, unknown>;
+        /** HTTP-level result of the direct_post submission. Always populated. */
+        submitted: SubmitPresentationResult;
+    }>;
+};
+/** Configuration passed to {@link getOpenID4VCPlugin}. */
+export interface OpenID4VCPluginConfig {
+    /**
+     * Fetch implementation used for HTTP calls (offer resolution,
+     * issuer metadata, token exchange, credential request).
+     *
+     * Defaults to `globalThis.fetch` when available.
+     */
+    fetch?: typeof fetch;
+    /**
+     * DID resolver used to verify signed Authorization Request Objects
+     * whose `client_id_scheme=did` (Slice 7.5). When omitted, a
+     * built-in resolver handles `did:jwk` (offline) and `did:web` (over
+     * `fetch`). Host apps shipping `did:key` / `did:ion` / `did:pkh`
+     * etc. wire their own resolver here.
+     */
+    didResolver?: DidResolver;
+    /**
+     * PEM-encoded trust anchors for signed Request Objects whose
+     * `client_id_scheme=x509_san_dns` (Slice 7.5). When empty, the
+     * plugin refuses x509-signed requests unless
+     * {@link unsafeAllowSelfSignedRequestObject} is explicitly true.
+     */
+    trustedX509Roots?: readonly string[];
+    /**
+     * **Dev-only.** When true, accept `x509_san_dns` chains that don't
+     * root into {@link trustedX509Roots}. Exists so smoke tests can
+     * hit self-signed staging verifiers; production wallets must leave
+     * this off.
+     */
+    unsafeAllowSelfSignedRequestObject?: boolean;
+    /**
+     * **Maximally dangerous, dev-only.** Skip JWS signature
+     * verification on signed Request Objects entirely (claims are
+     * still parsed). Use ONLY when interoperating with a verifier
+     * whose signing keys are pre-shared out-of-band and not
+     * published on any in-band channel (e.g. EUDI's reference
+     * verifier in `pre-registered` mode, which embeds
+     * `kid: "access_certificate"` referencing a keystore inside
+     * the verifier container with no JWKS endpoint).
+     *
+     * Production wallets MUST leave this off — when set, tampered
+     * Request Objects bypass detection. The other binding checks
+     * (URL `client_id` ↔ signed `client_id`, mutual exclusion of
+     * PEX vs. DCQL, etc.) still run because they're integrity
+     * checks against the host-supplied URL, not the signature.
+     */
+    unsafeSkipRequestObjectSignatureVerification?: boolean;
+}
+/** LearnCard shape the plugin factory consumes. */
+export type OpenID4VCDependentLearnCard = LearnCard<any, 'id', OpenID4VCPluginDependentMethods>;
+/** LearnCard shape after the plugin has been added. */
+export type OpenID4VCImplicitLearnCard = LearnCard<any, 'id', OpenID4VCPluginMethods & OpenID4VCPluginDependentMethods>;
+/** @group OpenID4VC Plugin */
+export type OpenID4VCPlugin = Plugin<'OpenID4VC', any, OpenID4VCPluginMethods, 'id', OpenID4VCPluginDependentMethods>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/vci/accept.d.ts

@@ -0,0 +1,24 @@
+import { CredentialOffer } from '../offer/types';
+import { AcceptCredentialOfferOptions, AcceptedCredentialResult, ProofJwtSigner } from './types';
+/**
+ * Drive the pre-authorized_code flow end-to-end for a single credential
+ * offer, returning the raw issued credentials.
+ *
+ * Flow:
+ *   1. Validate the offer has the pre-authorized_code grant.
+ *   2. Fetch issuer metadata + resolve the authorization server.
+ *   3. Fetch AS metadata to discover the token endpoint.
+ *   4. Exchange the pre-auth code (+ optional tx_code) for an access token.
+ *   5. Build a proof-of-possession JWT bound to the issuer + c_nonce.
+ *   6. POST a credential request per configuration id.
+ *   7. Aggregate the returned credentials.
+ *
+ * Storage (wallet index, LearnCloud) happens in Slice 3.
+ */
+export declare const acceptCredentialOffer: (args: {
+    offer: CredentialOffer;
+    signer: ProofJwtSigner;
+    options?: AcceptCredentialOfferOptions;
+    fetchImpl?: typeof fetch;
+}) => Promise<AcceptedCredentialResult>;
+//# sourceMappingURL=accept.d.ts.map

package/dist/vci/accept.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accept.d.ts","sourceRoot":"","sources":["../../src/vci/accept.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAA6B,MAAM,gBAAgB,CAAC;AAS5E,OAAO,EACH,4BAA4B,EAC5B,wBAAwB,EACxB,cAAc,EACjB,MAAM,SAAS,CAAC;AAGjB;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,qBAAqB,SAAgB;IAC9C,KAAK,EAAE,eAAe,CAAC;IACvB,MAAM,EAAE,cAAc,CAAC;IACvB,OAAO,CAAC,EAAE,4BAA4B,CAAC;IACvC,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;CAC5B,KAAG,OAAO,CAAC,wBAAwB,CA8InC,CAAC"}