@bcts/provenance-mark 1.0.0-alpha.16 → 1.0.0-alpha.18

package/dist/index.cjs

@@ -11,54 +11,54 @@ let _bcts_envelope = require("@bcts/envelope");
 /**
 * 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";
+	return ProvenanceMarkErrorType;
 }({});
 /**
 * Error class for Provenance Mark operations.
@@ -253,12 +253,12 @@ function dateToDateString(date) {
 * 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.
@@ -689,9 +689,9 @@ var ProvenanceSeed = class ProvenanceSeed {
 	/**
 	* 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));
+	static newUsing(randomData) {
+		if (randomData.length < PROVENANCE_SEED_LENGTH) throw new ProvenanceMarkError(ProvenanceMarkErrorType.InvalidSeedLength, void 0, { actual: randomData.length });
+		return ProvenanceSeed.fromBytes(randomData.slice(0, PROVENANCE_SEED_LENGTH));
 	}
 	/**
 	* Create a new seed from a passphrase.
@@ -797,6 +797,279 @@ function fromBase64(base64) {
 	throw new Error("atob not available and require is not defined");
 }
 
+//#endregion
+//#region src/validate.ts
+/**
+* Format for validation report output.
+*/
+let ValidationReportFormat = /* @__PURE__ */ function(ValidationReportFormat) {
+	/** Human-readable text format */
+	ValidationReportFormat["Text"] = "text";
+	/** Compact JSON format (no whitespace) */
+	ValidationReportFormat["JsonCompact"] = "json-compact";
+	/** Pretty-printed JSON format (with indentation) */
+	ValidationReportFormat["JsonPretty"] = "json-pretty";
+	return ValidationReportFormat;
+}({});
+/**
+* Format a validation issue as a string.
+*/
+function 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.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) => 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.ts
 /**
@@ -948,6 +1221,33 @@ var ProvenanceMark = class ProvenanceMark {
 		return prefix ? `\u{1F151} ${s}` : s;
 	}
 	/**
+	* A compact 8-letter identifier derived from the upper-case ByteWords
+	* identifier by taking the first and last letter of each ByteWords word
+	* (4 words x 2 letters = 8 letters).
+	*
+	* Example: "ABLE ACID ALSO APEX" -> "AEADAOAX"
+	* If prefix is true, prepends the provenance mark prefix character.
+	*/
+	bytewordsMinimalIdentifier(prefix) {
+		const full = (0, _bcts_uniform_resources.encodeBytewordsIdentifier)(this._hash.slice(0, 4));
+		const words = full.split(/\s+/);
+		let out = "";
+		if (words.length === 4) for (const w of words) {
+			if (w.length === 0) continue;
+			out += w[0].toUpperCase();
+			out += w[w.length - 1].toUpperCase();
+		}
+		if (out.length !== 8) {
+			out = "";
+			const compact = full.replace(/[^a-zA-Z]/g, "").toUpperCase();
+			for (let i = 0; i + 3 < compact.length; i += 4) {
+				out += compact[i];
+				out += compact[i + 3];
+			}
+		}
+		return prefix ? `\u{1F151} ${out}` : out;
+	}
+	/**
 	* Get the first four bytes of the hash as Bytemoji.
 	*/
 	bytemojiIdentifier(prefix) {
@@ -967,18 +1267,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(ProvenanceMarkErrorType.ValidationError, "non-genesis mark at sequence 0", { validationIssue: { type: "NonGenesisAtZero" } });
+		if (arraysEqual(next._key, next._chainId)) throw new ProvenanceMarkError(ProvenanceMarkErrorType.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(ProvenanceMarkErrorType.ValidationError, `sequence gap: expected ${this._seq + 1}, got ${next._seq}`, { validationIssue: issue });
+		}
+		if (this._date > next._date) {
+			const dateStr = this._date.toISOString().replace(".000Z", "Z");
+			const nextDateStr = next._date.toISOString().replace(".000Z", "Z");
+			const issue = {
+				type: "DateOrdering",
+				previous: dateStr,
+				next: nextDateStr
+			};
+			throw new ProvenanceMarkError(ProvenanceMarkErrorType.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(ProvenanceMarkErrorType.ValidationError, `hash mismatch: expected ${bytesToHex(expectedHash)}, got ${bytesToHex(this._hash)}`, { validationIssue: issue });
+		}
 	}
 	/**
 	* Check if a sequence of marks is valid.
@@ -1176,30 +1497,35 @@ var ProvenanceMark = class ProvenanceMark {
 		return new ProvenanceMark(res, key, hash, chainId, seqBytes, dateBytes, infoBytes, seq, date);
 	}
 	/**
-	* Convert this provenance mark to a Gordian Envelope.
+	* Validate a collection of provenance marks.
 	*
-	* The envelope contains the tagged CBOR representation of the mark.
+	* Matches Rust: `ProvenanceMark::validate()` which delegates to
+	* `ValidationReport::validate()`.
+	*/
+	static validate(marks) {
+		return validate(marks);
+	}
+	/**
+	* Convert this provenance mark to a Gordian Envelope.
 	*
-	* Note: Use provenanceMarkToEnvelope() for a standalone function alternative.
+	* 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.new(this.toCborData());
+		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 bytes = envelope.asByteString();
-		if (bytes !== void 0) return ProvenanceMark.fromCborData(bytes);
-		const envCase = envelope.case();
-		if (envCase.type === "node") {
-			const subjectBytes = envCase.subject.asByteString();
-			if (subjectBytes !== void 0) return ProvenanceMark.fromCborData(subjectBytes);
-		}
+		const leaf = envelope.subject().asLeaf();
+		if (leaf !== void 0) return ProvenanceMark.fromTaggedCbor(leaf);
 		throw new ProvenanceMarkError(ProvenanceMarkErrorType.CborError, void 0, { message: "Could not extract ProvenanceMark from envelope" });
 	}
 };
@@ -1264,8 +1590,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);
 	}
 	/**
@@ -1392,276 +1718,6 @@ var ProvenanceMarkGenerator = class ProvenanceMarkGenerator {
 	}
 };
 
-//#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: ""
-		};
-	}
-	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
 /**
@@ -1711,7 +1767,7 @@ var ProvenanceMarkInfo = class ProvenanceMarkInfo {
 		const lines = [];
 		lines.push("---");
 		lines.push("");
-		lines.push(this._mark.date().toISOString());
+		lines.push(this._mark.date().toISOString().replace(".000Z", "Z"));
 		lines.push("");
 		lines.push(`#### ${this._ur.toString()}`);
 		lines.push("");
@@ -1766,111 +1822,93 @@ var ProvenanceMarkInfo = class ProvenanceMarkInfo {
 /**
 * Registers provenance mark tags in the global format context.
 *
-* This function sets up a summarizer for the PROVENANCE_MARK tag that displays
-* provenance marks in a human-readable format.
+* Matches Rust: register_tags()
 */
 function registerTags() {
-	registerTagsIn(globalTagsContext);
+	(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) {
-	context.setSummarizer(Number(_bcts_tags.PROVENANCE_MARK.value), (cborValue) => {
-		return ProvenanceMark.fromUntaggedCbor(cborValue).toString();
+	(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"
+				}
+			};
+		}
 	});
 }
