@bcts/provenance-mark 1.0.0-alpha.9 → 1.0.0-beta.1

package/dist/index.iife.js

@@ -1,58 +1,75 @@
-var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, __noble_hashes_hkdf, __noble_ciphers_chacha, __bcts_rand, __bcts_tags, __bcts_uniform_resources) {
-
-
-//#region src/error.ts
-/**
+var bctsProvenanceMark = (function(exports, _bcts_dcbor, _bcts_rand, _noble_hashes_sha2_js, _noble_hashes_hkdf_js, _noble_ciphers_chacha_js, _bcts_tags, _bcts_uniform_resources, _bcts_envelope) {
+	Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+	//#region src/error.ts
+	/**
+	* Copyright © 2023-2026 Blockchain Commons, LLC
+	* Copyright © 2025-2026 Parity Technologies
+	*
+	*/
+	/**
 	* Error types for Provenance Mark operations.
 	*/
-	let ProvenanceMarkErrorType = /* @__PURE__ */ function(ProvenanceMarkErrorType$1) {
+	let ProvenanceMarkErrorType = /* @__PURE__ */ function(ProvenanceMarkErrorType) {
 		/** Invalid Seed length */
-		ProvenanceMarkErrorType$1["InvalidSeedLength"] = "InvalidSeedLength";
+		ProvenanceMarkErrorType["InvalidSeedLength"] = "InvalidSeedLength";
 		/** Duplicate key */
-		ProvenanceMarkErrorType$1["DuplicateKey"] = "DuplicateKey";
+		ProvenanceMarkErrorType["DuplicateKey"] = "DuplicateKey";
 		/** Missing key */
-		ProvenanceMarkErrorType$1["MissingKey"] = "MissingKey";
+		ProvenanceMarkErrorType["MissingKey"] = "MissingKey";
 		/** Invalid key */
-		ProvenanceMarkErrorType$1["InvalidKey"] = "InvalidKey";
+		ProvenanceMarkErrorType["InvalidKey"] = "InvalidKey";
 		/** Extra keys */
-		ProvenanceMarkErrorType$1["ExtraKeys"] = "ExtraKeys";
+		ProvenanceMarkErrorType["ExtraKeys"] = "ExtraKeys";
 		/** Invalid key length for the given resolution */
-		ProvenanceMarkErrorType$1["InvalidKeyLength"] = "InvalidKeyLength";
+		ProvenanceMarkErrorType["InvalidKeyLength"] = "InvalidKeyLength";
 		/** Invalid next key length for the given resolution */
-		ProvenanceMarkErrorType$1["InvalidNextKeyLength"] = "InvalidNextKeyLength";
+		ProvenanceMarkErrorType["InvalidNextKeyLength"] = "InvalidNextKeyLength";
 		/** Invalid chain ID length for the given resolution */
-		ProvenanceMarkErrorType$1["InvalidChainIdLength"] = "InvalidChainIdLength";
+		ProvenanceMarkErrorType["InvalidChainIdLength"] = "InvalidChainIdLength";
 		/** Invalid message length for the given resolution */
-		ProvenanceMarkErrorType$1["InvalidMessageLength"] = "InvalidMessageLength";
+		ProvenanceMarkErrorType["InvalidMessageLength"] = "InvalidMessageLength";
 		/** Invalid CBOR data in info field */
-		ProvenanceMarkErrorType$1["InvalidInfoCbor"] = "InvalidInfoCbor";
+		ProvenanceMarkErrorType["InvalidInfoCbor"] = "InvalidInfoCbor";
 		/** Date out of range for serialization */
-		ProvenanceMarkErrorType$1["DateOutOfRange"] = "DateOutOfRange";
+		ProvenanceMarkErrorType["DateOutOfRange"] = "DateOutOfRange";
 		/** Invalid date components */
-		ProvenanceMarkErrorType$1["InvalidDate"] = "InvalidDate";
+		ProvenanceMarkErrorType["InvalidDate"] = "InvalidDate";
 		/** Missing required URL parameter */
-		ProvenanceMarkErrorType$1["MissingUrlParameter"] = "MissingUrlParameter";
+		ProvenanceMarkErrorType["MissingUrlParameter"] = "MissingUrlParameter";
 		/** Year out of range for 2-byte serialization */
-		ProvenanceMarkErrorType$1["YearOutOfRange"] = "YearOutOfRange";
+		ProvenanceMarkErrorType["YearOutOfRange"] = "YearOutOfRange";
 		/** Invalid month or day */
-		ProvenanceMarkErrorType$1["InvalidMonthOrDay"] = "InvalidMonthOrDay";
+		ProvenanceMarkErrorType["InvalidMonthOrDay"] = "InvalidMonthOrDay";
 		/** Resolution serialization error */
-		ProvenanceMarkErrorType$1["ResolutionError"] = "ResolutionError";
+		ProvenanceMarkErrorType["ResolutionError"] = "ResolutionError";
 		/** Bytewords encoding/decoding error */
-		ProvenanceMarkErrorType$1["BytewordsError"] = "BytewordsError";
+		ProvenanceMarkErrorType["BytewordsError"] = "BytewordsError";
 		/** CBOR encoding/decoding error */
-		ProvenanceMarkErrorType$1["CborError"] = "CborError";
+		ProvenanceMarkErrorType["CborError"] = "CborError";
 		/** URL parsing error */
-		ProvenanceMarkErrorType$1["UrlError"] = "UrlError";
+		ProvenanceMarkErrorType["UrlError"] = "UrlError";
 		/** Base64 decoding error */
-		ProvenanceMarkErrorType$1["Base64Error"] = "Base64Error";
+		ProvenanceMarkErrorType["Base64Error"] = "Base64Error";
 		/** JSON serialization error */
-		ProvenanceMarkErrorType$1["JsonError"] = "JsonError";
+		ProvenanceMarkErrorType["JsonError"] = "JsonError";
 		/** Integer conversion error */
-		ProvenanceMarkErrorType$1["IntegerConversionError"] = "IntegerConversionError";
+		ProvenanceMarkErrorType["IntegerConversionError"] = "IntegerConversionError";
 		/** Validation error */
-		ProvenanceMarkErrorType$1["ValidationError"] = "ValidationError";
-		return ProvenanceMarkErrorType$1;
+		ProvenanceMarkErrorType["ValidationError"] = "ValidationError";
+		/**
+		* Envelope serialization/deserialization error.
+		*
+		* Mirrors Rust `Error::Envelope(...)`
+		* (`provenance-mark-rust/src/error.rs`). The Rust enum surfaces
+		* envelope-format failures as their own variant; in earlier
+		* revisions of this port they collapsed into `CborError`. Both
+		* shapes are still emitted in practice (CBOR errors during envelope
+		* round-trip stay as `CborError`); this variant exists for the
+		* structural-level mismatches the Rust port tags as
+		* `Error::Envelope`.
+		*/
+		ProvenanceMarkErrorType["EnvelopeError"] = "EnvelopeError";
+		return ProvenanceMarkErrorType;
 	}({});
 	/**
 	* Error class for Provenance Mark operations.
@@ -75,37 +92,42 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 				return JSON.stringify(value);
 			};
 			switch (type) {
-				case ProvenanceMarkErrorType.InvalidSeedLength: return `invalid seed length: expected 32 bytes, got ${d("actual")} bytes`;
-				case ProvenanceMarkErrorType.DuplicateKey: return `duplicate key: ${d("key")}`;
-				case ProvenanceMarkErrorType.MissingKey: return `missing key: ${d("key")}`;
-				case ProvenanceMarkErrorType.InvalidKey: return `invalid key: ${d("key")}`;
-				case ProvenanceMarkErrorType.ExtraKeys: return `wrong number of keys: expected ${d("expected")}, got ${d("actual")}`;
-				case ProvenanceMarkErrorType.InvalidKeyLength: return `invalid key length: expected ${d("expected")}, got ${d("actual")}`;
-				case ProvenanceMarkErrorType.InvalidNextKeyLength: return `invalid next key length: expected ${d("expected")}, got ${d("actual")}`;
-				case ProvenanceMarkErrorType.InvalidChainIdLength: return `invalid chain ID length: expected ${d("expected")}, got ${d("actual")}`;
-				case ProvenanceMarkErrorType.InvalidMessageLength: return `invalid message length: expected at least ${d("expected")}, got ${d("actual")}`;
-				case ProvenanceMarkErrorType.InvalidInfoCbor: return "invalid CBOR data in info field";
-				case ProvenanceMarkErrorType.DateOutOfRange: return `date out of range: ${d("details")}`;
-				case ProvenanceMarkErrorType.InvalidDate: return `invalid date: ${d("details")}`;
-				case ProvenanceMarkErrorType.MissingUrlParameter: return `missing required URL parameter: ${d("parameter")}`;
-				case ProvenanceMarkErrorType.YearOutOfRange: return `year out of range for 2-byte serialization: must be between 2023-2150, got ${d("year")}`;
-				case ProvenanceMarkErrorType.InvalidMonthOrDay: return `invalid month (${d("month")}) or day (${d("day")}) for year ${d("year")}`;
-				case ProvenanceMarkErrorType.ResolutionError: return `resolution serialization error: ${d("details")}`;
-				case ProvenanceMarkErrorType.BytewordsError: return `bytewords error: ${d("message")}`;
-				case ProvenanceMarkErrorType.CborError: return `CBOR error: ${d("message")}`;
-				case ProvenanceMarkErrorType.UrlError: return `URL parsing error: ${d("message")}`;
-				case ProvenanceMarkErrorType.Base64Error: return `base64 decoding error: ${d("message")}`;
-				case ProvenanceMarkErrorType.JsonError: return `JSON error: ${d("message")}`;
-				case ProvenanceMarkErrorType.IntegerConversionError: return `integer conversion error: ${d("message")}`;
-				case ProvenanceMarkErrorType.ValidationError: return `validation error: ${d("message")}`;
+				case "InvalidSeedLength": return `invalid seed length: expected 32 bytes, got ${d("actual")} bytes`;
+				case "DuplicateKey": return `duplicate key: ${d("key")}`;
+				case "MissingKey": return `missing key: ${d("key")}`;
+				case "InvalidKey": return `invalid key: ${d("key")}`;
+				case "ExtraKeys": return `wrong number of keys: expected ${d("expected")}, got ${d("actual")}`;
+				case "InvalidKeyLength": return `invalid key length: expected ${d("expected")}, got ${d("actual")}`;
+				case "InvalidNextKeyLength": return `invalid next key length: expected ${d("expected")}, got ${d("actual")}`;
+				case "InvalidChainIdLength": return `invalid chain ID length: expected ${d("expected")}, got ${d("actual")}`;
+				case "InvalidMessageLength": return `invalid message length: expected at least ${d("expected")}, got ${d("actual")}`;
+				case "InvalidInfoCbor": return "invalid CBOR data in info field";
+				case "DateOutOfRange": return `date out of range: ${d("details")}`;
+				case "InvalidDate": return `invalid date: ${d("details")}`;
+				case "MissingUrlParameter": return `missing required URL parameter: ${d("parameter")}`;
+				case "YearOutOfRange": return `year out of range for 2-byte serialization: must be between 2023-2150, got ${d("year")}`;
+				case "InvalidMonthOrDay": return `invalid month (${d("month")}) or day (${d("day")}) for year ${d("year")}`;
+				case "ResolutionError": return `resolution serialization error: ${d("details")}`;
+				case "BytewordsError": return `bytewords error: ${d("message")}`;
+				case "CborError": return `CBOR error: ${d("message")}`;
+				case "UrlError": return `URL parsing error: ${d("message")}`;
+				case "Base64Error": return `base64 decoding error: ${d("message")}`;
+				case "JsonError": return `JSON error: ${d("message")}`;
+				case "IntegerConversionError": return `integer conversion error: ${d("message")}`;
+				case "ValidationError": return `validation error: ${d("message")}`;
+				case "EnvelopeError": return `envelope error: ${d("message")}`;
 				default: return type;
 			}
 		}
 	};
-
-//#endregion
-//#region src/date.ts
-/**
+	//#endregion
+	//#region src/date.ts
+	/**
+	* Copyright © 2023-2026 Blockchain Commons, LLC
+	* Copyright © 2025-2026 Parity Technologies
+	*
+	*/
+	/**
 	* Reference date for 4-byte and 6-byte serialization (2001-01-01T00:00:00Z).
 	*/
 	const REFERENCE_DATE = Date.UTC(2001, 0, 1, 0, 0, 0, 0);
@@ -136,8 +158,8 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 		const month = date.getUTCMonth() + 1;
 		const day = date.getUTCDate();
 		const yy = year - 2023;
-		if (yy < 0 || yy >= 128) throw new ProvenanceMarkError(ProvenanceMarkErrorType.YearOutOfRange, void 0, { year });
-		if (month < 1 || month > 12 || day < 1 || day > 31) throw new ProvenanceMarkError(ProvenanceMarkErrorType.InvalidMonthOrDay, void 0, {
+		if (yy < 0 || yy >= 128) throw new ProvenanceMarkError("YearOutOfRange", void 0, { year });
+		if (month < 1 || month > 12 || day < 1 || day > 31) throw new ProvenanceMarkError("InvalidMonthOrDay", void 0, {
 			year,
 			month,
 			day
@@ -152,12 +174,12 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 	* Deserialize 2 bytes to a date.
 	*/
 	function deserialize2Bytes(bytes) {
-		if (bytes.length !== 2) throw new ProvenanceMarkError(ProvenanceMarkErrorType.InvalidDate, void 0, { details: `expected 2 bytes, got ${bytes.length}` });
+		if (bytes.length !== 2) throw new ProvenanceMarkError("InvalidDate", void 0, { details: `expected 2 bytes, got ${bytes.length}` });
 		const value = bytes[0] << 8 | bytes[1];
 		const day = value & 31;
 		const month = value >> 5 & 15;
 		const year = (value >> 9 & 127) + 2023;
-		if (month < 1 || month > 12 || !isValidDay(year, month, day)) throw new ProvenanceMarkError(ProvenanceMarkErrorType.InvalidMonthOrDay, void 0, {
+		if (month < 1 || month > 12 || !isValidDay(year, month, day)) throw new ProvenanceMarkError("InvalidMonthOrDay", void 0, {
 			year,
 			month,
 			day
@@ -170,7 +192,7 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 	function serialize4Bytes(date) {
 		const duration = date.getTime() - REFERENCE_DATE;
 		const seconds = Math.floor(duration / 1e3);
-		if (seconds < 0 || seconds > 4294967295) throw new ProvenanceMarkError(ProvenanceMarkErrorType.DateOutOfRange, void 0, { details: "seconds value out of range for u32" });
+		if (seconds < 0 || seconds > 4294967295) throw new ProvenanceMarkError("DateOutOfRange", void 0, { details: "seconds value out of range for u32" });
 		const buf = new Uint8Array(4);
 		buf[0] = seconds >> 24 & 255;
 		buf[1] = seconds >> 16 & 255;
@@ -182,7 +204,7 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 	* Deserialize 4 bytes to a date.
 	*/
 	function deserialize4Bytes(bytes) {
-		if (bytes.length !== 4) throw new ProvenanceMarkError(ProvenanceMarkErrorType.InvalidDate, void 0, { details: `expected 4 bytes, got ${bytes.length}` });
+		if (bytes.length !== 4) throw new ProvenanceMarkError("InvalidDate", void 0, { details: `expected 4 bytes, got ${bytes.length}` });
 		const seconds = (bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3]) >>> 0;
 		return new Date(REFERENCE_DATE + seconds * 1e3);
 	}
@@ -192,7 +214,7 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 	function serialize6Bytes(date) {
 		const duration = date.getTime() - REFERENCE_DATE;
 		const milliseconds = BigInt(duration);
-		if (milliseconds < 0n || milliseconds > BigInt(MAX_6_BYTE_VALUE)) throw new ProvenanceMarkError(ProvenanceMarkErrorType.DateOutOfRange, void 0, { details: "date exceeds maximum representable value" });
+		if (milliseconds < 0n || milliseconds > BigInt(MAX_6_BYTE_VALUE)) throw new ProvenanceMarkError("DateOutOfRange", void 0, { details: "date exceeds maximum representable value" });
 		const buf = new Uint8Array(6);
 		buf[0] = Number(milliseconds >> 40n & 255n);
 		buf[1] = Number(milliseconds >> 32n & 255n);
@@ -206,9 +228,9 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 	* Deserialize 6 bytes to a date.
 	*/
 	function deserialize6Bytes(bytes) {
-		if (bytes.length !== 6) throw new ProvenanceMarkError(ProvenanceMarkErrorType.InvalidDate, void 0, { details: `expected 6 bytes, got ${bytes.length}` });
+		if (bytes.length !== 6) throw new ProvenanceMarkError("InvalidDate", void 0, { details: `expected 6 bytes, got ${bytes.length}` });
 		const milliseconds = BigInt(bytes[0]) << 40n | BigInt(bytes[1]) << 32n | BigInt(bytes[2]) << 24n | BigInt(bytes[3]) << 16n | BigInt(bytes[4]) << 8n | BigInt(bytes[5]);
-		if (milliseconds > BigInt(MAX_6_BYTE_VALUE)) throw new ProvenanceMarkError(ProvenanceMarkErrorType.DateOutOfRange, void 0, { details: "date exceeds maximum representable value" });
+		if (milliseconds > BigInt(MAX_6_BYTE_VALUE)) throw new ProvenanceMarkError("DateOutOfRange", void 0, { details: "date exceeds maximum representable value" });
 		return new Date(REFERENCE_DATE + Number(milliseconds));
 	}
 	/**
@@ -231,7 +253,7 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 	*/
 	function dateFromIso8601(str) {
 		const date = new Date(str);
-		if (isNaN(date.getTime())) throw new ProvenanceMarkError(ProvenanceMarkErrorType.InvalidDate, void 0, { details: `cannot parse date: ${str}` });
+		if (isNaN(date.getTime())) throw new ProvenanceMarkError("InvalidDate", void 0, { details: `cannot parse date: ${str}` });
 		return date;
 	}
 	/**
@@ -240,19 +262,50 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 	function dateToDateString(date) {
 		return `${date.getUTCFullYear()}-${(date.getUTCMonth() + 1).toString().padStart(2, "0")}-${date.getUTCDate().toString().padStart(2, "0")}`;
 	}
-
-//#endregion
-//#region src/resolution.ts
-/**
+	/**
+	* Renders a `Date` the way Rust's `dcbor::Date::Display` does
+	* (`bc-dcbor-rust/src/date.rs:485-492`):
+	*
+	* - When the UTC time is exactly `00:00:00` (subsecond precision is
+	*   ignored — Rust's check is `hour == 0 && minute == 0 && second == 0`,
+	*   matching `chrono::SecondsFormat::Secs`), emit just `YYYY-MM-DD`.
+	* - Otherwise emit RFC 3339 with second precision (no fractional
+	*   seconds), e.g. `2023-02-08T15:30:45Z`.
+	*
+	* This is the canonical "Rust string" for dates across the
+	* provenance-mark public surface — `mark.toDebugString`,
+	* `mark.precedesOpt` `DateOrdering` issue, `markdownSummary`, and the
+	* validation report's `DateOrdering` payload all use it. Centralising
+	* here keeps every call site in lockstep with the Rust output.
+	*
+	* @example
+	* ```typescript
+	* dateToDisplay(new Date("2023-06-20T00:00:00Z"));   // "2023-06-20"
+	* dateToDisplay(new Date("2023-06-20T15:30:45Z"));   // "2023-06-20T15:30:45Z"
+	* dateToDisplay(new Date("2023-06-20T15:30:45.123Z")); // "2023-06-20T15:30:45Z"
+	* ```
+	*/
+	function dateToDisplay(date) {
+		if (!(date.getUTCHours() !== 0 || date.getUTCMinutes() !== 0 || date.getUTCSeconds() !== 0)) return dateToDateString(date);
+		return date.toISOString().replace(/\.\d{3}Z$/, "Z");
+	}
+	//#endregion
+	//#region src/resolution.ts
+	/**
+	* Copyright © 2023-2026 Blockchain Commons, LLC
+	* Copyright © 2025-2026 Parity Technologies
+	*
+	*/
+	/**
 	* Resolution levels for provenance marks.
 	* Higher resolution provides more security but larger mark sizes.
 	*/
-	let ProvenanceMarkResolution = /* @__PURE__ */ function(ProvenanceMarkResolution$1) {
-		ProvenanceMarkResolution$1[ProvenanceMarkResolution$1["Low"] = 0] = "Low";
-		ProvenanceMarkResolution$1[ProvenanceMarkResolution$1["Medium"] = 1] = "Medium";
-		ProvenanceMarkResolution$1[ProvenanceMarkResolution$1["Quartile"] = 2] = "Quartile";
-		ProvenanceMarkResolution$1[ProvenanceMarkResolution$1["High"] = 3] = "High";
-		return ProvenanceMarkResolution$1;
+	let ProvenanceMarkResolution = /* @__PURE__ */ function(ProvenanceMarkResolution) {
+		ProvenanceMarkResolution[ProvenanceMarkResolution["Low"] = 0] = "Low";
+		ProvenanceMarkResolution[ProvenanceMarkResolution["Medium"] = 1] = "Medium";
+		ProvenanceMarkResolution[ProvenanceMarkResolution["Quartile"] = 2] = "Quartile";
+		ProvenanceMarkResolution[ProvenanceMarkResolution["High"] = 3] = "High";
+		return ProvenanceMarkResolution;
 	}({});
 	/**
 	* Convert a resolution to its numeric value.
@@ -265,11 +318,11 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 	*/
 	function resolutionFromNumber(value) {
 		switch (value) {
-			case 0: return ProvenanceMarkResolution.Low;
-			case 1: return ProvenanceMarkResolution.Medium;
-			case 2: return ProvenanceMarkResolution.Quartile;
-			case 3: return ProvenanceMarkResolution.High;
-			default: throw new ProvenanceMarkError(ProvenanceMarkErrorType.ResolutionError, void 0, { details: `invalid provenance mark resolution value: ${value}` });
+			case 0: return 0;
+			case 1: return 1;
+			case 2: return 2;
+			case 3: return 3;
+			default: throw new ProvenanceMarkError("ResolutionError", void 0, { details: `invalid provenance mark resolution value: ${value}` });
 		}
 	}
 	/**
@@ -277,10 +330,10 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 	*/
 	function linkLength(res) {
 		switch (res) {
-			case ProvenanceMarkResolution.Low: return 4;
-			case ProvenanceMarkResolution.Medium: return 8;
-			case ProvenanceMarkResolution.Quartile: return 16;
-			case ProvenanceMarkResolution.High: return 32;
+			case 0: return 4;
+			case 1: return 8;
+			case 2: return 16;
+			case 3: return 32;
 		}
 	}
 	/**
@@ -288,10 +341,10 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 	*/
 	function seqBytesLength(res) {
 		switch (res) {
-			case ProvenanceMarkResolution.Low: return 2;
-			case ProvenanceMarkResolution.Medium:
-			case ProvenanceMarkResolution.Quartile:
-			case ProvenanceMarkResolution.High: return 4;
+			case 0: return 2;
+			case 1:
+			case 2:
+			case 3: return 4;
 		}
 	}
 	/**
@@ -299,10 +352,10 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 	*/
 	function dateBytesLength(res) {
 		switch (res) {
-			case ProvenanceMarkResolution.Low: return 2;
-			case ProvenanceMarkResolution.Medium: return 4;
-			case ProvenanceMarkResolution.Quartile:
-			case ProvenanceMarkResolution.High: return 6;
+			case 0: return 2;
+			case 1: return 4;
+			case 2:
+			case 3: return 6;
 		}
 	}
 	/**
@@ -370,10 +423,10 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 	*/
 	function serializeDate(res, date) {
 		switch (res) {
-			case ProvenanceMarkResolution.Low: return serialize2Bytes(date);
-			case ProvenanceMarkResolution.Medium: return serialize4Bytes(date);
-			case ProvenanceMarkResolution.Quartile:
-			case ProvenanceMarkResolution.High: return serialize6Bytes(date);
+			case 0: return serialize2Bytes(date);
+			case 1: return serialize4Bytes(date);
+			case 2:
+			case 3: return serialize6Bytes(date);
 		}
 	}
 	/**
@@ -381,46 +434,55 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 	*/
 	function deserializeDate(res, data) {
 		switch (res) {
-			case ProvenanceMarkResolution.Low:
-				if (data.length !== 2) throw new ProvenanceMarkError(ProvenanceMarkErrorType.ResolutionError, void 0, { details: `invalid date length: expected 2 bytes, got ${data.length}` });
+			case 0:
+				if (data.length !== 2) throw new ProvenanceMarkError("ResolutionError", void 0, { details: `invalid date length: expected 2 bytes, got ${data.length}` });
 				return deserialize2Bytes(data);
-			case ProvenanceMarkResolution.Medium:
-				if (data.length !== 4) throw new ProvenanceMarkError(ProvenanceMarkErrorType.ResolutionError, void 0, { details: `invalid date length: expected 4 bytes, got ${data.length}` });
+			case 1:
+				if (data.length !== 4) throw new ProvenanceMarkError("ResolutionError", void 0, { details: `invalid date length: expected 4 bytes, got ${data.length}` });
 				return deserialize4Bytes(data);
-			case ProvenanceMarkResolution.Quartile:
-			case ProvenanceMarkResolution.High:
-				if (data.length !== 6) throw new ProvenanceMarkError(ProvenanceMarkErrorType.ResolutionError, void 0, { details: `invalid date length: expected 6 bytes, got ${data.length}` });
+			case 2:
+			case 3:
+				if (data.length !== 6) throw new ProvenanceMarkError("ResolutionError", void 0, { details: `invalid date length: expected 6 bytes, got ${data.length}` });
 				return deserialize6Bytes(data);
 		}
 	}
 	/**
 	* Serialize a sequence number into bytes based on the resolution.
+	*
+	* Mirrors Rust's typed `u32` parameter (`generator.rs::serialize_seq`)
+	* — the input must be a non-negative integer in `[0, 2^32-1]` (a u32).
+	* For Low resolution the upper bound additionally narrows to `2^16-1`
+	* (a u16) per Rust `if seq > 0xFFFF`. Earlier revisions of this port
+	* accepted any JS `number` for the 4-byte branch and would silently
+	* truncate values above `2^32-1`; now we raise `ResolutionError` so
+	* the wire output never deviates from Rust's u32 contract.
 	*/
 	function serializeSeq(res, seq) {
+		if (!Number.isInteger(seq) || seq < 0) throw new ProvenanceMarkError("ResolutionError", void 0, { details: `sequence number must be a non-negative integer, got ${seq}` });
 		if (seqBytesLength(res) === 2) {
-			if (seq > 65535) throw new ProvenanceMarkError(ProvenanceMarkErrorType.ResolutionError, void 0, { details: `sequence number ${seq} out of range for 2-byte format (max 65535)` });
+			if (seq > 65535) throw new ProvenanceMarkError("ResolutionError", void 0, { details: `sequence number ${seq} out of range for 2-byte format (max 65535)` });
 			const buf = new Uint8Array(2);
 			buf[0] = seq >> 8 & 255;
 			buf[1] = seq & 255;
 			return buf;
-		} else {
-			const buf = new Uint8Array(4);
-			buf[0] = seq >> 24 & 255;
-			buf[1] = seq >> 16 & 255;
-			buf[2] = seq >> 8 & 255;
-			buf[3] = seq & 255;
-			return buf;
 		}
+		if (seq > 4294967295) throw new ProvenanceMarkError("ResolutionError", void 0, { details: `sequence number ${seq} out of range for 4-byte format (max 4294967295)` });
+		const buf = new Uint8Array(4);
+		buf[0] = seq >>> 24 & 255;
+		buf[1] = seq >>> 16 & 255;
+		buf[2] = seq >>> 8 & 255;
+		buf[3] = seq & 255;
+		return buf;
 	}
 	/**
 	* Deserialize bytes into a sequence number based on the resolution.
 	*/
 	function deserializeSeq(res, data) {
 		if (seqBytesLength(res) === 2) {
-			if (data.length !== 2) throw new ProvenanceMarkError(ProvenanceMarkErrorType.ResolutionError, void 0, { details: `invalid sequence number length: expected 2 bytes, got ${data.length}` });
+			if (data.length !== 2) throw new ProvenanceMarkError("ResolutionError", void 0, { details: `invalid sequence number length: expected 2 bytes, got ${data.length}` });
 			return data[0] << 8 | data[1];
 		} else {
-			if (data.length !== 4) throw new ProvenanceMarkError(ProvenanceMarkErrorType.ResolutionError, void 0, { details: `invalid sequence number length: expected 4 bytes, got ${data.length}` });
+			if (data.length !== 4) throw new ProvenanceMarkError("ResolutionError", void 0, { details: `invalid sequence number length: expected 4 bytes, got ${data.length}` });
 			return (data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3]) >>> 0;
 		}
 	}
@@ -429,34 +491,38 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 	*/
 	function resolutionToString(res) {
 		switch (res) {
-			case ProvenanceMarkResolution.Low: return "low";
-			case ProvenanceMarkResolution.Medium: return "medium";
-			case ProvenanceMarkResolution.Quartile: return "quartile";
-			case ProvenanceMarkResolution.High: return "high";
+			case 0: return "low";
+			case 1: return "medium";
+			case 2: return "quartile";
+			case 3: return "high";
 		}
 	}
 	/**
 	* Convert a resolution to CBOR.
 	*/
 	function resolutionToCbor(res) {
-		return (0, __bcts_dcbor.cbor)(res);
+		return (0, _bcts_dcbor.cbor)(res);
 	}
 	/**
 	* Create a resolution from CBOR.
 	*/
 	function resolutionFromCbor(cborValue) {
-		const value = (0, __bcts_dcbor.expectUnsigned)(cborValue);
+		const value = (0, _bcts_dcbor.expectUnsigned)(cborValue);
 		return resolutionFromNumber(Number(value));
 	}
-
-//#endregion
-//#region src/crypto-utils.ts
+	//#endregion
+	//#region src/crypto-utils.ts
+	/**
+	* Copyright © 2023-2026 Blockchain Commons, LLC
+	* Copyright © 2025-2026 Parity Technologies
+	*
+	*/
 	const SHA256_SIZE = 32;
 	/**
 	* Compute SHA-256 hash of data.
 	*/
 	function sha256(data) {
-		return (0, __noble_hashes_sha256.sha256)(data);
+		return (0, _noble_hashes_sha2_js.sha256)(data);
 	}
 	/**
 	* Compute SHA-256 hash and return a prefix of the given length.
@@ -474,7 +540,7 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 	* Compute HKDF-HMAC-SHA-256 for the given key material.
 	*/
 	function hkdfHmacSha256(keyMaterial, salt, keyLen) {
-		return (0, __noble_hashes_hkdf.hkdf)(__noble_hashes_sha256.sha256, keyMaterial, salt.length > 0 ? salt : void 0, new Uint8Array(0), keyLen);
+		return (0, _noble_hashes_hkdf_js.hkdf)(_noble_hashes_sha2_js.sha256, keyMaterial, salt.length > 0 ? salt : void 0, new Uint8Array(0), keyLen);
 	}
 	/**
 	* Obfuscate (or deobfuscate) a message using ChaCha20.
@@ -485,12 +551,183 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 		const extendedKey = extendKey(key instanceof Uint8Array ? key : new Uint8Array(key));
 		const iv = new Uint8Array(12);
 		for (let i = 0; i < 12; i++) iv[i] = extendedKey[31 - i];
-		return (0, __noble_ciphers_chacha.chacha20)(extendedKey, iv, message instanceof Uint8Array ? message : new Uint8Array(message));
+		return (0, _noble_ciphers_chacha_js.chacha20)(extendedKey, iv, message instanceof Uint8Array ? message : new Uint8Array(message));
 	}
-
-//#endregion
-//#region src/xoshiro256starstar.ts
-/**
+	//#endregion
+	//#region src/seed.ts
+	/**
+	* Copyright © 2023-2026 Blockchain Commons, LLC
+	* Copyright © 2025-2026 Parity Technologies
+	*
+	*/
+	const PROVENANCE_SEED_LENGTH = 32;
+	/**
+	* A seed for generating provenance marks.
+	*/
+	var ProvenanceSeed = class ProvenanceSeed {
+		data;
+		constructor(data) {
+			this.data = data;
+		}
+		/**
+		* Create a new random seed using secure random number generation.
+		*/
+		static new() {
+			const data = (0, _bcts_rand.randomData)(32);
+			return ProvenanceSeed.fromBytes(data);
+		}
+		/**
+		* Create a new seed using custom random data.
+		*/
+		static newUsing(randomData) {
+			if (randomData.length < 32) throw new ProvenanceMarkError("InvalidSeedLength", void 0, { actual: randomData.length });
+			return ProvenanceSeed.fromBytes(randomData.slice(0, 32));
+		}
+		/**
+		* Create a new seed from a passphrase.
+		*/
+		static newWithPassphrase(passphrase) {
+			const seedData = extendKey(new TextEncoder().encode(passphrase));
+			return ProvenanceSeed.fromBytes(seedData);
+		}
+		/**
+		* Get the raw bytes.
+		*/
+		toBytes() {
+			return new Uint8Array(this.data);
+		}
+		/**
+		* Create from a 32-byte array.
+		*/
+		static fromBytes(bytes) {
+			if (bytes.length !== 32) throw new ProvenanceMarkError("InvalidSeedLength", void 0, { actual: bytes.length });
+			return new ProvenanceSeed(new Uint8Array(bytes));
+		}
+		/**
+		* Create from a slice (validates length).
+		*/
+		static fromSlice(bytes) {
+			return ProvenanceSeed.fromBytes(bytes);
+		}
+		/**
+		* Get the hex representation.
+		*/
+		hex() {
+			return Array.from(this.data).map((b) => b.toString(16).padStart(2, "0")).join("");
+		}
+		/**
+		* Convert to CBOR (byte string).
+		*/
+		toCbor() {
+			return (0, _bcts_dcbor.cbor)(this.data);
+		}
+		/**
+		* Create from CBOR (byte string).
+		*/
+		static fromCbor(cborValue) {
+			const bytes = (0, _bcts_dcbor.expectBytes)(cborValue);
+			return ProvenanceSeed.fromBytes(bytes);
+		}
+	};
+	//#endregion
+	//#region src/utils.ts
+	/**
+	* Copyright © 2023-2026 Blockchain Commons, LLC
+	* Copyright © 2025-2026 Parity Technologies
+	*
+	*
+	* Utility functions for byte array conversions.
+	*
+	* These functions provide cross-platform support for common byte manipulation
+	* operations needed in provenance mark encoding.
+	*/
+	/**
+	* Convert a Uint8Array to a lowercase hexadecimal string.
+	*
+	* @param data - The byte array to convert
+	* @returns A lowercase hex string representation (2 characters per byte)
+	*/
+	function bytesToHex(data) {
+		return Array.from(data).map((b) => b.toString(16).padStart(2, "0")).join("");
+	}
+	/**
+	* Convert a Uint8Array to a base64-encoded string.
+	*
+	* This function works in both browser and Node.js environments.
+	*
+	* @param data - The byte array to encode
+	* @returns A base64-encoded string
+	*/
+	function toBase64(data) {
+		let binary = "";
+		for (const byte of data) binary += String.fromCharCode(byte);
+		return btoa(binary);
+	}
+	/**
+	* Convert a base64-encoded string to a Uint8Array.
+	*
+	* This function works in both browser and Node.js environments.
+	*
+	* @param base64 - A base64-encoded string
+	* @returns The decoded byte array
+	*/
+	function fromBase64(base64) {
+		const binary = atob(base64);
+		const bytes = new Uint8Array(binary.length);
+		for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+		return bytes;
+	}
+	/**
+	* Parse a base64-encoded provenance seed.
+	*
+	* Mirrors Rust's `parse_seed` user helper
+	* (`provenance-mark-rust/src/util.rs:34-38`), which round-trips the
+	* input through serde JSON / `deserialize_block` and so requires the
+	* decoded bytes to be exactly {@link PROVENANCE_SEED_LENGTH} (32) long.
+	* The TS equivalent decodes the base64 directly and delegates to
+	* {@link ProvenanceSeed.fromBytes} for the length check.
+	*
+	* @param s - Base64-encoded 32-byte seed string.
+	* @returns The decoded {@link ProvenanceSeed}.
+	* @throws {ProvenanceMarkError} If the input is not valid base64 or the
+	*   decoded length is not exactly 32 bytes.
+	*/
+	function parseSeed(s) {
+		let bytes;
+		try {
+			bytes = fromBase64(s);
+		} catch (e) {
+			throw new ProvenanceMarkError("Base64Error", "invalid base64 encoding for provenance seed", { details: e instanceof Error ? e.message : String(e) });
+		}
+		return ProvenanceSeed.fromBytes(bytes);
+	}
+	/**
+	* Parse a date string (`YYYY-MM-DD` or full RFC 3339) into a `Date`.
+	*
+	* Mirrors Rust's `parse_date` user helper
+	* (`provenance-mark-rust/src/util.rs:40-42`), which delegates to
+	* `Date::from_string` (the same parser the JSON deserializer uses).
+	* Accepts the same shapes the Rust parser does:
+	*
+	* - `YYYY-MM-DD` (interpreted as UTC midnight, matching JS spec).
+	* - Full RFC 3339, e.g. `2023-06-20T15:30:45Z` or
+	*   `2023-06-20T15:30:45.123Z`.
+	*
+	* @throws {ProvenanceMarkError} If the input fails to parse.
+	*/
+	function parseDate(s) {
+		const date = new Date(s);
+		if (Number.isNaN(date.getTime())) throw new ProvenanceMarkError("InvalidDate", `cannot parse date: ${s}`);
+		return date;
+	}
+	//#endregion
+	//#region src/xoshiro256starstar.ts
+	/**
+	* Copyright © 2023-2026 Blockchain Commons, LLC
+	* Copyright © 2025-2026 Parity Technologies
+	*
+	*/
+	/**
 	* Xoshiro256** PRNG implementation.
 	* A fast, high-quality pseudorandom number generator.
 	*/
@@ -610,9 +847,13 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 			this.s[3] = this.rotateLeft64(this.s[3], 45n);
 		}
 	};
-
-//#endregion
-//#region src/rng-state.ts
+	//#endregion
+	//#region src/rng-state.ts
+	/**
+	* Copyright © 2023-2026 Blockchain Commons, LLC
+	* Copyright © 2025-2026 Parity Technologies
+	*
+	*/
 	const RNG_STATE_LENGTH = 32;
 	/**
 	* RNG state for provenance marks (32 bytes).
@@ -632,7 +873,7 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 		* Create from a 32-byte array.
 		*/
 		static fromBytes(bytes) {
-			if (bytes.length !== RNG_STATE_LENGTH) throw new ProvenanceMarkError(ProvenanceMarkErrorType.InvalidSeedLength, void 0, { actual: bytes.length });
+			if (bytes.length !== 32) throw new ProvenanceMarkError("InvalidSeedLength", void 0, { actual: bytes.length });
 			return new RngState(new Uint8Array(bytes));
 		}
 		/**
@@ -651,149 +892,302 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 		* Convert to CBOR (byte string).
 		*/
 		toCbor() {
-			return (0, __bcts_dcbor.cbor)(this.data);
+			return (0, _bcts_dcbor.cbor)(this.data);
 		}
 		/**
 		* Create from CBOR (byte string).
 		*/
 		static fromCbor(cborValue) {
-			const bytes = (0, __bcts_dcbor.expectBytes)(cborValue);
+			const bytes = (0, _bcts_dcbor.expectBytes)(cborValue);
 			return RngState.fromBytes(bytes);
 		}
 	};
-
-//#endregion
-//#region src/seed.ts
-	const PROVENANCE_SEED_LENGTH = 32;
+	//#endregion
+	//#region src/validate.ts
 	/**
-	* A seed for generating provenance marks.
+	* Format for validation report output.
 	*/
-	var ProvenanceSeed = class ProvenanceSeed {
-		data;
-		constructor(data) {
-			this.data = data;
-		}
-		/**
-		* Create a new random seed using secure random number generation.
-		*/
-		static new() {
-			const data = (0, __bcts_rand.randomData)(PROVENANCE_SEED_LENGTH);
-			return ProvenanceSeed.fromBytes(data);
-		}
-		/**
-		* Create a new seed using custom random data.
-		*/
-		static newUsing(randomData$1) {
-			if (randomData$1.length < PROVENANCE_SEED_LENGTH) throw new ProvenanceMarkError(ProvenanceMarkErrorType.InvalidSeedLength, void 0, { actual: randomData$1.length });
-			return ProvenanceSeed.fromBytes(randomData$1.slice(0, PROVENANCE_SEED_LENGTH));
-		}
-		/**
-		* Create a new seed from a passphrase.
-		*/
-		static newWithPassphrase(passphrase) {
-			const seedData = extendKey(new TextEncoder().encode(passphrase));
-			return ProvenanceSeed.fromBytes(seedData);
-		}
-		/**
-		* Get the raw bytes.
-		*/
-		toBytes() {
-			return new Uint8Array(this.data);
-		}
-		/**
-		* Create from a 32-byte array.
-		*/
-		static fromBytes(bytes) {
-			if (bytes.length !== PROVENANCE_SEED_LENGTH) throw new ProvenanceMarkError(ProvenanceMarkErrorType.InvalidSeedLength, void 0, { actual: bytes.length });
-			return new ProvenanceSeed(new Uint8Array(bytes));
-		}
-		/**
-		* Create from a slice (validates length).
-		*/
-		static fromSlice(bytes) {
-			return ProvenanceSeed.fromBytes(bytes);
-		}
-		/**
-		* Get the hex representation.
-		*/
-		hex() {
-			return Array.from(this.data).map((b) => b.toString(16).padStart(2, "0")).join("");
-		}
-		/**
-		* Convert to CBOR (byte string).
-		*/
-		toCbor() {
-			return (0, __bcts_dcbor.cbor)(this.data);
-		}
-		/**
-		* Create from CBOR (byte string).
-		*/
-		static fromCbor(cborValue) {
-			const bytes = (0, __bcts_dcbor.expectBytes)(cborValue);
-			return ProvenanceSeed.fromBytes(bytes);
-		}
-	};
-
-//#endregion
-//#region src/utils.ts
-/**
-	* Convert a Uint8Array to a lowercase hexadecimal string.
-	*
-	* @param data - The byte array to convert
-	* @returns A lowercase hex string representation (2 characters per byte)
+	let ValidationReportFormat = /* @__PURE__ */ function(ValidationReportFormat) {
+		/** Human-readable text format */
+		ValidationReportFormat["Text"] = "text";
+		/** Compact JSON format (no whitespace) */
+		ValidationReportFormat["JsonCompact"] = "json-compact";
+		/** Pretty-printed JSON format (with indentation) */
+		ValidationReportFormat["JsonPretty"] = "json-pretty";
+		return ValidationReportFormat;
+	}({});
+	/**
+	* Format a validation issue as a string.
 	*/
-	function bytesToHex(data) {
-		return Array.from(data).map((b) => b.toString(16).padStart(2, "0")).join("");
+	function formatValidationIssue(issue) {
+		switch (issue.type) {
+			case "HashMismatch": return `hash mismatch: expected ${issue.expected}, got ${issue.actual}`;
+			case "KeyMismatch": return "key mismatch: current hash was not generated from next key";
+			case "SequenceGap": return `sequence number gap: expected ${issue.expected}, got ${issue.actual}`;
+			case "DateOrdering": return `date must be equal or later: previous is ${issue.previous}, next is ${issue.next}`;
+			case "NonGenesisAtZero": return "non-genesis mark at sequence 0";
+			case "InvalidGenesisKey": return "genesis mark must have key equal to chain_id";
+		}
 	}
 	/**
-	* Convert a Uint8Array to a base64-encoded string.
-	*
-	* This function works in both browser and Node.js environments.
-	*
-	* @param data - The byte array to encode
-	* @returns A base64-encoded string
+	* Get the chain ID as a hex string for display.
 	*/
-	function toBase64(data) {
-		const globalBtoa = globalThis.btoa;
-		if (typeof globalBtoa === "function") {
-			let binary = "";
-			for (const byte of data) binary += String.fromCharCode(byte);
-			return globalBtoa(binary);
-		}
-		const requireFn = require;
-		if (typeof requireFn === "function") {
-			const { Buffer: NodeBuffer } = requireFn("buffer");
-			return NodeBuffer.from(data).toString("base64");
-		}
-		throw new Error("btoa not available and require is not defined");
+	function chainIdHex(report) {
+		return hexEncode(report.chainId);
 	}
 	/**
-	* Convert a base64-encoded string to a Uint8Array.
-	*
-	* This function works in both browser and Node.js environments.
-	*
-	* @param base64 - A base64-encoded string
-	* @returns The decoded byte array
+	* Check if the validation report has any issues.
 	*/
-	function fromBase64(base64) {
-		const globalAtob = globalThis.atob;
-		if (typeof globalAtob === "function") {
-			const binary = globalAtob(base64);
-			const bytes = new Uint8Array(binary.length);
-			for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
-			return bytes;
-		}
-		const requireFn = require;
-		if (typeof requireFn === "function") {
-			const { Buffer: NodeBuffer } = requireFn("buffer");
-			return new Uint8Array(NodeBuffer.from(base64, "base64"));
-		}
-		throw new Error("atob not available and require is not defined");
-	}
-
-//#endregion
-//#region src/mark.ts
-/**
+	function hasIssues(report) {
+		for (const chain of report.chains) if (!chain.hasGenesis) return true;
+		for (const chain of report.chains) for (const seq of chain.sequences) for (const mark of seq.marks) if (mark.issues.length > 0) return true;
+		if (report.chains.length > 1) return true;
+		if (report.chains.length === 1 && report.chains[0].sequences.length > 1) return true;
+		return false;
+	}
+	/**
+	* Check if the validation report contains interesting information.
+	*/
+	function isInteresting(report) {
+		if (report.chains.length === 0) return false;
+		for (const chain of report.chains) if (!chain.hasGenesis) return true;
+		if (report.chains.length === 1) {
+			const chain = report.chains[0];
+			if (chain.sequences.length === 1) {
+				if (chain.sequences[0].marks.every((m) => m.issues.length === 0)) return false;
+			}
+		}
+		return true;
+	}
+	/**
+	* Format the validation report as human-readable text.
+	*/
+	function formatText(report) {
+		if (!isInteresting(report)) return "";
+		const lines = [];
+		lines.push(`Total marks: ${report.marks.length}`);
+		lines.push(`Chains: ${report.chains.length}`);
+		lines.push("");
+		for (let chainIdx = 0; chainIdx < report.chains.length; chainIdx++) {
+			const chain = report.chains[chainIdx];
+			const chainIdStr = chainIdHex(chain);
+			const shortChainId = chainIdStr.length > 8 ? chainIdStr.slice(0, 8) : chainIdStr;
+			lines.push(`Chain ${chainIdx + 1}: ${shortChainId}`);
+			if (!chain.hasGenesis) lines.push("  Warning: No genesis mark found");
+			for (const seq of chain.sequences) for (const flaggedMark of seq.marks) {
+				const mark = flaggedMark.mark;
+				const shortId = mark.idHex().slice(0, 8);
+				const seqNum = mark.seq();
+				const annotations = [];
+				if (mark.isGenesis()) annotations.push("genesis mark");
+				for (const issue of flaggedMark.issues) {
+					let issueStr;
+					switch (issue.type) {
+						case "SequenceGap":
+							issueStr = `gap: ${issue.expected} missing`;
+							break;
+						case "DateOrdering":
+							issueStr = `date ${issue.previous} < ${issue.next}`;
+							break;
+						case "HashMismatch":
+							issueStr = "hash mismatch";
+							break;
+						case "KeyMismatch":
+							issueStr = "key mismatch";
+							break;
+						case "NonGenesisAtZero":
+							issueStr = "non-genesis at seq 0";
+							break;
+						case "InvalidGenesisKey":
+							issueStr = "invalid genesis key";
+							break;
+					}
+					annotations.push(issueStr);
+				}
+				if (annotations.length === 0) lines.push(`  ${seqNum}: ${shortId}`);
+				else lines.push(`  ${seqNum}: ${shortId} (${annotations.join(", ")})`);
+			}
+			lines.push("");
+		}
+		return lines.join("\n").trimEnd();
+	}
+	/**
+	* Format the validation report.
+	*/
+	function formatReport(report, format) {
+		switch (format) {
+			case "text": return formatText(report);
+			case "json-compact": return JSON.stringify(reportToJSON(report));
+			case "json-pretty": return JSON.stringify(reportToJSON(report), null, 2);
+		}
+	}
+	/**
+	* Convert a report to a JSON-serializable object.
+	*/
+	function reportToJSON(report) {
+		return {
+			marks: report.marks.map((m) => m.urString()),
+			chains: report.chains.map((chain) => ({
+				chain_id: hexEncode(chain.chainId),
+				has_genesis: chain.hasGenesis,
+				marks: chain.marks.map((m) => m.urString()),
+				sequences: chain.sequences.map((seq) => ({
+					start_seq: seq.startSeq,
+					end_seq: seq.endSeq,
+					marks: seq.marks.map((fm) => ({
+						mark: fm.mark.urString(),
+						issues: fm.issues.map(issueToJSON)
+					}))
+				}))
+			}))
+		};
+	}
+	/**
+	* Convert a ValidationIssue to JSON matching Rust's serde format.
+	*
+	* Rust uses `#[serde(tag = "type", content = "data")]` which wraps
+	* struct variant data in a `"data"` field. Unit variants have no
+	* `"data"` field.
+	*/
+	function issueToJSON(issue) {
+		switch (issue.type) {
+			case "HashMismatch": return {
+				type: "HashMismatch",
+				data: {
+					expected: issue.expected,
+					actual: issue.actual
+				}
+			};
+			case "SequenceGap": return {
+				type: "SequenceGap",
+				data: {
+					expected: issue.expected,
+					actual: issue.actual
+				}
+			};
+			case "DateOrdering": return {
+				type: "DateOrdering",
+				data: {
+					previous: issue.previous,
+					next: issue.next
+				}
+			};
+			case "KeyMismatch": return { type: "KeyMismatch" };
+			case "NonGenesisAtZero": return { type: "NonGenesisAtZero" };
+			case "InvalidGenesisKey": return { type: "InvalidGenesisKey" };
+		}
+	}
+	/**
+	* Build sequence bins for a chain.
+	*/
+	function buildSequenceBins(marks) {
+		const sequences = [];
+		let currentSequence = [];
+		for (let i = 0; i < marks.length; i++) {
+			const mark = marks[i];
+			if (i === 0) currentSequence.push({
+				mark,
+				issues: []
+			});
+			else {
+				const prev = marks[i - 1];
+				try {
+					prev.precedesOpt(mark);
+					currentSequence.push({
+						mark,
+						issues: []
+					});
+				} catch (e) {
+					if (currentSequence.length > 0) sequences.push(createSequenceReport(currentSequence));
+					let issue;
+					if (e instanceof ProvenanceMarkError && e.details?.["validationIssue"] !== void 0) issue = e.details["validationIssue"];
+					else issue = { type: "KeyMismatch" };
+					currentSequence = [{
+						mark,
+						issues: [issue]
+					}];
+				}
+			}
+		}
+		if (currentSequence.length > 0) sequences.push(createSequenceReport(currentSequence));
+		return sequences;
+	}
+	/**
+	* Create a sequence report from flagged marks.
+	*/
+	function createSequenceReport(marks) {
+		return {
+			startSeq: marks.length > 0 ? marks[0].mark.seq() : 0,
+			endSeq: marks.length > 0 ? marks[marks.length - 1].mark.seq() : 0,
+			marks
+		};
+	}
+	/**
+	* Validate a collection of provenance marks.
+	*/
+	function validate(marks) {
+		const seen = /* @__PURE__ */ new Set();
+		const deduplicatedMarks = [];
+		for (const mark of marks) {
+			const key = `${mark.res()}:${hexEncode(mark.message())}`;
+			if (!seen.has(key)) {
+				seen.add(key);
+				deduplicatedMarks.push(mark);
+			}
+		}
+		const chainBins = /* @__PURE__ */ new Map();
+		for (const mark of deduplicatedMarks) {
+			const chainIdKey = hexEncode(mark.chainId());
+			const bin = chainBins.get(chainIdKey);
+			if (bin !== void 0) bin.push(mark);
+			else chainBins.set(chainIdKey, [mark]);
+		}
+		const chains = [];
+		for (const [chainIdKey, chainMarks] of chainBins) {
+			chainMarks.sort((a, b) => a.seq() - b.seq());
+			const hasGenesis = chainMarks.length > 0 && chainMarks[0].seq() === 0 && chainMarks[0].isGenesis();
+			const sequences = buildSequenceBins(chainMarks);
+			chains.push({
+				chainId: hexDecode(chainIdKey),
+				hasGenesis,
+				marks: chainMarks,
+				sequences
+			});
+		}
+		chains.sort((a, b) => {
+			const aHex = hexEncode(a.chainId);
+			const bHex = hexEncode(b.chainId);
+			if (aHex < bHex) return -1;
+			if (aHex > bHex) return 1;
+			return 0;
+		});
+		return {
+			marks: deduplicatedMarks,
+			chains
+		};
+	}
+	/**
+	* Helper function to encode bytes as hex.
+	*/
+	function hexEncode(bytes) {
+		return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+	}
+	/**
+	* Helper function to decode hex to bytes.
+	*/
+	function hexDecode(hex) {
+		const bytes = new Uint8Array(hex.length / 2);
+		for (let i = 0; i < hex.length; i += 2) bytes[i / 2] = parseInt(hex.slice(i, i + 2), 16);
+		return bytes;
+	}
+	//#endregion
+	//#region src/mark.ts
+	/**
+	* Copyright © 2023-2026 Blockchain Commons, LLC
+	* Copyright © 2025-2026 Parity Technologies
+	*
+	*/
+	/**
 	* A cryptographically-secured provenance mark.
 	*/
 	var ProvenanceMark = class ProvenanceMark {
@@ -860,29 +1254,29 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 		*/
 		info() {
 			if (this._infoBytes.length === 0) return;
-			return (0, __bcts_dcbor.decodeCbor)(this._infoBytes);
+			return (0, _bcts_dcbor.decodeCbor)(this._infoBytes);
 		}
 		/**
 		* Create a new provenance mark.
 		*/
 		static new(res, key, nextKey, chainId, seq, date, info) {
 			const linkLen = linkLength(res);
-			if (key.length !== linkLen) throw new ProvenanceMarkError(ProvenanceMarkErrorType.InvalidKeyLength, void 0, {
+			if (key.length !== linkLen) throw new ProvenanceMarkError("InvalidKeyLength", void 0, {
 				expected: linkLen,
 				actual: key.length
 			});
-			if (nextKey.length !== linkLen) throw new ProvenanceMarkError(ProvenanceMarkErrorType.InvalidNextKeyLength, void 0, {
+			if (nextKey.length !== linkLen) throw new ProvenanceMarkError("InvalidNextKeyLength", void 0, {
 				expected: linkLen,
 				actual: nextKey.length
 			});
-			if (chainId.length !== linkLen) throw new ProvenanceMarkError(ProvenanceMarkErrorType.InvalidChainIdLength, void 0, {
+			if (chainId.length !== linkLen) throw new ProvenanceMarkError("InvalidChainIdLength", void 0, {
 				expected: linkLen,
 				actual: chainId.length
 			});
 			const dateBytes = serializeDate(res, date);
 			const seqBytes = serializeSeq(res, seq);
 			const normalizedDate = deserializeDate(res, dateBytes);
-			const infoBytes = info !== void 0 ? (0, __bcts_dcbor.cborData)(info) : new Uint8Array(0);
+			const infoBytes = info !== void 0 ? (0, _bcts_dcbor.cborData)(info) : new Uint8Array(0);
 			const hash = ProvenanceMark.makeHash(res, key, nextKey, chainId, seqBytes, dateBytes, infoBytes);
 			return new ProvenanceMark(res, new Uint8Array(key), hash, new Uint8Array(chainId), seqBytes, dateBytes, infoBytes, seq, normalizedDate);
 		}
@@ -891,7 +1285,7 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 		*/
 		static fromMessage(res, message) {
 			const minLen = fixedLength(res);
-			if (message.length < minLen) throw new ProvenanceMarkError(ProvenanceMarkErrorType.InvalidMessageLength, void 0, {
+			if (message.length < minLen) throw new ProvenanceMarkError("InvalidMessageLength", void 0, {
 				expected: minLen,
 				actual: message.length
 			});
@@ -912,9 +1306,9 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 			const infoStart = infoRangeStart(res);
 			const infoBytes = payload.slice(infoStart);
 			if (infoBytes.length > 0) try {
-				(0, __bcts_dcbor.decodeCbor)(infoBytes);
+				(0, _bcts_dcbor.decodeCbor)(infoBytes);
 			} catch {
-				throw new ProvenanceMarkError(ProvenanceMarkErrorType.InvalidInfoCbor);
+				throw new ProvenanceMarkError("InvalidInfoCbor");
 			}
 			return new ProvenanceMark(res, new Uint8Array(key), new Uint8Array(hash), new Uint8Array(chainId), new Uint8Array(seqBytes), new Uint8Array(dateBytes), new Uint8Array(infoBytes), seq, date);
 		}
@@ -929,24 +1323,174 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 			]), linkLength(res));
 		}
 		/**
-		* Get the first four bytes of the hash as a hex string identifier.
+		* The 32-byte Mark ID.
+		*
+		* The first `linkLength` bytes are the mark's stored hash. The remaining
+		* bytes come from the mark's fingerprint (SHA-256 of CBOR encoding),
+		* ensuring a full 32-byte value is always available regardless of
+		* resolution.
+		*/
+		id() {
+			const result = new Uint8Array(32);
+			const n = this._hash.length;
+			result.set(this._hash, 0);
+			if (n < 32) {
+				const fp = this.fingerprint();
+				result.set(fp.subarray(0, 32 - n), n);
+			}
+			return result;
+		}
+		/**
+		* The full 32-byte Mark ID as a 64-character hex string.
+		*/
+		idHex() {
+			return bytesToHex(this.id());
+		}
+		/**
+		* The first `wordCount` bytes of the Mark ID as upper-case ByteWords.
+		*
+		* @param wordCount Number of bytes to encode, must be in `4..=32`.
+		* @param prefix If `true`, prepends the provenance-mark prefix character.
+		* @throws if `wordCount` is not in the range `4..=32`.
+		*/
+		idBytewords(wordCount, prefix) {
+			if (!Number.isInteger(wordCount) || wordCount < 4 || wordCount > 32) throw new Error(`word_count must be 4..=32, got ${wordCount}`);
+			const s = (0, _bcts_uniform_resources.encodeToWords)(this.id().subarray(0, wordCount)).toUpperCase();
+			return prefix ? `\u{1F15F} ${s}` : s;
+		}
+		/**
+		* The first `wordCount` bytes of the Mark ID as Bytemoji.
+		*
+		* @param wordCount Number of bytes to encode, must be in `4..=32`.
+		* @param prefix If `true`, prepends the provenance-mark prefix character.
+		* @throws if `wordCount` is not in the range `4..=32`.
+		*/
+		idBytemoji(wordCount, prefix) {
+			if (!Number.isInteger(wordCount) || wordCount < 4 || wordCount > 32) throw new Error(`word_count must be 4..=32, got ${wordCount}`);
+			const s = (0, _bcts_uniform_resources.encodeToBytemojis)(this.id().subarray(0, wordCount)).toUpperCase();
+			return prefix ? `\u{1F15F} ${s}` : s;
+		}
+		/**
+		* The first `wordCount` bytes of the Mark ID as upper-case minimal
+		* ByteWords (2 letters per byte, concatenated without separator).
+		*
+		* @param wordCount Number of bytes to encode, must be in `4..=32`.
+		* @param prefix If `true`, prepends the provenance-mark prefix character.
+		* @throws if `wordCount` is not in the range `4..=32`.
+		*/
+		idBytewordsMinimal(wordCount, prefix) {
+			if (!Number.isInteger(wordCount) || wordCount < 4 || wordCount > 32) throw new Error(`word_count must be 4..=32, got ${wordCount}`);
+			const s = (0, _bcts_uniform_resources.encodeToMinimalBytewords)(this.id().subarray(0, wordCount)).toUpperCase();
+			return prefix ? `\u{1F15F} ${s}` : s;
+		}
+		/**
+		* Legacy 8-character hex identifier — the first 4 bytes of the Mark ID.
+		*
+		* @deprecated Use {@link idHex} for the full 64-char hex, or
+		*   `idHex().slice(0, 8)` for this legacy short form. Retained for
+		*   backwards compatibility; will be removed in a future alpha.
 		*/
 		identifier() {
-			return Array.from(this._hash.slice(0, 4)).map((b) => b.toString(16).padStart(2, "0")).join("");
+			return this.idHex().slice(0, 8);
 		}
 		/**
-		* Get the first four bytes of the hash as upper-case ByteWords.
+		* Legacy 4-byte upper-case ByteWords identifier.
+		*
+		* @deprecated Equivalent to `idBytewords(4, prefix)`. Retained for
+		*   backwards compatibility; will be removed in a future alpha.
 		*/
 		bytewordsIdentifier(prefix) {
-			const s = (0, __bcts_uniform_resources.encodeBytewordsIdentifier)(this._hash.slice(0, 4)).toUpperCase();
-			return prefix ? `\u{1F151} ${s}` : s;
+			return this.idBytewords(4, prefix);
+		}
+		/**
+		* Legacy 8-letter minimal ByteWords identifier (first+last letter of each
+		* of the 4 ByteWords). Example: "ABLE ACID ALSO APEX" -> "AEADAOAX".
+		*
+		* @deprecated Equivalent to `idBytewordsMinimal(4, prefix)`. Retained
+		*   for backwards compatibility; will be removed in a future alpha.
+		*/
+		bytewordsMinimalIdentifier(prefix) {
+			return this.idBytewordsMinimal(4, prefix);
 		}
 		/**
-		* Get the first four bytes of the hash as Bytemoji.
+		* Legacy 4-byte upper-case Bytemoji identifier.
+		*
+		* @deprecated Equivalent to `idBytemoji(4, prefix)`. Retained for
+		*   backwards compatibility; will be removed in a future alpha.
 		*/
 		bytemojiIdentifier(prefix) {
-			const s = (0, __bcts_uniform_resources.encodeBytemojisIdentifier)(this._hash.slice(0, 4)).toUpperCase();
-			return prefix ? `\u{1F151} ${s}` : s;
+			return this.idBytemoji(4, prefix);
+		}
+		/**
+		* Computes the minimum prefix length (in bytes, `4..=32`) each mark needs
+		* so that every mark in the set has a unique Mark ID prefix.
+		*
+		* Non-colliding marks get the minimum of 4. Only marks whose 4-byte
+		* prefixes collide are extended.
+		*/
+		static minimalNoncollidingPrefixLengths(ids) {
+			const n = ids.length;
+			const lengths = new Array(n).fill(4);
+			const groups = /* @__PURE__ */ new Map();
+			for (let i = 0; i < n; i++) {
+				const key = bytesToHex(ids[i].subarray(0, 4));
+				const g = groups.get(key);
+				if (g !== void 0) g.push(i);
+				else groups.set(key, [i]);
+			}
+			for (const indices of groups.values()) {
+				if (indices.length <= 1) continue;
+				ProvenanceMark.resolveCollisionGroup(ids, indices, lengths);
+			}
+			return lengths;
+		}
+		static resolveCollisionGroup(ids, initialIndices, lengths) {
+			let unresolved = [...initialIndices];
+			for (let prefixLen = 5; prefixLen <= 32; prefixLen++) {
+				const subGroups = /* @__PURE__ */ new Map();
+				for (const i of unresolved) {
+					const key = bytesToHex(ids[i].subarray(0, prefixLen));
+					const g = subGroups.get(key);
+					if (g !== void 0) g.push(i);
+					else subGroups.set(key, [i]);
+				}
+				const nextUnresolved = [];
+				for (const subIndices of subGroups.values()) if (subIndices.length === 1) lengths[subIndices[0]] = prefixLen;
+				else nextUnresolved.push(...subIndices);
+				if (nextUnresolved.length === 0) return;
+				unresolved = nextUnresolved;
+			}
+			for (const i of unresolved) lengths[i] = 32;
+		}
+		/**
+		* Returns disambiguated upper-case ByteWords Mark IDs for a set of marks.
+		*
+		* Non-colliding marks get 4-word identifiers. Only marks whose 4-byte
+		* prefixes collide are extended with additional words (up to 32 bytes
+		* per identifier).
+		*/
+		static disambiguatedIdBytewords(marks, prefix) {
+			const ids = marks.map((m) => m.id());
+			const lengths = ProvenanceMark.minimalNoncollidingPrefixLengths(ids);
+			return ids.map((id, i) => {
+				const s = (0, _bcts_uniform_resources.encodeToWords)(id.subarray(0, lengths[i])).toUpperCase();
+				return prefix ? `\u{1F15F} ${s}` : s;
+			});
+		}
+		/**
+		* Returns disambiguated Bytemoji Mark IDs for a set of marks.
+		*
+		* Non-colliding marks get 4-emoji identifiers. Only marks whose 4-byte
+		* prefixes collide are extended with additional emojis (up to 32 bytes
+		* per identifier).
+		*/
+		static disambiguatedIdBytemoji(marks, prefix) {
+			const ids = marks.map((m) => m.id());
+			const lengths = ProvenanceMark.minimalNoncollidingPrefixLengths(ids);
+			return ids.map((id, i) => {
+				const s = (0, _bcts_uniform_resources.encodeToBytemojis)(id.subarray(0, lengths[i])).toUpperCase();
+				return prefix ? `\u{1F15F} ${s}` : s;
+			});
 		}
 		/**
 		* Check if this mark precedes another mark in the chain.
@@ -961,18 +1505,39 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 		}
 		/**
 		* Check if this mark precedes another mark, throwing on validation errors.
+		* Errors carry a structured `validationIssue` in their details, matching Rust's
+		* `Error::Validation(ValidationIssue)` pattern.
 		*/
 		precedesOpt(next) {
-			if (next._seq === 0) throw new ProvenanceMarkError(ProvenanceMarkErrorType.ValidationError, void 0, { message: "non-genesis mark at sequence 0" });
-			if (arraysEqual(next._key, next._chainId)) throw new ProvenanceMarkError(ProvenanceMarkErrorType.ValidationError, void 0, { message: "genesis mark must have key equal to chain_id" });
-			if (this._seq !== next._seq - 1) throw new ProvenanceMarkError(ProvenanceMarkErrorType.ValidationError, void 0, { message: `sequence gap: expected ${this._seq + 1}, got ${next._seq}` });
-			if (this._date > next._date) throw new ProvenanceMarkError(ProvenanceMarkErrorType.ValidationError, void 0, { message: `date ordering: ${this._date.toISOString()} > ${next._date.toISOString()}` });
+			if (next._seq === 0) throw new ProvenanceMarkError("ValidationError", "non-genesis mark at sequence 0", { validationIssue: { type: "NonGenesisAtZero" } });
+			if (arraysEqual(next._key, next._chainId)) throw new ProvenanceMarkError("ValidationError", "genesis mark must have key equal to chain_id", { validationIssue: { type: "InvalidGenesisKey" } });
+			if (this._seq !== next._seq - 1) {
+				const issue = {
+					type: "SequenceGap",
+					expected: this._seq + 1,
+					actual: next._seq
+				};
+				throw new ProvenanceMarkError("ValidationError", `sequence gap: expected ${this._seq + 1}, got ${next._seq}`, { validationIssue: issue });
+			}
+			if (this._date > next._date) {
+				const dateStr = dateToDisplay(this._date);
+				const nextDateStr = dateToDisplay(next._date);
+				const issue = {
+					type: "DateOrdering",
+					previous: dateStr,
+					next: nextDateStr
+				};
+				throw new ProvenanceMarkError("ValidationError", `date ordering: ${dateStr} > ${nextDateStr}`, { validationIssue: issue });
+			}
 			const expectedHash = ProvenanceMark.makeHash(this._res, this._key, next._key, this._chainId, this._seqBytes, this._dateBytes, this._infoBytes);
-			if (!arraysEqual(this._hash, expectedHash)) throw new ProvenanceMarkError(ProvenanceMarkErrorType.ValidationError, void 0, {
-				message: "hash mismatch",
-				expected: Array.from(expectedHash).map((b) => b.toString(16).padStart(2, "0")).join(""),
-				actual: Array.from(this._hash).map((b) => b.toString(16).padStart(2, "0")).join("")
-			});
+			if (!arraysEqual(this._hash, expectedHash)) {
+				const issue = {
+					type: "HashMismatch",
+					expected: bytesToHex(expectedHash),
+					actual: bytesToHex(this._hash)
+				};
+				throw new ProvenanceMarkError("ValidationError", `hash mismatch: expected ${bytesToHex(expectedHash)}, got ${bytesToHex(this._hash)}`, { validationIssue: issue });
+			}
 		}
 		/**
 		* Check if a sequence of marks is valid.
@@ -993,35 +1558,61 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 		* Encode as bytewords with the given style.
 		*/
 		toBytewordsWithStyle(style) {
-			return (0, __bcts_uniform_resources.encodeBytewords)(this.message(), style);
+			return (0, _bcts_uniform_resources.encodeBytewords)(this.message(), style);
 		}
 		/**
 		* Encode as standard bytewords.
 		*/
 		toBytewords() {
-			return this.toBytewordsWithStyle(__bcts_uniform_resources.BytewordsStyle.Standard);
+			return this.toBytewordsWithStyle(_bcts_uniform_resources.BytewordsStyle.Standard);
 		}
 		/**
 		* Decode from bytewords.
 		*/
 		static fromBytewords(res, bytewords) {
-			const message = (0, __bcts_uniform_resources.decodeBytewords)(bytewords, __bcts_uniform_resources.BytewordsStyle.Standard);
+			const message = (0, _bcts_uniform_resources.decodeBytewords)(bytewords, _bcts_uniform_resources.BytewordsStyle.Standard);
 			return ProvenanceMark.fromMessage(res, message);
 		}
 		/**
-		* Encode for URL (minimal bytewords of CBOR).
+		* Encode for URL (minimal bytewords of tagged CBOR).
 		*/
 		toUrlEncoding() {
-			return (0, __bcts_uniform_resources.encodeBytewords)(this.toCborData(), __bcts_uniform_resources.BytewordsStyle.Minimal);
+			return (0, _bcts_uniform_resources.encodeBytewords)(this.toCborData(), _bcts_uniform_resources.BytewordsStyle.Minimal);
 		}
 		/**
 		* Decode from URL encoding.
 		*/
 		static fromUrlEncoding(urlEncoding) {
-			const cborValue = (0, __bcts_dcbor.decodeCbor)((0, __bcts_uniform_resources.decodeBytewords)(urlEncoding, __bcts_uniform_resources.BytewordsStyle.Minimal));
+			const cborValue = (0, _bcts_dcbor.decodeCbor)((0, _bcts_uniform_resources.decodeBytewords)(urlEncoding, _bcts_uniform_resources.BytewordsStyle.Minimal));
 			return ProvenanceMark.fromTaggedCbor(cborValue);
 		}
 		/**
+		* Returns the {@link UR} representation of this mark (untagged CBOR
+		* with type `"provenance"`).
+		*
+		* Mirrors Rust `UREncodable::ur()` for `ProvenanceMark` — the
+		* blanket impl on `CBORTaggedEncodable` produces a UR whose
+		* payload is the *untagged* CBOR (the type name itself stands in
+		* for the tag). See `bc-ur-rust/src/ur_encodable.rs:8-18`.
+		*/
+		ur() {
+			return _bcts_uniform_resources.UR.new("provenance", this.untaggedCbor());
+		}
+		/**
+		* Get the UR string representation (e.g., "ur:provenance/...").
+		*/
+		urString() {
+			return this.ur().string();
+		}
+		/**
+		* Create from a UR string.
+		*/
+		static fromURString(urString) {
+			const ur = _bcts_uniform_resources.UR.fromURString(urString);
+			if (ur.urTypeStr() !== "provenance") throw new ProvenanceMarkError("CborError", void 0, { message: `Expected UR type 'provenance', got '${ur.urTypeStr()}'` });
+			return ProvenanceMark.fromUntaggedCbor(ur.cbor());
+		}
+		/**
 		* Build a URL with this mark as a query parameter.
 		*/
 		toUrl(base) {
@@ -1034,21 +1625,21 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 		*/
 		static fromUrl(url) {
 			const param = url.searchParams.get("provenance");
-			if (param === null || param === "") throw new ProvenanceMarkError(ProvenanceMarkErrorType.MissingUrlParameter, void 0, { parameter: "provenance" });
+			if (param === null || param === "") throw new ProvenanceMarkError("MissingUrlParameter", void 0, { parameter: "provenance" });
 			return ProvenanceMark.fromUrlEncoding(param);
 		}
 		/**
 		* Get the untagged CBOR representation.
 		*/
 		untaggedCbor() {
-			return (0, __bcts_dcbor.cbor)([resolutionToCbor(this._res), (0, __bcts_dcbor.cbor)(this.message())]);
+			return (0, _bcts_dcbor.cbor)([resolutionToCbor(this._res), (0, _bcts_dcbor.cbor)(this.message())]);
 		}
 		/**
 		* Get the tagged CBOR representation.
 		*/
 		taggedCbor() {
-			return (0, __bcts_dcbor.cbor)({
-				tag: __bcts_tags.PROVENANCE_MARK.value,
+			return (0, _bcts_dcbor.cbor)({
+				tag: _bcts_tags.PROVENANCE_MARK.value,
 				value: this.untaggedCbor()
 			});
 		}
@@ -1056,16 +1647,16 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 		* Serialize to CBOR bytes (tagged).
 		*/
 		toCborData() {
-			return (0, __bcts_dcbor.cborData)(this.taggedCbor());
+			return (0, _bcts_dcbor.cborData)(this.taggedCbor());
 		}
 		/**
 		* Create from untagged CBOR.
 		*/
 		static fromUntaggedCbor(cborValue) {
-			const arr = (0, __bcts_dcbor.expectArray)(cborValue);
-			if (arr.length !== 2) throw new ProvenanceMarkError(ProvenanceMarkErrorType.CborError, void 0, { message: "Invalid provenance mark length" });
+			const arr = (0, _bcts_dcbor.expectArray)(cborValue);
+			if (arr.length !== 2) throw new ProvenanceMarkError("CborError", void 0, { message: "Invalid provenance mark length" });
 			const res = resolutionFromCbor(arr[0]);
-			const message = (0, __bcts_dcbor.expectBytes)(arr[1]);
+			const message = (0, _bcts_dcbor.expectBytes)(arr[1]);
 			return ProvenanceMark.fromMessage(res, message);
 		}
 		/**
@@ -1073,15 +1664,15 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 		*/
 		static fromTaggedCbor(cborValue) {
 			const cborObj = cborValue;
-			if (cborObj.tag !== __bcts_tags.PROVENANCE_MARK.value) throw new ProvenanceMarkError(ProvenanceMarkErrorType.CborError, void 0, { message: `Expected tag ${__bcts_tags.PROVENANCE_MARK.value}, got ${String(cborObj.tag)}` });
-			if (cborObj.value === void 0) throw new ProvenanceMarkError(ProvenanceMarkErrorType.CborError, void 0, { message: "Tagged CBOR value is missing" });
+			if (cborObj.tag !== _bcts_tags.PROVENANCE_MARK.value) throw new ProvenanceMarkError("CborError", void 0, { message: `Expected tag ${_bcts_tags.PROVENANCE_MARK.value}, got ${String(cborObj.tag)}` });
+			if (cborObj.value === void 0) throw new ProvenanceMarkError("CborError", void 0, { message: "Tagged CBOR value is missing" });
 			return ProvenanceMark.fromUntaggedCbor(cborObj.value);
 		}
 		/**
 		* Create from CBOR bytes.
 		*/
 		static fromCborData(data) {
-			const cborValue = (0, __bcts_dcbor.decodeCbor)(data);
+			const cborValue = (0, _bcts_dcbor.decodeCbor)(data);
 			return ProvenanceMark.fromTaggedCbor(cborValue);
 		}
 		/**
@@ -1092,23 +1683,42 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 		}
 		/**
 		* Debug string representation.
+		*
+		* As of provenance-mark v0.24, this includes the full 64-character Mark ID
+		* hex (matching rust's `Display` impl). Pre-v0.24 callers that depended on
+		* the 8-character prefix should use `idHex().slice(0, 8)` directly.
 		*/
 		toString() {
-			return `ProvenanceMark(${this.identifier()})`;
+			return `ProvenanceMark(${this.idHex()})`;
 		}
 		/**
 		* Detailed debug representation.
+		*
+		* Mirrors Rust `Mark::Debug` exactly: every field is rendered
+		* Rust-style (hex bytes for keys/hashes/IDs, plain integer for
+		* `seq`, `Date::Display` for the date). The Low-resolution test
+		* vector in Rust `tests/mark.rs::test_low_resolution` ends with
+		* `date: 2023-06-20` — i.e. midnight-UTC dates are rendered without
+		* a time suffix. We use {@link dateToDisplay} to mirror that
+		* exactly; earlier revisions of this port stripped just the
+		* `.000Z` fractional component, which left `2023-06-20T00:00:00Z`
+		* and broke the Low-resolution debug-string parity.
 		*/
 		toDebugString() {
+			const dateStr = dateToDisplay(this._date);
 			const components = [
 				`key: ${bytesToHex(this._key)}`,
 				`hash: ${bytesToHex(this._hash)}`,
 				`chainID: ${bytesToHex(this._chainId)}`,
 				`seq: ${this._seq}`,
-				`date: ${this._date.toISOString()}`
+				`date: ${dateStr}`
 			];
 			const info = this.info();
-			if (info !== void 0) components.push(`info: ${JSON.stringify(info)}`);
+			if (info !== void 0) {
+				const textValue = info.asText();
+				if (textValue !== void 0) components.push(`info: "${textValue}"`);
+				else components.push(`info: ${info.toDiagnostic()}`);
+			}
 			return `ProvenanceMark(${components.join(", ")})`;
 		}
 		/**
@@ -1118,16 +1728,20 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 			return this._res === other._res && arraysEqual(this.message(), other.message());
 		}
 		/**
-		* JSON serialization.
+		* JSON serialization. Field order, names, and date format mirror Rust's
+		* `#[derive(Serialize)]` on `ProvenanceMark` (provenance-mark-rust/src/mark.rs):
+		* `seq, date, res, chain_id, key, hash[, info_bytes]`. The date uses
+		* `dateToDisplay()` (date-only when midnight, RFC3339-seconds with `Z`
+		* otherwise), matching Rust's `serialize_iso8601` / `Date::to_string()`.
 		*/
 		toJSON() {
 			const result = {
+				seq: this._seq,
+				date: dateToDisplay(this._date),
 				res: this._res,
+				chain_id: toBase64(this._chainId),
 				key: toBase64(this._key),
-				hash: toBase64(this._hash),
-				chainID: toBase64(this._chainId),
-				seq: this._seq,
-				date: this._date.toISOString()
+				hash: toBase64(this._hash)
 			};
 			if (this._infoBytes.length > 0) result["info_bytes"] = toBase64(this._infoBytes);
 			return result;
@@ -1139,16 +1753,55 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 			const res = json["res"];
 			const key = fromBase64(json["key"]);
 			const hash = fromBase64(json["hash"]);
-			const chainId = fromBase64(json["chainID"]);
+			const chainId = fromBase64(json["chain_id"] ?? json["chainID"]);
 			const seq = json["seq"];
 			const dateStr = json["date"];
 			const date = new Date(dateStr);
 			const seqBytes = serializeSeq(res, seq);
 			const dateBytes = serializeDate(res, date);
 			let infoBytes = new Uint8Array(0);
-			if (typeof json["info_bytes"] === "string") infoBytes = fromBase64(json["info_bytes"]);
+			if (typeof json["info_bytes"] === "string") {
+				infoBytes = fromBase64(json["info_bytes"]);
+				if (infoBytes.length > 0) try {
+					(0, _bcts_dcbor.decodeCbor)(infoBytes);
+				} catch (e) {
+					throw new ProvenanceMarkError("CborError", "info_bytes is not valid CBOR", { details: e instanceof Error ? e.message : String(e) });
+				}
+			}
 			return new ProvenanceMark(res, key, hash, chainId, seqBytes, dateBytes, infoBytes, seq, date);
 		}
+		/**
+		* Validate a collection of provenance marks.
+		*
+		* Matches Rust: `ProvenanceMark::validate()` which delegates to
+		* `ValidationReport::validate()`.
+		*/
+		static validate(marks) {
+			return validate(marks);
+		}
+		/**
+		* Convert this provenance mark to a Gordian Envelope.
+		*
+		* Creates a leaf envelope containing the tagged CBOR representation.
+		* Matches Rust: `Envelope::new(mark.to_cbor())` which creates a CBOR leaf.
+		*/
+		intoEnvelope() {
+			return _bcts_envelope.Envelope.newLeaf(this.taggedCbor());
+		}
+		/**
+		* Extract a ProvenanceMark from a Gordian Envelope.
+		*
+		* Matches Rust: `envelope.subject().try_leaf()?.try_into()`
+		*
+		* @param envelope - The envelope to extract from
+		* @returns The extracted provenance mark
+		* @throws ProvenanceMarkError if extraction fails
+		*/
+		static fromEnvelope(envelope) {
+			const leaf = envelope.subject().asLeaf();
+			if (leaf !== void 0) return ProvenanceMark.fromTaggedCbor(leaf);
+			throw new ProvenanceMarkError("CborError", void 0, { message: "Could not extract ProvenanceMark from envelope" });
+		}
 	};
 	/**
 	* Helper function to compare two Uint8Arrays.
@@ -1158,10 +1811,14 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 		for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
 		return true;
 	}
-
-//#endregion
-//#region src/generator.ts
-/**
+	//#endregion
+	//#region src/generator.ts
+	/**
+	* Copyright © 2023-2026 Blockchain Commons, LLC
+	* Copyright © 2025-2026 Parity Technologies
+	*
+	*/
+	/**
 	* Generator for creating provenance mark chains.
 	*/
 	var ProvenanceMarkGenerator = class ProvenanceMarkGenerator {
@@ -1211,8 +1868,8 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 		/**
 		* Create a new generator with custom random data.
 		*/
-		static newUsing(res, randomData$1) {
-			const seed = ProvenanceSeed.newUsing(randomData$1);
+		static newUsing(res, randomData) {
+			const seed = ProvenanceSeed.newUsing(randomData);
 			return ProvenanceMarkGenerator.newWithSeed(res, seed);
 		}
 		/**
@@ -1227,7 +1884,7 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 		*/
 		static new(res, seed, chainId, nextSeq, rngState) {
 			const linkLen = linkLength(res);
-			if (chainId.length !== linkLen) throw new ProvenanceMarkError(ProvenanceMarkErrorType.InvalidChainIdLength, void 0, {
+			if (chainId.length !== linkLen) throw new ProvenanceMarkError("InvalidChainIdLength", void 0, {
 				expected: linkLen,
 				actual: chainId.length
 			});
@@ -1253,9 +1910,24 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 		}
 		/**
 		* String representation.
+		*
+		* Mirrors Rust `Display for ProvenanceMarkGenerator`
+		* (`provenance-mark-rust/src/generator.rs:135-147`):
+		*
+		* ```rust
+		* write!(f, "ProvenanceMarkGenerator(chainID: {}, res: {}, seed: {}, nextSeq: {}, rngState: {:?})",
+		*     hex::encode(&self.chain_id), self.res, self.seed.hex(), self.next_seq, self.rng_state)
+		* ```
+		*
+		* The `rngState` field uses Rust's `{:?}` (Debug) format, which on a
+		* `RngState([u8; 32])` tuple struct produces `RngState([n0, n1, ...])`
+		* with each byte rendered as a decimal integer. Earlier revisions of
+		* this port omitted `rngState` entirely from `toString()`, so the
+		* output diverged from Rust's `Display`.
 		*/
 		toString() {
-			return `ProvenanceMarkGenerator(chainID: ${bytesToHex(this._chainId)}, res: ${this._res}, seed: ${this._seed.hex()}, nextSeq: ${this._nextSeq})`;
+			const rngBytes = Array.from(this._rngState.toBytes()).join(", ");
+			return `ProvenanceMarkGenerator(chainID: ${bytesToHex(this._chainId)}, res: ${this._res}, seed: ${this._seed.hex()}, nextSeq: ${this._nextSeq}, rngState: RngState([${rngBytes}]))`;
 		}
 		/**
 		* JSON serialization.
@@ -1280,281 +1952,67 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 			const rngState = RngState.fromBytes(fromBase64(json["rngState"]));
 			return ProvenanceMarkGenerator.new(res, seed, chainId, nextSeq, rngState);
 		}
-	};
-
-//#endregion
-//#region src/validate.ts
-/**
-	* Format for validation report output.
-	*/
-	let ValidationReportFormat = /* @__PURE__ */ function(ValidationReportFormat$1) {
-		/** Human-readable text format */
-		ValidationReportFormat$1["Text"] = "text";
-		/** Compact JSON format (no whitespace) */
-		ValidationReportFormat$1["JsonCompact"] = "json-compact";
-		/** Pretty-printed JSON format (with indentation) */
-		ValidationReportFormat$1["JsonPretty"] = "json-pretty";
-		return ValidationReportFormat$1;
-	}({});
-	/**
-	* Format a validation issue as a string.
-	*/
-	function formatValidationIssue(issue) {
-		switch (issue.type) {
-			case "HashMismatch": return `hash mismatch: expected ${issue.expected}, got ${issue.actual}`;
-			case "KeyMismatch": return "key mismatch: current hash was not generated from next key";
-			case "SequenceGap": return `sequence number gap: expected ${issue.expected}, got ${issue.actual}`;
-			case "DateOrdering": return `date must be equal or later: previous is ${issue.previous}, next is ${issue.next}`;
-			case "NonGenesisAtZero": return "non-genesis mark at sequence 0";
-			case "InvalidGenesisKey": return "genesis mark must have key equal to chain_id";
-		}
-	}
-	/**
-	* Get the chain ID as a hex string for display.
-	*/
-	function chainIdHex(report) {
-		return hexEncode(report.chainId);
-	}
-	/**
-	* Check if the validation report has any issues.
-	*/
-	function hasIssues(report) {
-		for (const chain of report.chains) if (!chain.hasGenesis) return true;
-		for (const chain of report.chains) for (const seq of chain.sequences) for (const mark of seq.marks) if (mark.issues.length > 0) return true;
-		if (report.chains.length > 1) return true;
-		if (report.chains.length === 1 && report.chains[0].sequences.length > 1) return true;
-		return false;
-	}
-	/**
-	* Check if the validation report contains interesting information.
-	*/
-	function isInteresting(report) {
-		if (report.chains.length === 0) return false;
-		for (const chain of report.chains) if (!chain.hasGenesis) return true;
-		if (report.chains.length === 1) {
-			const chain = report.chains[0];
-			if (chain.sequences.length === 1) {
-				if (chain.sequences[0].marks.every((m) => m.issues.length === 0)) return false;
-			}
-		}
-		return true;
-	}
-	/**
-	* Format the validation report as human-readable text.
-	*/
-	function formatText(report) {
-		if (!isInteresting(report)) return "";
-		const lines = [];
-		lines.push(`Total marks: ${report.marks.length}`);
-		lines.push(`Chains: ${report.chains.length}`);
-		lines.push("");
-		for (let chainIdx = 0; chainIdx < report.chains.length; chainIdx++) {
-			const chain = report.chains[chainIdx];
-			const chainIdStr = chainIdHex(chain);
-			const shortChainId = chainIdStr.length > 8 ? chainIdStr.slice(0, 8) : chainIdStr;
-			lines.push(`Chain ${chainIdx + 1}: ${shortChainId}`);
-			if (!chain.hasGenesis) lines.push("  Warning: No genesis mark found");
-			for (const seq of chain.sequences) for (const flaggedMark of seq.marks) {
-				const mark = flaggedMark.mark;
-				const shortId = mark.identifier();
-				const seqNum = mark.seq();
-				const annotations = [];
-				if (mark.isGenesis()) annotations.push("genesis mark");
-				for (const issue of flaggedMark.issues) {
-					let issueStr;
-					switch (issue.type) {
-						case "SequenceGap":
-							issueStr = `gap: ${issue.expected} missing`;
-							break;
-						case "DateOrdering":
-							issueStr = `date ${issue.previous} < ${issue.next}`;
-							break;
-						case "HashMismatch":
-							issueStr = "hash mismatch";
-							break;
-						case "KeyMismatch":
-							issueStr = "key mismatch";
-							break;
-						case "NonGenesisAtZero":
-							issueStr = "non-genesis at seq 0";
-							break;
-						case "InvalidGenesisKey":
-							issueStr = "invalid genesis key";
-							break;
-					}
-					annotations.push(issueStr);
-				}
-				if (annotations.length === 0) lines.push(`  ${seqNum}: ${shortId}`);
-				else lines.push(`  ${seqNum}: ${shortId} (${annotations.join(", ")})`);
-			}
-			lines.push("");
-		}
-		return lines.join("\n").trimEnd();
-	}
-	/**
-	* Format the validation report.
-	*/
-	function formatReport(report, format) {
-		switch (format) {
-			case ValidationReportFormat.Text: return formatText(report);
-			case ValidationReportFormat.JsonCompact: return JSON.stringify(reportToJSON(report));
-			case ValidationReportFormat.JsonPretty: return JSON.stringify(reportToJSON(report), null, 2);
-		}
-	}
-	/**
-	* Convert a report to a JSON-serializable object.
-	*/
-	function reportToJSON(report) {
-		return {
-			marks: report.marks.map((m) => m.toUrlEncoding()),
-			chains: report.chains.map((chain) => ({
-				chain_id: hexEncode(chain.chainId),
-				has_genesis: chain.hasGenesis,
-				marks: chain.marks.map((m) => m.toUrlEncoding()),
-				sequences: chain.sequences.map((seq) => ({
-					start_seq: seq.startSeq,
-					end_seq: seq.endSeq,
-					marks: seq.marks.map((fm) => ({
-						mark: fm.mark.toUrlEncoding(),
-						issues: fm.issues
-					}))
-				}))
-			}))
-		};
-	}
-	/**
-	* Build sequence bins for a chain.
-	*/
-	function buildSequenceBins(marks) {
-		const sequences = [];
-		let currentSequence = [];
-		for (let i = 0; i < marks.length; i++) {
-			const mark = marks[i];
-			if (i === 0) currentSequence.push({
-				mark,
-				issues: []
-			});
-			else {
-				const prev = marks[i - 1];
-				try {
-					prev.precedesOpt(mark);
-					currentSequence.push({
-						mark,
-						issues: []
-					});
-				} catch (e) {
-					if (currentSequence.length > 0) sequences.push(createSequenceReport(currentSequence));
-					currentSequence = [{
-						mark,
-						issues: [parseValidationError(e, prev, mark)]
-					}];
-				}
-			}
-		}
-		if (currentSequence.length > 0) sequences.push(createSequenceReport(currentSequence));
-		return sequences;
-	}
-	/**
-	* Parse a validation error into a ValidationIssue.
-	*/
-	function parseValidationError(e, prev, next) {
-		const message = e instanceof Error ? e.message : "";
-		if (message !== "" && message.includes("non-genesis mark at sequence 0")) return { type: "NonGenesisAtZero" };
-		if (message !== "" && message.includes("genesis mark must have key equal to chain_id")) return { type: "InvalidGenesisKey" };
-		if (message !== "" && message.includes("sequence gap")) {
-			const match = /expected (\d+), got (\d+)/.exec(message);
-			if (match !== null) return {
-				type: "SequenceGap",
-				expected: parseInt(match[1], 10),
-				actual: parseInt(match[2], 10)
-			};
-		}
-		if (message !== "" && message.includes("date ordering")) return {
-			type: "DateOrdering",
-			previous: prev.date().toISOString(),
-			next: next.date().toISOString()
-		};
-		if (message !== "" && message.includes("hash mismatch")) {
-			const match = /expected: (\w+), actual: (\w+)/.exec(message);
-			if (match !== null) return {
-				type: "HashMismatch",
-				expected: match[1],
-				actual: match[2]
-			};
-			return {
-				type: "HashMismatch",
-				expected: "",
-				actual: ""
+		/**
+		* Convert this generator to a Gordian Envelope.
+		*
+		* The envelope contains structured assertions for all generator fields:
+		* - isA: "provenance-generator"
+		* - res: The resolution
+		* - seed: The seed
+		* - next-seq: The next sequence number
+		* - rng-state: The RNG state
+		*
+		* Note: Use provenanceMarkGeneratorToEnvelope() for a standalone function alternative.
+		*/
+		intoEnvelope() {
+			let envelope = _bcts_envelope.Envelope.new(this._chainId);
+			envelope = envelope.addType("provenance-generator");
+			envelope = envelope.addAssertion("res", resolutionToNumber(this._res));
+			envelope = envelope.addAssertion("seed", this._seed.toBytes());
+			envelope = envelope.addAssertion("next-seq", this._nextSeq);
+			envelope = envelope.addAssertion("rng-state", this._rngState.toBytes());
+			return envelope;
+		}
+		/**
+		* Extract a ProvenanceMarkGenerator from a Gordian Envelope.
+		*
+		* @param envelope - The envelope to extract from
+		* @returns The extracted generator
+		* @throws ProvenanceMarkError if extraction fails
+		*/
+		static fromEnvelope(envelope) {
+			const env = envelope;
+			if (!env.hasType("provenance-generator")) throw new ProvenanceMarkError("CborError", void 0, { message: "Envelope is not a provenance-generator" });
+			const chainId = env.subject().asByteString();
+			if (chainId === void 0) throw new ProvenanceMarkError("CborError", void 0, { message: "Could not extract chain ID" });
+			const extractAssertion = (predicate) => {
+				const assertions = env.assertionsWithPredicate(predicate);
+				if (assertions.length === 0) throw new ProvenanceMarkError("CborError", void 0, { message: `Missing ${predicate} assertion` });
+				const assertionCase = assertions[0].case();
+				if (assertionCase.type !== "assertion") throw new ProvenanceMarkError("CborError", void 0, { message: `Invalid ${predicate} assertion` });
+				const obj = assertionCase.assertion.object();
+				const objCase = obj.case();
+				if (objCase.type === "leaf") return {
+					cbor: objCase.cbor,
+					bytes: obj.asByteString()
+				};
+				throw new ProvenanceMarkError("CborError", void 0, { message: `Invalid ${predicate} value` });
 			};
+			const res = resolutionFromCbor(extractAssertion("res").cbor);
+			const seedValue = extractAssertion("seed");
+			if (seedValue.bytes === void 0) throw new ProvenanceMarkError("CborError", void 0, { message: "Invalid seed data" });
+			const seed = ProvenanceSeed.fromBytes(seedValue.bytes);
+			const seqValue = extractAssertion("next-seq");
+			const nextSeq = Number(seqValue.cbor);
+			const rngValue = extractAssertion("rng-state");
+			if (rngValue.bytes === void 0) throw new ProvenanceMarkError("CborError", void 0, { message: "Invalid rng-state data" });
+			const rngState = RngState.fromBytes(rngValue.bytes);
+			return ProvenanceMarkGenerator.new(res, seed, chainId, nextSeq, rngState);
 		}
-		return { type: "KeyMismatch" };
-	}
-	/**
-	* Create a sequence report from flagged marks.
-	*/
-	function createSequenceReport(marks) {
-		return {
-			startSeq: marks.length > 0 ? marks[0].mark.seq() : 0,
-			endSeq: marks.length > 0 ? marks[marks.length - 1].mark.seq() : 0,
-			marks
-		};
-	}
-	/**
-	* Validate a collection of provenance marks.
-	*/
-	function validate(marks) {
-		const seen = /* @__PURE__ */ new Set();
-		const deduplicatedMarks = [];
-		for (const mark of marks) {
-			const key = mark.toUrlEncoding();
-			if (!seen.has(key)) {
-				seen.add(key);
-				deduplicatedMarks.push(mark);
-			}
-		}
-		const chainBins = /* @__PURE__ */ new Map();
-		for (const mark of deduplicatedMarks) {
-			const chainIdKey = hexEncode(mark.chainId());
-			const bin = chainBins.get(chainIdKey);
-			if (bin !== void 0) bin.push(mark);
-			else chainBins.set(chainIdKey, [mark]);
-		}
-		const chains = [];
-		for (const [chainIdKey, chainMarks] of chainBins) {
-			chainMarks.sort((a, b) => a.seq() - b.seq());
-			const hasGenesis = chainMarks.length > 0 && chainMarks[0].seq() === 0 && chainMarks[0].isGenesis();
-			const sequences = buildSequenceBins(chainMarks);
-			chains.push({
-				chainId: hexDecode(chainIdKey),
-				hasGenesis,
-				marks: chainMarks,
-				sequences
-			});
-		}
-		chains.sort((a, b) => hexEncode(a.chainId).localeCompare(hexEncode(b.chainId)));
-		return {
-			marks: deduplicatedMarks,
-			chains
-		};
-	}
-	/**
-	* Helper function to encode bytes as hex.
-	*/
-	function hexEncode(bytes) {
-		return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
-	}
+	};
+	//#endregion
+	//#region src/mark-info.ts
 	/**
-	* Helper function to decode hex to bytes.
-	*/
-	function hexDecode(hex) {
-		const bytes = new Uint8Array(hex.length / 2);
-		for (let i = 0; i < hex.length; i += 2) bytes[i / 2] = parseInt(hex.slice(i, i + 2), 16);
-		return bytes;
-	}
-
-//#endregion
-//#region src/mark-info.ts
-/**
 	* Wrapper for a provenance mark with additional display information.
 	*/
 	var ProvenanceMarkInfo = class ProvenanceMarkInfo {
@@ -1572,12 +2030,19 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 		}
 		/**
 		* Create a new ProvenanceMarkInfo from a mark.
+		*
+		* Mirrors Rust `ProvenanceMarkInfo::new`
+		* (`provenance-mark-rust/src/mark_info.rs`), which calls
+		* `mark.ur()` — i.e. the `UREncodable` implementation, whose
+		* payload is the **untagged** CBOR with type `"provenance"`. Earlier
+		* revisions of this port called `decodeCbor(mark.toCborData())` and
+		* wrapped the resulting *tagged* CBOR in `UR.new("provenance", ...)`,
+		* which prepended the CBOR tag to the UR bytewords and broke
+		* cross-impl interop (UR strings produced by Rust would not parse,
+		* and vice versa).
 		*/
 		static new(mark, comment = "") {
-			const tagName = __bcts_tags.PROVENANCE_MARK.name;
-			if (tagName === void 0) throw new Error("PROVENANCE_MARK tag has no name");
-			const cborValue = (0, __bcts_dcbor.decodeCbor)(mark.toCborData());
-			return new ProvenanceMarkInfo(mark, __bcts_uniform_resources.UR.new(tagName, cborValue), mark.bytewordsIdentifier(true), mark.bytemojiIdentifier(true), comment);
+			return new ProvenanceMarkInfo(mark, mark.ur(), mark.idBytewords(4, true), mark.idBytemoji(4, true), comment);
 		}
 		mark() {
 			return this._mark;
@@ -1596,12 +2061,16 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 		}
 		/**
 		* Generate a markdown summary of the mark.
+		*
+		* Date rendering uses {@link dateToDisplay} so midnight-UTC dates
+		* appear as `YYYY-MM-DD` (matching Rust `format!("{}",
+		* self.mark.date())`), not as `YYYY-MM-DDT00:00:00Z`.
 		*/
 		markdownSummary() {
 			const lines = [];
 			lines.push("---");
 			lines.push("");
-			lines.push(this._mark.date().toISOString());
+			lines.push(dateToDisplay(this._mark.date()));
 			lines.push("");
 			lines.push(`#### ${this._ur.toString()}`);
 			lines.push("");
@@ -1616,85 +2085,204 @@ var BCProvenanceMark = (function(exports, __bcts_dcbor, __noble_hashes_sha256, _
 			return lines.join("\n");
 		}
 		/**
-		* JSON serialization.
+		* JSON serialization. Field order mirrors Rust's `#[derive(Serialize)]`
+		* on `ProvenanceMarkInfo` (provenance-mark-rust/src/mark_info.rs):
+		* `ur, bytewords, bytemoji, [comment,] mark` — `comment` (when present)
+		* comes BEFORE `mark`. Rust uses `skip_serializing_if = "String::is_empty"`,
+		* matched here by the `if (...length > 0)` guard.
 		*/
 		toJSON() {
 			const result = {
 				ur: this._ur.toString(),
 				bytewords: this._bytewords,
-				bytemoji: this._bytemoji,
-				mark: this._mark.toJSON()
+				bytemoji: this._bytemoji
 			};
 			if (this._comment.length > 0) result["comment"] = this._comment;
+			result["mark"] = this._mark.toJSON();
 			return result;
 		}
 		/**
 		* Create from JSON object.
+		*
+		* Decodes the UR string through {@link ProvenanceMark.fromURString},
+		* which correctly handles the **untagged** CBOR payload that
+		* `mark.ur()` produces — symmetric with the constructor.
 		*/
 		static fromJSON(json) {
 			const urString = json["ur"];
-			const ur = __bcts_uniform_resources.UR.fromURString(urString);
-			const cborBytes = (0, __bcts_dcbor.cborData)(ur.cbor());
-			const mark = ProvenanceMark.fromCborData(cborBytes);
+			const mark = ProvenanceMark.fromURString(urString);
+			const ur = mark.ur();
 			const bytewords = json["bytewords"];
 			const bytemoji = json["bytemoji"];
 			return new ProvenanceMarkInfo(mark, ur, bytewords, bytemoji, typeof json["comment"] === "string" ? json["comment"] : "");
 		}
 	};
+	//#endregion
+	//#region src/envelope.ts
+	/**
+	* Copyright © 2023-2026 Blockchain Commons, LLC
+	* Copyright © 2025-2026 Parity Technologies
+	*
+	*
+	* Envelope support for Provenance Marks
+	*
+	* This module provides Gordian Envelope integration for ProvenanceMark and
+	* ProvenanceMarkGenerator, enabling them to be used with the bc-envelope
+	* ecosystem.
+	*
+	* Ported from provenance-mark-rust/src/mark.rs and generator.rs (envelope feature)
+	*/
+	/**
+	* Registers provenance mark tags in the global format context.
+	*
+	* Matches Rust: register_tags()
+	*/
+	function registerTags() {
+		(0, _bcts_envelope.withFormatContextMut)((context) => {
+			registerTagsIn(context);
+		});
+	}
+	/**
+	* Registers provenance mark tags in a specific format context.
+	*
+	* Matches Rust: register_tags_in()
+	*
+	* @param context - The format context to register tags in
+	*/
+	function registerTagsIn(context) {
+		(0, _bcts_envelope.registerTagsIn)(context);
+		context.tags().setSummarizer(BigInt(_bcts_tags.PROVENANCE_MARK.value), (untaggedCbor, _flat) => {
+			try {
+				return {
+					ok: true,
+					value: ProvenanceMark.fromUntaggedCbor(untaggedCbor).toString()
+				};
+			} catch {
+				return {
+					ok: false,
+					error: {
+						type: "Custom",
+						message: "invalid provenance mark"
+					}
+				};
+			}
+		});
+	}
+	/**
+	* Convert a ProvenanceMark to an Envelope.
+	*
+	* Delegates to ProvenanceMark.intoEnvelope() — single source of truth.
+	*
+	* @param mark - The provenance mark to convert
+	* @returns An envelope containing the mark
+	*/
+	function provenanceMarkToEnvelope(mark) {
+		return mark.intoEnvelope();
+	}
+	/**
+	* Extract a ProvenanceMark from an Envelope.
+	*
+	* Delegates to ProvenanceMark.fromEnvelope() — single source of truth.
+	*
+	* @param envelope - The envelope to extract from
+	* @returns The extracted provenance mark
+	* @throws ProvenanceMarkError if extraction fails
+	*/
+	function provenanceMarkFromEnvelope(envelope) {
+		return ProvenanceMark.fromEnvelope(envelope);
+	}
+	/**
+	* Convert a ProvenanceMarkGenerator to an Envelope.
+	*
+	* Delegates to ProvenanceMarkGenerator.intoEnvelope() — single source of truth.
+	*
+	* @param generator - The generator to convert
+	* @returns An envelope containing the generator
+	*/
+	function provenanceMarkGeneratorToEnvelope(generator) {
+		return generator.intoEnvelope();
+	}
+	/**
+	* Extract a ProvenanceMarkGenerator from an Envelope.
+	*
+	* Delegates to ProvenanceMarkGenerator.fromEnvelope() — single source of truth.
+	*
+	* @param envelope - The envelope to extract from
+	* @returns The extracted generator
+	* @throws ProvenanceMarkError if extraction fails
+	*/
+	function provenanceMarkGeneratorFromEnvelope(envelope) {
+		return ProvenanceMarkGenerator.fromEnvelope(envelope);
+	}
+	//#endregion
+	Object.defineProperty(exports, "FormatContext", {
+		enumerable: true,
+		get: function() {
+			return _bcts_envelope.FormatContext;
+		}
+	});
+	exports.PROVENANCE_SEED_LENGTH = PROVENANCE_SEED_LENGTH;
+	exports.ProvenanceMark = ProvenanceMark;
+	exports.ProvenanceMarkError = ProvenanceMarkError;
+	exports.ProvenanceMarkErrorType = ProvenanceMarkErrorType;
+	exports.ProvenanceMarkGenerator = ProvenanceMarkGenerator;
+	exports.ProvenanceMarkInfo = ProvenanceMarkInfo;
+	exports.ProvenanceMarkResolution = ProvenanceMarkResolution;
+	exports.ProvenanceSeed = ProvenanceSeed;
+	exports.RNG_STATE_LENGTH = RNG_STATE_LENGTH;
+	exports.RngState = RngState;
+	exports.SHA256_SIZE = SHA256_SIZE;
+	exports.ValidationReportFormat = ValidationReportFormat;
+	exports.Xoshiro256StarStar = Xoshiro256StarStar;
+	exports.chainIdHex = chainIdHex;
+	exports.chainIdRange = chainIdRange;
+	exports.dateBytesLength = dateBytesLength;
+	exports.dateBytesRange = dateBytesRange;
+	exports.dateFromIso8601 = dateFromIso8601;
+	exports.dateToDateString = dateToDateString;
+	exports.dateToDisplay = dateToDisplay;
+	exports.dateToIso8601 = dateToIso8601;
+	exports.deserialize2Bytes = deserialize2Bytes;
+	exports.deserialize4Bytes = deserialize4Bytes;
+	exports.deserialize6Bytes = deserialize6Bytes;
+	exports.deserializeDate = deserializeDate;
+	exports.deserializeSeq = deserializeSeq;
+	exports.extendKey = extendKey;
+	exports.fixedLength = fixedLength;
+	exports.formatReport = formatReport;
+	exports.formatValidationIssue = formatValidationIssue;
+	exports.hasIssues = hasIssues;
+	exports.hashRange = hashRange;
+	exports.hkdfHmacSha256 = hkdfHmacSha256;
+	exports.infoRangeStart = infoRangeStart;
+	exports.keyRange = keyRange;
+	exports.linkLength = linkLength;
+	exports.obfuscate = obfuscate;
+	exports.parseDate = parseDate;
+	exports.parseSeed = parseSeed;
+	exports.provenanceMarkFromEnvelope = provenanceMarkFromEnvelope;
+	exports.provenanceMarkGeneratorFromEnvelope = provenanceMarkGeneratorFromEnvelope;
+	exports.provenanceMarkGeneratorToEnvelope = provenanceMarkGeneratorToEnvelope;
+	exports.provenanceMarkToEnvelope = provenanceMarkToEnvelope;
+	exports.rangeOfDaysInMonth = rangeOfDaysInMonth;
+	exports.registerTags = registerTags;
+	exports.registerTagsIn = registerTagsIn;
+	exports.resolutionFromCbor = resolutionFromCbor;
+	exports.resolutionFromNumber = resolutionFromNumber;
+	exports.resolutionToCbor = resolutionToCbor;
+	exports.resolutionToNumber = resolutionToNumber;
+	exports.resolutionToString = resolutionToString;
+	exports.seqBytesLength = seqBytesLength;
+	exports.seqBytesRange = seqBytesRange;
+	exports.serialize2Bytes = serialize2Bytes;
+	exports.serialize4Bytes = serialize4Bytes;
+	exports.serialize6Bytes = serialize6Bytes;
+	exports.serializeDate = serializeDate;
+	exports.serializeSeq = serializeSeq;
+	exports.sha256 = sha256;
+	exports.sha256Prefix = sha256Prefix;
+	exports.validate = validate;
+	return exports;
+})({}, bctsDcbor, bctsRand, nobleHashesSha2, nobleHashesHkdf, nobleCiphersChacha, bctsTags, bctsUniformResources, bctsEnvelope);
 
-//#endregion
-exports.PROVENANCE_SEED_LENGTH = PROVENANCE_SEED_LENGTH;
-exports.ProvenanceMark = ProvenanceMark;
-exports.ProvenanceMarkError = ProvenanceMarkError;
-exports.ProvenanceMarkErrorType = ProvenanceMarkErrorType;
-exports.ProvenanceMarkGenerator = ProvenanceMarkGenerator;
-exports.ProvenanceMarkInfo = ProvenanceMarkInfo;
-exports.ProvenanceMarkResolution = ProvenanceMarkResolution;
-exports.ProvenanceSeed = ProvenanceSeed;
-exports.RNG_STATE_LENGTH = RNG_STATE_LENGTH;
-exports.RngState = RngState;
-exports.SHA256_SIZE = SHA256_SIZE;
-exports.ValidationReportFormat = ValidationReportFormat;
-exports.Xoshiro256StarStar = Xoshiro256StarStar;
-exports.chainIdHex = chainIdHex;
-exports.chainIdRange = chainIdRange;
-exports.dateBytesLength = dateBytesLength;
-exports.dateBytesRange = dateBytesRange;
-exports.dateFromIso8601 = dateFromIso8601;
-exports.dateToDateString = dateToDateString;
-exports.dateToIso8601 = dateToIso8601;
-exports.deserialize2Bytes = deserialize2Bytes;
-exports.deserialize4Bytes = deserialize4Bytes;
-exports.deserialize6Bytes = deserialize6Bytes;
-exports.deserializeDate = deserializeDate;
-exports.deserializeSeq = deserializeSeq;
-exports.extendKey = extendKey;
-exports.fixedLength = fixedLength;
-exports.formatReport = formatReport;
-exports.formatValidationIssue = formatValidationIssue;
-exports.hasIssues = hasIssues;
-exports.hashRange = hashRange;
-exports.hkdfHmacSha256 = hkdfHmacSha256;
-exports.infoRangeStart = infoRangeStart;
-exports.keyRange = keyRange;
-exports.linkLength = linkLength;
-exports.obfuscate = obfuscate;
-exports.rangeOfDaysInMonth = rangeOfDaysInMonth;
-exports.resolutionFromCbor = resolutionFromCbor;
-exports.resolutionFromNumber = resolutionFromNumber;
-exports.resolutionToCbor = resolutionToCbor;
-exports.resolutionToNumber = resolutionToNumber;
-exports.resolutionToString = resolutionToString;
-exports.seqBytesLength = seqBytesLength;
-exports.seqBytesRange = seqBytesRange;
-exports.serialize2Bytes = serialize2Bytes;
-exports.serialize4Bytes = serialize4Bytes;
-exports.serialize6Bytes = serialize6Bytes;
-exports.serializeDate = serializeDate;
-exports.serializeSeq = serializeSeq;
-exports.sha256 = sha256;
-exports.sha256Prefix = sha256Prefix;
-exports.validate = validate;
-return exports;
-})({}, BCDcbor, __noble_hashes_sha256, __noble_hashes_hkdf, __noble_ciphers_chacha, BCRand, BCTags, BCUR);
 //# sourceMappingURL=index.iife.js.map