@blamejs/core 0.12.40 → 0.12.42

package/CHANGELOG.md

@@ -8,6 +8,10 @@ upgrading across more than a few patches at a time.
 
 ## v0.12.x
 
+- v0.12.42 (2026-05-24) — **`b.vc.present` / `b.vc.verifyPresentation` — W3C Verifiable Presentations.** Completes b.vc with the holder side: a Verifiable Presentation is a holder-signed envelope wrapping one or more credentials, proving the presenter controls the key the credentials were issued to. b.vc.present builds and signs a VerifiablePresentation (each credential enveloped per VC-JOSE-COSE) as a compact JWS (vp+jwt) or COSE_Sign1 (application/vp+cose), matching b.vc.issue's algorithms; an optional nonce / audience is embedded in the signed presentation for holder-binding and replay protection. b.vc.verifyPresentation verifies the holder signature (auto-detected jose/cose, mandatory algorithm allowlist, JOSE none refused), the VCDM structure, and the embedded nonce / audience / expectedHolder when given, and — with verifyCredentials: true — verifies each enveloped credential through b.vc.verify and returns them. The holder is typically a DID, resolved to a key via b.did. Composes b.cose; no new runtime dependency. **Added:** *`b.vc.present(opts)` / `b.vc.verifyPresentation(secured, opts)`* — `present` wraps `opts.credentials` (secured VCs — compact-JWS strings or COSE_Sign1 bytes, each enveloped as an `EnvelopedVerifiableCredential` data: URI) in a `VerifiablePresentation` signed by the holder, with optional `nonce` / `audience` embedded for binding. `verifyPresentation` verifies the holder signature against the mandatory `opts.algorithms` allowlist (JOSE `none` always refused), re-checks the VCDM structure, enforces `expectedHolder` / `nonce` / `audience` when supplied, and with `verifyCredentials: true` verifies each enveloped credential through `b.vc.verify` (using `opts.credentialOpts`), returning `{ presentation, holder, credentials, securing, alg }`. The enveloped-credential count is bounded. A `vp+jwt` presentation is refused by `b.vc.verify` and a `vc+jwt` credential is refused by `verifyPresentation` — the media-type binding keeps the two surfaces distinct.
+
+- v0.12.41 (2026-05-24) — **`b.did` — W3C DID resolution (did:key + did:web) feeding the credential verifiers.** Resolve W3C Decentralized Identifiers (DID Core 1.0) to verification keys — the link that lets a credential's issuer be named by a DID rather than a raw key. Resolve the issuer DID of a b.vc / b.mdoc / b.scitt credential to a node:crypto KeyObject and hand it to the verifier. did:key encodes the public key in the identifier (multicodec + base58btc), so resolution is deterministic and offline — Ed25519, P-256, P-384, and secp256k1 round-trip; did:web places the DID document at an HTTPS URL derived from the identifier, with the network fetch left to the operator (the framework parses the operator-fetched document and extracts its verification methods, as publicKeyMultibase or publicKeyJwk). b.did.keyToDid encodes a KeyObject as a did:key (an issuer naming itself), b.did.parse splits the identifier (and returns the did:web URL to fetch), and b.did.resolve returns the document and verification keys. DID Core 1.0 is a W3C Recommendation; the method specs (did:key W3C CCG report, did:web DID method registry — EUDI-mandated) are deployed-stable. Composes node:crypto; no new runtime dependency. **Added:** *`b.did.resolve(did, opts?)` / `b.did.keyToDid(publicKey)` / `b.did.parse(did)`* — `resolve` returns `{ didDocument, verificationMethods: [{ id, controller, type, publicKey }] }` with each `publicKey` a `node:crypto` KeyObject ready for `b.vc.verify` / `b.mdoc.verifyIssuerSigned` / `b.scitt.verifyStatement`. did:key resolves deterministically and offline (base58btc + multicodec → Ed25519 raw key or EC compressed point, rebuilt via SPKI); did:web requires the operator to pass the fetched DID document as `opts.document` (the URL to GET is on `b.did.parse(did).url`) and the document `id` must match the requested DID. A publicKeyJwk in a DID document is imported only after its `kty`/`crv` is allowlisted (Ed25519 / P-256 / P-384 / secp256k1) — an unexpected key type from an untrusted document is refused, not blindly imported. `keyToDid` encodes an Ed25519 / P-256 / P-384 / secp256k1 KeyObject as a did:key; `parse` derives the did:web HTTPS URL (`host[:port][:path]` → `https://host/path/did.json`, or `/.well-known/did.json`). Unknown methods, malformed base58, unsupported multicodec codes, and unsupported key types are each refused.
+
 - v0.12.40 (2026-05-24) — **`b.mdoc` — ISO 18013-5 mdoc / mDL issuer-data verification.** Verify the issuer-signed data of an ISO/IEC 18013-5 mdoc — the credential format behind mobile driving licences (mDL) and the ISO track of the EU Digital Identity Wallet. This is the relying-party side: confirm that the data elements a holder presents were signed by the issuer and have not been altered. An mdoc's IssuerSigned carries the disclosed data elements and an issuerAuth that is a COSE_Sign1 (b.cose) over a Mobile Security Object (MSO) holding a per-element digest. b.mdoc.verifyIssuerSigned verifies the COSE signature with the issuer certificate from the COSE x5chain header, parses the MSO, enforces its validityInfo window, and recomputes each disclosed element's digest (the full Tag-24 IssuerSignedItemBytes) to match it against the MSO constant-time — the integrity check that makes selective disclosure trustworthy. An absent or mismatched digest is refused. Signing algorithms follow b.cose verification (the classical ES256/384/512 + EdDSA that real mDL issuers use; the caller names the allowlist); opts.trustAnchorsPem additionally verifies the issuer certificate chain. This completes the credential trio alongside W3C VCDM (b.vc) and IETF SD-JWT VC (b.auth.sdJwtVc). Composes b.cose + b.cbor; no new runtime dependency. **Added:** *`b.mdoc.verifyIssuerSigned(issuerSigned, opts)`* — Takes the CBOR `IssuerSigned` map (the operator extracts it from the device response / QR) and returns `{ docType, version, digestAlgorithm, validityInfo, namespaces, signerCert, alg }`. Verifies the COSE_Sign1 `issuerAuth` against the mandatory `opts.algorithms` allowlist using the issuer certificate from its `x5chain` (label 33) header; parses the Tag-24 Mobile Security Object; enforces the MSO `validityInfo` window against `opts.at` (default now; must be a valid Date; malformed dates fail closed); and recomputes the digest of every disclosed `IssuerSignedItem` (over the full Tag-24 bytes, with the MSO `digestAlgorithm` — SHA-256/384/512) to match the MSO `valueDigests` constant-time — an absent or mismatched digest is refused with `mdoc/digest-mismatch`. `opts.expectedDocType` pins the document type; `opts.trustAnchorsPem` (a PEM string or array) additionally verifies the issuer certificate chain and validity at the asserted time. A malformed `x5chain` certificate is refused with a clean `mdoc/bad-cert`. The mdoc device-authentication half (the SessionTranscript-bound holder-binding proof) is a presentation-protocol concern and is not part of issuer-data verification.
 
 - v0.12.39 (2026-05-24) — **`b.vc` — W3C Verifiable Credentials 2.0 (issue / verify, JOSE + COSE securing).** Issue and verify W3C Verifiable Credentials (VC Data Model 2.0, a W3C Recommendation) secured per Securing Verifiable Credentials using JOSE and COSE (VC-JOSE-COSE, also a W3C Recommendation, May 2025). A verifiable credential is a tamper-evident, signed set of claims an issuer makes about a subject — a diploma, a membership, a license, an age assertion. Two securing mechanisms are supported, both signing the credential itself (no JWT/CWT claims wrapper): JOSE produces a compact JWS with the vc+jwt media type, signed with ES256/384/512 or EdDSA; COSE produces a COSE_Sign1 (application/vc+cose) over b.cose, which also accepts ML-DSA-87 for PQC-forward deployments. b.vc.verify auto-detects the form from the input, requires an algorithm allowlist, always refuses the JOSE none algorithm, re-checks the VCDM 2.0 structural rules, and enforces the validFrom / validUntil window. This is the W3C credential model, distinct from the IETF SD-JWT VC already at b.auth.sdJwtVc. Composes b.cose; no new runtime dependency. **Added:** *`b.vc.issue(credential, opts)` / `b.vc.verify(secured, opts)`* — `issue` validates the credential against the VCDM 2.0 structural rules (the `credentials/v2` context first, a `VerifiableCredential` type, an issuer, a credential subject) and signs it: `securing: "jose"` returns a compact JWS string (`typ` header `vc+jwt`), `securing: "cose"` returns COSE_Sign1 bytes (`typ` header `application/vc+cose`, content type `application/vc`) via `b.cose`. The credential is the exact signed payload — no JWT/CWT claims are injected. `verify` auto-detects the securing form from the input (compact-JWS string vs. COSE_Sign1 bytes), verifies the signature against the mandatory `opts.algorithms` allowlist (the JOSE `none` algorithm is always refused), re-checks the structural rules, enforces the `validFrom` / `validUntil` window against `opts.at` (default now; must be a valid Date), and optionally matches `opts.expectedIssuer` against the credential issuer id. Returns `{ credential, securing, alg, issuer }`.