-const globalTagsContext = { setSummarizer(_tag, _summarizer) {} };
 /**
 * Convert a ProvenanceMark to an Envelope.
 *
-* The envelope contains the tagged CBOR representation of the mark.
+* 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 _bcts_envelope.Envelope.new(mark.toCborData());
+	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) {
-	const bytes = envelope.asByteString();
-	if (bytes !== void 0) return ProvenanceMark.fromCborData(bytes);
-	const envCase = envelope.case();
-	if (envCase.type === "node") {
-		const subjectBytes = envCase.subject.asByteString();
-		if (subjectBytes !== void 0) return ProvenanceMark.fromCborData(subjectBytes);
-	}
-	throw new ProvenanceMarkError(ProvenanceMarkErrorType.CborError, void 0, { message: "Could not extract ProvenanceMark from envelope" });
+	return ProvenanceMark.fromEnvelope(envelope);
 }
 /**
 * Convert a ProvenanceMarkGenerator to an Envelope.
 *
-* The envelope contains structured assertions for all generator fields:
-* - type: "provenance-generator"
-* - res: The resolution
-* - seed: The seed
-* - next-seq: The next sequence number
-* - rng-state: The RNG state
+* Delegates to ProvenanceMarkGenerator.intoEnvelope() — single source of truth.
 *
 * @param generator - The generator to convert
 * @returns An envelope containing the generator
 */
 function provenanceMarkGeneratorToEnvelope(generator) {
-	let envelope = _bcts_envelope.Envelope.new(generator.chainId());
-	envelope = envelope.addType("provenance-generator");
-	envelope = envelope.addAssertion("res", resolutionToNumber(generator.res()));
-	envelope = envelope.addAssertion("seed", generator.seed().toBytes());
-	envelope = envelope.addAssertion("next-seq", generator.nextSeq());
-	envelope = envelope.addAssertion("rng-state", generator.rngState().toBytes());
-	return envelope;
+	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) {
-	const env = envelope;
-	if (!env.hasType("provenance-generator")) throw new ProvenanceMarkError(ProvenanceMarkErrorType.CborError, void 0, { message: "Envelope is not a provenance-generator" });
-	const chainId = env.subject().asByteString();
-	if (chainId === void 0) throw new ProvenanceMarkError(ProvenanceMarkErrorType.CborError, void 0, { message: "Could not extract chain ID" });
-	const extractAssertion = (predicate) => {
-		const assertions = env.assertionsWithPredicate(predicate);
-		if (assertions.length === 0) throw new ProvenanceMarkError(ProvenanceMarkErrorType.CborError, void 0, { message: `Missing ${predicate} assertion` });
-		const assertionCase = assertions[0].case();
-		if (assertionCase.type !== "assertion") throw new ProvenanceMarkError(ProvenanceMarkErrorType.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(ProvenanceMarkErrorType.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(ProvenanceMarkErrorType.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(ProvenanceMarkErrorType.CborError, void 0, { message: "Invalid rng-state data" });
-	const rngState = RngState.fromBytes(rngValue.bytes);
-	return ProvenanceMarkGenerator.new(res, seed, chainId, nextSeq, rngState);
+	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;