@bcts/provenance-mark-cli 1.0.0-alpha.13

package/dist/src-XNNUeTzh.cjs

@@ -0,0 +1,889 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let fs = require("fs");
+fs = __toESM(fs);
+let path = require("path");
+path = __toESM(path);
+let _bcts_dcbor = require("@bcts/dcbor");
+let _bcts_uniform_resources = require("@bcts/uniform-resources");
+let _bcts_components = require("@bcts/components");
+let _bcts_provenance_mark = require("@bcts/provenance-mark");
+let _bcts_envelope = require("@bcts/envelope");
+let _bcts_known_values = require("@bcts/known-values");
+
+//#region src/utils.ts
+/**
+* Utilities module - 1:1 port of utils.rs
+*
+* Helper functions for CLI operations.
+*/
+/**
+* Read a new path, supporting globbing, and resolving relative paths.
+*
+* Corresponds to Rust `read_new_path()`
+*/
+function readNewPath(pathStr) {
+	let effectivePath;
+	if (path.isAbsolute(pathStr)) effectivePath = pathStr;
+	else {
+		const currentDir = process.cwd();
+		effectivePath = path.join(currentDir, pathStr);
+	}
+	return path.normalize(effectivePath);
+}
+/**
+* Read an existing directory path, supporting globbing, and resolving relative paths.
+*
+* Corresponds to Rust `read_existing_directory_path()`
+*/
+function readExistingDirectoryPath(pathStr) {
+	const effectivePath = readNewPath(pathStr);
+	if (!fs.existsSync(effectivePath)) throw new Error(`Path does not exist: ${effectivePath}`);
+	if (!fs.statSync(effectivePath).isDirectory()) throw new Error(`Path is not a directory: ${effectivePath}`);
+	return effectivePath;
+}
+/**
+* Read an argument from command line or stdin.
+*
+* Corresponds to Rust `read_argument()`
+*/
+function readArgument(argument) {
+	if (argument !== void 0 && argument !== "") return argument;
+	const input = readStdinSync();
+	if (input.trim() === "") throw new Error("No argument provided");
+	return input.trim();
+}
+/**
+* Read all stdin synchronously.
+*/
+function readStdinSync() {
+	let input = "";
+	const BUFSIZE = 256;
+	const buf = Buffer.alloc(BUFSIZE);
+	try {
+		const fd = process.stdin.fd;
+		while (true) try {
+			const bytesRead = fs.readSync(fd, buf, 0, BUFSIZE, null);
+			if (bytesRead === 0) break;
+			input += buf.toString("utf8", 0, bytesRead);
+		} catch {
+			break;
+		}
+	} catch {}
+	return input;
+}
+/**
+* Convert bytes to hex string.
+*/
+function bytesToHex(bytes) {
+	return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+/**
+* Convert hex string to bytes.
+*/
+function hexToBytes(hex) {
+	const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
+	const bytes = new Uint8Array(cleanHex.length / 2);
+	for (let i = 0; i < cleanHex.length; i += 2) bytes[i / 2] = parseInt(cleanHex.slice(i, i + 2), 16);
+	return bytes;
+}
+/**
+* Convert bytes to base64 string.
+*/
+function toBase64(bytes) {
+	return Buffer.from(bytes).toString("base64");
+}
+/**
+* Convert base64 string to bytes.
+*/
+function fromBase64(base64) {
+	return new Uint8Array(Buffer.from(base64, "base64"));
+}
+
+//#endregion
+//#region src/cmd/info.ts
+/**
+* Info args - 1:1 port of info.rs
+*
+* Shared arguments for supplying provenance mark `info` payloads.
+*/
+/**
+* Parse info args to CBOR.
+*
+* Corresponds to Rust `InfoArgs::to_cbor()`
+*/
+function parseInfoArgs(args) {
+	if (args.info !== void 0) return parseInfo(args.info, args.infoTag);
+	if (args.infoTag !== void 0) throw new Error("--info-tag requires a UR payload");
+}
+/**
+* Parse hex-encoded CBOR.
+*
+* Corresponds to Rust `parse_hex()`
+*/
+function parseHex(input) {
+	const trimmed = input.trim();
+	const hexStr = trimmed.startsWith("0x") ? trimmed.slice(2) : trimmed;
+	try {
+		return (0, _bcts_dcbor.decodeCbor)(hexToBytes(hexStr));
+	} catch (e) {
+		const message = e instanceof Error ? e.message : String(e);
+		throw new Error(`failed to decode hex info payload: ${message}`);
+	}
+}
+/**
+* Parse info payload from raw string.
+*
+* Corresponds to Rust `parse_info()`
+*/
+function parseInfo(raw, tagOverride) {
+	const trimmed = raw.trim();
+	if (trimmed === "") throw new Error("info payload must not be empty");
+	if (trimmed.length >= 3 && trimmed.slice(0, 3).toLowerCase() === "ur:") return parseUrPayload(trimmed, tagOverride);
+	try {
+		const cborResult = parseHex(trimmed);
+		if (tagOverride !== void 0) throw new Error("--info-tag is only valid when the payload is a UR");
+		return cborResult;
+	} catch (hexErr) {
+		try {
+			return parseUrPayload(trimmed, tagOverride);
+		} catch (urErr) {
+			const hexMsg = hexErr instanceof Error ? hexErr.message : String(hexErr);
+			const urMsg = urErr instanceof Error ? urErr.message : String(urErr);
+			throw new Error(`failed to parse --info payload as hex (${hexMsg}) or UR (${urMsg})`);
+		}
+	}
+}
+/**
+* Parse UR payload.
+*
+* Corresponds to Rust `parse_ur_payload()`
+*/
+function parseUrPayload(input, tagOverride) {
+	let ur;
+	try {
+		ur = _bcts_uniform_resources.UR.fromURString(input.trim());
+	} catch (e) {
+		const message = e instanceof Error ? e.message : String(e);
+		throw new Error(`failed to parse UR info payload: ${message}`);
+	}
+	const typeStr = ur.urTypeStr();
+	const registeredTag = (0, _bcts_dcbor.getGlobalTagsStore)().tagForName(typeStr);
+	const registeredTagValue = registeredTag !== void 0 ? Number(registeredTag.value) : void 0;
+	if (registeredTagValue !== void 0 && tagOverride !== void 0) throw new Error(`UR type '${typeStr}' has a known CBOR tag; --info-tag must not be supplied`);
+	const expectedTag = registeredTagValue ?? tagOverride;
+	if (expectedTag === void 0) throw new Error(`UR type '${typeStr}' is not registered; supply --info-tag with the CBOR tag value`);
+	return ensureTag(ur.cbor(), expectedTag, typeStr);
+}
+/**
+* Ensure CBOR has the expected tag.
+*
+* Corresponds to Rust `ensure_tag()`
+*/
+function ensureTag(cborValue, expectedTag, typeStr) {
+	if ((0, _bcts_dcbor.isTagged)(cborValue)) {
+		const tag = (0, _bcts_dcbor.tagValue)(cborValue);
+		if (tag !== BigInt(expectedTag)) throw new Error(`UR type '${typeStr}' encodes CBOR tag ${tag} but ${expectedTag} was expected`);
+		return cborValue;
+	}
+	return (0, _bcts_dcbor.cbor)({
+		tag: expectedTag,
+		value: cborValue
+	});
+}
+
+//#endregion
+//#region src/cmd/seed.ts
+/**
+* Seed parsing - 1:1 port of seed.rs
+*
+* Functions for parsing provenance seeds from various formats.
+*/
+/**
+* Parse a seed from a string.
+*
+* Supports the following formats:
+* - `ur:seed/...` - UR-encoded seed
+* - `0x...` or hex string - Hex-encoded seed
+* - Base64 string - Base64-encoded seed
+*
+* Corresponds to Rust `parse_seed()`
+*/
+function parseSeed(input) {
+	const trimmed = input.trim();
+	if (trimmed === "") throw new Error("seed string is empty");
+	if (trimmed.toLowerCase().startsWith("ur:")) return parseSeedUr(trimmed);
+	const hexResult = parseSeedHex(trimmed);
+	if (hexResult !== void 0) return hexResult;
+	return parseSeedBase64(trimmed);
+}
+/**
+* Parse a seed from a UR string.
+*
+* Corresponds to Rust `parse_seed_ur()`
+*/
+function parseSeedUr(input) {
+	try {
+		const ur = _bcts_uniform_resources.UR.fromURString(input);
+		return seedFromExact(_bcts_components.Seed.fromUR(ur).toData());
+	} catch (e) {
+		const message = e instanceof Error ? e.message : String(e);
+		throw new Error(`failed to parse seed UR: ${message}`);
+	}
+}
+/**
+* Parse a seed from a hex string.
+*
+* Returns undefined if the string is not valid hex format.
+*
+* Corresponds to Rust `parse_seed_hex()`
+*/
+function parseSeedHex(input) {
+	const source = input.startsWith("0x") ? input.slice(2) : input;
+	if (source === "") return;
+	if (source.length % 2 !== 0) return;
+	if (!/^[0-9a-fA-F]+$/.test(source)) return;
+	try {
+		return seedFromExact(hexToBytes(source));
+	} catch (e) {
+		const message = e instanceof Error ? e.message : String(e);
+		throw new Error(`failed to decode hex seed: ${message}`);
+	}
+}
+/**
+* Parse a seed from a base64 string.
+*
+* Corresponds to Rust `parse_seed_base64()`
+*/
+function parseSeedBase64(input) {
+	try {
+		return seedFromExact(fromBase64(input));
+	} catch (e) {
+		const message = e instanceof Error ? e.message : String(e);
+		throw new Error(`failed to decode base64 seed: ${message}`);
+	}
+}
+/**
+* Create a seed from exactly PROVENANCE_SEED_LENGTH bytes.
+*
+* Corresponds to Rust `seed_from_exact()`
+*/
+function seedFromExact(bytes) {
+	if (bytes.length !== _bcts_provenance_mark.PROVENANCE_SEED_LENGTH) throw new Error(`seed must be ${_bcts_provenance_mark.PROVENANCE_SEED_LENGTH} bytes but found ${bytes.length}`);
+	return _bcts_provenance_mark.ProvenanceSeed.fromBytes(bytes);
+}
+
+//#endregion
+//#region src/cmd/new.ts
+/**
+* New command - 1:1 port of new.rs
+*
+* Initialize a directory with a new provenance mark chain.
+*/
+/**
+* Output format for the creation summary.
+*
+* Corresponds to Rust `OutputFormat`
+*/
+let OutputFormat = /* @__PURE__ */ function(OutputFormat$1) {
+	OutputFormat$1["Markdown"] = "markdown";
+	OutputFormat$1["Ur"] = "ur";
+	OutputFormat$1["Json"] = "json";
+	return OutputFormat$1;
+}({});
+/**
+* Resolution level for the provenance mark chain.
+*
+* Corresponds to Rust `Resolution`
+*/
+let Resolution = /* @__PURE__ */ function(Resolution$1) {
+	/** Good for physical works of art and applications requiring minimal mark size. */
+	Resolution$1["Low"] = "low";
+	/** Good for digital works of art. */
+	Resolution$1["Medium"] = "medium";
+	/** Good for general use. */
+	Resolution$1["Quartile"] = "quartile";
+	/** Industrial strength, largest mark. */
+	Resolution$1["High"] = "high";
+	return Resolution$1;
+}({});
+/**
+* Convert Resolution to ProvenanceMarkResolution.
+*/
+function resolutionToProvenanceMarkResolution(res) {
+	switch (res) {
+		case Resolution.Low: return _bcts_provenance_mark.ProvenanceMarkResolution.Low;
+		case Resolution.Medium: return _bcts_provenance_mark.ProvenanceMarkResolution.Medium;
+		case Resolution.Quartile: return _bcts_provenance_mark.ProvenanceMarkResolution.Quartile;
+		case Resolution.High: return _bcts_provenance_mark.ProvenanceMarkResolution.High;
+	}
+}
+/**
+* Parse a resolution string.
+*/
+function parseResolution(value) {
+	switch (value.toLowerCase()) {
+		case "low": return Resolution.Low;
+		case "medium": return Resolution.Medium;
+		case "quartile": return Resolution.Quartile;
+		case "high": return Resolution.High;
+		default: throw new Error(`Invalid resolution: ${value}. Must be one of: low, medium, quartile, high`);
+	}
+}
+/**
+* Parse an output format string.
+*/
+function parseOutputFormat(value) {
+	switch (value.toLowerCase()) {
+		case "markdown": return OutputFormat.Markdown;
+		case "ur": return OutputFormat.Ur;
+		case "json": return OutputFormat.Json;
+		default: throw new Error(`Invalid format: ${value}. Must be one of: markdown, ur, json`);
+	}
+}
+/**
+* Create default args for the new command.
+*/
+function defaultNewCommandArgs() {
+	return {
+		path: "",
+		resolution: Resolution.Quartile,
+		comment: "Genesis mark.",
+		quiet: false,
+		format: OutputFormat.Markdown,
+		info: {}
+	};
+}
+/**
+* New command implementation.
+*
+* Corresponds to Rust `impl Exec for CommandArgs`
+*/
+var NewCommand = class {
+	args;
+	constructor(args) {
+		this.args = args;
+	}
+	exec() {
+		const dirPath = this.createDir();
+		const marksPath = path.join(dirPath, "marks");
+		fs.mkdirSync(marksPath);
+		const resolution = resolutionToProvenanceMarkResolution(this.args.resolution);
+		let generator;
+		if (this.args.seed !== void 0) generator = _bcts_provenance_mark.ProvenanceMarkGenerator.newWithSeed(resolution, this.args.seed);
+		else generator = _bcts_provenance_mark.ProvenanceMarkGenerator.newRandom(resolution);
+		const date = this.args.date ?? /* @__PURE__ */ new Date();
+		const info = parseInfoArgs(this.args.info);
+		const mark = generator.next(date, info);
+		const markInfo = _bcts_provenance_mark.ProvenanceMarkInfo.new(mark, this.args.comment);
+		const markJson = JSON.stringify(markInfo.toJSON(), null, 2);
+		const markPath = path.join(marksPath, `mark-${mark.seq()}.json`);
+		fs.writeFileSync(markPath, markJson);
+		const generatorJson = JSON.stringify(generator.toJSON(), null, 2);
+		const generatorPath = path.join(dirPath, "generator.json");
+		fs.writeFileSync(generatorPath, generatorJson);
+		const statusLines = [`Provenance mark chain created at: ${dirPath}`, `Mark ${mark.seq()} written to: ${markPath}`];
+		switch (this.args.format) {
+			case OutputFormat.Markdown: {
+				const paragraphs = [];
+				if (!this.args.quiet) paragraphs.push(...statusLines);
+				paragraphs.push(markInfo.markdownSummary());
+				return paragraphs.join("\n\n");
+			}
+			case OutputFormat.Ur:
+				if (!this.args.quiet) for (const line of statusLines) console.error(line);
+				return markInfo.ur().toString();
+			case OutputFormat.Json:
+				if (!this.args.quiet) for (const line of statusLines) console.error(line);
+				return JSON.stringify(markInfo.toJSON(), null, 2);
+		}
+	}
+	createDir() {
+		const dirPath = readNewPath(this.args.path);
+		if (fs.existsSync(dirPath)) throw new Error(`Path already exists: ${dirPath}`);
+		const parent = path.dirname(dirPath);
+		if (!fs.existsSync(parent)) throw new Error(`Parent directory does not exist: ${parent}`);
+		fs.mkdirSync(dirPath);
+		return dirPath;
+	}
+};
+
+//#endregion
+//#region src/cmd/next.ts
+/**
+* Next command - 1:1 port of next.rs
+*
+* Generate the next provenance mark in a chain.
+*/
+/**
+* Create default args for the next command.
+*/
+function defaultNextCommandArgs() {
+	return {
+		path: "",
+		comment: "Blank.",
+		quiet: false,
+		format: OutputFormat.Markdown,
+		info: {}
+	};
+}
+/**
+* Next command implementation.
+*
+* Corresponds to Rust `impl Exec for CommandArgs`
+*/
+var NextCommand = class {
+	args;
+	constructor(args) {
+		this.args = args;
+	}
+	exec() {
+		const dirPath = readExistingDirectoryPath(this.args.path);
+		const generatorPath = path.join(dirPath, "generator.json");
+		const generatorJson = fs.readFileSync(generatorPath, "utf-8");
+		const generator = _bcts_provenance_mark.ProvenanceMarkGenerator.fromJSON(JSON.parse(generatorJson));
+		const date = this.args.date ?? /* @__PURE__ */ new Date();
+		const info = parseInfoArgs(this.args.info);
+		const mark = generator.next(date, info);
+		const markInfo = _bcts_provenance_mark.ProvenanceMarkInfo.new(mark, this.args.comment);
+		const marksPath = path.join(dirPath, "marks");
+		const markJson = JSON.stringify(markInfo.toJSON(), null, 2);
+		const markPath = path.join(marksPath, `mark-${mark.seq()}.json`);
+		fs.writeFileSync(markPath, markJson);
+		const newGeneratorJson = JSON.stringify(generator.toJSON(), null, 2);
+		fs.writeFileSync(generatorPath, newGeneratorJson);
+		const statusLine = `Mark ${mark.seq()} written to: ${markPath}`;
+		switch (this.args.format) {
+			case OutputFormat.Markdown: {
+				const paragraphs = [];
+				if (!this.args.quiet) paragraphs.push(statusLine);
+				paragraphs.push(markInfo.markdownSummary());
+				return paragraphs.join("\n\n");
+			}
+			case OutputFormat.Ur:
+				if (!this.args.quiet) console.error(statusLine);
+				return markInfo.ur().toString();
+			case OutputFormat.Json:
+				if (!this.args.quiet) console.error(statusLine);
+				return JSON.stringify(markInfo.toJSON(), null, 2);
+		}
+	}
+};
+
+//#endregion
+//#region src/cmd/print.ts
+/**
+* Print command - 1:1 port of print.rs
+*
+* Prints provenance marks in a chain.
+*/
+/**
+* Create default args for the print command.
+*/
+function defaultPrintCommandArgs() {
+	return {
+		path: "",
+		start: 0,
+		format: OutputFormat.Markdown
+	};
+}
+/**
+* Print command implementation.
+*
+* Corresponds to Rust `impl Exec for CommandArgs`
+*/
+var PrintCommand = class {
+	args;
+	constructor(args) {
+		this.args = args;
+	}
+	exec() {
+		const dirPath = readExistingDirectoryPath(this.args.path);
+		const generatorPath = path.join(dirPath, "generator.json");
+		const generatorJson = fs.readFileSync(generatorPath, "utf-8");
+		const lastValidSeq = _bcts_provenance_mark.ProvenanceMarkGenerator.fromJSON(JSON.parse(generatorJson)).nextSeq() - 1;
+		const startSeq = this.args.start;
+		const endSeq = this.args.end ?? lastValidSeq;
+		if (startSeq > endSeq) throw new Error("The start sequence number must be less than or equal to the end sequence number.");
+		if (endSeq > lastValidSeq) throw new Error("The end sequence number must be less than or equal to the last valid sequence number.");
+		const markInfos = [];
+		for (let seq = startSeq; seq <= endSeq; seq++) {
+			const markPath = path.join(dirPath, "marks", `mark-${seq}.json`);
+			const markJson = fs.readFileSync(markPath, "utf-8");
+			const markInfo = _bcts_provenance_mark.ProvenanceMarkInfo.fromJSON(JSON.parse(markJson));
+			markInfos.push(markInfo);
+		}
+		switch (this.args.format) {
+			case OutputFormat.Markdown: return markInfos.map((info) => info.markdownSummary()).join("\n");
+			case OutputFormat.Ur: return markInfos.map((info) => info.ur().toString()).join("\n");
+			case OutputFormat.Json: {
+				const jsonArray = markInfos.map((info) => info.toJSON());
+				return JSON.stringify(jsonArray, null, 2);
+			}
+		}
+	}
+};
+
+//#endregion
+//#region src/cmd/validate.ts
+/**
+* Validate command - 1:1 port of validate.rs
+*
+* Validate one or more provenance marks.
+*/
+/**
+* Output format for the validation report.
+*
+* Corresponds to Rust `Format`
+*/
+let ValidateFormat = /* @__PURE__ */ function(ValidateFormat$1) {
+	ValidateFormat$1["Text"] = "text";
+	ValidateFormat$1["JsonCompact"] = "json-compact";
+	ValidateFormat$1["JsonPretty"] = "json-pretty";
+	return ValidateFormat$1;
+}({});
+/**
+* Convert ValidateFormat to ValidationReportFormat.
+*/
+function formatToValidationReportFormat(format) {
+	switch (format) {
+		case ValidateFormat.Text: return _bcts_provenance_mark.ValidationReportFormat.Text;
+		case ValidateFormat.JsonCompact: return _bcts_provenance_mark.ValidationReportFormat.JsonCompact;
+		case ValidateFormat.JsonPretty: return _bcts_provenance_mark.ValidationReportFormat.JsonPretty;
+	}
+}
+/**
+* Parse a format string.
+*/
+function parseValidateFormat(value) {
+	switch (value.toLowerCase()) {
+		case "text": return ValidateFormat.Text;
+		case "json-compact": return ValidateFormat.JsonCompact;
+		case "json-pretty": return ValidateFormat.JsonPretty;
+		default: throw new Error(`Invalid format: ${value}. Must be one of: text, json-compact, json-pretty`);
+	}
+}
+/**
+* Create default args for the validate command.
+*/
+function defaultValidateCommandArgs() {
+	return {
+		marks: [],
+		warn: false,
+		format: ValidateFormat.Text
+	};
+}
+/**
+* Validate command implementation.
+*
+* Corresponds to Rust `impl Exec for CommandArgs`
+*/
+var ValidateCommand = class {
+	args;
+	constructor(args) {
+		this.args = args;
+	}
+	exec() {
+		let marks;
+		if (this.args.dir !== void 0) marks = this.loadMarksFromDir(this.args.dir);
+		else marks = this.parseMarksFromUrs(this.args.marks);
+		const report = (0, _bcts_provenance_mark.validate)(marks);
+		const output = (0, _bcts_provenance_mark.formatReport)(report, formatToValidationReportFormat(this.args.format));
+		if ((0, _bcts_provenance_mark.hasIssues)(report) && !this.args.warn) throw new Error(`Validation failed with issues:\n${output}`);
+		return output;
+	}
+	/**
+	* Parse marks from UR strings.
+	*
+	* Corresponds to Rust `parse_marks_from_urs()`
+	*/
+	parseMarksFromUrs(urStrings) {
+		const marks = [];
+		for (const urString of urStrings) {
+			const mark = this.extractProvenanceMark(urString.trim());
+			marks.push(mark);
+		}
+		return marks;
+	}
+	/**
+	* Extract a ProvenanceMark from a UR string.
+	*
+	* Supports three types of URs:
+	* 1. `ur:provenance` - Direct provenance mark
+	* 2. `ur:envelope` - Envelope with a 'provenance' assertion
+	* 3. Any other UR type - Attempts to decode CBOR as an envelope
+	*
+	* Corresponds to Rust `extract_provenance_mark()`
+	*/
+	extractProvenanceMark(urString) {
+		let ur;
+		try {
+			ur = _bcts_uniform_resources.UR.fromURString(urString);
+		} catch (e) {
+			const message = e instanceof Error ? e.message : String(e);
+			throw new Error(`Failed to parse UR '${urString}': ${message}`);
+		}
+		const urType = ur.urTypeStr();
+		const cborValue = ur.cbor();
+		if (urType === "provenance") try {
+			return _bcts_provenance_mark.ProvenanceMark.fromUntaggedCbor(cborValue);
+		} catch (e) {
+			const message = e instanceof Error ? e.message : String(e);
+			throw new Error(`Failed to decode provenance mark from '${urString}': ${message}`);
+		}
+		let envelope;
+		try {
+			envelope = _bcts_envelope.Envelope.fromUntaggedCbor(cborValue);
+		} catch (e) {
+			const message = e instanceof Error ? e.message : String(e);
+			throw new Error(`UR type '${urType}' is not 'provenance', and CBOR is not decodable as an envelope: ${message}`);
+		}
+		return this.extractProvenanceMarkFromEnvelope(envelope, urString);
+	}
+	/**
+	* Extract a ProvenanceMark from an Envelope.
+	*
+	* The envelope must contain exactly one 'provenance' assertion,
+	* and the object subject of that assertion must be a ProvenanceMark.
+	*
+	* Corresponds to Rust `extract_provenance_mark_from_envelope()`
+	*/
+	extractProvenanceMarkFromEnvelope(envelope, urString) {
+		let workingEnvelope = envelope;
+		if (envelope.isWrapped()) {
+			const innerEnvelope = envelope.unwrap();
+			if (innerEnvelope !== void 0) workingEnvelope = innerEnvelope;
+		}
+		const provenancePredicate = _bcts_envelope.Envelope.newWithKnownValue(_bcts_known_values.PROVENANCE);
+		const provenanceAssertions = workingEnvelope.assertionsWithPredicate(provenancePredicate);
+		if (provenanceAssertions.length === 0) throw new Error(`Envelope in '${urString}' does not contain a 'provenance' assertion`);
+		if (provenanceAssertions.length > 1) throw new Error(`Envelope in '${urString}' contains ${provenanceAssertions.length} 'provenance' assertions, expected exactly one`);
+		const objectEnvelope = provenanceAssertions[0].asObject();
+		if (objectEnvelope === void 0) throw new Error(`Failed to extract object from provenance assertion in '${urString}'`);
+		try {
+			const cborValue = objectEnvelope.asLeaf();
+			if (cborValue === void 0) throw new Error("Object envelope is not a leaf");
+			return _bcts_provenance_mark.ProvenanceMark.fromTaggedCbor(cborValue);
+		} catch (e) {
+			const message = e instanceof Error ? e.message : String(e);
+			throw new Error(`Failed to decode ProvenanceMark from provenance assertion in '${urString}': ${message}`);
+		}
+	}
+	/**
+	* Load marks from a directory.
+	*
+	* Corresponds to Rust `load_marks_from_dir()`
+	*/
+	loadMarksFromDir(dirPath) {
+		const resolvedPath = readExistingDirectoryPath(dirPath);
+		const marksPath = path.join(resolvedPath, "marks");
+		if (!fs.existsSync(marksPath) || !fs.statSync(marksPath).isDirectory()) throw new Error(`Marks subdirectory not found: ${marksPath}`);
+		const markFiles = fs.readdirSync(marksPath).map((entry) => path.join(marksPath, entry)).filter((p) => p.endsWith(".json")).sort();
+		if (markFiles.length === 0) throw new Error(`No mark JSON files found in: ${marksPath}`);
+		const marks = [];
+		for (const markFile of markFiles) try {
+			const jsonContent = fs.readFileSync(markFile, "utf-8");
+			const markInfo = _bcts_provenance_mark.ProvenanceMarkInfo.fromJSON(JSON.parse(jsonContent));
+			marks.push(markInfo.mark());
+		} catch (e) {
+			const message = e instanceof Error ? e.message : String(e);
+			throw new Error(`Failed to parse JSON from ${markFile}: ${message}`);
+		}
+		return marks;
+	}
+};
+
+//#endregion
+//#region src/index.ts
+/**
+* @bcts/provenance-mark-cli - Command line tool for creating and managing Provenance Marks
+*
+* This is a 1:1 TypeScript port of provenance-mark-cli-rust.
+*
+* @packageDocumentation
+*/
+const VERSION = "1.0.0-alpha.13";
+
+//#endregion
+Object.defineProperty(exports, 'NewCommand', {
+  enumerable: true,
+  get: function () {
+    return NewCommand;
+  }
+});
+Object.defineProperty(exports, 'NextCommand', {
+  enumerable: true,
+  get: function () {
+    return NextCommand;
+  }
+});
+Object.defineProperty(exports, 'OutputFormat', {
+  enumerable: true,
+  get: function () {
+    return OutputFormat;
+  }
+});
+Object.defineProperty(exports, 'PrintCommand', {
+  enumerable: true,
+  get: function () {
+    return PrintCommand;
+  }
+});
+Object.defineProperty(exports, 'Resolution', {
+  enumerable: true,
+  get: function () {
+    return Resolution;
+  }
+});
+Object.defineProperty(exports, 'VERSION', {
+  enumerable: true,
+  get: function () {
+    return VERSION;
+  }
+});
+Object.defineProperty(exports, 'ValidateCommand', {
+  enumerable: true,
+  get: function () {
+    return ValidateCommand;
+  }
+});
+Object.defineProperty(exports, 'ValidateFormat', {
+  enumerable: true,
+  get: function () {
+    return ValidateFormat;
+  }
+});
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});
+Object.defineProperty(exports, 'bytesToHex', {
+  enumerable: true,
+  get: function () {
+    return bytesToHex;
+  }
+});
+Object.defineProperty(exports, 'defaultNewCommandArgs', {
+  enumerable: true,
+  get: function () {
+    return defaultNewCommandArgs;
+  }
+});
+Object.defineProperty(exports, 'defaultNextCommandArgs', {
+  enumerable: true,
+  get: function () {
+    return defaultNextCommandArgs;
+  }
+});
+Object.defineProperty(exports, 'defaultPrintCommandArgs', {
+  enumerable: true,
+  get: function () {
+    return defaultPrintCommandArgs;
+  }
+});
+Object.defineProperty(exports, 'defaultValidateCommandArgs', {
+  enumerable: true,
+  get: function () {
+    return defaultValidateCommandArgs;
+  }
+});
+Object.defineProperty(exports, 'fromBase64', {
+  enumerable: true,
+  get: function () {
+    return fromBase64;
+  }
+});
+Object.defineProperty(exports, 'hexToBytes', {
+  enumerable: true,
+  get: function () {
+    return hexToBytes;
+  }
+});
+Object.defineProperty(exports, 'parseInfoArgs', {
+  enumerable: true,
+  get: function () {
+    return parseInfoArgs;
+  }
+});
+Object.defineProperty(exports, 'parseOutputFormat', {
+  enumerable: true,
+  get: function () {
+    return parseOutputFormat;
+  }
+});
+Object.defineProperty(exports, 'parseResolution', {
+  enumerable: true,
+  get: function () {
+    return parseResolution;
+  }
+});
+Object.defineProperty(exports, 'parseSeed', {
+  enumerable: true,
+  get: function () {
+    return parseSeed;
+  }
+});
+Object.defineProperty(exports, 'parseValidateFormat', {
+  enumerable: true,
+  get: function () {
+    return parseValidateFormat;
+  }
+});
+Object.defineProperty(exports, 'readArgument', {
+  enumerable: true,
+  get: function () {
+    return readArgument;
+  }
+});
+Object.defineProperty(exports, 'readExistingDirectoryPath', {
+  enumerable: true,
+  get: function () {
+    return readExistingDirectoryPath;
+  }
+});
+Object.defineProperty(exports, 'readNewPath', {
+  enumerable: true,
+  get: function () {
+    return readNewPath;
+  }
+});
+Object.defineProperty(exports, 'readStdinSync', {
+  enumerable: true,
+  get: function () {
+    return readStdinSync;
+  }
+});
+Object.defineProperty(exports, 'toBase64', {
+  enumerable: true,
+  get: function () {
+    return toBase64;
+  }
+});
+//# sourceMappingURL=src-XNNUeTzh.cjs.map