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

package/dist/index.iife.js

@@ -791,6 +791,279 @@ var bctsProvenanceMark = (function(exports, _bcts_dcbor, _noble_hashes_sha2_js,
 		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
 /**
@@ -942,6 +1215,33 @@ var bctsProvenanceMark = (function(exports, _bcts_dcbor, _noble_hashes_sha2_js,
 			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) {
@@ -961,18 +1261,39 @@ var bctsProvenanceMark = (function(exports, _bcts_dcbor, _noble_hashes_sha2_js,
 		}
 		/**
 		* 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.
@@ -1170,30 +1491,35 @@ var bctsProvenanceMark = (function(exports, _bcts_dcbor, _noble_hashes_sha2_js,
 			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" });
 		}
 	};
@@ -1386,276 +1712,6 @@ var bctsProvenanceMark = (function(exports, _bcts_dcbor, _noble_hashes_sha2_js,
 		}
 	};
 
-//#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.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
 /**
@@ -1705,7 +1761,7 @@ var bctsProvenanceMark = (function(exports, _bcts_dcbor, _noble_hashes_sha2_js,
 			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("");
@@ -1760,111 +1816,93 @@ var bctsProvenanceMark = (function(exports, _bcts_dcbor, _noble_hashes_sha2_js,
 	/**
 	* 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;