@interop/wallet-core 0.69.0 → 0.71.0

package/dist/request/processRequest.d.ts

@@ -1,45 +0,0 @@
-import type { IVerifiableCredential, IVPRDetails, PresentationSigner, RequestProcessors, WalletResponse } from './types.js';
-/**
- * Domain-binding check (VCALM §3.4.3 advisement): a DID-Auth `domain` MUST match
- * the channel the request arrived on, otherwise a dishonest verifier could relay
- * the challenge from another origin and replay the response.
- *
- * @param options {object}
- * @param options.domain {string} - The `domain` from the request.
- * @param [options.origin] {string} - The channel origin (for CHAPI,
- *   `event.credentialRequestOrigin`).
- * @returns {boolean}
- */
-export declare function domainMatchesOrigin({ domain, origin }: {
-    domain: string;
-    origin?: string;
-}): boolean;
-/**
- * Processes a Verifiable Presentation Request and composes the wallet's
- * response. Assumes the user has already consented and (for VC sharing) picked
- * which credentials to send.
- *
- * @param options {object}
- * @param options.request {IVPRDetails} - The VPR body.
- * @param options.presentationSigner {PresentationSigner} - Authentication signer
- *   and holder DID.
- * @param [options.selectedVCs] {IVerifiableCredential[]} - VCs the user chose to
- *   share (empty for a DID-Auth-only or zcap-only response).
- * @param [options.credentialRequestOrigin] {string} - Channel origin, used for
- *   the domain-binding check and required by the App Connect branch.
- * @param [options.processors] {RequestProcessors} - App-side capability /
- *   App Connect processors.
- * @param [options.cryptosuite] {string} - Cryptosuite override; when absent it
- *   is negotiated from the request's `acceptedCryptosuites`.
- * @returns {Promise<WalletResponse>} The response VP (and any granted zcaps), or
- *   `{}` when there is nothing to send.
- */
-export declare function processRequest({ request, presentationSigner, selectedVCs, credentialRequestOrigin, processors, cryptosuite }: {
-    request: IVPRDetails;
-    presentationSigner: PresentationSigner;
-    selectedVCs?: IVerifiableCredential[];
-    credentialRequestOrigin?: string;
-    processors?: RequestProcessors;
-    cryptosuite?: string;
-}): Promise<WalletResponse>;
-//# sourceMappingURL=processRequest.d.ts.map

package/dist/request/processRequest.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"processRequest.d.ts","sourceRoot":"","sources":["../../src/request/processRequest.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EACV,qBAAqB,EACrB,WAAW,EAEX,kBAAkB,EAClB,iBAAiB,EACjB,cAAc,EACf,MAAM,YAAY,CAAA;AAkBnB;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,EAClC,MAAM,EACN,MAAM,EACP,EAAE;IACD,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,GAAG,OAAO,CAOV;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,cAAc,CAAC,EACnC,OAAO,EACP,kBAAkB,EAClB,WAAgB,EAChB,uBAAuB,EACvB,UAAU,EACV,WAAW,EACZ,EAAE;IACD,OAAO,EAAE,WAAW,CAAA;IACpB,kBAAkB,EAAE,kBAAkB,CAAA;IACtC,WAAW,CAAC,EAAE,qBAAqB,EAAE,CAAA;IACrC,uBAAuB,CAAC,EAAE,MAAM,CAAA;IAChC,UAAU,CAAC,EAAE,iBAAiB,CAAA;IAC9B,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,GAAG,OAAO,CAAC,cAAc,CAAC,CAgF1B"}

package/dist/request/processRequest.js

