@bcts/seedtool-cli 1.0.0-alpha.14

package/dist/main.mjs

@@ -0,0 +1,1375 @@
+#!/usr/bin/env node
+import { Command, Option } from "commander";
+import { SecureRandomNumberGenerator } from "@bcts/rand";
+import { SSKRGroupSpec, SSKRSecret, SSKRShare, SSKRSpec, Seed, sskrCombine, sskrGenerate } from "@bcts/components";
+import * as readline from "readline";
+import { Envelope, SymmetricKey } from "@bcts/envelope";
+import { DATE, NAME, NOTE, SEED_TYPE } from "@bcts/known-values";
+import { CborDate, decodeCbor, expectBytes, toByteString, toTaggedValue } from "@bcts/dcbor";
+import { entropyToMnemonic, mnemonicToEntropy, validateMnemonic } from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english";
+import { BytewordsStyle, MultipartDecoder, MultipartEncoder, UR, decodeBytewords, encodeBytewords } from "@bcts/uniform-resources";
+import { SSKR_SHARE, SSKR_SHARE_V1 } from "@bcts/tags";
+import { sha256 } from "@noble/hashes/sha256";
+import { hkdf } from "@noble/hashes/hkdf";
+import * as fs from "node:fs";
+
+//#region src/cli.ts
+/**
+* CLI types and interfaces
+* Ported from seedtool-cli-rust/src/cli.rs
+*/
+/**
+* Input format keys.
+* Matches Rust InputFormatKey enum in format.rs
+*/
+let InputFormatKey = /* @__PURE__ */ function(InputFormatKey$1) {
+	InputFormatKey$1["Random"] = "random";
+	InputFormatKey$1["Hex"] = "hex";
+	InputFormatKey$1["Btw"] = "btw";
+	InputFormatKey$1["Btwu"] = "btwu";
+	InputFormatKey$1["Btwm"] = "btwm";
+	InputFormatKey$1["Bits"] = "bits";
+	InputFormatKey$1["Cards"] = "cards";
+	InputFormatKey$1["Dice"] = "dice";
+	InputFormatKey$1["Base6"] = "base6";
+	InputFormatKey$1["Base10"] = "base10";
+	InputFormatKey$1["Ints"] = "ints";
+	InputFormatKey$1["Bip39"] = "bip39";
+	InputFormatKey$1["Sskr"] = "sskr";
+	InputFormatKey$1["Envelope"] = "envelope";
+	InputFormatKey$1["Multipart"] = "multipart";
+	InputFormatKey$1["Seed"] = "seed";
+	return InputFormatKey$1;
+}({});
+/**
+* Output format keys.
+* Matches Rust OutputFormatKey enum in format.rs
+*/
+let OutputFormatKey = /* @__PURE__ */ function(OutputFormatKey$1) {
+	OutputFormatKey$1["Hex"] = "hex";
+	OutputFormatKey$1["Btw"] = "btw";
+	OutputFormatKey$1["Btwu"] = "btwu";
+	OutputFormatKey$1["Btwm"] = "btwm";
+	OutputFormatKey$1["Bits"] = "bits";
+	OutputFormatKey$1["Cards"] = "cards";
+	OutputFormatKey$1["Dice"] = "dice";
+	OutputFormatKey$1["Base6"] = "base6";
+	OutputFormatKey$1["Base10"] = "base10";
+	OutputFormatKey$1["Ints"] = "ints";
+	OutputFormatKey$1["Bip39"] = "bip39";
+	OutputFormatKey$1["Sskr"] = "sskr";
+	OutputFormatKey$1["Envelope"] = "envelope";
+	OutputFormatKey$1["Multipart"] = "multipart";
+	OutputFormatKey$1["Seed"] = "seed";
+	return OutputFormatKey$1;
+}({});
+/**
+* SSKR output format keys.
+* Matches Rust SSKRFormatKey enum in sskr.rs
+*/
+let SSKRFormatKey = /* @__PURE__ */ function(SSKRFormatKey$1) {
+	SSKRFormatKey$1["Envelope"] = "envelope";
+	SSKRFormatKey$1["Btw"] = "btw";
+	SSKRFormatKey$1["Btwm"] = "btwm";
+	SSKRFormatKey$1["Btwu"] = "btwu";
+	SSKRFormatKey$1["Ur"] = "ur";
+	return SSKRFormatKey$1;
+}({});
+/**
+* CLI state and configuration.
+* Matches Rust Cli struct.
+*/
+var Cli = class Cli {
+	/** The input to be transformed. If required and not present, will be read from stdin. */
+	input;
+	/** The number of output units (hex bytes, base-10 digits, etc.) */
+	count = 16;
+	/** The input format. Default: Random */
+	in = InputFormatKey.Random;
+	/** The output format. Default: Hex */
+	out = OutputFormatKey.Hex;
+	/** The lowest int returned (0-254). Default: 0 */
+	low = 0;
+	/** The highest int returned (1-255), low < high. Default: 9 */
+	high = 9;
+	/** The name of the seed. */
+	name;
+	/** The note associated with the seed. */
+	note;
+	/** The seed's creation date, in ISO-8601 format. May also be `now`. */
+	date;
+	/** For `multipart` output, max fragment length. Default: 500 */
+	maxFragmentLen = 500;
+	/** For `multipart` output, additional parts for fountain encoding. Default: 0 */
+	additionalParts = 0;
+	/** Group specifications for SSKR. */
+	groups = [];
+	/** The number of groups that must meet their threshold. Default: 1 */
+	groupThreshold = 1;
+	/** SSKR output format. Default: Envelope */
+	sskrFormat = SSKRFormatKey.Envelope;
+	/** Deterministic RNG seed string. */
+	deterministic;
+	/** The seed being processed (internal state). */
+	seed;
+	/** The RNG source (internal state). */
+	rng;
+	/**
+	* Get input from argument or read from stdin.
+	* Matches Rust expect_input method.
+	*/
+	expectInput() {
+		if (this.input !== void 0) return this.input;
+		throw new Error("Input required but not provided. Use stdin or pass as argument.");
+	}
+	/**
+	* Get input from argument or read from stdin asynchronously.
+	* This is the async version for actual CLI use.
+	*/
+	async expectInputAsync() {
+		if (this.input !== void 0) return this.input;
+		return new Promise((resolve, reject) => {
+			let data = "";
+			const rl = readline.createInterface({
+				input: process.stdin,
+				output: process.stdout,
+				terminal: false
+			});
+			rl.on("line", (line) => {
+				data += line + "\n";
+			});
+			rl.on("close", () => {
+				resolve(data.trim());
+			});
+			rl.on("error", (err) => {
+				reject(err);
+			});
+		});
+	}
+	/**
+	* Get the seed, throwing if not initialized.
+	* Matches Rust expect_seed method.
+	*/
+	expectSeed() {
+		if (this.seed === void 0) throw new Error("Seed not initialized");
+		return this.seed;
+	}
+	/**
+	* Generate random data using the configured RNG.
+	* Matches Rust random_data method.
+	*/
+	randomData(size) {
+		if (this.rng === void 0) throw new Error("RNG not initialized");
+		if (this.rng.type === "secure") return this.rng.rng.randomData(size);
+		else return this.rng.rng.deterministicRandomData(size);
+	}
+	/**
+	* Get the seed with CLI overrides applied (name, note, date).
+	* Matches Rust seed_with_overrides method.
+	*/
+	seedWithOverrides() {
+		const seed = this.expectSeed().clone();
+		if (this.name !== void 0) seed.setName(this.name);
+		if (this.note !== void 0) seed.setNote(this.note);
+		if (this.date !== void 0) seed.setCreationDate(this.date);
+		return seed;
+	}
+	/**
+	* Convert the seed (with overrides) to an Envelope.
+	* Matches Rust to_envelope method.
+	*/
+	toEnvelope() {
+		return this.seedWithOverrides().toEnvelope();
+	}
+	/**
+	* Build SSKR spec from CLI options.
+	* Matches Rust sskr_spec method.
+	*/
+	sskrSpec() {
+		return SSKRSpec.new(this.groupThreshold, this.groups);
+	}
+	/**
+	* Clone the CLI state.
+	*/
+	clone() {
+		const cli = new Cli();
+		cli.input = this.input;
+		cli.count = this.count;
+		cli.in = this.in;
+		cli.out = this.out;
+		cli.low = this.low;
+		cli.high = this.high;
+		cli.name = this.name;
+		cli.note = this.note;
+		cli.date = this.date;
+		cli.maxFragmentLen = this.maxFragmentLen;
+		cli.additionalParts = this.additionalParts;
+		cli.groups = [...this.groups];
+		cli.groupThreshold = this.groupThreshold;
+		cli.sskrFormat = this.sskrFormat;
+		cli.deterministic = this.deterministic;
+		cli.seed = this.seed?.clone();
+		cli.rng = this.rng;
+		return cli;
+	}
+};
+
+//#endregion
+//#region src/seed.ts
+/**
+* Seed type for seedtool-cli
+* Ported from seedtool-cli-rust/src/seed.rs
+*
+* This is a local Seed type that wraps the seed data with metadata
+* and provides Envelope conversion. It differs from @bcts/components Seed
+* in that it doesn't enforce minimum length (for CLI flexibility) and
+* has direct Envelope conversion methods.
+*/
+/**
+* Seed with optional metadata.
+* Matches Rust Seed struct in seed.rs.
+*/
+var Seed$1 = class Seed$1 {
+	_data;
+	_name;
+	_note;
+	_creationDate;
+	/**
+	* Create a new Seed with the given data.
+	* Matches Rust Seed::new function.
+	*/
+	constructor(data) {
+		this._data = new Uint8Array(data);
+		this._name = "";
+		this._note = "";
+		this._creationDate = void 0;
+	}
+	/**
+	* Create a new Seed with data and optional metadata.
+	* Matches Rust Seed::new_opt function.
+	*/
+	static newOpt(data, name, note, creationDate) {
+		const seed = new Seed$1(data);
+		seed._name = name;
+		seed._note = note;
+		seed._creationDate = creationDate;
+		return seed;
+	}
+	/**
+	* Create a new Seed from raw data.
+	* Convenience factory method.
+	*/
+	static new(data) {
+		return new Seed$1(data);
+	}
+	/**
+	* Get the seed data.
+	* Matches Rust seed.data() method.
+	*/
+	data() {
+		return this._data;
+	}
+	/**
+	* Get the seed name.
+	* Matches Rust seed.name() method.
+	* Returns empty string if not set.
+	*/
+	name() {
+		return this._name;
+	}
+	/**
+	* Set the seed name.
+	* Matches Rust seed.set_name() method.
+	*/
+	setName(name) {
+		this._name = name;
+	}
+	/**
+	* Get the seed note.
+	* Matches Rust seed.note() method.
+	* Returns empty string if not set.
+	*/
+	note() {
+		return this._note;
+	}
+	/**
+	* Set the seed note.
+	* Matches Rust seed.set_note() method.
+	*/
+	setNote(note) {
+		this._note = note;
+	}
+	/**
+	* Get the creation date.
+	* Matches Rust seed.creation_date() method.
+	*/
+	creationDate() {
+		return this._creationDate;
+	}
+	/**
+	* Set the creation date.
+	* Matches Rust seed.set_creation_date() method.
+	*/
+	setCreationDate(date) {
+		this._creationDate = date;
+	}
+	/**
+	* Clone the seed.
+	*/
+	clone() {
+		return Seed$1.newOpt(new Uint8Array(this._data), this._name, this._note, this._creationDate);
+	}
+	/**
+	* Convert to Envelope.
+	* Matches Rust impl From<Seed> for Envelope.
+	*
+	* Creates an envelope with:
+	* - Subject: byte string of seed data
+	* - Type assertion: 'Seed'
+	* - Optional date assertion
+	* - Optional name assertion (if not empty)
+	* - Optional note assertion (if not empty)
+	*/
+	toEnvelope() {
+		let envelope = Envelope.new(toByteString(this._data));
+		envelope = envelope.addType(SEED_TYPE);
+		if (this._creationDate !== void 0) {
+			const cborDate = CborDate.fromDatetime(this._creationDate);
+			envelope = envelope.addAssertion(DATE, cborDate);
+		}
+		if (this._name.length > 0) envelope = envelope.addAssertion(NAME, this._name);
+		if (this._note.length > 0) envelope = envelope.addAssertion(NOTE, this._note);
+		return envelope;
+	}
+	/**
+	* Create a Seed from an Envelope.
+	* Matches Rust impl TryFrom<Envelope> for Seed.
+	*/
+	static fromEnvelope(envelope) {
+		envelope.checkTypeValue(SEED_TYPE);
+		const leaf = envelope.subject().asLeaf();
+		if (leaf === void 0) throw new Error("Seed envelope must have a leaf subject");
+		const data = leaf.asByteString();
+		if (data === void 0) throw new Error("Seed envelope subject must be a byte string");
+		let name = "";
+		try {
+			const nameObj = envelope.objectForPredicate(NAME);
+			if (nameObj !== void 0) {
+				const nameStr = nameObj.asText();
+				if (nameStr !== void 0) name = nameStr;
+			}
+		} catch {}
+		let note = "";
+		try {
+			const noteObj = envelope.objectForPredicate(NOTE);
+			if (noteObj !== void 0) {
+				const noteStr = noteObj.asText();
+				if (noteStr !== void 0) note = noteStr;
+			}
+		} catch {}
+		let creationDate;
+		try {
+			const dateObj = envelope.objectForPredicate(DATE);
+			if (dateObj !== void 0) {
+				const leaf$1 = dateObj.asLeaf();
+				if (leaf$1 !== void 0) creationDate = CborDate.fromTaggedCbor(leaf$1).datetime();
+			}
+		} catch {
+			try {
+				const dateObj = envelope.objectForPredicate(DATE);
+				if (dateObj !== void 0) {
+					const dateStr = dateObj.asText();
+					if (dateStr !== void 0) creationDate = new Date(dateStr);
+				}
+			} catch {}
+		}
+		return Seed$1.newOpt(data, name, note, creationDate);
+	}
+	/**
+	* Convert to @bcts/components Seed.
+	* Matches Rust impl TryFrom<&Seed> for ComponentsSeed.
+	*/
+	toComponentsSeed() {
+		return Seed.newOpt(this._data, this._name.length > 0 ? this._name : void 0, this._note.length > 0 ? this._note : void 0, this._creationDate);
+	}
+	/**
+	* Create from @bcts/components Seed.
+	* Matches Rust impl From<ComponentsSeed> for Seed.
+	*/
+	static fromComponentsSeed(seed) {
+		return Seed$1.newOpt(seed.asBytes(), seed.name(), seed.note(), seed.creationDate());
+	}
+	/**
+	* Get string representation.
+	*/
+	toString() {
+		return `Seed(${Array.from(this._data.slice(0, 8)).map((b) => b.toString(16).padStart(2, "0")).join("")}..., ${this._data.length} bytes)`;
+	}
+	/**
+	* Check equality with another Seed.
+	*/
+	equals(other) {
+		if (this._data.length !== other._data.length) return false;
+		for (let i = 0; i < this._data.length; i++) if (this._data[i] !== other._data[i]) return false;
+		if (this._name !== other._name) return false;
+		if (this._note !== other._note) return false;
+		if (this._creationDate?.getTime() !== other._creationDate?.getTime()) return false;
+		return true;
+	}
+};
+
+//#endregion
+//#region src/util.ts
+/**
+* Utility functions for data conversion
+* Ported from seedtool-cli-rust/src/util.rs
+*/
+/**
+* Convert bytes to hex string.
+* Matches Rust data_to_hex function.
+*/
+function dataToHex(bytes) {
+	return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+/**
+* Convert hex string to bytes.
+* Matches Rust hex_to_data function.
+*/
+function hexToData(hex) {
+	if (hex.length % 2 !== 0) throw new Error("Hex string must have even length");
+	const bytes = new Uint8Array(hex.length / 2);
+	for (let i = 0; i < hex.length; i += 2) {
+		const byte = parseInt(hex.substring(i, i + 2), 16);
+		if (isNaN(byte)) throw new Error(`Invalid hex character at position ${i}`);
+		bytes[i / 2] = byte;
+	}
+	return bytes;
+}
+/**
+* Convert byte values to a different base range [0, base-1].
+* Each byte (0-255) is scaled proportionally to the target base.
+* Matches Rust data_to_base function.
+*
+* @param buf - Input bytes
+* @param base - Target base (e.g., 6 for base-6)
+* @returns Array of values in range [0, base-1]
+*/
+function dataToBase(buf, base) {
+	const result = new Uint8Array(buf.length);
+	for (let i = 0; i < buf.length; i++) result[i] = Math.round(buf[i] / 255 * (base - 1));
+	return result;
+}
+/**
+* Convert bytes to an alphabet string using a base and alphabet function.
+* Matches Rust data_to_alphabet function.
+*
+* @param buf - Input bytes
+* @param base - Target base
+* @param toAlphabet - Function to convert index to character
+* @returns String of alphabet characters
+*/
+function dataToAlphabet(buf, base, toAlphabet) {
+	const data = dataToBase(buf, base);
+	return Array.from(data).map((b) => toAlphabet(b)).join("");
+}
+/**
+* Parse whitespace-separated integers.
+* Matches Rust parse_ints function.
+*
+* @param input - Space-separated integer string
+* @returns Array of bytes
+* @throws Error if any integer is out of range [0, 255]
+*/
+function parseInts(input) {
+	const parts = input.trim().split(/\s+/);
+	const result = [];
+	for (const s of parts) {
+		if (s === "") continue;
+		const i = parseInt(s, 10);
+		if (isNaN(i)) throw new Error(`Invalid integer: ${s}`);
+		if (i < 0 || i > 255) throw new Error("Integer out of range. Allowed: [0-255]");
+		result.push(i);
+	}
+	return new Uint8Array(result);
+}
+/**
+* Convert bytes to a string of integers in a given range.
+* Matches Rust data_to_ints function.
+*
+* @param buf - Input bytes
+* @param low - Lowest output value (0-254)
+* @param high - Highest output value (1-255), low < high
+* @param separator - String to separate values
+* @returns String of integers
+* @throws Error if range is invalid
+*/
+function dataToInts(buf, low, high, separator) {
+	if (!(low < high && high <= 255)) throw new Error("Int conversion range must be in 0 <= low < high <= 255.");
+	const data = dataToBase(buf, high - low + 1);
+	return Array.from(data).map((b) => (b + low).toString()).join(separator);
+}
+/**
+* Parse a string of digits in a given range to bytes.
+* Matches Rust digits_to_data function.
+*
+* @param inStr - String of digits
+* @param low - Lowest valid digit
+* @param high - Highest valid digit
+* @returns Array of digit values
+* @throws Error if any digit is out of range
+*/
+function digitsToData(inStr, low, high) {
+	const result = [];
+	for (const c of inStr) {
+		const n = c.charCodeAt(0) - "0".charCodeAt(0);
+		if (n < low || n > high) throw new Error(`Invalid digit: ${c}. Expected range [${low}-${high}].`);
+		result.push(n);
+	}
+	return new Uint8Array(result);
+}
+
+//#endregion
+//#region src/formats/hex.ts
+/**
+* Hexadecimal format handler.
+* Round-trippable: hex → seed → hex.
+*/
+var HexFormat = class {
+	name() {
+		return "hex";
+	}
+	roundTrippable() {
+		return true;
+	}
+	processInput(state) {
+		const input = state.expectInput();
+		state.seed = Seed$1.new(hexToData(input));
+		return state;
+	}
+	processOutput(state) {
+		return dataToHex(state.expectSeed().data());
+	}
+};
+
+//#endregion
+//#region src/formats/bip39.ts
+/**
+* BIP39 mnemonic format handler.
+* Round-trippable: mnemonic → seed → mnemonic.
+*/
+var Bip39Format = class {
+	name() {
+		return "bip39";
+	}
+	roundTrippable() {
+		return true;
+	}
+	processInput(state) {
+		const normalized = state.expectInput().toLowerCase().trim().replace(/\s+/g, " ");
+		if (!validateMnemonic(normalized, wordlist)) throw new Error("Invalid BIP39 mnemonic");
+		const entropy = mnemonicToEntropy(normalized, wordlist);
+		state.seed = Seed$1.new(entropy);
+		return state;
+	}
+	processOutput(state) {
+		return entropyToMnemonic(state.expectSeed().data(), wordlist);
+	}
+};
+
+//#endregion
+//#region src/formats/sskr.ts
+/**
+* SSKR format handler.
+* Round-trippable: sskr shares → seed → sskr shares.
+* Supports multiple sub-formats: envelope, btw, btwm, btwu, ur.
+*/
+var SSKRFormat = class {
+	name() {
+		return "sskr";
+	}
+	roundTrippable() {
+		return true;
+	}
+	processInput(state) {
+		state.seed = parseSskrSeed(state.expectInput());
+		return state;
+	}
+	processOutput(state) {
+		const spec = state.sskrSpec();
+		const seed = state.expectSeed();
+		const format = state.sskrFormat;
+		return outputSskrSeed(seed, spec, format);
+	}
+};
+function outputSskrSeed(seed, spec, format) {
+	switch (format) {
+		case "envelope": {
+			const envelope = seed.toEnvelope();
+			const contentKey = SymmetricKey.new();
+			return envelope.wrap().encryptSubject(contentKey).sskrSplitFlattened(spec, contentKey).map((envelope$1) => envelope$1.urString()).join("\n");
+		}
+		case "btw": return makeBytewordsShares(spec, seed, BytewordsStyle.Standard);
+		case "btwm": return makeBytewordsShares(spec, seed, BytewordsStyle.Minimal);
+		case "btwu": return makeBytewordsShares(spec, seed, BytewordsStyle.Uri);
+		case "ur": return makeShares(spec, seed).map((share) => {
+			return UR.fromCbor("sskr", toByteString(share.asBytes())).toString();
+		}).join("\n");
+	}
+}
+function makeShares(spec, seed) {
+	const shareGroups = sskrGenerate(spec, SSKRSecret.new(seed.data()));
+	const flatShares = [];
+	for (const group of shareGroups) for (const shareData of group) flatShares.push(SSKRShare.fromData(shareData));
+	return flatShares;
+}
+function makeBytewordsShares(spec, seed, style) {
+	return makeShares(spec, seed).map((share) => toTaggedValue(SSKR_SHARE.value, toByteString(share.asBytes()))).map((share) => encodeBytewords(share.toData(), style)).join("\n");
+}
+function parseEnvelopes(input) {
+	try {
+		const shareStrings = input.split(/\s+/).filter((s) => s.length > 0);
+		const shareEnvelopes = [];
+		for (const str of shareStrings) try {
+			const envelope = Envelope.fromURString(str);
+			shareEnvelopes.push(envelope);
+		} catch {}
+		if (shareEnvelopes.length === 0) return null;
+		const recoveredEnvelope = Envelope.sskrJoin(shareEnvelopes).unwrap();
+		return Seed$1.fromEnvelope(recoveredEnvelope);
+	} catch {
+		return null;
+	}
+}
+function fromUntaggedCborShares(untaggedCborShares) {
+	try {
+		const recoveredSecret = sskrCombine(untaggedCborShares);
+		return Seed$1.new(recoveredSecret.getData());
+	} catch {
+		return null;
+	}
+}
+function fromTaggedCborShares(taggedCborDataShares) {
+	try {
+		const untaggedShares = [];
+		for (const data of taggedCborDataShares) {
+			const cbor = decodeCbor(data);
+			const tagged = cbor;
+			if (tagged.tag !== SSKR_SHARE.value && tagged.tag !== SSKR_SHARE_V1.value) return null;
+			const bytes = expectBytes(tagged.value || cbor);
+			untaggedShares.push(bytes);
+		}
+		return fromUntaggedCborShares(untaggedShares);
+	} catch {
+		return null;
+	}
+}
+function parseBytewords(input, style) {
+	try {
+		let shareStrings;
+		if (style === BytewordsStyle.Standard) shareStrings = input.split("\n").filter((s) => s.length > 0);
+		else shareStrings = input.split(/\s+/).filter((s) => s.length > 0);
+		const cborDataShares = [];
+		for (const s of shareStrings) try {
+			const decoded = decodeBytewords(s, style);
+			cborDataShares.push(decoded);
+		} catch {}
+		if (cborDataShares.length === 0) return null;
+		return fromTaggedCborShares(cborDataShares);
+	} catch {
+		return null;
+	}
+}
+function parseUr(input, expectedTagValue, allowTaggedCbor) {
+	try {
+		const expectedType = expectedTagValue === SSKR_SHARE.value ? "sskr" : "crypto-sskr";
+		const shareStrings = input.split(/\s+/).filter((s) => s.length > 0);
+		const urs = [];
+		for (const str of shareStrings) try {
+			const ur = UR.fromURString(str);
+			urs.push(ur);
+		} catch {}
+		if (urs.length === 0) return null;
+		for (const ur of urs) if (ur.type() !== expectedType) return null;
+		const untaggedCborShares = [];
+		for (const ur of urs) {
+			let cbor = ur.cbor();
+			if (allowTaggedCbor) try {
+				const tagged = decodeCbor(cbor.toData());
+				if (tagged.tag === SSKR_SHARE.value || tagged.tag === SSKR_SHARE_V1.value) cbor = tagged.value;
+			} catch {}
+			const bytes = expectBytes(cbor);
+			untaggedCborShares.push(bytes);
+		}
+		return fromUntaggedCborShares(untaggedCborShares);
+	} catch {
+		return null;
+	}
+}
+function parseSskrSeed(input) {
+	const envelopeResult = parseEnvelopes(input);
+	if (envelopeResult !== null) return envelopeResult;
+	const btwResult = parseBytewords(input, BytewordsStyle.Standard);
+	if (btwResult !== null) return btwResult;
+	const btwmResult = parseBytewords(input, BytewordsStyle.Minimal);
+	if (btwmResult !== null) return btwmResult;
+	const btwuResult = parseBytewords(input, BytewordsStyle.Uri);
+	if (btwuResult !== null) return btwuResult;
+	const urResult = parseUr(input, SSKR_SHARE.value, false);
+	if (urResult !== null) return urResult;
+	const urLegacyResult = parseUr(input, SSKR_SHARE_V1.value, true);
+	if (urLegacyResult !== null) return urLegacyResult;
+	throw new Error("Insufficient or invalid SSKR shares.");
+}
+
+//#endregion
+//#region src/formats/envelope.ts
+/**
+* Gordian Envelope format handler.
+* Round-trippable: envelope UR → seed → envelope UR.
+*/
+var EnvelopeFormat = class {
+	name() {
+		return "envelope";
+	}
+	roundTrippable() {
+		return true;
+	}
+	processInput(state) {
+		const input = state.expectInput();
+		const envelope = Envelope.fromURString(input);
+		state.seed = Seed$1.fromEnvelope(envelope);
+		return state;
+	}
+	processOutput(state) {
+		return state.toEnvelope().urString();
+	}
+};
+
+//#endregion
+//#region src/formats/seed-format.ts
+/**
+* Seed UR format handler.
+* Round-trippable: seed UR → seed → seed UR.
+* Uses the ur:seed format from bc-components.
+*/
+var SeedFormat = class {
+	name() {
+		return "seed";
+	}
+	roundTrippable() {
+		return true;
+	}
+	processInput(state) {
+		const input = state.expectInput();
+		const componentsSeed = Seed.fromURString(input);
+		state.seed = Seed$1.fromComponentsSeed(componentsSeed);
+		return state;
+	}
+	processOutput(state) {
+		return state.seedWithOverrides().toComponentsSeed().urString();
+	}
+};
+
+//#endregion
+//#region src/formats/multipart.ts
+/**
+* Multipart UR format handler.
+* Round-trippable: multipart URs → seed → multipart URs.
+* Uses fountain encoding for reliable transmission.
+*/
+var MultipartFormat = class {
+	name() {
+		return "multipart";
+	}
+	roundTrippable() {
+		return true;
+	}
+	processInput(state) {
+		const shares = state.expectInput().split(/\s+/).filter((s) => s.length > 0);
+		const decoder = new MultipartDecoder();
+		for (const share of shares) {
+			decoder.receive(share);
+			if (decoder.isComplete()) break;
+		}
+		if (!decoder.isComplete()) throw new Error("Insufficient multipart shares");
+		const ur = decoder.message();
+		if (ur === void 0) throw new Error("Failed to decode multipart message");
+		const envelope = Envelope.fromUR(ur);
+		state.seed = Seed$1.fromEnvelope(envelope);
+		return state;
+	}
+	processOutput(state) {
+		const encoder = new MultipartEncoder(state.toEnvelope().ur(), state.maxFragmentLen);
+		const partsCount = encoder.partsCount() + state.additionalParts;
+		const parts = [];
+		for (let i = 0; i < partsCount; i++) parts.push(encoder.nextPart());
+		return parts.join("\n");
+	}
+};
+
+//#endregion
+//#region src/formats/random.ts
+/**
+* Random seed generation format.
+* Input-only: generates a new random seed.
+*/
+var RandomFormat = class {
+	name() {
+		return "random";
+	}
+	roundTrippable() {
+		return true;
+	}
+	processInput(state) {
+		const data = state.randomData(state.count);
+		state.seed = Seed$1.new(data);
+		return state;
+	}
+};
+
+//#endregion
+//#region src/random.ts
+/**
+* Random number generation utilities
+* Ported from seedtool-cli-rust/src/random.rs
+*/
+/** SHA256 output size in bytes */
+const SHA256_SIZE = 32;
+/**
+* Deterministic random number generator.
+* Matches Rust DeterministicRandomNumberGenerator struct.
+*
+* Uses HKDF-HMAC-SHA256 to generate deterministic random data
+* from a seed, with an incrementing salt for each call.
+*/
+var DeterministicRandomNumberGenerator = class DeterministicRandomNumberGenerator {
+	seed;
+	salt;
+	/**
+	* Create a new deterministic RNG from a 32-byte seed.
+	*/
+	constructor(seed) {
+		if (seed.length !== SHA256_SIZE) throw new Error(`Seed must be ${SHA256_SIZE} bytes, got ${seed.length}`);
+		this.seed = new Uint8Array(seed);
+		this.salt = 0n;
+	}
+	/**
+	* Create a new deterministic RNG from a seed string.
+	* The string is hashed with SHA256 to produce the seed.
+	* Matches Rust new_with_seed function.
+	*/
+	static newWithSeed(seedString) {
+		return new DeterministicRandomNumberGenerator(sha256(new TextEncoder().encode(seedString)));
+	}
+	/**
+	* Generate deterministic random data.
+	* Matches Rust deterministic_random_data method.
+	*
+	* Each call increments the salt and uses HKDF to derive
+	* the requested number of bytes.
+	*/
+	deterministicRandomData(size) {
+		this.salt += 1n;
+		const saltBytes = new Uint8Array(8);
+		const view = new DataView(saltBytes.buffer);
+		const low = Number(this.salt & 4294967295n);
+		const high = Number(this.salt >> 32n & 4294967295n);
+		view.setUint32(0, low, true);
+		view.setUint32(4, high, true);
+		return hkdfHmacSha256(this.seed, saltBytes, size);
+	}
+	/**
+	* Clone the RNG state.
+	*/
+	clone() {
+		const rng = new DeterministicRandomNumberGenerator(this.seed);
+		rng.salt = this.salt;
+		return rng;
+	}
+};
+/**
+* HKDF-HMAC-SHA256 key derivation.
+* Matches Rust hkdf_hmac_sha256 function from bc-crypto.
+*/
+function hkdfHmacSha256(ikm, salt, length) {
+	return hkdf(sha256, ikm, salt, new Uint8Array(0), length);
+}
+/**
+* Generate deterministic random data from entropy using SHA256.
+* If n <= 32, returns the first n bytes of SHA256(entropy).
+* Matches Rust sha256_deterministic_random function.
+*
+* @param entropy - The entropy bytes to hash
+* @param n - Number of bytes to return (must be <= 32)
+* @throws Error if n > 32
+*/
+function sha256DeterministicRandom(entropy, n) {
+	const seed = sha256(entropy);
+	if (n <= seed.length) return seed.slice(0, n);
+	else throw new Error("Random number generator limits reached.");
+}
+/**
+* Generate deterministic random data from a string using SHA256.
+* Matches Rust sha256_deterministic_random_string function.
+*
+* @param str - The string to hash
+* @param n - Number of bytes to return (must be <= 32)
+* @throws Error if n > 32
+*/
+function sha256DeterministicRandomString(str, n) {
+	return sha256DeterministicRandom(new TextEncoder().encode(str), n);
+}
+/**
+* Generate deterministic random data from entropy using HKDF.
+* This can generate any length output.
+* Matches Rust deterministic_random function.
+*
+* @param entropy - The entropy bytes
+* @param n - Number of bytes to return
+*/
+function deterministicRandom(entropy, n) {
+	return hkdfHmacSha256(sha256(entropy), new Uint8Array(0), n);
+}
+
+//#endregion
+//#region src/formats/base6.ts
+/**
+* Base-6 format handler.
+* NOT round-trippable: input is entropy source.
+* Digits 0-5 (compatible with https://iancoleman.io/bip39/).
+*/
+var Base6Format = class {
+	name() {
+		return "base6";
+	}
+	roundTrippable() {
+		return false;
+	}
+	processInput(state) {
+		const input = state.expectInput();
+		digitsToData(input, 0, 5);
+		const data = sha256DeterministicRandomString(input, state.count);
+		state.seed = Seed$1.new(data);
+		return state;
+	}
+	processOutput(state) {
+		return dataToInts(state.expectSeed().data(), 0, 5, "");
+	}
+};
+
+//#endregion
+//#region src/formats/base10.ts
+/**
+* Base-10 format handler.
+* NOT round-trippable: input is entropy source.
+* Digits 0-9 (compatible with https://iancoleman.io/bip39/).
+*/
+var Base10Format = class {
+	name() {
+		return "base10";
+	}
+	roundTrippable() {
+		return false;
+	}
+	processInput(state) {
+		const input = state.expectInput();
+		digitsToData(input, 0, 9);
+		const data = sha256DeterministicRandomString(input, state.count);
+		state.seed = Seed$1.new(data);
+		return state;
+	}
+	processOutput(state) {
+		return dataToInts(state.expectSeed().data(), 0, 9, "");
+	}
+};
+
+//#endregion
+//#region src/formats/bits.ts
+/**
+* Binary format handler.
+* NOT round-trippable: input is entropy source.
+* Bits 0-1 (compatible with https://iancoleman.io/bip39/).
+*/
+var BitsFormat = class {
+	name() {
+		return "bits";
+	}
+	roundTrippable() {
+		return false;
+	}
+	processInput(state) {
+		const input = state.expectInput();
+		digitsToData(input, 0, 1);
+		const data = sha256DeterministicRandomString(input, state.count);
+		state.seed = Seed$1.new(data);
+		return state;
+	}
+	processOutput(state) {
+		return dataToInts(state.expectSeed().data(), 0, 1, "");
+	}
+};
+
+//#endregion
+//#region src/formats/dice.ts
+/**
+* Dice roll format handler.
+* NOT round-trippable: input is entropy source.
+* Digits 1-6 (compatible with https://iancoleman.io/bip39/).
+*/
+var DiceFormat = class {
+	name() {
+		return "dice";
+	}
+	roundTrippable() {
+		return false;
+	}
+	processInput(state) {
+		const input = state.expectInput();
+		digitsToData(input, 1, 6);
+		const data = sha256DeterministicRandomString(input, state.count);
+		state.seed = Seed$1.new(data);
+		return state;
+	}
+	processOutput(state) {
+		return dataToInts(state.expectSeed().data(), 1, 6, "");
+	}
+};
+
+//#endregion
+//#region src/formats/cards.ts
+const CARD_SUITS = "cdhs";
+const CARD_RANKS = "a23456789tjqk";
+/**
+* Parse a card rank character.
+* Returns index 0-12.
+*/
+function parseRank(c) {
+	const lower = c.toLowerCase();
+	const index = CARD_RANKS.indexOf(lower);
+	if (index === -1) throw new Error(`Invalid card rank: ${c}. Allowed: [A,2-9,T,J,Q,K]`);
+	return index;
+}
+/**
+* Parse a card suit character.
+* Returns index 0-3.
+*/
+function parseSuit(c) {
+	const lower = c.toLowerCase();
+	const index = CARD_SUITS.indexOf(lower);
+	if (index === -1) throw new Error(`Invalid card suit: ${c}. Allowed: [C,D,H,S]`);
+	return index;
+}
+/**
+* Convert card string to byte array.
+* Each pair of characters represents one card.
+*/
+function cardsToData(cards) {
+	const len = cards.length;
+	if (len % 2 !== 0) throw new Error("Cards string must have even number of characters.");
+	const count = len / 2;
+	const result = new Uint8Array(count);
+	for (let i = 0; i < count; i++) {
+		const rank = parseRank(cards[i * 2]);
+		result[i] = parseSuit(cards[i * 2 + 1]) * 13 + rank;
+	}
+	return result;
+}
+/**
+* Convert a card index (0-51) to card string.
+*/
+function toCard(n) {
+	if (n > 51) throw new Error(`Card index out of range: ${n}`);
+	const rank = n % 13;
+	const suit = Math.floor(n / 13);
+	return CARD_RANKS[rank] + CARD_SUITS[suit];
+}
+/**
+* Playing cards format handler.
+* NOT round-trippable: input is entropy source.
+* Card notation: rank (A,2-9,T,J,Q,K) + suit (C,D,H,S).
+*/
+var CardsFormat = class {
+	name() {
+		return "cards";
+	}
+	roundTrippable() {
+		return false;
+	}
+	processInput(state) {
+		const data = deterministicRandom(cardsToData(state.expectInput()), state.count);
+		state.seed = Seed$1.new(data);
+		return state;
+	}
+	processOutput(state) {
+		return dataToAlphabet(state.expectSeed().data(), 52, toCard);
+	}
+};
+
+//#endregion
+//#region src/formats/ints.ts
+/**
+* Integer list format handler.
+* NOT round-trippable: input is entropy source.
+* Configurable range via --low and --high CLI options.
+*/
+var IntsFormat = class {
+	name() {
+		return "ints";
+	}
+	roundTrippable() {
+		return false;
+	}
+	processInput(state) {
+		const data = deterministicRandom(parseInts(state.expectInput()), state.count);
+		state.seed = Seed$1.new(data);
+		return state;
+	}
+	processOutput(state) {
+		return dataToInts(state.expectSeed().data(), state.low, state.high, " ");
+	}
+};
+
+//#endregion
+//#region src/formats/bytewords-standard.ts
+/**
+* Bytewords Standard format handler.
+* Round-trippable: bytewords → seed → bytewords.
+* Uses full words separated by spaces.
+*/
+var BytewordsStandardFormat = class {
+	name() {
+		return "btw";
+	}
+	roundTrippable() {
+		return true;
+	}
+	processInput(state) {
+		const data = decodeBytewords(state.expectInput(), BytewordsStyle.Standard);
+		state.seed = Seed$1.new(data);
+		return state;
+	}
+	processOutput(state) {
+		return encodeBytewords(state.expectSeed().data(), BytewordsStyle.Standard);
+	}
+};
+
+//#endregion
+//#region src/formats/bytewords-minimal.ts
+/**
+* Bytewords Minimal format handler.
+* Round-trippable: bytewords → seed → bytewords.
+* Uses 2-letter abbreviations without separators.
+*/
+var BytewordsMinimalFormat = class {
+	name() {
+		return "btwm";
+	}
+	roundTrippable() {
+		return true;
+	}
+	processInput(state) {
+		const data = decodeBytewords(state.expectInput(), BytewordsStyle.Minimal);
+		state.seed = Seed$1.new(data);
+		return state;
+	}
+	processOutput(state) {
+		return encodeBytewords(state.expectSeed().data(), BytewordsStyle.Minimal);
+	}
+};
+
+//#endregion
+//#region src/formats/bytewords-uri.ts
+/**
+* Bytewords URI format handler.
+* Round-trippable: bytewords → seed → bytewords.
+* Uses full words separated by hyphens (URI-safe).
+*/
+var BytewordsUriFormat = class {
+	name() {
+		return "btwu";
+	}
+	roundTrippable() {
+		return true;
+	}
+	processInput(state) {
+		const data = decodeBytewords(state.expectInput(), BytewordsStyle.Uri);
+		state.seed = Seed$1.new(data);
+		return state;
+	}
+	processOutput(state) {
+		return encodeBytewords(state.expectSeed().data(), BytewordsStyle.Uri);
+	}
+};
+
+//#endregion
+//#region src/formats/format.ts
+/**
+* Select input format by key.
+* Matches Rust select_input_format function.
+*/
+function selectInputFormat(key) {
+	switch (key) {
+		case "random": return new RandomFormat();
+		case "hex": return new HexFormat();
+		case "btw": return new BytewordsStandardFormat();
+		case "btwu": return new BytewordsUriFormat();
+		case "btwm": return new BytewordsMinimalFormat();
+		case "bits": return new BitsFormat();
+		case "cards": return new CardsFormat();
+		case "dice": return new DiceFormat();
+		case "base6": return new Base6Format();
+		case "base10": return new Base10Format();
+		case "ints": return new IntsFormat();
+		case "bip39": return new Bip39Format();
+		case "sskr": return new SSKRFormat();
+		case "envelope": return new EnvelopeFormat();
+		case "multipart": return new MultipartFormat();
+		case "seed": return new SeedFormat();
+		default: throw new Error(`Unknown input format: ${key}`);
+	}
+}
+/**
+* Select output format by key.
+* Matches Rust select_output_format function.
+*/
+function selectOutputFormat(key) {
+	switch (key) {
+		case "hex": return new HexFormat();
+		case "btw": return new BytewordsStandardFormat();
+		case "btwu": return new BytewordsUriFormat();
+		case "btwm": return new BytewordsMinimalFormat();
+		case "bits": return new BitsFormat();
+		case "cards": return new CardsFormat();
+		case "dice": return new DiceFormat();
+		case "base6": return new Base6Format();
+		case "base10": return new Base10Format();
+		case "ints": return new IntsFormat();
+		case "bip39": return new Bip39Format();
+		case "sskr": return new SSKRFormat();
+		case "envelope": return new EnvelopeFormat();
+		case "multipart": return new MultipartFormat();
+		case "seed": return new SeedFormat();
+		default: throw new Error(`Unknown output format: ${key}`);
+	}
+}
+
+//#endregion
+//#region src/main.ts
+/**
+* A tool for generating and transforming cryptographic seeds.
+* Ported from seedtool-cli-rust/src/main.rs
+*/
+const VERSION = "0.4.0";
+function parseLowInt(value) {
+	const num = parseInt(value, 10);
+	if (isNaN(num) || num < 0 || num > 254) throw new Error("LOW must be between 0 and 254");
+	return num;
+}
+function parseHighInt(value) {
+	const num = parseInt(value, 10);
+	if (isNaN(num) || num < 1 || num > 255) throw new Error("HIGH must be between 1 and 255");
+	return num;
+}
+function parseGroupThreshold(value) {
+	const num = parseInt(value, 10);
+	if (isNaN(num) || num < 1 || num > 16) throw new Error("THRESHOLD must be between 1 and 16");
+	return num;
+}
+function parseCliDate(value) {
+	if (value === "now") return /* @__PURE__ */ new Date();
+	const date = new Date(value);
+	if (isNaN(date.getTime())) throw new Error(`Invalid date: ${value}. Use ISO-8601 format or 'now'.`);
+	return date;
+}
+function parseGroupSpec(value, previous) {
+	const spec = SSKRGroupSpec.parse(value);
+	return [...previous, spec];
+}
+async function main() {
+	const program = new Command();
+	program.name("seedtool").description("A tool for generating and transforming cryptographic seeds.\n\nby Wolf McNally and Christopher Allen\n\nReport bugs to ChristopherA@BlockchainCommons.com.\n© 2024 Blockchain Commons.").version(VERSION).argument("[INPUT]", "The input to be transformed. If required and not present, it will be read from stdin.").option("-c, --count <COUNT>", "The number of output units (hex bytes, base-10 digits, etc.)", "16").addOption(new Option("-i, --in <INPUT_TYPE>", "The input format. If not specified, a new random seed is generated using a secure random number generator.").choices([
+		"random",
+		"hex",
+		"btw",
+		"btwm",
+		"btwu",
+		"bits",
+		"cards",
+		"dice",
+		"base6",
+		"base10",
+		"ints",
+		"bip39",
+		"sskr",
+		"envelope",
+		"seed",
+		"multipart"
+	]).default("random")).addOption(new Option("-o, --out <OUTPUT_TYPE>", "The output format.").choices([
+		"hex",
+		"btw",
+		"btwm",
+		"btwu",
+		"bits",
+		"cards",
+		"dice",
+		"base6",
+		"base10",
+		"ints",
+		"bip39",
+		"sskr",
+		"envelope",
+		"seed",
+		"multipart"
+	]).default("hex")).option("--low <LOW>", "The lowest int returned (0-254)", parseLowInt, 0).option("--high <HIGH>", "The highest int returned (1-255), low < high", parseHighInt, 9).option("--name <NAME>", "The name of the seed.").option("--note <NOTE>", "The note associated with the seed.").option("--date <DATE>", "The seed's creation date, in ISO-8601 format. May also be `now`.").option("--max-fragment-len <MAX_FRAG_LEN>", "For `multipart` output, the UR will be segmented into parts with fragments no larger than MAX_FRAG_LEN", "500").option("--additional-parts <NUM_PARTS>", "For `multipart` output, the number of additional parts above the minimum to generate using fountain encoding.", "0").option("-g, --groups <M-of-N>", "Group specifications. May appear more than once. M must be < N", parseGroupSpec, []).option("-t, --group-threshold <THRESHOLD>", "The number of groups that must meet their threshold. Must be <= the number of group specifications.", parseGroupThreshold, 1).addOption(new Option("-s, --sskr-format <SSKR_FORMAT>", "SSKR output format.").choices([
+		"envelope",
+		"btw",
+		"btwm",
+		"btwu",
+		"ur"
+	]).default("envelope")).option("-d, --deterministic <SEED_STRING>", "Use a deterministic random number generator with the given seed string. Output generated from this seed will be the same every time, so generated seeds are only as secure as the seed string.");
+	program.parse();
+	const options = program.opts();
+	const args = program.args;
+	const cli = new Cli();
+	if (args.length > 0) cli.input = args[0];
+	else if (!process.stdin.isTTY) cli.input = fs.readFileSync(0, "utf-8").trim();
+	cli.count = parseInt(options.count, 10);
+	cli.in = options.in;
+	cli.out = options.out;
+	cli.low = options.low;
+	cli.high = options.high;
+	cli.name = options.name;
+	cli.note = options.note;
+	if (options.date) cli.date = parseCliDate(options.date);
+	cli.maxFragmentLen = parseInt(options.maxFragmentLen, 10);
+	cli.additionalParts = parseInt(options.additionalParts, 10);
+	cli.groups = options.groups;
+	cli.groupThreshold = options.groupThreshold;
+	cli.sskrFormat = options.sskrFormat;
+	if (options.deterministic) cli.rng = {
+		type: "deterministic",
+		rng: DeterministicRandomNumberGenerator.newWithSeed(options.deterministic)
+	};
+	else cli.rng = {
+		type: "secure",
+		rng: new SecureRandomNumberGenerator()
+	};
+	const inputFormat = selectInputFormat(cli.in);
+	const outputFormat = selectOutputFormat(cli.out);
+	if (!outputFormat.roundTrippable() && inputFormat.name() !== "random") {
+		console.error(`Input for output form "${outputFormat.name()}" must be random.`);
+		process.exit(1);
+	}
+	const processedCli = inputFormat.processInput(cli);
+	const output = outputFormat.processOutput(processedCli);
+	console.log(output);
+}
+main().catch((error) => {
+	console.error(error.message);
+	process.exit(1);
+});
+
+//#endregion
+export {  };
+//# sourceMappingURL=main.mjs.map