@bcts/provenance-mark 1.0.0-alpha.8 → 1.0.0-beta.0

package/dist/index.cjs

@@ -1,63 +1,82 @@
-let __bcts_dcbor = require("@bcts/dcbor");
-let __noble_hashes_sha256 = require("@noble/hashes/sha256");
-let __noble_hashes_hkdf = require("@noble/hashes/hkdf");
-let __noble_ciphers_chacha = require("@noble/ciphers/chacha");
-let __bcts_rand = require("@bcts/rand");
-let __bcts_tags = require("@bcts/tags");
-let __bcts_uniform_resources = require("@bcts/uniform-resources");
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _bcts_dcbor = require("@bcts/dcbor");
+let _bcts_rand = require("@bcts/rand");
+let _noble_hashes_sha2_js = require("@noble/hashes/sha2.js");
+let _noble_hashes_hkdf_js = require("@noble/hashes/hkdf.js");
+let _noble_ciphers_chacha_js = require("@noble/ciphers/chacha.js");
+let _bcts_tags = require("@bcts/tags");
+let _bcts_uniform_resources = require("@bcts/uniform-resources");
+let _bcts_envelope = require("@bcts/envelope");
 //#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.
@@ -80,37 +99,42 @@ var ProvenanceMarkError = class ProvenanceMarkError extends Error {
 			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
 /**
+* 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);
@@ -141,8 +165,8 @@ function serialize2Bytes(date) {
 	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
@@ -157,12 +181,12 @@ function serialize2Bytes(date) {
 * 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
@@ -175,7 +199,7 @@ function deserialize2Bytes(bytes) {
 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;
@@ -187,7 +211,7 @@ function serialize4Bytes(date) {
 * 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);
 }
@@ -197,7 +221,7 @@ function deserialize4Bytes(bytes) {
 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);
@@ -211,9 +235,9 @@ function serialize6Bytes(date) {
 * 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));
 }
 /**
@@ -236,7 +260,7 @@ function dateToIso8601(date) {
 */
 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;
 }
 /**
@@ -245,19 +269,50 @@ function dateFromIso8601(str) {
 function dateToDateString(date) {
 	return `${date.getUTCFullYear()}-${(date.getUTCMonth() + 1).toString().padStart(2, "0")}-${date.getUTCDate().toString().padStart(2, "0")}`;
 }
-
+/**
+* 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.
@@ -270,11 +325,11 @@ function resolutionToNumber(res) {
 */
 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}` });
 	}
 }
 /**
@@ -282,10 +337,10 @@ function resolutionFromNumber(value) {
 */
 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;
 	}
 }
 /**
@@ -293,10 +348,10 @@ function linkLength(res) {
 */
 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;
 	}
 }
 /**
@@ -304,10 +359,10 @@ function seqBytesLength(res) {
 */
 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;
 	}
 }
 /**
@@ -375,10 +430,10 @@ function infoRangeStart(res) {
 */
 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);
 	}
 }
 /**
@@ -386,46 +441,55 @@ function serializeDate(res, date) {
 */
 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;
 	}
 }
@@ -434,34 +498,38 @@ function deserializeSeq(res, data) {
 */
 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
+/**
+* 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.
@@ -479,7 +547,7 @@ function extendKey(data) {
 * 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.
@@ -490,12 +558,183 @@ function obfuscate(key, message) {
 	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/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.
 */
@@ -615,9 +854,13 @@ var Xoshiro256StarStar = class Xoshiro256StarStar {
 		this.s[3] = this.rotateLeft64(this.s[3], 45n);
 	}
 };
-
 //#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).
@@ -637,7 +880,7 @@ var RngState = class RngState {
 	* 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));
 	}
 	/**
@@ -656,149 +899,302 @@ var RngState = class RngState {
 	* 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;
+//#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
+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;
+}({});
 /**
-* 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)
+* 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"));
+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;
+		}
 	}
-	throw new Error("atob not available and require is not defined");
+	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 {
@@ -865,29 +1261,29 @@ var ProvenanceMark = class ProvenanceMark {
 	*/
 	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);
 	}
@@ -896,7 +1292,7 @@ var ProvenanceMark = class ProvenanceMark {
 	*/
 	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
 		});
@@ -917,9 +1313,9 @@ var ProvenanceMark = class ProvenanceMark {
 		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);
 	}
@@ -934,24 +1330,174 @@ var ProvenanceMark = class ProvenanceMark {
 		]), 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);
 	}
 	/**
-	* Get the first four bytes of the hash as Bytemoji.
+	* 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);
+	}
+	/**
+	* 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.
@@ -966,18 +1512,39 @@ var ProvenanceMark = class ProvenanceMark {
 	}
 	/**
 	* 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.
@@ -998,35 +1565,61 @@ var ProvenanceMark = class ProvenanceMark {
 	* 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) {
@@ -1039,21 +1632,21 @@ var ProvenanceMark = class ProvenanceMark {
 	*/
 	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()
 		});
 	}
@@ -1061,16 +1654,16 @@ var ProvenanceMark = class ProvenanceMark {
 	* 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);
 	}
 	/**
@@ -1078,15 +1671,15 @@ var ProvenanceMark = class ProvenanceMark {
 	*/
 	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);
 	}
 	/**
@@ -1097,23 +1690,42 @@ var ProvenanceMark = class ProvenanceMark {
 	}
 	/**
 	* 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(", ")})`;
 	}
 	/**
@@ -1123,16 +1735,20 @@ var ProvenanceMark = class ProvenanceMark {
 		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;
@@ -1144,15 +1760,54 @@ var ProvenanceMark = class ProvenanceMark {
 		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"]);
-		return new ProvenanceMark(res, key, hash, chainId, seqBytes, dateBytes, infoBytes, seq, date);
+		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" });
 	}
 };
 /**
@@ -1163,10 +1818,14 @@ function arraysEqual(a, b) {
 	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
 	return true;
 }
-
 //#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 {
@@ -1216,8 +1875,8 @@ var ProvenanceMarkGenerator = class ProvenanceMarkGenerator {
 	/**
 	* 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);
 	}
 	/**
@@ -1232,7 +1891,7 @@ var ProvenanceMarkGenerator = class ProvenanceMarkGenerator {
 	*/
 	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
 		});