@@ -1,147 +0,0 @@
-/*!
- * Copyright (c) 2026 Interop Alliance. All rights reserved.
- */
-/**
- * Framework-agnostic request processing: turns a classified VPR body plus the
- * user's VC selection into a {@link WalletResponse} (a possibly-signed VP, plus
- * any delegated zcaps). The response channel (CHAPI `respondWith`, an
- * exchange-URL POST) stays with the caller -- this function only returns data,
- * and assumes the user has already consented and picked which credentials to
- * send.
- *
- * Ported from Freewallet's `src/lib/walletRequest/processRequest.ts` (the pure
- * shape). The two app-specific side effects -- capability delegation and the App
- * Connect branch -- are injected as {@link RequestProcessors} rather than
- * imported, so this layer carries no session / grant-resolution machinery. The
- * signer and holder DID are injected as a {@link PresentationSigner}.
- */
-import { log } from '../log.js';
-import { appConnectRequestOf, classifyRequest, queriesOf } from './classify.js';
-import { composeVp } from './composeVp.js';
-import { negotiateCryptosuite } from './presentationSuite.js';
-import { isAppConnectQuery } from './queryPredicates.js';
-/**
- * Extracts the host (`host:port`) from a value that may be a full URL or a bare
- * host / host:port. Returns undefined if it cannot be parsed.
- */
-function hostOf(value) {
-    try {
-        const url = value.includes('://')
-            ? new URL(value)
-            : new URL(`https://${value}`);
-        return url.host;
-    }
-    catch (err) {
-        log.warn('Could not parse host', { value, err });
-        return undefined;
-    }
-}
-/**
- * Domain-binding check (VCALM §3.4.3 advisement): a DID-Auth `domain` MUST match
- * the channel the request arrived on, otherwise a dishonest verifier could relay
- * the challenge from another origin and replay the response.
- *
- * @param options {object}
- * @param options.domain {string} - The `domain` from the request.
- * @param [options.origin] {string} - The channel origin (for CHAPI,
- *   `event.credentialRequestOrigin`).
- * @returns {boolean}
- */
-export function domainMatchesOrigin({ domain, origin }) {
-    if (!origin) {
-        return false;
-    }
-    const originHost = hostOf(origin);
-    const domainHost = hostOf(domain);
-    return !!originHost && originHost === domainHost;
-}
-/**
- * Processes a Verifiable Presentation Request and composes the wallet's
- * response. Assumes the user has already consented and (for VC sharing) picked
- * which credentials to send.
- *
- * @param options {object}
- * @param options.request {IVPRDetails} - The VPR body.
- * @param options.presentationSigner {PresentationSigner} - Authentication signer
- *   and holder DID.
- * @param [options.selectedVCs] {IVerifiableCredential[]} - VCs the user chose to
- *   share (empty for a DID-Auth-only or zcap-only response).
- * @param [options.credentialRequestOrigin] {string} - Channel origin, used for
- *   the domain-binding check and required by the App Connect branch.
- * @param [options.processors] {RequestProcessors} - App-side capability /
- *   App Connect processors.
- * @param [options.cryptosuite] {string} - Cryptosuite override; when absent it
- *   is negotiated from the request's `acceptedCryptosuites`.
- * @returns {Promise<WalletResponse>} The response VP (and any granted zcaps), or
- *   `{}` when there is nothing to send.
- */
-export async function processRequest({ request, presentationSigner, selectedVCs = [], credentialRequestOrigin, processors, cryptosuite }) {
-    const { didAuth, zcapRequests } = classifyRequest(request);
-    const queries = queriesOf(request);
-    const { challenge, domain } = request;
-    // Honor any cryptosuite the verifier asks for (VCALM `acceptedCryptosuites`),
-    // unless the caller pinned one.
-    const negotiatedCryptosuite = cryptosuite ?? negotiateCryptosuite(queries);
-    // Security: never sign an authentication proof bound to a domain the request
-    // did not actually arrive from. Enforced whenever a `domain` is present,
-    // including a zcap-only request whose (unsigned) VP still names an origin.
-    if (domain &&
-        !domainMatchesOrigin({ domain, origin: credentialRequestOrigin })) {
-        throw new Error(`DID Auth domain "${domain}" does not match request origin ` +
-            `"${credentialRequestOrigin}".`);
-    }
-    // An App Connect request takes its own single-round branch, handled by the
-    // injected processor. The requesting origin is what the app key is bound to
-    // (and what the query's `appUrl` is validated against), so it is required;
-    // the query itself is validated here (`appConnectRequestOf` throws on a
-    // malformed `app` block), so the processor only ever sees a well-formed
-    // request whose `appUrl` is already in serialized form.
-    const appConnectRequested = queries.some(isAppConnectQuery);
-    if (appConnectRequested) {
-        if (!processors?.processAppConnect) {
-            throw new Error('An App Connect request was received but no processAppConnect ' +
-                'processor was provided.');
-        }
-        if (!credentialRequestOrigin) {
-            throw new Error('An App Connect request requires a requesting origin.');
-        }
-        const appConnect = appConnectRequestOf({
-            queries,
-            origin: credentialRequestOrigin
-        });
-        if (!appConnect) {
-            throw new Error('An AppConnectQuery could not be classified.');
-        }
-        return processors.processAppConnect({
-            request,
-            appConnect,
-            origin: credentialRequestOrigin,
-            challenge,
-            domain,
-            didAuthRequested: didAuth,
-            cryptosuite: negotiatedCryptosuite
-        });
-    }
-    // Delegate the approved capabilities first, then embed them in the VP.
-    const zcaps = zcapRequests.length > 0 && processors?.processZcaps
-        ? await processors.processZcaps({ zcapRequests })
-        : [];
-    if (!didAuth && selectedVCs.length === 0 && zcaps.length === 0) {
-        // Nothing to send: no DID Auth, no VCs, and no satisfiable grants.
-        return {};
-    }
-    const verifiablePresentation = await composeVp({
-        presentationSigner,
-        selectedVcs: selectedVCs,
-        challenge,
-        domain,
-        didAuthRequested: didAuth,
-        cryptosuite: negotiatedCryptosuite,
-        zcaps
-    });
-    // Return the delegated capabilities alongside the VP so the caller can log
-    // exactly what was granted from these objects, rather than reading them back
-    // off the composed VP.
-    return { verifiablePresentation, zcaps };
-}
-//# sourceMappingURL=processRequest.js.map

