@govuk-one-login/mobile-wallet-mdoc-builder 0.0.0 → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 GOV.UK One Login
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,71 @@
+# Mobile Wallet mdoc Builder
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+## Overview
+
+A TypeScript library for building mdoc (ISO 18013-5) documents for use with GOV.UK Wallet. It provides a type-safe API
+for constructing and encoding mdoc-based credentials.
+
+## Tech stack
+
+Built with TypeScript and Node.js, published as a dual-format (ESM and CJS) npm package.
+
+## Prerequisites
+
+- [Node.js](https://nodejs.org/en) — we recommend managing versions with [nvm](https://github.com/nvm-sh/nvm)
+- [Pre-commit](https://pre-commit.com/)
+
+## Set up locally
+
+### Install
+
+```bash
+nvm use
+npm install
+```
+
+### Lint and format
+
+```bash
+npm run lint
+npm run format
+```
+
+### Type check
+
+```bash
+npm run typecheck
+```
+
+### Build
+
+```bash
+npm run build
+```
+
+## Contributing
+
+This project uses [pre-commit](https://pre-commit.com/) to enforce code quality and validate commit messages against [Conventional Commits](https://www.conventionalcommits.org/) standards. Non-conforming messages will be rejected.
+
+Ensure your branch is up to date and all hooks pass before opening a pull request. Avoid using the git `--no-verify` flag to skip these checks unless absolutely necessary.
+
+### Installing pre-commit hooks
+
+```bash
+brew install pre-commit
+```
+
+```bash
+pre-commit install --hook-type pre-commit --hook-type commit-msg
+```
+
+## Documentation
+
+- [Release process](docs/release-process.md)
+- [Component architecture](docs/component-architecture.md)
+- [CBOR test guide](docs/cbor-test-guide.md)
+
+## Licence
+
+[MIT License](LICENSE)

package/dist/index.cjs

@@ -0,0 +1,602 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let zod = require("zod");
+let node_crypto = require("node:crypto");
+node_crypto = __toESM(node_crypto, 1);
+let cbor2 = require("cbor2");
+//#region src/types/dateFormat.ts
+/**
+* Specifies the date encoding format for a data element.
+*
+* Used to indicate whether a Date value should be encoded as a full-date
+* (YYYY-MM-DD) or a date-time (ISO 8601 with time component) in the
+* resulting CBOR structure.
+*/
+let DateFormat = /* @__PURE__ */ function(DateFormat) {
+	/** Encode as a full-date (YYYY-MM-DD) per RFC 3339. */
+	DateFormat[DateFormat["FullDate"] = 0] = "FullDate";
+	/** Encode as a date-time (YYYY-MM-DDTHH:mm:ssZ) per RFC 3339. */
+	DateFormat[DateFormat["DateTime"] = 1] = "DateTime";
+	return DateFormat;
+}({});
+//#endregion
+//#region src/types/mdocBuilderError.ts
+/**
+* Error thrown by the mdoc builder when construction or signing fails.
+*
+* When the failure is caused by input validation, `violations` holds the
+* complete set of {@link ValidationError} entries which callers can inspect.
+*/
+var MdocBuilderError = class extends Error {
+	/** The validation violations that caused the failure, if any. */
+	violations;
+	constructor(message, options) {
+		super(message, options);
+		this.name = "MdocBuilderError";
+		if (options?.violations !== void 0) this.violations = options.violations;
+	}
+};
+//#endregion
+//#region src/validation/constants.ts
+const ELEMENT_VALUE_MAX_BYTES = 1572864;
+const DEVICE_KEY_MAX_BYTES = 2048;
+const CERTIFICATE_MAX_BYTES = 8192;
+const STATUS_LIST_IDX_MAX = 4294967295;
+const DOCUMENT_TYPE_MAX_LENGTH = 128;
+const IDENTIFIER_MAX_LENGTH = 256;
+const STRING_VALUE_MAX_LENGTH = 150;
+const COLLECTION_MAX_ENTRIES = 256;
+const VALIDATION_LIMITS = {
+	documentType: {
+		minLength: 1,
+		maxLength: DOCUMENT_TYPE_MAX_LENGTH
+	},
+	nameSpaces: {
+		namespaceKey: {
+			minLength: 1,
+			maxLength: IDENTIFIER_MAX_LENGTH
+		},
+		minDataElements: 1,
+		maxDataElements: COLLECTION_MAX_ENTRIES,
+		elementIdentifier: {
+			minLength: 1,
+			maxLength: IDENTIFIER_MAX_LENGTH
+		}
+	},
+	elementValue: {
+		string: {
+			minLength: 1,
+			maxLength: STRING_VALUE_MAX_LENGTH
+		},
+		number: {
+			min: Number.MIN_SAFE_INTEGER,
+			max: Number.MAX_SAFE_INTEGER
+		},
+		uint8Array: {
+			minByteLength: 1,
+			maxByteLength: ELEMENT_VALUE_MAX_BYTES
+		}
+	},
+	collections: {
+		minLength: 1,
+		maxLength: COLLECTION_MAX_ENTRIES
+	},
+	deviceKey: {
+		minByteLength: 1,
+		maxByteLength: DEVICE_KEY_MAX_BYTES
+	},
+	statusList: {
+		idx: {
+			min: 0,
+			max: STATUS_LIST_IDX_MAX
+		},
+		uri: { maxLength: 2048 }
+	},
+	certificateChain: {
+		minLength: 1,
+		entry: {
+			minByteLength: 1,
+			maxByteLength: CERTIFICATE_MAX_BYTES
+		}
+	}
+};
+//#endregion
+//#region src/validation/helpers/latin1.ts
+const LATIN1_PATTERN = /^[\u0000-\u00FF]*$/;
+const LATIN1_MESSAGE = "must contain only Latin1 (ISO/IEC 8859-1) characters";
+function isLatin1(value) {
+	return LATIN1_PATTERN.test(value);
+}
+//#endregion
+//#region src/validation/topLevelCredentialFields.ts
+const { documentType, deviceKey, statusList, certificateChain } = VALIDATION_LIMITS;
+function byteLengthSchema(minByteLength, maxByteLength) {
+	return zod.z.instanceof(Uint8Array).refine((value) => value.length >= minByteLength, { message: "must not be empty" }).refine((value) => value.length <= maxByteLength, { message: `must not exceed ${maxByteLength.toString()} bytes` });
+}
+const documentTypeSchema = zod.z.string().min(documentType.minLength).max(documentType.maxLength).refine(isLatin1, { message: LATIN1_MESSAGE });
+const deviceKeySchema = byteLengthSchema(deviceKey.minByteLength, deviceKey.maxByteLength);
+const statusListSchema = zod.z.object({
+	idx: zod.z.number().int().min(statusList.idx.min).max(statusList.idx.max),
+	uri: zod.z.url().max(statusList.uri.maxLength)
+}).strict();
+const certificateChainSchema = zod.z.array(byteLengthSchema(certificateChain.entry.minByteLength, certificateChain.entry.maxByteLength)).min(certificateChain.minLength);
+//#endregion
+//#region src/validation/primitives.ts
+const { string, number, uint8Array } = VALIDATION_LIMITS.elementValue;
+const stringValueSchema = zod.z.string().min(string.minLength).max(string.maxLength).refine(isLatin1, { message: LATIN1_MESSAGE });
+const numberValueSchema = zod.z.number().min(number.min).max(number.max);
+const booleanValueSchema = zod.z.boolean();
+const dateValueSchema = zod.z.date();
+const uint8ArrayValueSchema = zod.z.instanceof(Uint8Array).refine((value) => value.length >= uint8Array.minByteLength, { message: "must not be empty" }).refine((value) => value.length <= uint8Array.maxByteLength, { message: `must not exceed ${uint8Array.maxByteLength.toString()} bytes` });
+//#endregion
+//#region src/validation/dataElementValue.ts
+const { minLength, maxLength } = VALIDATION_LIMITS.collections;
+const latin1KeySchema = zod.z.string().refine(isLatin1, { message: LATIN1_MESSAGE });
+const primitiveValueSchema = zod.z.union([
+	stringValueSchema,
+	numberValueSchema,
+	booleanValueSchema,
+	dateValueSchema,
+	uint8ArrayValueSchema
+]);
+function primitiveTypeTag(value) {
+	if (value instanceof Uint8Array) return "uint8Array";
+	if (value instanceof Date) return "date";
+	if (typeof value === "string") return "string";
+	if (typeof value === "number") return "number";
+	return "boolean";
+}
+function isHomogeneous(values) {
+	let tag;
+	for (const value of values) {
+		const current = primitiveTypeTag(value);
+		tag ??= current;
+		if (current !== tag) return false;
+	}
+	return true;
+}
+const HOMOGENEITY_MESSAGE = "all values must be the same primitive type";
+const primitiveArraySchema = zod.z.array(primitiveValueSchema).min(minLength).max(maxLength).refine(isHomogeneous, { message: HOMOGENEITY_MESSAGE });
+const primitiveMapSchema = zod.z.map(latin1KeySchema, primitiveValueSchema).refine((map) => map.size >= minLength, { message: "must not be empty" }).refine((map) => map.size <= maxLength, { message: `must not exceed ${maxLength.toString()} entries` }).refine((map) => isHomogeneous(map.values()), { message: HOMOGENEITY_MESSAGE });
+const primitiveMapArraySchema = zod.z.array(zod.z.map(latin1KeySchema, primitiveValueSchema)).min(minLength).max(maxLength).refine((maps) => maps.every((map) => map.size >= minLength), { message: "each map must not be empty" }).refine((maps) => maps.every((map) => map.size <= maxLength), { message: `each map must not exceed ${maxLength.toString()} entries` }).refine((maps) => isHomogeneous(maps.flatMap((map) => [...map.values()])), { message: HOMOGENEITY_MESSAGE });
+const dataElementValueSchema = zod.z.union([
+	primitiveMapArraySchema,
+	primitiveMapSchema,
+	primitiveArraySchema,
+	primitiveValueSchema
+]);
+//#endregion
+//#region src/validation/nameSpaces.ts
+const { namespaceKey, elementIdentifier, minDataElements, maxDataElements } = VALIDATION_LIMITS.nameSpaces;
+function isDateTyped(value) {
+	if (value instanceof Date) return true;
+	if (value instanceof Map) return [...value.values()].some((v) => v instanceof Date);
+	if (Array.isArray(value)) return value.some(isDateTyped);
+	return false;
+}
+const namespaceKeySchema = zod.z.string().min(namespaceKey.minLength).max(namespaceKey.maxLength).refine(isLatin1, { message: LATIN1_MESSAGE });
+const dataElementSchema = zod.z.object({
+	elementIdentifier: zod.z.string().min(elementIdentifier.minLength).max(elementIdentifier.maxLength).refine(isLatin1, { message: LATIN1_MESSAGE }),
+	elementValue: dataElementValueSchema,
+	dateFormat: zod.z.enum(DateFormat).optional()
+}).superRefine((element, ctx) => {
+	if (!isDateTyped(element.elementValue) && element.dateFormat !== void 0) ctx.addIssue({
+		code: "custom",
+		message: "dateFormat must not be provided when elementValue is not date-typed",
+		path: ["dateFormat"]
+	});
+});
+const nameSpacesSchema = zod.z.map(namespaceKeySchema, zod.z.array(dataElementSchema).min(minDataElements).max(maxDataElements)).refine((nameSpaces) => nameSpaces.size >= 1, { message: "must not be empty" });
+//#endregion
+//#region src/validation/credentialValidity.ts
+function credentialValiditySchema(now) {
+	return zod.z.object({
+		earliestValidFrom: zod.z.date().optional(),
+		validUntil: zod.z.date(),
+		expectedUpdate: zod.z.date().optional()
+	}).superRefine((validity, ctx) => {
+		if (validity.validUntil.getTime() <= now.getTime()) ctx.addIssue({
+			code: "custom",
+			message: "must be after the current time",
+			path: ["validUntil"]
+		});
+		if (validity.earliestValidFrom !== void 0 && validity.earliestValidFrom.getTime() >= validity.validUntil.getTime()) ctx.addIssue({
+			code: "custom",
+			message: "must be before validUntil",
+			path: ["earliestValidFrom"]
+		});
+		if (validity.expectedUpdate !== void 0 && validity.expectedUpdate.getTime() > validity.validUntil.getTime()) ctx.addIssue({
+			code: "custom",
+			message: "must be before or equal to validUntil",
+			path: ["expectedUpdate"]
+		});
+	});
+}
+//#endregion
+//#region src/validation/errors.ts
+function formatFieldPath(path) {
+	return path.reduce((acc, segment) => {
+		if (typeof segment === "number") return `${acc}[${segment.toString()}]`;
+		const key = String(segment);
+		return acc === "" ? key : `${acc}.${key}`;
+	}, "");
+}
+function mapZodErrorToValidationErrors(error) {
+	return error.issues.flatMap((issue) => {
+		if (issue.code === "unrecognized_keys") return issue.keys.map((key) => ({
+			field: formatFieldPath([...issue.path, key]),
+			message: issue.message
+		}));
+		return {
+			field: formatFieldPath(issue.path),
+			message: issue.message
+		};
+	});
+}
+//#endregion
+//#region src/validation/validateMdocBuilderInput.ts
+function mdocBuilderInputSchema(now) {
+	return zod.z.object({
+		documentType: documentTypeSchema,
+		nameSpaces: nameSpacesSchema,
+		deviceKey: deviceKeySchema,
+		credentialValidity: credentialValiditySchema(now),
+		statusList: statusListSchema,
+		certificateChain: certificateChainSchema
+	}).strict();
+}
+function validateMdocBuilderInput(input) {
+	const result = mdocBuilderInputSchema(/* @__PURE__ */ new Date()).safeParse(input);
+	return result.success ? [] : mapZodErrorToValidationErrors(result.error);
+}
+//#endregion
+//#region src/deviceKey/helpers/padCoordinate.ts
+const P256_COORDINATE_LENGTH = 32;
+function decodeAndPadCoordinate(base64url) {
+	return padCoordinate(new Uint8Array(Buffer.from(base64url, "base64url")));
+}
+function padCoordinate(coordinate) {
+	if (coordinate.length === P256_COORDINATE_LENGTH) return new Uint8Array(coordinate);
+	const padded = new Uint8Array(P256_COORDINATE_LENGTH);
+	padded.set(coordinate, P256_COORDINATE_LENGTH - coordinate.length);
+	return padded;
+}
+//#endregion
+//#region src/deviceKey/deviceKey.ts
+const COSE_KEY_LABEL = {
+	/** Key Type (kty) */
+	KTY: 1,
+	/** EC Curve (crv) */
+	CRV: -1,
+	/** x-coordinate */
+	X: -2,
+	/** y-coordinate */
+	Y: -3
+};
+const COSE_KEY_VALUE = {
+	/** Key type: Elliptic Curve (EC2) */
+	KTY_EC2: 2,
+	/** Curve: P-256 */
+	CRV_P256: 1
+};
+const DEVICE_KEY_INFO_KEY = {
+	DEVICE_KEY: "deviceKey",
+	KEY_AUTHORIZATIONS: "keyAuthorizations",
+	NAME_SPACES: "nameSpaces"
+};
+function buildDeviceKeyInfo(spkiBytes, namespaceNames) {
+	const jwk = importSpki(spkiBytes).export({ format: "jwk" });
+	if (jwk.kty !== "EC") throw new MdocBuilderError(`Unsupported key type: ${String(jwk.kty)}. Only EC keys are supported.`);
+	if (jwk.crv !== "P-256") throw new MdocBuilderError(`Unsupported curve: ${String(jwk.crv)}. Only P-256 is supported.`);
+	const coseKey = buildCoseKey(jwk);
+	const deviceKeyInfo = /* @__PURE__ */ new Map();
+	deviceKeyInfo.set(DEVICE_KEY_INFO_KEY.DEVICE_KEY, coseKey);
+	if (namespaceNames.length > 0) {
+		const keyAuthorizations = /* @__PURE__ */ new Map();
+		keyAuthorizations.set(DEVICE_KEY_INFO_KEY.NAME_SPACES, namespaceNames);
+		deviceKeyInfo.set(DEVICE_KEY_INFO_KEY.KEY_AUTHORIZATIONS, keyAuthorizations);
+	}
+	return deviceKeyInfo;
+}
+function buildCoseKey(jwk) {
+	const x = decodeAndPadCoordinate(jwk.x);
+	const y = decodeAndPadCoordinate(jwk.y);
+	const coseKey = /* @__PURE__ */ new Map();
+	coseKey.set(COSE_KEY_LABEL.KTY, COSE_KEY_VALUE.KTY_EC2);
+	coseKey.set(COSE_KEY_LABEL.CRV, COSE_KEY_VALUE.CRV_P256);
+	coseKey.set(COSE_KEY_LABEL.X, x);
+	coseKey.set(COSE_KEY_LABEL.Y, y);
+	return coseKey;
+}
+function importSpki(spkiBytes) {
+	try {
+		return node_crypto.default.createPublicKey({
+			key: Buffer.from(spkiBytes),
+			format: "der",
+			type: "spki"
+		});
+	} catch (error) {
+		const message = error.message;
+		throw new MdocBuilderError(`Failed to import SPKI key: ${message}`, { cause: error });
+	}
+}
+//#endregion
+//#region src/cbor/cbor.ts
+var TaggedValue = class {
+	tagNumber;
+	contents;
+	constructor(tagNumber, contents) {
+		this.tagNumber = tagNumber;
+		this.contents = contents;
+	}
+};
+const CBOR_TAG = {
+	/** Tag 0: Standard date/time string () */
+	TDATE: 0,
+	/** Tag 24: Encoded CBOR data item (bstr-wrapped CBOR) */
+	EMBEDDED_CBOR: 24,
+	/** Tag 1004: Full-date string (YYYY-MM-DD) */
+	FULL_DATE: 1004
+};
+function tdate(date) {
+	const iso = date.toISOString().replace(/\.\d{3}/, "");
+	return new TaggedValue(CBOR_TAG.TDATE, iso);
+}
+function fullDate(date) {
+	if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) throw new MdocBuilderError(`fullDate requires a "YYYY-MM-DD" string, received: "${date}"`);
+	return new TaggedValue(CBOR_TAG.FULL_DATE, date);
+}
+function embeddedCbor(bytes) {
+	return new TaggedValue(CBOR_TAG.EMBEDDED_CBOR, bytes);
+}
+function encode(value) {
+	const prepared = convertTags(value);
+	return (0, cbor2.encode)(prepared);
+}
+function convertTags(value) {
+	if (value instanceof TaggedValue) return new cbor2.Tag(value.tagNumber, convertTags(value.contents));
+	if (value instanceof Map) {
+		const prepared = /* @__PURE__ */ new Map();
+		for (const [k, v] of value) prepared.set(convertTags(k), convertTags(v));
+		return prepared;
+	}
+	if (Array.isArray(value)) return value.map(convertTags);
+	return value;
+}
+//#endregion
+//#region src/issuerSigned/buildSingleItem.ts
+const SALT_LENGTH_BYTES = 16;
+function generateDigestId(existingIds) {
+	let id;
+	do
+		id = (0, node_crypto.randomBytes)(4).readUInt32BE(0) >>> 1;
+	while (existingIds.has(id));
+	return id;
+}
+function encodeElementValue(element) {
+	const { elementValue, dateFormat } = element;
+	if (elementValue instanceof Date) return encodeDateValue(elementValue, dateFormat);
+	if (elementValue instanceof Map) return encodeDateMap(elementValue, dateFormat);
+	if (Array.isArray(elementValue)) return elementValue.map((item) => {
+		if (item instanceof Date) return encodeDateValue(item, dateFormat);
+		if (item instanceof Map) return encodeDateMap(item, dateFormat);
+		return item;
+	});
+	return elementValue;
+}
+function encodeDateMap(map, dateFormat) {
+	const result = /* @__PURE__ */ new Map();
+	for (const [key, value] of map) result.set(key, value instanceof Date ? encodeDateValue(value, dateFormat) : value);
+	return result;
+}
+function encodeDateValue(date, dateFormat) {
+	if (dateFormat === 0) return fullDate(`${date.getUTCFullYear().toString().padStart(4, "0")}-${(date.getUTCMonth() + 1).toString().padStart(2, "0")}-${date.getUTCDate().toString().padStart(2, "0")}`);
+	return tdate(date);
+}
+function buildSingleItem(element, usedIds) {
+	const digestId = generateDigestId(usedIds);
+	usedIds.add(digestId);
+	const salt = new Uint8Array((0, node_crypto.randomBytes)(SALT_LENGTH_BYTES));
+	return {
+		digestId,
+		tag24Bytes: encode(embeddedCbor(encode(/* @__PURE__ */ new Map([
+			["digestID", digestId],
+			["random", salt],
+			["elementIdentifier", element.elementIdentifier],
+			["elementValue", encodeElementValue(element)]
+		]))))
+	};
+}
+//#endregion
+//#region src/issuerSigned/helpers/digest.ts
+async function digestItem(tag24Bytes) {
+	const buffer = await crypto.subtle.digest("SHA-256", tag24Bytes);
+	return new Uint8Array(buffer);
+}
+//#endregion
+//#region src/issuerSigned/issuerSignedItem.ts
+async function buildIssuerSignedItems(nameSpaces) {
+	const issuerSignedItemBytes = /* @__PURE__ */ new Map();
+	const valueDigests = /* @__PURE__ */ new Map();
+	const namespaceResults = await Promise.all([...nameSpaces].map(async ([namespace, elements]) => {
+		const usedIds = /* @__PURE__ */ new Set();
+		const items = elements.map((element) => buildSingleItem(element, usedIds));
+		const digestEntries = await Promise.all(items.map(async ({ digestId, tag24Bytes }) => [digestId, await digestItem(tag24Bytes)]));
+		return {
+			namespace,
+			itemBytes: items.map(({ tag24Bytes }) => tag24Bytes),
+			digests: new Map(digestEntries)
+		};
+	}));
+	for (const { namespace, itemBytes, digests } of namespaceResults) {
+		issuerSignedItemBytes.set(namespace, itemBytes);
+		valueDigests.set(namespace, digests);
+	}
+	return {
+		issuerSignedItemBytes,
+		valueDigests
+	};
+}
+//#endregion
+//#region src/issuerSigned/assembleIssuerSigned.ts
+function assembleIssuerSigned(nameSpaces, issuerAuth) {
+	const nameSpacesMap = /* @__PURE__ */ new Map();
+	for (const [namespace, items] of nameSpaces) nameSpacesMap.set(namespace, items.map((itemBytes) => embeddedCbor(itemBytes)));
+	const issuerSigned = /* @__PURE__ */ new Map();
+	issuerSigned.set("nameSpaces", nameSpacesMap);
+	issuerSigned.set("issuerAuth", issuerAuth);
+	return encode(issuerSigned);
+}
+//#endregion
+//#region src/validityInfo/buildValidityInfo.ts
+function buildValidityInfo(input) {
+	const signed = /* @__PURE__ */ new Date();
+	const validityInfo = {
+		signed,
+		validFrom: input.earliestValidFrom && input.earliestValidFrom > signed ? input.earliestValidFrom : signed,
+		validUntil: input.validUntil
+	};
+	if (input.expectedUpdate !== void 0) validityInfo.expectedUpdate = input.expectedUpdate;
+	return validityInfo;
+}
+//#endregion
+//#region src/mso/buildMso.ts
+function buildMso(input) {
+	const validityInfoMap = /* @__PURE__ */ new Map();
+	validityInfoMap.set("signed", tdate(input.validityInfo.signed));
+	validityInfoMap.set("validFrom", tdate(input.validityInfo.validFrom));
+	validityInfoMap.set("validUntil", tdate(input.validityInfo.validUntil));
+	if (input.validityInfo.expectedUpdate !== void 0) validityInfoMap.set("expectedUpdate", tdate(input.validityInfo.expectedUpdate));
+	const statusListMap = /* @__PURE__ */ new Map();
+	statusListMap.set("idx", input.statusList.idx);
+	statusListMap.set("uri", input.statusList.uri);
+	const statusMap = /* @__PURE__ */ new Map();
+	statusMap.set("status_list", statusListMap);
+	const mso = /* @__PURE__ */ new Map();
+	mso.set("version", "1.0");
+	mso.set("digestAlgorithm", "SHA-256");
+	mso.set("valueDigests", input.valueDigests);
+	mso.set("deviceKeyInfo", input.deviceKeyInfo);
+	mso.set("validityInfo", validityInfoMap);
+	mso.set("status", statusMap);
+	mso.set("docType", input.docType);
+	return encode(embeddedCbor(encode(mso)));
+}
+//#endregion
+//#region src/issuerAuth/buildProtectedHeader.ts
+const COSE_HEADER_ALG = 1;
+const COSE_ALG_ES256 = -7;
+function buildProtectedHeader() {
+	return encode(/* @__PURE__ */ new Map([[COSE_HEADER_ALG, COSE_ALG_ES256]]));
+}
+//#endregion
+//#region src/issuerAuth/buildUnprotectedHeader.ts
+const COSE_HEADER_X5CHAIN = 33;
+function buildUnprotectedHeader(certificateChain) {
+	const [signingCertificate] = certificateChain;
+	return /* @__PURE__ */ new Map([[COSE_HEADER_X5CHAIN, signingCertificate]]);
+}
+//#endregion
+//#region src/issuerAuth/buildToBeSigned.ts
+const SIG_STRUCTURE_CONTEXT = "Signature1";
+const EXTERNAL_AAD = /* @__PURE__ */ new Uint8Array(0);
+function buildToBeSigned(protectedHeaderBytes, payloadBytes) {
+	return encode([
+		SIG_STRUCTURE_CONTEXT,
+		protectedHeaderBytes,
+		EXTERNAL_AAD,
+		payloadBytes
+	]);
+}
+//#endregion
+//#region src/issuerAuth/assembleIssuerAuth.ts
+const EXPECTED_SIGNATURE_LENGTH = 64;
+async function assembleIssuerAuth(msoBytes, certificateChain, sign) {
+	const protectedHeader = buildProtectedHeader();
+	const unprotectedHeader = buildUnprotectedHeader(certificateChain);
+	const toBeSigned = buildToBeSigned(protectedHeader, msoBytes);
+	let signature;
+	try {
+		signature = await sign(toBeSigned);
+	} catch (error) {
+		throw new MdocBuilderError("Signing function threw an error", { cause: error });
+	}
+	if (!(signature instanceof Uint8Array)) throw new MdocBuilderError("Signing function must return a Uint8Array signature");
+	if (signature.length !== EXPECTED_SIGNATURE_LENGTH) throw new MdocBuilderError(`Invalid signature length: expected ${String(EXPECTED_SIGNATURE_LENGTH)} bytes, got ${String(signature.length)}`);
+	return [
+		protectedHeader,
+		unprotectedHeader,
+		msoBytes,
+		signature
+	];
+}
+//#endregion
+//#region src/mdoc/mdoc.ts
+var MdocOutput = class {
+	bytes;
+	constructor(bytes) {
+		this.bytes = Uint8Array.from(bytes);
+	}
+	asBase64Url() {
+		return Buffer.from(this.bytes).toString("base64url");
+	}
+	asHex() {
+		return Buffer.from(this.bytes).toString("hex");
+	}
+	asBytes() {
+		return Uint8Array.from(this.bytes);
+	}
+};
+//#endregion
+//#region src/index.ts
+/**
+* Builds an mdoc (ISO 18013-5) document from the provided input.
+*
+* @param input - The mdoc builder input containing document data and metadata.
+* @param sign - A signing function called with the `toBeSigned` bytes.
+* @returns A promise resolving to the built Mdoc document.
+* @throws {MdocBuilderError} If input validation fails, with the aggregated
+* violations in the message. Errors from any other component propagate to the
+* caller unchanged.
+*/
+async function buildMdoc(input, sign) {
+	const violations = validateMdocBuilderInput(input);
+	if (violations.length > 0) throw new MdocBuilderError("Input validation failed", { violations });
+	const deviceKeyInfo = buildDeviceKeyInfo(input.deviceKey, [...input.nameSpaces.keys()]);
+	const { issuerSignedItemBytes, valueDigests } = await buildIssuerSignedItems(input.nameSpaces);
+	const validityInfo = buildValidityInfo(input.credentialValidity);
+	return new MdocOutput(assembleIssuerSigned(issuerSignedItemBytes, await assembleIssuerAuth(buildMso({
+		docType: input.documentType,
+		valueDigests,
+		deviceKeyInfo,
+		validityInfo,
+		statusList: input.statusList
+	}), input.certificateChain, sign)));
+}
+//#endregion
+exports.DateFormat = DateFormat;
+exports.MdocBuilderError = MdocBuilderError;
+exports.buildMdoc = buildMdoc;
+
+//# sourceMappingURL=index.cjs.map