package/README.md

@@ -131,8 +131,9 @@ The framework bundles the surface a typical Node app reaches for. Every primitiv
 - **Entity Attestation Token** — `b.eat` EAT sign/verify (RFC 9711) over `b.cwt`: device + software attestation claims (ueid / oemid / hwmodel / measurements / submods) with verifier-nonce freshness binding, `dbgstat` debug-status policy, and `eat_profile` pinning
 - **SCITT signed statements** — `b.scitt` sign/verify a signed, attributable claim about an artifact (signed SBOM, build attestation, release approval) over `b.cose`: the issuer + subject bind in the integrity-protected CWT_Claims header (RFC 9597); verification refuses any statement missing the iss/sub binding. The issuer side, on finalized RFCs; the transparency receipt (COSE Receipts draft) opts in on publication
 - **Trusted timestamping** — `b.tsa` RFC 3161 timestamp client: `buildRequest` a TimeStampReq, `parseResponse`, and `verifyToken` against your data — the message imprint, sent nonce, critical/sole `id-kp-timeStamping` EKU, and CMS signature are all checked, with optional certificate-chain verification. Timestamp a release artifact, audit checkpoint, or signed statement against any RFC 3161 TSA. Composes `b.cms` + the in-tree ASN.1 DER codec
-- **Verifiable Credentials** — `b.vc` W3C Verifiable Credentials Data Model 2.0 (VC-JOSE-COSE): `issue` / `verify` a signed credential as a compact JWS (`vc+jwt`, ES256/384/512 + EdDSA) or a COSE_Sign1 (`vc+cose`, + ML-DSA-87) over `b.cose`. VCDM structural + `validFrom`/`validUntil` checks; the JOSE `none` algorithm is always refused. The W3C model, distinct from the IETF SD-JWT VC at `b.auth.sdJwtVc`
+- **Verifiable Credentials** — `b.vc` W3C Verifiable Credentials Data Model 2.0 (VC-JOSE-COSE): `issue` / `verify` a signed credential, and `present` / `verifyPresentation` a holder-signed Verifiable Presentation wrapping credentials (with `nonce`/`audience` holder-binding) — as a compact JWS (`vc+jwt` / `vp+jwt`, ES256/384/512 + EdDSA) or a COSE_Sign1 (`vc+cose` / `vp+cose`, + ML-DSA-87) over `b.cose`. VCDM structural + `validFrom`/`validUntil` checks; the JOSE `none` algorithm is always refused. The W3C model, distinct from the IETF SD-JWT VC at `b.auth.sdJwtVc`
 - **Mobile credentials (mDL)** — `b.mdoc` ISO/IEC 18013-5 issuer-data verification: `verifyIssuerSigned` checks the COSE_Sign1 IssuerAuth (issuer cert from the `x5chain` header), the Mobile Security Object validity window, and every disclosed element's digest against the MSO `valueDigests` (the selective-disclosure integrity check), with optional issuer-chain verification. The ISO credential ecosystem alongside `b.vc` and `b.auth.sdJwtVc`. Composes `b.cose` + `b.cbor`
+- **Decentralized Identifiers** — `b.did` W3C DID resolution (DID Core 1.0): `resolve` a `did:key` (deterministic, offline — Ed25519 / P-256 / P-384 / secp256k1) or `did:web` (operator-fetched document) to `node:crypto` verification keys, so a credential's issuer DID resolves to the key that verifies it (`b.vc` / `b.mdoc` / `b.scitt`). `keyToDid` names a key as a `did:key`; document JWKs are kty/crv-allowlisted before import
 - **Document parsers** — `b.parsers` (XML / TOML / YAML / .env); `b.config` (schema-validated env)
 - **File-type detection** — `b.fileType` magic-byte content classification with deny-on-upload categories (image / document / archive / executable / etc.)
 ### Content-safety gates

package/index.js