package/dist/request/processRequest.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"processRequest.js","sourceRoot":"","sources":["../../src/request/processRequest.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAE,GAAG,EAAE,MAAM,WAAW,CAAA;AAC/B,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC/E,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAA;AAC7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AAUxD;;;GAGG;AACH,SAAS,MAAM,CAAC,KAAa;IAC3B,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC;YAC/B,CAAC,CAAC,IAAI,GAAG,CAAC,KAAK,CAAC;YAChB,CAAC,CAAC,IAAI,GAAG,CAAC,WAAW,KAAK,EAAE,CAAC,CAAA;QAC/B,OAAO,GAAG,CAAC,IAAI,CAAA;IACjB,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,GAAG,CAAC,IAAI,CAAC,sBAAsB,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAA;QAChD,OAAO,SAAS,CAAA;IAClB,CAAC;AACH,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,mBAAmB,CAAC,EAClC,MAAM,EACN,MAAM,EAIP;IACC,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,OAAO,KAAK,CAAA;IACd,CAAC;IACD,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,CAAA;IACjC,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,CAAA;IACjC,OAAO,CAAC,CAAC,UAAU,IAAI,UAAU,KAAK,UAAU,CAAA;AAClD,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,EACnC,OAAO,EACP,kBAAkB,EAClB,WAAW,GAAG,EAAE,EAChB,uBAAuB,EACvB,UAAU,EACV,WAAW,EAQZ;IACC,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,GAAG,eAAe,CAAC,OAAO,CAAC,CAAA;IAC1D,MAAM,OAAO,GAAG,SAAS,CAAC,OAAO,CAAC,CAAA;IAClC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,OAAO,CAAA;IACrC,8EAA8E;IAC9E,gCAAgC;IAChC,MAAM,qBAAqB,GAAG,WAAW,IAAI,oBAAoB,CAAC,OAAO,CAAC,CAAA;IAE1E,6EAA6E;IAC7E,yEAAyE;IACzE,2EAA2E;IAC3E,IACE,MAAM;QACN,CAAC,mBAAmB,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,uBAAuB,EAAE,CAAC,EACjE,CAAC;QACD,MAAM,IAAI,KAAK,CACb,oBAAoB,MAAM,kCAAkC;YAC1D,IAAI,uBAAuB,IAAI,CAClC,CAAA;IACH,CAAC;IAED,2EAA2E;IAC3E,4EAA4E;IAC5E,2EAA2E;IAC3E,wEAAwE;IACxE,wEAAwE;IACxE,wDAAwD;IACxD,MAAM,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAA;IAC3D,IAAI,mBAAmB,EAAE,CAAC;QACxB,IAAI,CAAC,UAAU,EAAE,iBAAiB,EAAE,CAAC;YACnC,MAAM,IAAI,KAAK,CACb,+DAA+D;gBAC7D,yBAAyB,CAC5B,CAAA;QACH,CAAC;QACD,IAAI,CAAC,uBAAuB,EAAE,CAAC;YAC7B,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAA;QACzE,CAAC;QACD,MAAM,UAAU,GAAG,mBAAmB,CAAC;YACrC,OAAO;YACP,MAAM,EAAE,uBAAuB;SAChC,CAAC,CAAA;QACF,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAA;QAChE,CAAC;QACD,OAAO,UAAU,CAAC,iBAAiB,CAAC;YAClC,OAAO;YACP,UAAU;YACV,MAAM,EAAE,uBAAuB;YAC/B,SAAS;YACT,MAAM;YACN,gBAAgB,EAAE,OAAO;YACzB,WAAW,EAAE,qBAAqB;SACnC,CAAC,CAAA;IACJ,CAAC;IAED,uEAAuE;IACvE,MAAM,KAAK,GACT,YAAY,CAAC,MAAM,GAAG,CAAC,IAAI,UAAU,EAAE,YAAY;QACjD,CAAC,CAAC,MAAM,UAAU,CAAC,YAAY,CAAC,EAAE,YAAY,EAAE,CAAC;QACjD,CAAC,CAAC,EAAE,CAAA;IAER,IAAI,CAAC,OAAO,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC/D,mEAAmE;QACnE,OAAO,EAAE,CAAA;IACX,CAAC;IAED,MAAM,sBAAsB,GAAG,MAAM,SAAS,CAAC;QAC7C,kBAAkB;QAClB,WAAW,EAAE,WAAW;QACxB,SAAS;QACT,MAAM;QACN,gBAAgB,EAAE,OAAO;QACzB,WAAW,EAAE,qBAAqB;QAClC,KAAK;KACN,CAAC,CAAA;IACF,2EAA2E;IAC3E,6EAA6E;IAC7E,uBAAuB;IACvB,OAAO,EAAE,sBAAsB,EAAE,KAAK,EAAE,CAAA;AAC1C,CAAC"}