@@ -1258,9 +1917,24 @@ var ProvenanceMarkGenerator = class ProvenanceMarkGenerator {
 	}
 	/**
 	* 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.
@@ -1285,278 +1959,64 @@ var ProvenanceMarkGenerator = class ProvenanceMarkGenerator {
 		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("");
-}
-/**
-* 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
 /**
@@ -1577,12 +2037,19 @@ var ProvenanceMarkInfo = class ProvenanceMarkInfo {
 	}
 	/**
 	* 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;
@@ -1601,12 +2068,16 @@ var ProvenanceMarkInfo = class ProvenanceMarkInfo {
 	}
 	/**
 	* 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("");
@@ -1621,33 +2092,142 @@ var ProvenanceMarkInfo = class ProvenanceMarkInfo {
 		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;
@@ -1667,6 +2247,7 @@ exports.dateBytesLength = dateBytesLength;
 exports.dateBytesRange = dateBytesRange;
 exports.dateFromIso8601 = dateFromIso8601;
 exports.dateToDateString = dateToDateString;
+exports.dateToDisplay = dateToDisplay;
 exports.dateToIso8601 = dateToIso8601;
 exports.deserialize2Bytes = deserialize2Bytes;
 exports.deserialize4Bytes = deserialize4Bytes;
@@ -1684,7 +2265,15 @@ 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;
@@ -1700,4 +2289,5 @@ exports.serializeSeq = serializeSeq;
 exports.sha256 = sha256;
 exports.sha256Prefix = sha256Prefix;
 exports.validate = validate;
+
 //# sourceMappingURL=index.cjs.map