@@ -463,6 +463,7 @@ module.exports = {
   tsa:              require("./lib/tsa"),
   vc:               require("./lib/vc"),
   mdoc:             require("./lib/mdoc"),
+  did:              require("./lib/did"),
   queue:            queue,
   logStream:        logStream,
   redact:           redact,

package/lib/did.js

@@ -0,0 +1,367 @@
+"use strict";
+/**
+ * @module b.did
+ * @nav    Crypto
+ * @title  Decentralized Identifiers (DID)
+ *
+ * @intro
+ *   Resolve W3C Decentralized Identifiers (DID Core 1.0, a W3C
+ *   Recommendation) to verification keys — the missing link that lets a
+ *   credential's issuer be named by a DID rather than a raw key. Resolve
+ *   the issuer DID of a <code>b.vc</code> / <code>b.mdoc</code> /
+ *   <code>b.scitt</code> credential to a <code>node:crypto</code>
+ *   KeyObject, then hand that key to the verifier.
+ *
+ *   Two methods are supported. <strong>did:key</strong> encodes a public
+ *   key directly in the identifier (multicodec + base58btc multibase),
+ *   so resolution is deterministic and offline — Ed25519, P-256, P-384,
+ *   and secp256k1 keys round-trip. <strong>did:web</strong> places the
+ *   DID document at an HTTPS URL derived from the identifier; the network
+ *   fetch is the operator's to make (the same operator-supplied-input
+ *   stance as the rest of the framework), and <code>resolve</code> takes
+ *   the fetched document and extracts its verification methods.
+ *
+ *   <code>b.did.keyToDid(publicKey)</code> produces a did:key from a
+ *   KeyObject (an issuer naming itself); <code>b.did.parse(did)</code>
+ *   splits the identifier (and, for did:web, returns the HTTPS URL to
+ *   fetch); <code>b.did.resolve(did, opts)</code> returns the DID
+ *   document and its verification methods as KeyObjects. Verification
+ *   methods expressed as <code>publicKeyMultibase</code> or
+ *   <code>publicKeyJwk</code> are both understood.
+ *
+ *   <strong>Maturity.</strong> DID Core 1.0 is a Recommendation, but the
+ *   method specs are deployed-stable rather than Recommendations:
+ *   did:key is a W3C CCG report and did:web is a registered DID method
+ *   (mandated by the EU Digital Identity Wallet). They are widely
+ *   deployed and interoperable today; pin the dependency deliberately.
+ *
+ * @card
+ *   W3C DID resolution (did:key + did:web) → verification KeyObjects for
+ *   the credential verifiers. did:key is deterministic + offline
+ *   (Ed25519 / P-256 / P-384 / secp256k1); did:web parses an
+ *   operator-fetched DID document. Composes node:crypto; no new dep.
+ */
+
+var nodeCrypto = require("node:crypto");
+var validateOpts = require("./validate-opts");
+var { defineClass } = require("./framework-error");
+
+var DidError = defineClass("DidError", { alwaysPermanent: true });
+
+var B58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+var B58_MAP = (function () {
+  var m = {};
+  for (var i = 0; i < B58_ALPHABET.length; i += 1) m[B58_ALPHABET[i]] = i;
+  return m;
+})();
+var MAX_MULTIBASE_CHARS = 1024;                        // allow:raw-byte-literal — bounded did:key multibase length (DoS cap)
+
+// multicodec public-key codes (unsigned-varint) → curve descriptor.
+// keyLen is the multicodec payload: Ed25519 raw 32; EC compressed point.
+var MULTICODEC = {
+  0xed:   { name: "Ed25519",   kind: "okp" },                                    // ed25519-pub
+  0x1200: { name: "P-256",     kind: "ec", curveOid: "1.2.840.10045.3.1.7" },    // allow:raw-byte-literal allow:raw-time-literal — p256-pub multicodec code + OID dotted-form
+  0x1201: { name: "P-384",     kind: "ec", curveOid: "1.3.132.0.34" },           // allow:raw-byte-literal — p384-pub multicodec code
+  0xe7:   { name: "secp256k1", kind: "ec", curveOid: "1.3.132.0.10" },           // secp256k1-pub
+};
+var NAME_TO_CODE = {};
+Object.keys(MULTICODEC).forEach(function (c) { NAME_TO_CODE[MULTICODEC[c].name] = Number(c); });
+
+// ---- base58btc (bounded) ----
+
+function _b58decode(str) {
+  if (str.length > MAX_MULTIBASE_CHARS) {
+    throw new DidError("did/too-long", "did: multibase value exceeds the " + MAX_MULTIBASE_CHARS + "-char cap");
+  }
+  var bytes = [0];
+  for (var i = 0; i < str.length; i += 1) {
+    var v = B58_MAP[str[i]];
+    if (v === undefined) throw new DidError("did/bad-base58", "did: invalid base58btc character '" + str[i] + "'");
+    var carry = v;
+    for (var j = 0; j < bytes.length; j += 1) {
+      carry += bytes[j] * 58;
+      bytes[j] = carry & 0xff;
+      carry >>= 8;                                     // allow:raw-byte-literal — base-256 carry
+    }
+    while (carry > 0) { bytes.push(carry & 0xff); carry >>= 8; }   // allow:raw-byte-literal — base-256 carry
+  }
+  // Leading '1's are leading zero bytes.
+  for (var k = 0; k < str.length && str[k] === "1"; k += 1) bytes.push(0);
+  return Buffer.from(bytes.reverse());
+}
+
+function _b58encode(buf) {
+  var digits = [0];
+  for (var i = 0; i < buf.length; i += 1) {
+    var carry = buf[i];
+    for (var j = 0; j < digits.length; j += 1) {
+      carry += digits[j] << 8;                         // allow:raw-byte-literal — base-256 shift
+      digits[j] = carry % 58;
+      carry = (carry / 58) | 0;
+    }
+    while (carry > 0) { digits.push(carry % 58); carry = (carry / 58) | 0; }
+  }
+  var out = "";
+  for (var z = 0; z < buf.length && buf[z] === 0; z += 1) out += "1";
+  for (var d = digits.length - 1; d >= 0; d -= 1) out += B58_ALPHABET[digits[d]];
+  return out;
+}
+
+// Read an unsigned LEB128 varint (multicodec code). Bounded to 4 bytes.
+function _readVarint(buf) {
+  var value = 0, shift = 0, len = 0;
+  for (var i = 0; i < buf.length && i < 4; i += 1) {   // allow:raw-byte-literal — multicodec varint ≤ 4 bytes
+    var b = buf[i];
+    value |= (b & 0x7f) << shift;
+    len += 1;
+    if ((b & 0x80) === 0) return { value: value >>> 0, length: len };
+    shift += 7;                                        // allow:raw-byte-literal — 7 bits per varint byte
+  }
+  throw new DidError("did/bad-multicodec", "did: multicodec varint did not terminate");
+}
+function _encodeVarint(code) {
+  var out = [];
+  var n = code;
+  do { var b = n & 0x7f; n >>>= 7; if (n > 0) b |= 0x80; out.push(b); } while (n > 0);   // allow:raw-byte-literal — LEB128 7-bit groups
+  return Buffer.from(out);
+}
+
+// ---- key <-> bytes ----
+
+var ED25519_SPKI_PREFIX = Buffer.from("302a300506032b6570032100", "hex");   // RFC 8410 Ed25519 SubjectPublicKeyInfo header
+
+function _keyObjectFromMulticodec(code, keyBytes) {
+  var desc = MULTICODEC[code];
+  if (!desc) throw new DidError("did/unsupported-key", "did: unsupported multicodec key code 0x" + code.toString(16));   // allow:raw-byte-literal — hex radix
+  if (desc.kind === "okp") {
+    if (keyBytes.length !== 32) {                      // allow:raw-byte-literal — Ed25519 public key is 32 bytes
+      throw new DidError("did/bad-key", "did: Ed25519 key must be 32 bytes (got " + keyBytes.length + ")");
+    }
+    return nodeCrypto.createPublicKey({ key: Buffer.concat([ED25519_SPKI_PREFIX, keyBytes]), format: "der", type: "spki" });
+  }
+  // EC: keyBytes is a compressed point (0x02/0x03 + X). Build an SPKI and
+  // let node decompress.
+  if (keyBytes.length < 2 || (keyBytes[0] !== 0x02 && keyBytes[0] !== 0x03)) {
+    throw new DidError("did/bad-key", "did: EC key must be a compressed point (0x02/0x03 prefix)");
+  }
+  var algid = _ecAlgId(desc.curveOid);
+  var bitstr = Buffer.concat([Buffer.from([0x03, keyBytes.length + 1, 0x00]), keyBytes]);
+  var body = Buffer.concat([algid, bitstr]);
+  var spki = Buffer.concat([Buffer.from([0x30, body.length]), body]);      // allow:raw-byte-literal — SEQUENCE tag; single-byte DER length holds for these curves
+  try { return nodeCrypto.createPublicKey({ key: spki, format: "der", type: "spki" }); }
+  catch (e) { throw new DidError("did/bad-key", "did: could not import EC key: " + ((e && e.message) || e)); }
+}
+
+// AlgorithmIdentifier SEQUENCE { id-ecPublicKey, namedCurve OID }.
+function _ecAlgId(curveOid) {
+  var idEcPublicKey = Buffer.from("06072a8648ce3d0201", "hex");            // allow:raw-byte-literal allow:raw-time-literal — DER OID for id-ecPublicKey
+  var curve = _oidDer(curveOid);
+  var inner = Buffer.concat([idEcPublicKey, curve]);
+  return Buffer.concat([Buffer.from([0x30, inner.length]), inner]);
+}
+function _oidDer(dotted) {
+  var parts = dotted.split(".").map(Number);
+  var bytes = [parts[0] * 40 + parts[1]];                                  // allow:raw-byte-literal — X.690 first-arc encoding
+  for (var i = 2; i < parts.length; i += 1) {
+    var arc = parts[i], stack = [];
+    do { stack.unshift(arc & 0x7f); arc >>>= 7; } while (arc > 0);        // allow:raw-byte-literal — base-128 OID arc
+    for (var j = 0; j < stack.length - 1; j += 1) stack[j] |= 0x80;       // allow:raw-byte-literal — continuation bit
+    bytes = bytes.concat(stack);
+  }
+  return Buffer.concat([Buffer.from([0x06, bytes.length]), Buffer.from(bytes)]);
+}
+
+// Compressed point + curve name from an EC KeyObject's JWK.
+function _compressedPoint(jwk) {
+  var x = Buffer.from(jwk.x, "base64url");
+  var y = Buffer.from(jwk.y, "base64url");
+  return Buffer.concat([Buffer.from([(y[y.length - 1] & 1) ? 0x03 : 0x02]), x]);
+}
+
+/**
+ * @primitive b.did.parse
+ * @signature b.did.parse(did)
+ * @since     0.12.41
+ * @status    experimental
+ * @related   b.did.resolve, b.did.keyToDid
+ *
+ * Split a DID string into its method and method-specific id. For
+ * <code>did:web</code> the HTTPS URL of the DID document is also
+ * returned (host[:port][:path] → <code>https://host/path/did.json</code>,
+ * or <code>/.well-known/did.json</code> with no path).
+ *
+ * @example
+ *   b.did.parse("did:web:example.com:issuers:42");
+ *   // → { method: "web", id: "example.com:issuers:42", url: "https://example.com/issuers/42/did.json" }
+ */
+function parse(did) {
+  if (typeof did !== "string" || did.indexOf("did:") !== 0) {
+    throw new DidError("did/bad-did", "did.parse: not a DID (must start with 'did:')");
+  }
+  var rest = did.slice(4);
+  var colon = rest.indexOf(":");
+  if (colon <= 0) throw new DidError("did/bad-did", "did.parse: DID is missing a method-specific id");
+  var method = rest.slice(0, colon);
+  var id = rest.slice(colon + 1);
+  var out = { method: method, id: id };
+  if (method === "web") out.url = _didWebUrl(id);
+  return out;
+}
+
+function _didWebUrl(id) {
+  // did-method-web §read: ':' separates segments (→ '/'); only the host
+  // may carry a percent-encoded port (%3A → ':'). Path segments are kept
+  // verbatim — NOT percent-decoded — so an escaped reserved char (e.g.
+  // %3F) stays path data rather than becoming URL control syntax, and a
+  // malformed escape never throws a raw URIError.
+  var segs = id.split(":");
+  var host = segs[0].replace(/%3[Aa]/g, ":");
+  if (!host) throw new DidError("did/bad-did", "did:web: missing host");
+  var path = segs.slice(1);
+  var base = "https://" + host;
+  return path.length ? base + "/" + path.join("/") + "/did.json" : base + "/.well-known/did.json";
+}
+
+/**
+ * @primitive b.did.keyToDid
+ * @signature b.did.keyToDid(publicKey)
+ * @since     0.12.41
+ * @status    experimental
+ * @related   b.did.resolve
+ *
+ * Encode a public key (a <code>node:crypto</code> KeyObject or PEM) as a
+ * <code>did:key</code> — the inverse of resolution, for an issuer that
+ * names itself by its key. Ed25519, P-256, P-384, and secp256k1 are
+ * supported.
+ *
+ * @example
+ *   var did = b.did.keyToDid(issuerPublicKey);   // → "did:key:z6Mk…"
+ */
+function keyToDid(publicKey) {
+  var key = (publicKey && typeof publicKey === "object" && publicKey.asymmetricKeyType)
+    ? publicKey : nodeCrypto.createPublicKey(publicKey);
+  var jwk = key.export({ format: "jwk" });
+  var code, payload;
+  if (jwk.kty === "OKP" && jwk.crv === "Ed25519") {
+    code = NAME_TO_CODE["Ed25519"];
+    payload = Buffer.from(jwk.x, "base64url");
+  } else if (jwk.kty === "EC") {
+    var name = jwk.crv === "P-256" ? "P-256" : jwk.crv === "P-384" ? "P-384" : jwk.crv === "secp256k1" ? "secp256k1" : null;
+    if (!name) throw new DidError("did/unsupported-key", "did.keyToDid: unsupported EC curve '" + jwk.crv + "'");
+    code = NAME_TO_CODE[name];
+    payload = _compressedPoint(jwk);
+  } else {
+    throw new DidError("did/unsupported-key", "did.keyToDid: unsupported key type '" + jwk.kty + "/" + jwk.crv + "'");
+  }
+  return "did:key:z" + _b58encode(Buffer.concat([_encodeVarint(code), payload]));
+}
+
+/**
+ * @primitive b.did.resolve
+ * @signature b.did.resolve(did, opts?)
+ * @since     0.12.41
+ * @status    experimental
+ * @compliance soc2
+ * @related   b.did.parse, b.vc.verify, b.mdoc.verifyIssuerSigned
+ *
+ * Resolve a DID to its document and verification methods (each with a
+ * <code>node:crypto</code> public KeyObject ready for a verifier).
+ * <code>did:key</code> resolves deterministically and offline.
+ * <code>did:web</code> requires the operator to supply the fetched DID
+ * document as <code>opts.document</code> (the network fetch is the
+ * operator's; the URL to fetch is on <code>b.did.parse(did).url</code>).
+ *
+ * @opts
+ *   {
+ *     document: object,   // did:web — the fetched did.json (required for did:web)
+ *   }
+ *
+ * @example
+ *   var r = b.did.resolve("did:key:z6Mk…");
+ *   var key = r.verificationMethods[0].publicKey;   // → KeyObject for b.vc.verify / b.mdoc / b.scitt
+ */
+function resolve(did, opts) {
+  opts = opts || {};
+  validateOpts.requireObject(opts, "did.resolve", DidError);
+  validateOpts(opts, ["document"], "did.resolve");
+  var parsed = parse(did);
+
+  if (parsed.method === "key") {
+    if (parsed.id[0] !== "z") {
+      throw new DidError("did/bad-did", "did:key: method-specific id must be base58btc multibase (start with 'z')");
+    }
+    var raw = _b58decode(parsed.id.slice(1));
+    var vh = _readVarint(raw);
+    var key = _keyObjectFromMulticodec(vh.value, raw.slice(vh.length));
+    var vmId = did + "#" + parsed.id;
+    var vm = { id: vmId, controller: did, type: MULTICODEC[vh.value].name, publicKey: key };
+    var doc = {
+      "@context": ["https://www.w3.org/ns/did/v1"],
+      id: did,
+      verificationMethod: [{ id: vmId, controller: did, type: "Multikey", publicKeyMultibase: parsed.id }],
+      assertionMethod: [vmId], authentication: [vmId],
+    };
+    return { didDocument: doc, verificationMethods: [vm] };
+  }
+
+  if (parsed.method === "web") {
+    if (!opts.document || typeof opts.document !== "object") {
+      throw new DidError("did/document-required",
+        "did:web: the DID document must be fetched by the operator and passed as opts.document (GET " + parsed.url + ")");
+    }
+    var docW = opts.document;
+    if (docW.id !== did) {
+      throw new DidError("did/document-mismatch", "did:web: document id '" + docW.id + "' does not match the requested DID");
+    }
+    return { didDocument: docW, verificationMethods: _extractVerificationMethods(docW) };
+  }
+
+  throw new DidError("did/unsupported-method", "did.resolve: unsupported DID method '" + parsed.method + "' (did:key and did:web only)");
+}
+
+// Import a publicKeyJwk after allowlisting its kty/crv — a DID document
+// is untrusted input, so an unexpected key type (RSA / oct / unknown
+// curve) is refused before it reaches node:crypto rather than blindly
+// imported (the DID-context equivalent of the JWT alg/kty cross-check;
+// there is no single verification `alg` in a DID document).
+function _jwkToKey(jwk) {
+  var ok = (jwk.kty === "OKP" && jwk.crv === "Ed25519") ||
+    (jwk.kty === "EC" && (jwk.crv === "P-256" || jwk.crv === "P-384" || jwk.crv === "secp256k1"));
+  if (!ok) {
+    throw new DidError("did/unsupported-key",
+      "did: verificationMethod publicKeyJwk has unsupported kty/crv (" + jwk.kty + "/" + jwk.crv + ")");
+  }
+  try { return nodeCrypto.createPublicKey({ key: jwk, format: "jwk" }); }
+  catch (e) { throw new DidError("did/bad-key", "did: verificationMethod publicKeyJwk is invalid: " + ((e && e.message) || e)); }
+}
+
+// Extract verification methods from a DID document → KeyObjects.
+function _extractVerificationMethods(doc) {
+  var vms = Array.isArray(doc.verificationMethod) ? doc.verificationMethod : [];
+  var out = [];
+  for (var i = 0; i < vms.length; i += 1) {
+    var vm = vms[i];
+    if (!vm || typeof vm !== "object") continue;
+    var key = null;
+    if (typeof vm.publicKeyMultibase === "string" && vm.publicKeyMultibase[0] === "z") {
+      var raw = _b58decode(vm.publicKeyMultibase.slice(1));
+      var vh = _readVarint(raw);
+      key = _keyObjectFromMulticodec(vh.value, raw.slice(vh.length));
+    } else if (vm.publicKeyJwk && typeof vm.publicKeyJwk === "object") {
+      key = _jwkToKey(vm.publicKeyJwk);
+    } else {
+      continue;   // unknown key encoding — skip rather than guess
+    }
+    out.push({ id: vm.id, controller: vm.controller, type: vm.type, publicKey: key });
+  }
+  if (!out.length) throw new DidError("did/no-keys", "did: document has no resolvable verification methods");
+  return out;
+}
+
+module.exports = {
+  parse:       parse,
+  keyToDid:    keyToDid,
+  resolve:     resolve,
+  MULTICODEC:  MULTICODEC,
+  DidError:    DidError,
+};

package/lib/vc.js

@@ -51,6 +51,11 @@ var VCDM_V2_CONTEXT = "https://www.w3.org/ns/credentials/v2";
 var JOSE_TYP = "vc+jwt";
 var COSE_TYP = "application/vc+cose";
 var COSE_CONTENT_TYPE = "application/vc";
+var VP_JOSE_TYP = "vp+jwt";
+var VP_COSE_TYP = "application/vp+cose";
+var VP_COSE_CONTENT_TYPE = "application/vp";
+var MAX_PRESENTATION_CREDENTIALS = 64;                 // allow:raw-byte-literal — bounded count of enveloped VCs per presentation
+var ENVELOPED_VC_TYPE = "EnvelopedVerifiableCredential";
 var HDR_COSE_TYP = 16;                                 // allow:raw-byte-literal — COSE "typ" header label (RFC 9596)
 
 // JOSE signature algorithms (final RFC 7518 / 8037), mapped to node
@@ -165,36 +170,43 @@ async function issue(credential, opts) {
   _validateVcdm(credential, null);
   if (!opts.privateKey) throw new VcError("vc/no-key", "vc.issue: opts.privateKey is required");
 
+  return _sign(credential, opts, JOSE_TYP, COSE_TYP, COSE_CONTENT_TYPE, "vc.issue");
+}
+
+// Secure a JSON document (credential or presentation) as a compact JWS
+// (jose) or COSE_Sign1 (cose) with the given media-type headers. The
+// document is the exact signed payload — no claims wrapper.
+function _sign(doc, opts, joseTyp, coseTyp, coseContentType, fnName) {
   if (opts.securing === "cose") {
     var protectedHeaders = {};
-    protectedHeaders[HDR_COSE_TYP] = COSE_TYP;
-    return cose.sign(Buffer.from(JSON.stringify(credential), "utf8"), {
+    protectedHeaders[HDR_COSE_TYP] = coseTyp;
+    return cose.sign(Buffer.from(JSON.stringify(doc), "utf8"), {
       alg:              opts.alg,
       privateKey:       opts.privateKey,
       kid:              opts.kid,
-      contentType:      COSE_CONTENT_TYPE,
+      contentType:      coseContentType,
       protectedHeaders: protectedHeaders,
     });
   }
   if (opts.securing === "jose") {
     var params = JOSE_ALGS[opts.alg];
     if (!params) {
-      throw new VcError("vc/bad-alg", "vc.issue: JOSE securing requires alg ES256/384/512 or EdDSA (got " + opts.alg + ")");
+      throw new VcError("vc/bad-alg", fnName + ": JOSE securing requires alg ES256/384/512 or EdDSA (got " + opts.alg + ")");
     }
     var key = _toKey(opts.privateKey, "private");
-    var header = { alg: opts.alg, typ: JOSE_TYP };
+    var header = { alg: opts.alg, typ: joseTyp };
     if (typeof opts.kid === "string") header.kid = opts.kid;
     if (typeof opts.cty === "string") header.cty = opts.cty;
-    var signingInput = _b64urlJson(header) + "." + _b64urlJson(credential);
+    var signingInput = _b64urlJson(header) + "." + _b64urlJson(doc);
     var sig = params.nodeHash === null
       ? nodeCrypto.sign(null, Buffer.from(signingInput, "ascii"), key)
       : nodeCrypto.sign(params.nodeHash, Buffer.from(signingInput, "ascii"), { key: key, dsaEncoding: params.dsaEncoding });
     return signingInput + "." + sig.toString("base64url");
   }
-  throw new VcError("vc/bad-securing", "vc.issue: securing must be 'jose' or 'cose'");
+  throw new VcError("vc/bad-securing", fnName + ": securing must be 'jose' or 'cose'");
 }
 
-function _verifyJose(token, opts) {
+function _verifyJose(token, opts, expectedTyp) {
   var parts = token.split(".");
   if (parts.length !== 3) {
     throw new VcError("vc/malformed", "vc.verify: not a compact JWS (expected three dot-separated segments)");
@@ -202,8 +214,8 @@ function _verifyJose(token, opts) {
   var header;
   try { header = safeJson.parse(Buffer.from(parts[0], "base64url").toString("utf8")); }
   catch (_e) { throw new VcError("vc/malformed", "vc.verify: JWS header is not valid base64url-JSON"); }
-  if (!header || header.typ !== JOSE_TYP) {
-    throw new VcError("vc/bad-typ", "vc.verify: JWS typ must be '" + JOSE_TYP + "'");
+  if (!header || header.typ !== expectedTyp) {
+    throw new VcError("vc/bad-typ", "vc.verify: JWS typ must be '" + expectedTyp + "'");
   }
   // crit-bypass defense (RFC 7515 §4.1.11): a `crit` header marks
   // extensions the verifier MUST understand and process. This verifier
@@ -228,16 +240,16 @@ function _verifyJose(token, opts) {
     ? nodeCrypto.verify(null, Buffer.from(signingInput, "ascii"), pub, sig)
     : nodeCrypto.verify(params.nodeHash, Buffer.from(signingInput, "ascii"), { key: pub, dsaEncoding: params.dsaEncoding }, sig);
   if (!ok) throw new VcError("vc/bad-signature", "vc.verify: JWS signature did not verify");
-  var credential;
-  try { credential = safeJson.parse(Buffer.from(parts[1], "base64url").toString("utf8")); }
+  var payload;
+  try { payload = safeJson.parse(Buffer.from(parts[1], "base64url").toString("utf8")); }
   catch (_e) { throw new VcError("vc/malformed", "vc.verify: JWS payload is not valid base64url-JSON"); }
-  return { credential: credential, alg: header.alg };
+  return { payload: payload, alg: header.alg };
 }
 
-async function _verifyCose(bytes, opts) {
+async function _verifyCose(bytes, opts, expectedTyp) {
   var algorithms = opts.algorithms.filter(function (a) { return a in cose.ALGORITHMS; });
   if (!algorithms.length) {
-    throw new VcError("vc/no-cose-alg", "vc.verify: opts.algorithms has no COSE algorithm for a vc+cose credential");
+    throw new VcError("vc/no-cose-alg", "vc.verify: opts.algorithms has no COSE algorithm for a COSE-secured credential");
   }
   var out = await cose.verify(bytes, {
     algorithms:  algorithms,
@@ -245,13 +257,25 @@ async function _verifyCose(bytes, opts) {
     keyResolver: opts.keyResolver,
   });
   var typ = out.protectedHeaders.get(HDR_COSE_TYP);
-  if (typ !== undefined && typ !== COSE_TYP) {
-    throw new VcError("vc/bad-typ", "vc.verify: COSE typ header is '" + typ + "', expected '" + COSE_TYP + "'");
+  if (typ !== undefined && typ !== expectedTyp) {
+    throw new VcError("vc/bad-typ", "vc.verify: COSE typ header is '" + typ + "', expected '" + expectedTyp + "'");
   }
-  var credential;
-  try { credential = safeJson.parse(out.payload.toString("utf8")); }
+  var payload;
+  try { payload = safeJson.parse(out.payload.toString("utf8")); }
   catch (_e) { throw new VcError("vc/malformed", "vc.verify: COSE payload is not valid JSON"); }
-  return { credential: credential, alg: out.alg };
+  return { payload: payload, alg: out.alg };
+}
+
+// Verify a secured JSON document (the JOSE/COSE envelope) → { payload,
+// alg, securing }. Shared by credential + presentation verification.
+async function _verifySecured(secured, opts, joseTyp, coseTyp) {
+  if (typeof secured === "string") {
+    return Object.assign({ securing: "jose" }, _verifyJose(secured, opts, joseTyp));
+  }
+  if (Buffer.isBuffer(secured) || secured instanceof Uint8Array) {
+    return Object.assign({ securing: "cose" }, await _verifyCose(Buffer.from(secured), opts, coseTyp));
+  }
+  throw new VcError("vc/bad-input", "vc.verify: secured must be a compact-JWS string or COSE_Sign1 bytes");
 }
 
 /**
@@ -300,28 +324,202 @@ async function verify(secured, opts) {
     at = opts.at;
   }
 
-  var securing, result;
-  if (typeof secured === "string") {
-    securing = "jose";
-    result = _verifyJose(secured, opts);
-  } else if (Buffer.isBuffer(secured) || secured instanceof Uint8Array) {
-    securing = "cose";
-    result = await _verifyCose(Buffer.from(secured), opts);
-  } else {
-    throw new VcError("vc/bad-input", "vc.verify: secured must be a compact-JWS string or COSE_Sign1 bytes");
-  }
+  var result = await _verifySecured(secured, opts, JOSE_TYP, COSE_TYP);
 
-  _validateVcdm(result.credential, { temporal: true, at: at });
-  var issuer = _issuerId(result.credential);
+  _validateVcdm(result.payload, { temporal: true, at: at });
+  var issuer = _issuerId(result.payload);
   if (opts.expectedIssuer !== undefined && issuer !== opts.expectedIssuer) {
     throw new VcError("vc/issuer-mismatch", "vc.verify: credential issuer does not match expectedIssuer");
   }
-  return { credential: result.credential, securing: securing, alg: result.alg, issuer: issuer };
+  return { credential: result.payload, securing: result.securing, alg: result.alg, issuer: issuer };
+}
+
+// VCDM 2.0 presentation structural rules.
+function _validateVp(vp) {
+  if (!vp || typeof vp !== "object" || Array.isArray(vp)) {
+    throw new VcError("vc/bad-presentation", "vc: presentation must be a JSON object");
+  }
+  var ctx = vp["@context"];
+  if (!Array.isArray(ctx) || ctx[0] !== VCDM_V2_CONTEXT) {
+    throw new VcError("vc/bad-context", "vc: presentation @context must start with '" + VCDM_V2_CONTEXT + "'");
+  }
+  var types = Array.isArray(vp.type) ? vp.type : [vp.type];
+  if (types.indexOf("VerifiablePresentation") === -1) {
+    throw new VcError("vc/bad-type", "vc: type must include 'VerifiablePresentation'");
+  }
+  // verifiableCredential, when present, MUST be an array — a non-array
+  // value must fail closed rather than coerce to empty (which would let
+  // a holder bypass credential verification with a malformed container).
+  if (vp.verifiableCredential !== undefined && !Array.isArray(vp.verifiableCredential)) {
+    throw new VcError("vc/bad-presentation", "vc: verifiableCredential must be an array");
+  }
+}
+
+// An enveloped VC (VC-JOSE-COSE §enveloping): a data: URI whose media
+// type selects the securing and whose body is the secured credential.
+function _envelopeVc(securedVc) {
+  if (typeof securedVc === "string") {
+    return { "@context": [VCDM_V2_CONTEXT], type: ENVELOPED_VC_TYPE, id: "data:application/vc+jwt," + securedVc };
+  }
+  if (Buffer.isBuffer(securedVc) || securedVc instanceof Uint8Array) {
+    return { "@context": [VCDM_V2_CONTEXT], type: ENVELOPED_VC_TYPE,
+      id: "data:application/vc+cose;base64," + Buffer.from(securedVc).toString("base64") };
+  }
+  throw new VcError("vc/bad-credential", "vc.present: each credential must be a compact-JWS string or COSE_Sign1 bytes");
+}
+
+function _parseEnvelopedVc(entry) {
+  if (!entry || typeof entry !== "object" || entry.type !== ENVELOPED_VC_TYPE || typeof entry.id !== "string") {
+    throw new VcError("vc/bad-enveloped", "vc.verifyPresentation: verifiableCredential entries must be EnvelopedVerifiableCredential data: URIs");
+  }
+  var comma = entry.id.indexOf(",");
+  if (entry.id.indexOf("data:") !== 0 || comma === -1) {
+    throw new VcError("vc/bad-enveloped", "vc.verifyPresentation: enveloped credential id is not a data: URI");
+  }
+  var meta = entry.id.slice("data:".length, comma);
+  var body = entry.id.slice(comma + 1);
+  if (meta.indexOf("application/vc+cose") === 0) return Buffer.from(body, "base64");
+  if (meta.indexOf("application/vc+jwt") === 0) return body;
+  throw new VcError("vc/bad-enveloped", "vc.verifyPresentation: unsupported enveloped media type '" + meta + "'");
+}
+
+/**
+ * @primitive b.vc.present
+ * @signature b.vc.present(opts)
+ * @since     0.12.42
+ * @status    experimental
+ * @compliance gdpr, soc2
+ * @related   b.vc.verifyPresentation, b.vc.issue
+ *
+ * Build and sign a W3C Verifiable Presentation: a holder-signed envelope
+ * wrapping one or more secured credentials (each enveloped per
+ * VC-JOSE-COSE). <code>securing</code> and the algorithms match
+ * <code>b.vc.issue</code> (compact JWS <code>vp+jwt</code>, or COSE_Sign1
+ * <code>application/vp+cose</code>). Supply <code>nonce</code> /
+ * <code>audience</code> for holder-binding / replay protection — they
+ * are embedded in the signed presentation and checked at verification.
+ *
+ * @opts
+ *   {
+ *     credentials: array,    // secured VCs (compact-JWS strings or COSE_Sign1 bytes)
+ *     holder:      string,   // the presenter (a DID or other id)
+ *     securing:    string,   // "jose" | "cose"
+ *     alg:         string,   // JOSE: ES256/384/512 | EdDSA. COSE: + ML-DSA-87
+ *     privateKey:  object,   // the holder's key
+ *     kid:         string,   // optional key id
+ *     nonce:       string,   // optional verifier challenge (embedded + checked)
+ *     audience:    string,   // optional intended verifier (embedded + checked)
+ *   }
+ *
+ * @example
+ *   var vp = await b.vc.present({ credentials: [jws], holder: holderDid, securing: "jose", alg: "ES256", privateKey: holderKey, nonce: challenge });
+ */
+async function present(opts) {
+  validateOpts.requireObject(opts, "vc.present", VcError);
+  validateOpts(opts, ["credentials", "holder", "securing", "alg", "privateKey", "kid", "nonce", "audience"], "vc.present");
+  if (!Array.isArray(opts.credentials) || opts.credentials.length === 0) {
+    throw new VcError("vc/no-credentials", "vc.present: opts.credentials must be a non-empty array");
+  }
+  if (opts.credentials.length > MAX_PRESENTATION_CREDENTIALS) {
+    throw new VcError("vc/too-many-credentials", "vc.present: at most " + MAX_PRESENTATION_CREDENTIALS + " credentials per presentation");
+  }
+  if (typeof opts.holder !== "string" || !opts.holder) {
+    throw new VcError("vc/no-holder", "vc.present: opts.holder is required (the presenter id / DID)");
+  }
+  if (!opts.privateKey) throw new VcError("vc/no-key", "vc.present: opts.privateKey is required");
+
+  var vp = {
+    "@context": [VCDM_V2_CONTEXT],
+    type: ["VerifiablePresentation"],
+    holder: opts.holder,
+    verifiableCredential: opts.credentials.map(_envelopeVc),
+  };
+  if (typeof opts.nonce === "string") vp.nonce = opts.nonce;
+  if (typeof opts.audience === "string") vp.audience = opts.audience;
+
+  return _sign(vp, opts, VP_JOSE_TYP, VP_COSE_TYP, VP_COSE_CONTENT_TYPE, "vc.present");
+}
+
+/**
+ * @primitive b.vc.verifyPresentation
+ * @signature b.vc.verifyPresentation(secured, opts)
+ * @since     0.12.42
+ * @status    experimental
+ * @compliance gdpr, soc2
+ * @related   b.vc.present, b.vc.verify
+ *
+ * Verify a Verifiable Presentation: the holder signature (auto-detected
+ * jose / cose, mandatory algorithm allowlist, JOSE <code>none</code>
+ * refused), the VCDM structure, and the embedded <code>nonce</code> /
+ * <code>audience</code> / <code>expectedHolder</code> when given. With
+ * <code>verifyCredentials: true</code> each enveloped credential is
+ * verified through <code>b.vc.verify</code> (using
+ * <code>opts.credentialOpts</code>) and returned.
+ *
+ * @opts
+ *   {
+ *     algorithms:      string[],  // required — holder-signature alg allowlist
+ *     publicKey:       object,    // the holder verification key
+ *     keyResolver:     function,  // (header) → holder key
+ *     expectedHolder:  string,    // require presentation holder to match
+ *     nonce:           string,    // require embedded nonce to match
+ *     audience:        string,    // require embedded audience to match
+ *     verifyCredentials: boolean, // verify each enveloped VC via b.vc.verify
+ *     credentialOpts:  object,    // opts passed to b.vc.verify for each VC
+ *   }
+ *
+ * @example
+ *   var out = await b.vc.verifyPresentation(vp, {
+ *     algorithms: ["ES256"], publicKey: holderKey, nonce: challenge,
+ *     verifyCredentials: true, credentialOpts: { algorithms: ["ES256"], publicKey: issuerKey },
+ *   });
+ *   // → { presentation, holder, credentials: [verified VCs], securing, alg }
+ */
+async function verifyPresentation(secured, opts) {
+  validateOpts.requireObject(opts, "vc.verifyPresentation", VcError);
+  validateOpts(opts, ["algorithms", "publicKey", "keyResolver", "expectedHolder", "nonce", "audience", "verifyCredentials", "credentialOpts"], "vc.verifyPresentation");
+  if (!Array.isArray(opts.algorithms) || opts.algorithms.length === 0) {
+    throw new VcError("vc/algorithms-required", "vc.verifyPresentation: opts.algorithms is required");
+  }
+  if (!opts.publicKey && typeof opts.keyResolver !== "function") {
+    throw new VcError("vc/no-key", "vc.verifyPresentation: pass publicKey or keyResolver");
+  }
+
+  var result = await _verifySecured(secured, opts, VP_JOSE_TYP, VP_COSE_TYP);
+  var vp = result.payload;
+  _validateVp(vp);
+
+  if (opts.expectedHolder !== undefined && vp.holder !== opts.expectedHolder) {
+    throw new VcError("vc/holder-mismatch", "vc.verifyPresentation: presentation holder does not match expectedHolder");
+  }
+  if (opts.nonce !== undefined && vp.nonce !== opts.nonce) {
+    throw new VcError("vc/nonce-mismatch", "vc.verifyPresentation: presentation nonce does not match");
+  }
+  if (opts.audience !== undefined && vp.audience !== opts.audience) {
+    throw new VcError("vc/audience-mismatch", "vc.verifyPresentation: presentation audience does not match");
+  }
+
+  var entries = vp.verifiableCredential || [];   // _validateVp guarantees array-or-absent
+  if (entries.length > MAX_PRESENTATION_CREDENTIALS) {
+    throw new VcError("vc/too-many-credentials", "vc.verifyPresentation: presentation carries more than " + MAX_PRESENTATION_CREDENTIALS + " credentials");
+  }
+  var credentials = [];
+  if (opts.verifyCredentials) {
+    var credOpts = opts.credentialOpts;
+    validateOpts.requireObject(credOpts, "vc.verifyPresentation.credentialOpts", VcError);
+    for (var i = 0; i < entries.length; i += 1) {
+      credentials.push(await verify(_parseEnvelopedVc(entries[i]), credOpts));
+    }
+  }
+
+  return { presentation: vp, holder: vp.holder, credentials: credentials, securing: result.securing, alg: result.alg };
 }
 
 module.exports = {
   issue:          issue,
   verify:         verify,
+  present:        present,
+  verifyPresentation: verifyPresentation,
   JOSE_ALGS:      JOSE_ALGS,
   VCDM_V2_CONTEXT: VCDM_V2_CONTEXT,
   VcError:        VcError,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blamejs/core",
-  "version": "0.12.40",
+  "version": "0.12.42",
   "description": "The Node framework that owns its stack.",
   "license": "Apache-2.0",
   "author": "blamejs contributors",

package/sbom.cdx.json

@@ -2,10 +2,10 @@
   "$schema": "http://cyclonedx.org/schema/bom-1.5.schema.json",
   "bomFormat": "CycloneDX",
   "specVersion": "1.5",
-  "serialNumber": "urn:uuid:6a95f7d3-c5ac-4994-955e-1fb82f6bb11b",
+  "serialNumber": "urn:uuid:313dd43c-bb3f-4c16-a801-2af63046b56f",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-05-25T04:51:15.499Z",
+    "timestamp": "2026-05-25T06:48:54.423Z",
     "lifecycles": [
       {
         "phase": "build"
@@ -19,14 +19,14 @@
       }
     ],
     "component": {
-      "bom-ref": "@blamejs/core@0.12.40",
+      "bom-ref": "@blamejs/core@0.12.42",
       "type": "application",
       "name": "blamejs",
-      "version": "0.12.40",
+      "version": "0.12.42",
       "scope": "required",
       "author": "blamejs contributors",
       "description": "The Node framework that owns its stack.",
-      "purl": "pkg:npm/%40blamejs/core@0.12.40",
+      "purl": "pkg:npm/%40blamejs/core@0.12.42",
       "properties": [],
       "externalReferences": [
         {
@@ -54,7 +54,7 @@
   "components": [],
   "dependencies": [
     {
-      "ref": "@blamejs/core@0.12.40",
+      "ref": "@blamejs/core@0.12.42",
       "dependsOn": []
     }
   ]