package/dist/request/queryPredicates.d.ts

@@ -1,98 +0,0 @@
-/*!
- * Copyright (c) 2026 Interop Alliance. All rights reserved.
- */
-/**
- * Import-free helpers shared by the request classifiers: which VPR query
- * type a query object carries, and the parse-and-no-fragment core every URL
- * validated straight off a request body layers its own rule on top of. Kept
- * in one dependency-light leaf file so `onboarding.ts` can classify a
- * `WalletOnboardingQuery` without pulling `classify.ts`'s heavier graph.
- */
-import type { IVPRQuery, IZcapQuery } from './types.js';
-/**
- * Whether a query is a standalone capability query, under either type string:
- * `AuthorizationCapabilityQuery` (the canonical VCALM spelling) or the legacy
- * `ZcapQuery`.
- *
- * The one reader of that alias pair. Both exclusivity checks and both
- * capability extractors ask through here, so retiring or extending the pair
- * is one edit rather than four.
- *
- * @param query {IVPRQuery}
- * @returns {boolean}
- */
-export declare function isZcapQuery(query: IVPRQuery): query is IZcapQuery;
-/**
- * Whether a query is an `AppConnectQuery`. `AppConnectQuery` extends the spec
- * query union rather than being part of it, so it is matched by its `type`
- * string and upcast rather than narrowed via a type predicate -- callers
- * filtering on this still cast the result to `IAppConnectQuery[]`.
- *
- * @param query {IVPRQuery}
- * @returns {boolean}
- */
-export declare function isAppConnectQuery(query: IVPRQuery): boolean;
-/**
- * Whether a query is a `WalletOnboardingQuery`. Matched the same way as
- * {@link isAppConnectQuery}.
- *
- * @param query {IVPRQuery}
- * @returns {boolean}
- */
-export declare function isWalletOnboardingQuery(query: IVPRQuery): boolean;
-/**
- * The singleton query of a set, under the one-mental-model-per-exchange rule:
- * a query type that stands alone in its request. Returns `null` when no query
- * of the type is present, the one query when exactly one is, and throws when
- * more than one appears or when a query of any mutually exclusive type sits
- * beside it. `AppConnectQuery` and `WalletOnboardingQuery` are the two such
- * types today, each excluding `QueryByExample`, standalone capability
- * queries, and the other; a third is one more call of this with its own
- * predicate and exclusion list.
- *
- * @param options {object}
- * @param options.queries {IVPRQuery[]}   the request's query set
- * @param options.isSingleton {(query: IVPRQuery) => boolean}   matches the
- *   singleton type
- * @param options.isExcluded {(query: IVPRQuery) => boolean}   matches the
- *   types that may not accompany it
- * @param options.typeName {string}   the singleton's type string, for the
- *   duplicate refusal
- * @param options.mixedMessage {string}   thrown when an excluded type is
- *   present
- * @returns {IVPRQuery | null}
- */
-export declare function singletonQueryOf({ queries, isSingleton, isExcluded, typeName, mixedMessage }: {
-    queries: IVPRQuery[];
-    isSingleton: (query: IVPRQuery) => boolean;
-    isExcluded: (query: IVPRQuery) => boolean;
-    typeName: string;
-    mixedMessage: string;
-}): IVPRQuery | null;
-/**
- * Parses a wire value as an absolute URL with no fragment: the shared core
- * every request field that copies a URL verbatim from an untrusted body
- * layers its own rule on top of (an App Connect `appUrl`'s same-origin check,
- * a wallet-onboarding `host`'s http(s)-only check). Throws a caller-supplied
- * message on a parse failure (with the parse error as `cause`) or on a
- * fragment, so each site keeps its own wording while the parse-and-no-
- * fragment logic is written once.
- *
- * The fragment check reads the serialized URL rather than `url.hash`: a bare
- * trailing `#` sets an empty (non-null) fragment that `hash` reports as `''`,
- * and a percent-encoded `%23` never appears as `#` in the serialization.
- *
- * @param options {object}
- * @param options.value {string}   the raw wire value to parse
- * @param options.notAbsoluteMessage {string}   thrown, with the parse error
- *   as `cause`, when `value` does not parse as an absolute URL
- * @param options.fragmentMessage {string}   thrown when the parsed URL
- *   carries a fragment
- * @returns {URL}   the parsed URL
- */
-export declare function parsedAbsoluteUrl({ value, notAbsoluteMessage, fragmentMessage }: {
-    value: string;
-    notAbsoluteMessage: string;
-    fragmentMessage: string;
-}): URL;
-//# sourceMappingURL=queryPredicates.d.ts.map

package/dist/request/queryPredicates.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"queryPredicates.d.ts","sourceRoot":"","sources":["../../src/request/queryPredicates.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAEvD;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,GAAG,KAAK,IAAI,UAAU,CAIjE;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAE3D;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAEjE;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAAC,EAC/B,OAAO,EACP,WAAW,EACX,UAAU,EACV,QAAQ,EACR,YAAY,EACb,EAAE;IACD,OAAO,EAAE,SAAS,EAAE,CAAA;IACpB,WAAW,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,OAAO,CAAA;IAC1C,UAAU,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,OAAO,CAAA;IACzC,QAAQ,EAAE,MAAM,CAAA;IAChB,YAAY,EAAE,MAAM,CAAA;CACrB,GAAG,SAAS,GAAG,IAAI,CAYnB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,KAAK,EACL,kBAAkB,EAClB,eAAe,EAChB,EAAE;IACD,KAAK,EAAE,MAAM,CAAA;IACb,kBAAkB,EAAE,MAAM,CAAA;IAC1B,eAAe,EAAE,MAAM,CAAA;CACxB,GAAG,GAAG,CAWN"}

package/dist/request/queryPredicates.js

@@ -1,107 +0,0 @@
-/**
- * Whether a query is a standalone capability query, under either type string:
- * `AuthorizationCapabilityQuery` (the canonical VCALM spelling) or the legacy
- * `ZcapQuery`.
- *
- * The one reader of that alias pair. Both exclusivity checks and both
- * capability extractors ask through here, so retiring or extending the pair
- * is one edit rather than four.
- *
- * @param query {IVPRQuery}
- * @returns {boolean}
- */
-export function isZcapQuery(query) {
-    return (query.type === 'AuthorizationCapabilityQuery' || query.type === 'ZcapQuery');
-}
-/**
- * Whether a query is an `AppConnectQuery`. `AppConnectQuery` extends the spec
- * query union rather than being part of it, so it is matched by its `type`
- * string and upcast rather than narrowed via a type predicate -- callers
- * filtering on this still cast the result to `IAppConnectQuery[]`.
- *
- * @param query {IVPRQuery}
- * @returns {boolean}
- */
-export function isAppConnectQuery(query) {
-    return query.type === 'AppConnectQuery';
-}
-/**
- * Whether a query is a `WalletOnboardingQuery`. Matched the same way as
- * {@link isAppConnectQuery}.
- *
- * @param query {IVPRQuery}
- * @returns {boolean}
- */
-export function isWalletOnboardingQuery(query) {
-    return query.type === 'WalletOnboardingQuery';
-}
-/**
- * The singleton query of a set, under the one-mental-model-per-exchange rule:
- * a query type that stands alone in its request. Returns `null` when no query
- * of the type is present, the one query when exactly one is, and throws when
- * more than one appears or when a query of any mutually exclusive type sits
- * beside it. `AppConnectQuery` and `WalletOnboardingQuery` are the two such
- * types today, each excluding `QueryByExample`, standalone capability
- * queries, and the other; a third is one more call of this with its own
- * predicate and exclusion list.
- *
- * @param options {object}
- * @param options.queries {IVPRQuery[]}   the request's query set
- * @param options.isSingleton {(query: IVPRQuery) => boolean}   matches the
- *   singleton type
- * @param options.isExcluded {(query: IVPRQuery) => boolean}   matches the
- *   types that may not accompany it
- * @param options.typeName {string}   the singleton's type string, for the
- *   duplicate refusal
- * @param options.mixedMessage {string}   thrown when an excluded type is
- *   present
- * @returns {IVPRQuery | null}
- */
-export function singletonQueryOf({ queries, isSingleton, isExcluded, typeName, mixedMessage }) {
-    const matches = queries.filter(isSingleton);
-    if (matches.length === 0) {
-        return null;
-    }
-    if (matches.length > 1) {
-        throw new Error(`More than one ${typeName} found, exiting.`);
-    }
-    if (queries.some(isExcluded)) {
-        throw new Error(mixedMessage);
-    }
-    return matches[0];
-}
-/**
- * Parses a wire value as an absolute URL with no fragment: the shared core
- * every request field that copies a URL verbatim from an untrusted body
- * layers its own rule on top of (an App Connect `appUrl`'s same-origin check,
- * a wallet-onboarding `host`'s http(s)-only check). Throws a caller-supplied
- * message on a parse failure (with the parse error as `cause`) or on a
- * fragment, so each site keeps its own wording while the parse-and-no-
- * fragment logic is written once.
- *
- * The fragment check reads the serialized URL rather than `url.hash`: a bare
- * trailing `#` sets an empty (non-null) fragment that `hash` reports as `''`,
- * and a percent-encoded `%23` never appears as `#` in the serialization.
- *
- * @param options {object}
- * @param options.value {string}   the raw wire value to parse
- * @param options.notAbsoluteMessage {string}   thrown, with the parse error
- *   as `cause`, when `value` does not parse as an absolute URL
- * @param options.fragmentMessage {string}   thrown when the parsed URL
- *   carries a fragment
- * @returns {URL}   the parsed URL
- */
-export function parsedAbsoluteUrl({ value, notAbsoluteMessage, fragmentMessage }) {
-    let url;
-    try {
-        url = new URL(value);
-    }
-    catch (err) {
-        throw new Error(notAbsoluteMessage, { cause: err });
-    }
-    if (url.href.includes('#')) {
-        throw new Error(fragmentMessage);
-    }
-    return url;
-}
-//# sourceMappingURL=queryPredicates.js.map

package/dist/request/queryPredicates.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"queryPredicates.js","sourceRoot":"","sources":["../../src/request/queryPredicates.ts"],"names":[],"mappings":"AAYA;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,WAAW,CAAC,KAAgB;IAC1C,OAAO,CACL,KAAK,CAAC,IAAI,KAAK,8BAA8B,IAAI,KAAK,CAAC,IAAI,KAAK,WAAW,CAC5E,CAAA;AACH,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAAgB;IAChD,OAAQ,KAAK,CAAC,IAAe,KAAK,iBAAiB,CAAA;AACrD,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,uBAAuB,CAAC,KAAgB;IACtD,OAAQ,KAAK,CAAC,IAAe,KAAK,uBAAuB,CAAA;AAC3D,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,gBAAgB,CAAC,EAC/B,OAAO,EACP,WAAW,EACX,UAAU,EACV,QAAQ,EACR,YAAY,EAOb;IACC,MAAM,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,CAAA;IAC3C,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO,IAAI,CAAA;IACb,CAAC;IACD,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACvB,MAAM,IAAI,KAAK,CAAC,iBAAiB,QAAQ,kBAAkB,CAAC,CAAA;IAC9D,CAAC;IACD,IAAI,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,KAAK,CAAC,YAAY,CAAC,CAAA;IAC/B,CAAC;IACD,OAAO,OAAO,CAAC,CAAC,CAAE,CAAA;AACpB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,iBAAiB,CAAC,EAChC,KAAK,EACL,kBAAkB,EAClB,eAAe,EAKhB;IACC,IAAI,GAAQ,CAAA;IACZ,IAAI,CAAC;QACH,GAAG,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,CAAA;IACtB,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,IAAI,KAAK,CAAC,kBAAkB,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAA;IACrD,CAAC;IACD,IAAI,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QAC3B,MAAM,IAAI,KAAK,CAAC,eAAe,CAAC,CAAA;IAClC,CAAC;IACD,OAAO,GAAG,CAAA;AACZ,CAAC"}

package/dist/request/types.d.ts

@@ -1,257 +0,0 @@
-/*!
- * Copyright (c) 2026 Interop Alliance. All rights reserved.
- */
-/**
- * Shared types for the `@interop/wallet-core/request` subpath. The Verifiable
- * Presentation Request (VPR) vocabulary itself is owned by
- * `@interop/data-integrity-core` (its `VPR` module) and re-exported here so a
- * request consumer imports one package; this file adds only the request-local
- * types the app sources carried alongside that vocabulary: the CHAPI event
- * shapes, the VC-API exchange reply shape, the classified-request profile, and
- * the injection-seam types (`PresentationSigner`, `FetchLike`,
- * `RequestProcessors`) that keep this layer free of any single app's session /
- * network / consent machinery.
- *
- * Ported from DCW's `app/lib/walletRequestApi.ts` and Freewallet's
- * `src/lib/walletRequest/{types,classify}.ts`.
- *
- * The VPR vocabulary (and the loose-shape guards in `classify` / `matching`) is
- * imported from the `@interop/data-integrity-core/vpr` and `/guards` subpaths
- * rather than the package root: the vocabulary was added to data-integrity-core
- * without a version bump, so the package root can dedup onto an older cached
- * build that predates it, whereas the subpath entry points resolve only against
- * the current build that defines them.
- */
-import type { ISigner } from '@interop/data-integrity-core';
-import type { IVerifiableCredential, IVerifiablePresentation, IZcap } from '@interop/data-integrity-core';
-import type { ICapabilityQueryDetail, IQueryByExample, IVPRDetails as ISpecVPRDetails, WalletResponse } from '@interop/data-integrity-core/vpr';
-export type { IVPRequest, IVPOffer, IIssueRequest, IExchangeInvitation, IOid4VCIOffer, IVPRInteract, IVPRQuery, IQueryByExample, ICredentialQuery, IAcceptedCryptosuites, IDIDAuthenticationQuery, IZcapQuery, ICapabilityQueryDetail, IInvocationTarget, IAllowedAction, WalletApiMessage, WalletResponse, IVpRequest, IVpOffer, IVprDetails, IVprQuery, IDidAuthenticationQuery } from '@interop/data-integrity-core/vpr';
-export type { IVerifiableCredential, IVerifiablePresentation, IZcap } from '@interop/data-integrity-core';
-/**
- * The protocol handles a verifier offers alongside a CHAPI request. Only
- * `vcapi` (and the newer `interact` meta-protocol) are acted on; `OID4VP` /
- * `OID4VCI` are recognized but unused.
- */
-export interface CHAPIProtocols {
-    vcapi?: string;
-    interact?: string;
-    OID4VP?: string;
-    OID4VCI?: string;
-}
-/**
- * The body of a Verifiable Presentation Request, widened from the spec
- * vocabulary with the wallet-layer `agent` member: the requester's
- * self-declared display name on a standalone capability request (an agent
- * asking for grants through an interaction URL, where no attested origin
- * names it). One member at the VPR root rather than one per query, since a
- * single agent sends the whole request. Display only and attacker-controlled,
- * like App Connect's `app.name`; `requestingAgentOf` validates it.
- */
-export type IVPRDetails = ISpecVPRDetails & {
-    agent?: {
-        name: string;
-    };
-};
-/**
- * Raw CHAPI credential-get event. The `VerifiablePresentation` object CHAPI
- * hands us *is* the VPR body (`query` / `challenge` / `domain`); classification
- * rewraps it as an `IVPRequest`. When the verifier names a `protocols` handle
- * it sends that body empty instead, and the VPR must be fetched from the
- * protocol exchange (see `exchangeClient.ts`).
- */
-export interface CHAPIGetEvent {
-    credentialRequestOrigin: string;
-    credentialRequestOptions?: {
-        web?: {
-            VerifiablePresentation?: IVPRDetails;
-            protocols?: CHAPIProtocols;
-        };
-    };
-    respondWith(promise: Promise<{
-        dataType: string;
-        data: unknown;
-    } | null>): void;
-}
-/**
- * Raw CHAPI credential-store event. `credential.data` is the offered payload,
- * and `credential.dataType` names its shape: issuers may offer either a
- * `VerifiablePresentation` wrapping the credential(s), or a bare
- * `VerifiableCredential` (what vcplayground.org sends). An issuer that names a
- * `protocols` handle in `credential.options` sends `data` empty instead, and
- * the offered credentials must be fetched from the protocol exchange (see
- * `exchangeClient.ts`).
- */
-export interface CHAPIStoreEvent {
-    credentialRequestOrigin?: string;
-    credential: {
-        dataType?: string;
-        data: IVerifiablePresentation | IVerifiableCredential;
-        options?: {
-            protocols?: CHAPIProtocols;
-            recommendedHandlerOrigins?: string[];
-        };
-    };
-    respondWith(promise: Promise<{
-        dataType: string;
-        data: unknown;
-    } | null>): void;
-}
-/**
- * The exchange's reply to either wallet call. A multi-step exchange answers a
- * submitted presentation with another `verifiablePresentationRequest`; a
- * finished one answers with nothing, or with credentials it issued, or with a
- * `redirectUrl` for the user to land on.
- */
-export interface VCAPIExchangeResponse {
-    verifiablePresentationRequest?: IVPRDetails;
-    verifiablePresentation?: IVerifiablePresentation;
-    redirectUrl?: string;
-}
-/**
- * A VP Request classified on independent axes: whether DID Authentication is
- * requested, what credentials are asked for (`vcQueries`), and what capability
- * delegations are asked for (`zcapRequests`). Any combination is valid,
- * including zcap-only. An app that layers additional query kinds on top (e.g.
- * Freewallet's App Connect) extends this shape with its own field.
- */
-export interface WalletRequestProfile {
-    didAuth: boolean;
-    vcQueries: IQueryByExample[];
-    zcapRequests: ICapabilityQueryDetail[];
-    /**
-     * The requester's self-declared display name (the VPR's `agent.name`,
-     * validated and trimmed), present only when the request carried one.
-     */
-    agent?: {
-        name: string;
-    };
-}
-/**
- * A capability request entry as an `AppConnectQuery` carries it: the standard
- * capability-query detail minus the members the wallet itself fills or refuses
- * (`controller` is filled with the app-key subject DID at delegation time;
- * `reason` is display-bearing and not accepted from an App Connect request).
- */
-export type IAppConnectCapabilityQuery = Omit<ICapabilityQueryDetail, 'controller' | 'reason'>;
-/**
- * The app identity an App Connect request presents: a display `name` for the
- * consent surface (attacker-controlled free text, never evidence of identity)
- * and the application's canonical `appUrl`, which scopes the app-key identity
- * within the requesting origin. Validated by `appConnectRequestOf`: the
- * `appUrl` must parse as an absolute URL, carry no fragment, and be
- * same-origin with the attested requesting origin.
- */
-export type IAppConnectApp = {
-    name: string;
-    appUrl: string;
-};
-/**
- * "Connect this app to the user's wallet and Space" -- a single-round request
- * that combines app-key recovery-or-minting with capability delegation. The
- * wallet finds (or self-issues) the app-key credential for the requesting
- * origin and `appUrl`, delegates the requested capabilities to its subject
- * DID, and returns credential + grants in one signed presentation.
- */
-export type IAppConnectQuery = {
-    type: 'AppConnectQuery';
-    app: IAppConnectApp;
-    capabilityQuery?: IAppConnectCapabilityQuery | IAppConnectCapabilityQuery[];
-};
-/**
- * An App Connect request as classified and validated by
- * `appConnectRequestOf`: the app identity (its `appUrl` already in serialized
- * form) plus its capability queries normalized to an array.
- */
-export type IAppConnectRequest = {
-    app: IAppConnectApp;
-    capabilityQueries: IAppConnectCapabilityQuery[];
-};
-/**
- * "Connect a new wallet client to this account" -- the query an already-
- * enrolled wallet client (the inviter) puts in the VPR of an ephemeral
- * exchange for a fresh wallet (the enrollee) to answer. It carries everything
- * the enrollee needs to find the account, so no secret is required of the
- * person joining:
- *
- * - `did` -- the account's stable did:webvh id, whose log is world-readable
- *   and is where the enrollee verifies its own approval.
- * - `spaceId` and `host` -- where the account lives (the WAS server base URL
- *   and the Space on it); together with `did` these are exactly the account
- *   pointer a keyring record carries (keyring's `AccountPointer` shape), so
- *   the inviter passes its session pointer straight in.
- * - `controller` -- the account controller did:key, what the enrollee's own
- *   profile link stores once it has joined.
- *
- * Discovery only: the query names the account but authorizes nothing. Every
- * act on the Space still requires zcaps a holder of the QR or capability URL
- * does not have, and nothing is authorized before the ceremony's
- * confirmation-code comparison. The enrollee answers off-band of the VPR
- * vocabulary, with the onboarding response envelope
- * (`@interop/wallet-core/enrollment`), whose payload is an ordinary connect
- * code.
- */
-export type IWalletOnboardingQuery = {
-    type: 'WalletOnboardingQuery';
-    host: string;
-    did: string;
-    spaceId: string;
-    controller: string;
-};
-/**
- * A wallet-onboarding request as classified and validated by
- * `walletOnboardingRequestOf`: the account's did:webvh `did`, its `spaceId`,
- * the `host` already in serialized URL form (the three together being the
- * account pointer), and the account controller did:key.
- */
-export type IWalletOnboardingRequest = {
-    host: string;
-    did: string;
-    spaceId: string;
-    controller: string;
-};
-/**
- * The authentication signer plus the DID to name as the VP `holder`. Each app
- * resolves this from its own key material (DCW from the selected profile's
- * `authentication` signer + DID; Freewallet from the KMS did:web key or the
- * passphrase-derived root key) before handing it to the shared compose path.
- */
-export interface PresentationSigner {
-    signer: ISigner;
-    holder: string;
-}
-/**
- * Injected network transport. Defaults to `globalThis.fetch`; DCW passes its
- * `fetchWithTimeout`, Freewallet its CORS-proxy fetch.
- */
-export type FetchLike = (url: string, init?: RequestInit) => Promise<Response>;
-/**
- * App-side processors injected into {@link processRequest}. Both are optional:
- * a wallet that grants no capabilities omits `processZcaps`, and a wallet
- * without an App Connect flow omits `processAppConnect` (the branch is then
- * inert).
- */
-export interface RequestProcessors {
-    /**
-     * Delegates the approved capabilities and returns the minted zcaps.
-     * Freewallet supplies `processZcaps(session)`; DCW supplies a no-op / `[]`.
-     */
-    processZcaps?: (args: {
-        zcapRequests: ICapabilityQueryDetail[];
-    }) => Promise<IZcap[]>;
-    /**
-     * Handles the App Connect single-round branch. Invoked when the request
-     * carries an `AppConnectQuery`; `appConnect` arrives already validated by
-     * `appConnectRequestOf` (its `app.appUrl` in serialized form), so the
-     * processor never sees a malformed app block.
-     */
-    processAppConnect?: (args: {
-        request: IVPRDetails;
-        appConnect: IAppConnectRequest;
-        origin: string;
-        challenge?: string;
-        domain?: string;
-        didAuthRequested: boolean;
-        cryptosuite?: string;
-    }) => Promise<WalletResponse>;
-}
-//# sourceMappingURL=types.d.ts.map