@bcts/frost-hubert 1.0.0-alpha.17

package/dist/cmd-C8pmNd28.mjs

@@ -0,0 +1,4664 @@
+import { n as __require, t as __exportAll } from "./chunk-D3JzZLW2.mjs";
+import { n as DkgInvite, t as DkgInvitation } from "./dkg-DqGrAV81.mjs";
+import { a as resolveRegistryPath, c as ContributionPaths, d as PendingRequests, i as Registry, l as GroupParticipant, u as GroupRecord } from "./registry-CWp2amuo.mjs";
+import { A as serializeSignatureShare, D as serializePublicKeyPackage, E as serializeKeyPackage, M as serializeSigningNonces, N as signingRound1, O as serializeSignature, P as signingRound2, _ as dkgPart3, a as bytesToHex, b as identifierFromU16, d as deserializeKeyPackage, f as deserializePublicKeyPackage, g as dkgPart2, h as dkgPart1, i as aggregateSignatures, j as serializeSigningCommitments, m as deserializeSigningCommitments, o as createRng, p as deserializeSignatureShare, s as createSigningPackage, w as serializeDkgRound2Package, x as identifierToHex, y as hexToBytes$1 } from "./frost-Csp0IOrd.mjs";
+import { ARID, JSON as JSON$1, Signature, XID } from "@bcts/components";
+import { CborDate } from "@bcts/dcbor";
+import { Envelope, Function } from "@bcts/envelope";
+import { SealedEvent, SealedRequest, SealedResponse } from "@bcts/gstp";
+import { XIDDocument, XIDVerifySignature } from "@bcts/xid";
+import { UR } from "@bcts/uniform-resources";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { Ed25519Sha512, serde } from "@frosts/ed25519";
+import { CoefficientCommitment, Nonce, SigningNonces, VerifiableSecretSharingCommitment, round1, round2 } from "@frosts/core";
+
+//#region src/cmd/common.ts
+/**
+* Common utilities for commands.
+*
+* Port of cmd/common.rs from frost-hubert-rust.
+*
+* @module
+*/
+/**
+* Get the group state directory for a given registry path and group ID.
+*
+* Port of `group_state_dir()` from cmd/common.rs.
+*/
+function groupStateDir(registryPath, groupIdHex) {
+	const base = path.dirname(registryPath);
+	return path.join(base, "group-state", groupIdHex);
+}
+/**
+* Global verbose flag.
+*/
+let verboseFlag = false;
+/**
+* Set the verbose flag.
+*/
+function setVerbose(value) {
+	verboseFlag = value;
+}
+/**
+* Check if verbose mode is enabled.
+*
+* Port of `is_verbose()` from cmd/common.rs.
+*/
+function isVerbose() {
+	return verboseFlag;
+}
+
+//#endregion
+//#region src/cmd/busy.ts
+/**
+* Put an envelope to storage with a progress indicator.
+*
+* Port of `put_with_indicator()` from cmd/busy.rs.
+*/
+async function putWithIndicator(client, arid, envelope, message, verbose) {
+	if (verbose) console.log(`${message}...`);
+	await client.put(arid, envelope);
+	if (verbose) console.log(`${message}... done`);
+}
+/**
+* Get an envelope from storage with a progress indicator.
+*
+* Port of `get_with_indicator()` from cmd/busy.rs.
+*/
+async function getWithIndicator(client, arid, message, timeoutSeconds, verbose) {
+	if (verbose) console.log(`${message}...`);
+	const envelope = await client.get(arid, timeoutSeconds);
+	if (verbose) if (envelope) console.log(`${message}... found`);
+	else console.log(`${message}... not found`);
+	return envelope;
+}
+
+//#endregion
+//#region src/cmd/parallel.ts
+/**
+* Create a Pending status.
+*/
+function fetchStatusPending() {
+	return { type: "Pending" };
+}
+/**
+* Create a Success status.
+*/
+function fetchStatusSuccess(envelope) {
+	return {
+		type: "Success",
+		envelope
+	};
+}
+/**
+* Create a Rejected status.
+*/
+function fetchStatusRejected(reason) {
+	return {
+		type: "Rejected",
+		reason
+	};
+}
+/**
+* Create an Error status.
+*/
+function fetchStatusError(error) {
+	return {
+		type: "Error",
+		error
+	};
+}
+/**
+* Create a Timeout status.
+*/
+function fetchStatusTimeout() {
+	return { type: "Timeout" };
+}
+/**
+* Direction of the operation (get or put).
+*
+* Port of `enum Direction` from cmd/parallel.rs.
+*/
+let Direction = /* @__PURE__ */ function(Direction) {
+	/** Downloading from storage */
+	Direction["Get"] = "Get";
+	/** Uploading to storage */
+	Direction["Put"] = "Put";
+	return Direction;
+}({});
+/**
+* Get the emoji for a direction.
+*
+* Port of `Direction::emoji()` from cmd/parallel.rs.
+*/
+function directionEmoji(direction) {
+	switch (direction) {
+		case Direction.Get: return "⬇️";
+		case Direction.Put: return "⬆️";
+	}
+}
+/**
+* Default timeout in seconds (10 minutes).
+*/
+const DEFAULT_TIMEOUT_SECONDS = 600;
+/**
+* Create a config with the specified timeout.
+*/
+function parallelFetchConfigWithTimeout(timeoutSeconds) {
+	return { timeoutSeconds };
+}
+/**
+* Result of collecting responses from multiple participants.
+*
+* Port of `struct CollectionResult` from cmd/parallel.rs.
+*/
+var CollectionResult = class {
+	/** Successful responses as [XID, T] tuples */
+	successes;
+	/** Participants who explicitly rejected as [XID, reason] tuples */
+	rejections;
+	/** Participants with network/parsing errors as [XID, error] tuples */
+	errors;
+	/** Participants who timed out */
+	timeouts;
+	constructor() {
+		this.successes = [];
+		this.rejections = [];
+		this.errors = [];
+		this.timeouts = [];
+	}
+	/**
+	* Check if enough responses were received to proceed.
+	*
+	* Port of `CollectionResult::can_proceed()` from cmd/parallel.rs.
+	*/
+	canProceed(minRequired) {
+		return this.successes.length >= minRequired;
+	}
+	/**
+	* Total number of participants.
+	*
+	* Port of `CollectionResult::total()` from cmd/parallel.rs.
+	*/
+	total() {
+		return this.successes.length + this.rejections.length + this.errors.length + this.timeouts.length;
+	}
+	/**
+	* Check if all responses succeeded.
+	*
+	* Port of `CollectionResult::all_succeeded()` from cmd/parallel.rs.
+	*/
+	allSucceeded() {
+		return this.rejections.length === 0 && this.errors.length === 0 && this.timeouts.length === 0;
+	}
+};
+/**
+* Create an empty collection result.
+*/
+function emptyCollectionResult() {
+	return new CollectionResult();
+}
+/**
+* Helper to build request tuples from pending requests and registry.
+*
+* Port of `build_fetch_requests()` from cmd/parallel.rs.
+*/
+function buildFetchRequests(pending, getName) {
+	const requests = [];
+	for (const [xid, arid] of pending) {
+		const name = getName(xid);
+		requests.push([
+			xid,
+			arid,
+			name
+		]);
+	}
+	return requests;
+}
+/**
+* Simple progress output for non-interactive terminals.
+*/
+function logProgress(direction, name, status, message) {
+	const emoji = directionEmoji(direction);
+	switch (status) {
+		case "success":
+			console.error(`${emoji}  ✅ ${name}`);
+			break;
+		case "error":
+			console.error(`${emoji}  ❌ ${name}: ${message ?? "Error"}`);
+			break;
+		case "timeout":
+			console.error(`${emoji}  ❌ ${name}: Timeout`);
+			break;
+	}
+}
+/**
+* Fetch messages from multiple ARIDs in parallel.
+*
+* Port of `parallel_fetch()` from cmd/parallel.rs.
+*/
+async function parallelFetch(client, requests, validate, config) {
+	const result = new CollectionResult();
+	const timeoutSeconds = config.timeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS;
+	if (config.verbose === true) console.error(`Waiting for ${requests.length} responses...`);
+	const promises = requests.map(async ([xid, arid, name]) => {
+		try {
+			const envelope = await client.get(arid, timeoutSeconds);
+			if (!envelope) {
+				result.timeouts.push(xid);
+				if (config.verbose === true) logProgress(Direction.Get, name, "timeout");
+				return;
+			}
+			const parsed = validate(envelope, xid);
+			if (parsed !== null && typeof parsed === "object" && "rejected" in parsed) {
+				result.rejections.push([xid, parsed.rejected]);
+				if (config.verbose === true) logProgress(Direction.Get, name, "error", parsed.rejected);
+			} else {
+				result.successes.push([xid, parsed]);
+				if (config.verbose === true) logProgress(Direction.Get, name, "success");
+			}
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			if (errorMessage.includes("Timeout") || errorMessage.includes("timeout")) {
+				result.timeouts.push(xid);
+				if (config.verbose === true) logProgress(Direction.Get, name, "timeout");
+			} else {
+				result.errors.push([xid, `${name}: ${errorMessage}`]);
+				if (config.verbose === true) logProgress(Direction.Get, name, "error", errorMessage);
+			}
+		}
+	});
+	await Promise.all(promises);
+	if (config.verbose === true) {
+		console.error(`Collected ${result.successes.length} responses`);
+		if (result.rejections.length > 0) console.error(`  ${result.rejections.length} rejections`);
+		if (result.errors.length > 0) console.error(`  ${result.errors.length} errors`);
+		if (result.timeouts.length > 0) console.error(`  ${result.timeouts.length} timeouts`);
+	}
+	return result;
+}
+/**
+* Send messages to multiple ARIDs in parallel.
+*
+* Port of `parallel_send()` from cmd/parallel.rs.
+*/
+async function parallelSend(client, messages, verbose) {
+	const results = [];
+	if (verbose === true) console.error(`Sending to ${messages.length} participants...`);
+	const promises = messages.map(async ([xid, arid, envelope, name]) => {
+		try {
+			await client.put(arid, envelope);
+			results.push([xid, null]);
+			if (verbose === true) logProgress(Direction.Put, name, "success");
+		} catch (error) {
+			const err = error instanceof Error ? error : new Error(String(error));
+			results.push([xid, err]);
+			if (verbose === true) logProgress(Direction.Put, name, "error", err.message);
+		}
+	});
+	await Promise.all(promises);
+	if (verbose === true) {
+		const successes = results.filter(([_, err]) => err === null).length;
+		const failures = results.length - successes;
+		console.error(`Sent ${successes} messages`);
+		if (failures > 0) console.error(`  ${failures} failed`);
+	}
+	return results;
+}
+
+//#endregion
+//#region src/cmd/storage.ts
+/**
+* Create a storage client based on the selection.
+*
+* Port of storage client creation from cmd/storage.rs.
+*/
+async function createStorageClient(selection, serverUrl) {
+	switch (selection) {
+		case "server": {
+			const { ServerKvClient } = await import("@bcts/hubert/server");
+			const client = new ServerKvClient(serverUrl ?? "http://localhost:8080");
+			return {
+				async put(arid, envelope) {
+					await client.put(arid, envelope);
+				},
+				async get(arid, timeoutSeconds) {
+					return await client.get(arid, timeoutSeconds) ?? void 0;
+				},
+				exists(arid) {
+					return client.exists(arid);
+				}
+			};
+		}
+		case "mainline": {
+			const { MainlineDhtKv } = await import("@bcts/hubert/mainline");
+			const client = await MainlineDhtKv.create();
+			return {
+				async put(arid, envelope) {
+					await client.put(arid, envelope);
+				},
+				async get(arid, timeoutSeconds) {
+					return await client.get(arid, timeoutSeconds) ?? void 0;
+				},
+				exists(arid) {
+					return client.exists(arid);
+				}
+			};
+		}
+		case "ipfs": {
+			const { IpfsKv } = await import("@bcts/hubert/ipfs");
+			const client = new IpfsKv("http://127.0.0.1:5001");
+			return {
+				async put(arid, envelope) {
+					await client.put(arid, envelope);
+				},
+				async get(arid, timeoutSeconds) {
+					return await client.get(arid, timeoutSeconds) ?? void 0;
+				},
+				exists(arid) {
+					return client.exists(arid);
+				}
+			};
+		}
+		case "hybrid": {
+			const { HybridKv } = await import("@bcts/hubert/hybrid");
+			const client = await HybridKv.create("http://127.0.0.1:5001");
+			return {
+				async put(arid, envelope) {
+					await client.put(arid, envelope);
+				},
+				async get(arid, timeoutSeconds) {
+					return await client.get(arid, timeoutSeconds) ?? void 0;
+				},
+				exists(arid) {
+					return client.exists(arid);
+				}
+			};
+		}
+	}
+}
+
+//#endregion
+//#region src/cmd/check.ts
+/**
+* Check if an ARID exists in storage.
+*
+* Port of check functionality from cmd/check.rs.
+*/
+async function checkAridExists(client, arid) {
+	return client.exists(arid);
+}
+
+//#endregion
+//#region src/cmd/dkg/common.ts
+/**
+* Common utilities for DKG commands.
+*
+* Port of cmd/dkg/common.rs from frost-hubert-rust.
+*
+* @module
+*/
+/**
+* Parse an ARID from a UR string.
+*
+* Port of `parse_arid_ur()` from cmd/dkg/common.rs.
+*/
+function parseAridUr(urString) {
+	const ur = UR.fromURString(urString.trim());
+	if (ur.urTypeStr() !== "arid") throw new Error(`Expected ur:arid, found ur:${ur.urTypeStr()}`);
+	const { ARID: ARIDClass } = __require("@bcts/components");
+	return ARIDClass.fromCbor(ur.cbor());
+}
+/**
+* Parse an envelope from a UR string.
+*
+* Port of `parse_envelope_ur()` from cmd/dkg/common.rs.
+*/
+function parseEnvelopeUr(urString) {
+	const ur = UR.fromURString(urString.trim());
+	if (ur.urTypeStr() !== "envelope") throw new Error(`Expected ur:envelope, found ur:${ur.urTypeStr()}`);
+	const { Envelope: EnvelopeClass } = __require("@bcts/envelope");
+	return EnvelopeClass.fromCbor(ur.cbor());
+}
+/**
+* Resolve the sender XID document from the registry.
+*
+* Port of `resolve_sender()` from cmd/dkg/common.rs.
+*/
+function resolveSender(registry) {
+	const owner = registry.owner();
+	if (!owner) throw new Error("No owner set in registry. Run 'registry owner set' first.");
+	return owner.xidDocument();
+}
+/**
+* Resolve participant identifiers (XID URs or pet names) to records.
+*
+* Port of `resolve_participants()` from cmd/dkg/common.rs lines 29-74.
+*/
+function resolveParticipants(registry, inputs) {
+	const seenArgs = /* @__PURE__ */ new Set();
+	const seenXids = /* @__PURE__ */ new Set();
+	const resolved = [];
+	for (const raw of inputs) {
+		const trimmed = raw.trim();
+		if (trimmed === "") throw new Error("Participant identifier cannot be empty");
+		if (seenArgs.has(trimmed)) throw new Error(`Duplicate participant argument: ${trimmed}`);
+		seenArgs.add(trimmed);
+		let xid;
+		let record;
+		try {
+			const { XID: XIDClass } = __require("@bcts/components");
+			xid = XIDClass.fromURString(trimmed);
+			const foundRecord = registry.participant(xid);
+			if (!foundRecord) throw new Error(`Participant with XID ${xid.urString()} not found in registry`);
+			record = foundRecord;
+		} catch {
+			const result = registry.participantByPetName(trimmed);
+			if (!result) throw new Error(`Participant with pet name '${trimmed}' not found`);
+			[xid, record] = result;
+		}
+		const xidUr = xid.urString();
+		if (seenXids.has(xidUr)) throw new Error(`Duplicate participant specified; multiple inputs resolve to ${xidUr}`);
+		seenXids.add(xidUr);
+		resolved.push([xid, record]);
+	}
+	return resolved;
+}
+/**
+* Get display name for sender from registry.
+*
+* Port of `resolve_sender_name()` from cmd/dkg/common.rs lines 96-116.
+*/
+function resolveSenderName$1(registry, sender) {
+	const owner = registry.owner();
+	const senderXid = sender.xid();
+	if (owner?.xidDocument().xid().urString() === senderXid.urString()) return formatNameWithOwnerMarker(owner.petName() ?? senderXid.urString(), true);
+	const record = registry.participant(senderXid);
+	if (record) return formatNameWithOwnerMarker(record.petName() ?? record.xid().urString(), false);
+}
+/**
+* Build GroupParticipant[] from XIDDocuments using registry lookups.
+*
+* Port of `build_group_participants()` from cmd/dkg/common.rs lines 122-131.
+*/
+function buildGroupParticipants(registry, owner, participants) {
+	return participants.map((doc) => groupParticipantFromRegistry(registry, owner, doc));
+}
+/**
+* Create a GroupParticipant from a XIDDocument, validating against the registry.
+*
+* Port of `group_participant_from_registry()` from cmd/dkg/common.rs lines 133-149.
+*/
+function groupParticipantFromRegistry(registry, owner, document) {
+	const xid = document.xid();
+	if (xid.urString() === owner.xid().urString()) return new GroupParticipant(xid);
+	if (!registry.participant(xid)) throw new Error(`Invite participant not found in registry: ${xid.urString()}`);
+	return new GroupParticipant(xid);
+}
+/**
+* Format a participant name with owner marker if applicable.
+*
+* Port of `format_name_with_owner_marker()` from cmd/dkg/common.rs lines 155-157.
+*/
+function formatNameWithOwnerMarker(name, isOwner) {
+	return isOwner ? `* ${name}` : name;
+}
+/**
+* Get display names for participants, sorted by XID, with owner marked.
+*
+* Port of `participant_names_from_registry()` from cmd/dkg/common.rs lines 159-191.
+*/
+function participantNamesFromRegistry(registry, participants, ownerXid, ownerPetName) {
+	return [...participants].sort((a, b) => a.xid().urString().localeCompare(b.xid().urString())).map((document) => {
+		const xid = document.xid();
+		const isOwner = xid.urString() === ownerXid.urString();
+		let name;
+		if (isOwner) name = ownerPetName ?? xid.urString();
+		else {
+			const record = registry.participant(xid);
+			if (!record) throw new Error(`Invite participant not found in registry: ${xid.urString()}`);
+			name = record.petName() ?? xid.urString();
+		}
+		return formatNameWithOwnerMarker(name, isOwner);
+	});
+}
+/**
+* Get the DKG state directory for a given registry path and group ID.
+*
+* Port of `dkg_state_dir()` from cmd/dkg/common.rs.
+*/
+function dkgStateDir(registryPath, groupIdHex) {
+	const base = path.dirname(registryPath);
+	return path.join(base, "group-state", groupIdHex, "dkg");
+}
+/**
+* Convert a verifying key bytes to a SigningPublicKey.
+*
+* Port of `signing_key_from_verifying()` from cmd/dkg/common.rs.
+*/
+function signingKeyFromVerifying(verifyingKeyBytes) {
+	const { SigningPublicKey: SigningPublicKeyClass } = __require("@bcts/components");
+	return SigningPublicKeyClass.fromBytes(verifyingKeyBytes);
+}
+
+//#endregion
+//#region src/cmd/dkg/coordinator/invite.ts
+/**
+* DKG coordinator invite command.
+*
+* Port of cmd/dkg/coordinator/invite.rs from frost-hubert-rust.
+*
+* @module
+*/
+/**
+* Build the DKG invite with validation.
+*
+* Port of `build_invite()` from cmd/dkg/coordinator/invite.rs lines 128-181.
+*/
+function buildInvite(registry, minSignersArg, charter, participantNames, validDays) {
+	const resolved = resolveParticipants(registry, participantNames);
+	const participantDocs = resolved.map(([, record]) => record.xidDocumentUr());
+	const participantXids = resolved.map(([xid]) => xid);
+	const collectFromArids = participantDocs.map(() => ARID.new());
+	const pendingRequests = new PendingRequests();
+	for (let i = 0; i < participantXids.length; i++) pendingRequests.addCollectOnly(participantXids[i], collectFromArids[i]);
+	const participantCount = participantDocs.length;
+	if (participantCount < 2) throw new Error("At least two participants are required for a DKG invite");
+	const minSigners = minSignersArg ?? participantCount;
+	if (minSigners < 2) throw new Error("--min-signers must be at least 2");
+	if (minSigners > participantCount) throw new Error("--min-signers cannot exceed participant count");
+	const sender = resolveSender(registry);
+	const now = /* @__PURE__ */ new Date();
+	const validUntil = new Date(Date.now() + validDays * 24 * 60 * 60 * 1e3);
+	return {
+		invite: DkgInvite.create(ARID.new(), sender, ARID.new(), now, validUntil, minSigners, charter, participantDocs, collectFromArids),
+		participantXids,
+		pendingRequests
+	};
+}
+/**
+* Execute the DKG invite command.
+*
+* Port of `invite()` from cmd/dkg/coordinator/invite.rs.
+*/
+async function invite$1(client, options, cwd) {
+	const registryPath = resolveRegistryPath(options.registryPath, cwd);
+	const registry = Registry.load(registryPath);
+	const { invite: dkgInvite, participantXids, pendingRequests } = buildInvite(registry, options.minSigners, options.charter, options.participantNames, options.validDays);
+	const groupId = dkgInvite.groupId();
+	const requestId = dkgInvite.requestId();
+	const envelope = dkgInvite.toEnvelope();
+	const startArid = ARID.new();
+	await putWithIndicator(client, startArid, envelope, "Sending DKG invite", options.verbose ?? false);
+	const owner = registry.owner();
+	if (!owner) throw new Error("Registry owner is required to issue invites");
+	const coordinator = new GroupParticipant(owner.xid());
+	const groupParticipants = participantXids.map((xid) => new GroupParticipant(xid));
+	const groupRecord = new GroupRecord(options.charter, dkgInvite.minSigners(), coordinator, groupParticipants);
+	groupRecord.setPendingRequests(pendingRequests);
+	registry.recordGroup(groupId, groupRecord);
+	registry.save(registryPath);
+	const stateDir = dkgStateDir(registryPath, groupId.hex());
+	fs.mkdirSync(stateDir, { recursive: true });
+	const inviteState = {
+		group: groupId.urString(),
+		request_id: requestId.urString(),
+		start_arid: startArid.urString(),
+		valid_until: dkgInvite.validUntil().toISOString(),
+		participants: dkgInvite.participants().map((p) => ({
+			xid: p.xid().urString(),
+			response_arid: p.responseArid().urString()
+		}))
+	};
+	fs.writeFileSync(path.join(stateDir, "invite.json"), JSON.stringify(inviteState, null, 2));
+	if (options.verbose === true) {
+		console.log(`Group ID: ${groupId.urString()}`);
+		console.log(`Start ARID: ${startArid.urString()}`);
+	}
+	return {
+		groupId,
+		requestId,
+		envelopeUr: envelope.urString()
+	};
+}
+
+//#endregion
+//#region src/cmd/dkg/coordinator/round1.ts
+/**
+* DKG coordinator round 1 command.
+*
+* Port of cmd/dkg/coordinator/round1.rs from frost-hubert-rust.
+*
+* @module
+*/
+/**
+* Validate that the owner is the coordinator for this group.
+*
+* Port of `validate_coordinator()` from cmd/dkg/coordinator/round1.rs lines 201-214.
+*/
+function validateCoordinator$3(groupRecord, owner) {
+	if (groupRecord.coordinator().xid().urString() !== owner.xid().urString()) throw new Error(`Only the coordinator can collect and send Round 2 requests. Coordinator: ${groupRecord.coordinator().xid().urString()}, Owner: ${owner.xid().urString()}`);
+}
+/**
+* Fetch a single round 1 response from storage.
+*
+* Port of `fetch_and_validate_response()` from cmd/dkg/coordinator/round1.rs lines 512-566.
+*/
+async function fetchRound1Response(client, responseArid, timeout, coordinator, expectedGroupId, participantName) {
+	const envelope = await getWithIndicator(client, responseArid, participantName, timeout, isVerbose());
+	if (envelope === void 0) throw new Error("Response not found in Hubert storage");
+	const coordinatorPrivateKeys = coordinator.inceptionPrivateKeys();
+	if (coordinatorPrivateKeys === void 0) throw new Error("Coordinator XID document has no inception private keys");
+	const now = CborDate.now().datetime();
+	const sealedResponse = SealedResponse.tryFromEncryptedEnvelope(envelope, void 0, now, coordinatorPrivateKeys);
+	if (sealedResponse.isErr()) {
+		const reasonEnvelope = sealedResponse.error().objectForPredicate("reason");
+		const reason = reasonEnvelope !== void 0 ? reasonEnvelope.extractSubject((cbor) => cbor.toText()) : "unknown reason";
+		throw new Error(`Participant rejected invite: ${reason}`);
+	}
+	const result = sealedResponse.result();
+	validateRound1Response(result, expectedGroupId);
+	const nextResponseArid = result.tryObjectForPredicate("response_arid", (cbor) => {
+		return ARID.fromTaggedCbor(cbor);
+	});
+	return [extractRound1Package(result), nextResponseArid];
+}
+/**
+* Validate a round 1 response envelope.
+*
+* Port of `validate_round1_response()` from cmd/dkg/coordinator/round1.rs lines 568-586.
+*/
+function validateRound1Response(result, expectedGroupId) {
+	result.checkSubjectUnit();
+	result.checkType("dkgRound1Response");
+	const groupId = result.tryObjectForPredicate("group", (cbor) => {
+		return ARID.fromTaggedCbor(cbor);
+	});
+	if (groupId.urString() !== expectedGroupId.urString()) throw new Error(`Response group ID ${groupId.urString()} does not match expected ${expectedGroupId.urString()}`);
+}
+/**
+* Extract a round 1 package from a response envelope.
+*
+* Port of `extract_round1_package()` from cmd/dkg/coordinator/round1.rs lines 588-598.
+*/
+function extractRound1Package(result) {
+	const round1Envelope = result.objectForPredicate("round1_package");
+	if (round1Envelope === void 0) throw new Error("round1_package missing from response");
+	const round1Json = round1Envelope.extractSubject((cbor) => {
+		return JSON$1.fromTaggedCbor(cbor);
+	});
+	const jsonStr = new TextDecoder().decode(round1Json.asBytes());
+	const jsonObj = globalThis.JSON.parse(jsonStr);
+	return serde.round1PackageFromJson(jsonObj);
+}
+/**
+* Validate and extract data from a round 1 response (for parallel fetch).
+*
+* Port of `validate_and_extract_round1_response()` from cmd/dkg/coordinator/round1.rs lines 674-707.
+*/
+function validateAndExtractRound1Response(envelope, coordinatorKeys, expectedGroupId) {
+	const now = CborDate.now().datetime();
+	const sealedResponse = SealedResponse.tryFromEncryptedEnvelope(envelope, void 0, now, coordinatorKeys);
+	if (sealedResponse.isErr()) {
+		const reasonEnvelope = sealedResponse.error().objectForPredicate("reason");
+		return { rejected: `Participant rejected invite: ${reasonEnvelope !== void 0 ? reasonEnvelope.extractSubject((cbor) => cbor.toText()) : "unknown reason"}` };
+	}
+	const result = sealedResponse.result();
+	validateRound1Response(result, expectedGroupId);
+	const nextResponseArid = result.tryObjectForPredicate("response_arid", (cbor) => {
+		return ARID.fromTaggedCbor(cbor);
+	});
+	return {
+		package: extractRound1Package(result),
+		nextResponseArid
+	};
+}
+/**
+* Collect Round 1 responses in parallel with progress display.
+*
+* Port of `collect_round1_responses_parallel()` from cmd/dkg/coordinator/round1.rs lines 636-671.
+*/
+async function collectRound1Parallel(client, registry, pendingRequests, coordinator, expectedGroupId, timeout) {
+	const requests = [];
+	for (const [xid, arid] of pendingRequests.iterCollect()) {
+		const name = registry.participant(xid)?.petName() ?? xid.urString();
+		requests.push([
+			xid,
+			arid,
+			name
+		]);
+	}
+	const coordinatorKeys = coordinator.inceptionPrivateKeys();
+	if (coordinatorKeys === void 0) throw new Error("Missing coordinator private keys");
+	const config = { timeoutSeconds: timeout };
+	const groupId = expectedGroupId;
+	return parallelFetch(client, requests, (envelope, _xid) => {
+		return validateAndExtractRound1Response(envelope, coordinatorKeys, groupId);
+	}, config);
+}
+/**
+* Build a Round 2 request for a single participant.
+*
+* Port of `build_round2_request_for_participant()` from cmd/dkg/coordinator/round1.rs lines 604-623.
+*/
+function buildRound2RequestForParticipant(sender, groupId, round1Packages, responseArid) {
+	let request = SealedRequest.new("dkgRound2", ARID.new(), sender).withParameter("group", groupId).withParameter("responseArid", responseArid);
+	for (const [xid, pkg] of round1Packages) {
+		const packageJson = serde.round1PackageToJson(pkg);
+		const jsonStr = globalThis.JSON.stringify(packageJson);
+		const jsonBytes = new TextEncoder().encode(jsonStr);
+		const jsonWrapper = JSON$1.fromData(jsonBytes);
+		const packageEnvelope = Envelope.new(jsonWrapper).addAssertion("participant", xid);
+		request = request.withParameter("round1Package", packageEnvelope);
+	}
+	return request;
+}
+/**
+* Dispatch Round 2 requests in parallel.
+*
+* Port of `dispatch_round2_requests_parallel()` from cmd/dkg/coordinator/round1.rs lines 729-844.
+*/
+async function dispatchRound2RequestsParallel(client, registry, registryPath, coordinator, groupId, successes, preview) {
+	const signerPrivateKeys = coordinator.inceptionPrivateKeys();
+	if (signerPrivateKeys === void 0) throw new Error("Coordinator XID document has no signing keys");
+	const validUntil = new Date(Date.now() + 3600 * 1e3);
+	const round1Packages = successes.map(([xid, data]) => [xid, data.package]);
+	const messages = [];
+	const collectArids = [];
+	let previewOutput;
+	for (const [xid, data] of successes) {
+		const participant = registry.participant(xid);
+		if (participant === void 0) throw new Error(`Participant ${xid.urString()} not found in registry`);
+		const recipientDoc = participant.xidDocument();
+		const participantName = participant.petName() ?? xid.urString();
+		const collectFromArid = ARID.new();
+		collectArids.push([xid, collectFromArid]);
+		const request = buildRound2RequestForParticipant(coordinator, groupId, round1Packages, collectFromArid);
+		if (preview && previewOutput === void 0) previewOutput = [participantName, request.toEnvelope(validUntil, signerPrivateKeys, void 0).urString()];
+		const sealedEnvelope = request.toEnvelope(validUntil, signerPrivateKeys, recipientDoc);
+		messages.push([
+			xid,
+			data.nextResponseArid,
+			sealedEnvelope,
+			participantName
+		]);
+	}
+	console.error();
+	const sendResults = await parallelSend(client, messages, isVerbose());
+	const failures = [];
+	for (const [xid, err] of sendResults) if (err !== null) failures.push([xid, err.message]);
+	if (failures.length > 0) {
+		for (const [xid, error] of failures) console.error(`Failed to send to ${xid.urString()}: ${error}`);
+		throw new Error(`Failed to send Round 2 requests to ${failures.length} participants`);
+	}
+	const newPendingRequests = new PendingRequests();
+	for (const [xid, collectFromArid] of collectArids) newPendingRequests.addCollectOnly(xid, collectFromArid);
+	const groupRecord = registry.groupMut(groupId);
+	if (groupRecord === void 0) throw new Error("Group not found in registry");
+	groupRecord.setPendingRequests(newPendingRequests);
+	registry.save(registryPath);
+	return previewOutput;
+}
+/**
+* Update pending requests from parallel collection results.
+*
+* Port of `update_pending_for_round2_from_collection()` from cmd/dkg/coordinator/round1.rs lines 710-726.
+*/
+function updatePendingForRound2FromCollection(registry, registryPath, groupId, successes) {
+	const newPending = new PendingRequests();
+	for (const [xid, data] of successes) newPending.addSendOnly(xid, data.nextResponseArid);
+	const groupRecord = registry.groupMut(groupId);
+	if (groupRecord === void 0) throw new Error("Group not found in registry");
+	groupRecord.setPendingRequests(newPending);
+	registry.save(registryPath);
+}
+/**
+* Persist collected round 1 packages to disk.
+*
+* Port of `persist_round1_packages()` from cmd/dkg/coordinator/round1.rs lines 301-340.
+*/
+function persistRound1Packages(registryPath, groupId, packages) {
+	const packagesDir = groupStateDir(registryPath, groupId.hex());
+	fs.mkdirSync(packagesDir, { recursive: true });
+	const round1PackagesPath = path.join(packagesDir, "collected_round1.json");
+	const packagesJson = {};
+	for (const [xid, pkg] of packages) packagesJson[xid.urString()] = serde.round1PackageToJson(pkg);
+	fs.writeFileSync(round1PackagesPath, globalThis.JSON.stringify(packagesJson, null, 2));
+	const cwd = process.cwd();
+	if (round1PackagesPath.startsWith(cwd)) return round1PackagesPath.slice(cwd.length + 1);
+	return round1PackagesPath;
+}
+/**
+* Fetch all round 1 packages sequentially.
+*
+* Port of `fetch_all_round1_packages()` from cmd/dkg/coordinator/round1.rs lines 243-299.
+*/
+async function fetchAllRound1Packages(ctx, pendingRequests, timeout) {
+	const round1Packages = [];
+	const nextResponseArids = [];
+	const errors = [];
+	for (const [participantXid, collectFromArid] of pendingRequests.iterCollect()) {
+		const participantName = ctx.registry.participant(participantXid)?.petName() ?? participantXid.urString();
+		try {
+			const [pkg, nextArid] = await fetchRound1Response(ctx.client, collectFromArid, timeout, ctx.ownerDoc, ctx.groupId, participantName);
+			round1Packages.push([participantXid, pkg]);
+			nextResponseArids.push([participantXid, nextArid]);
+		} catch (e) {
+			errors.push([participantXid, e instanceof Error ? e.message : String(e)]);
+		}
+	}
+	if (errors.length > 0) {
+		if (isVerbose()) {
+			console.error();
+			console.error(`Failed to collect from ${errors.length} participants:`);
+		}
+		for (const [xid, error] of errors) console.error(`  ${xid.urString()}: ${error}`);
+		throw new Error(`Round 1 collection incomplete: ${errors.length} of ${pendingRequests.len()} responses failed`);
+	}
+	return [round1Packages, nextResponseArids];
+}
+/**
+* Collect round 1 responses sequentially.
+*
+* Port of `collect_round1_responses()` from cmd/dkg/coordinator/round1.rs lines 220-241.
+*/
+async function collectRound1Responses(ctx, pendingRequests, timeout) {
+	if (isVerbose()) console.error(`Collecting Round 1 responses from ${pendingRequests.len()} participants...`);
+	const [packages, nextResponseArids] = await fetchAllRound1Packages(ctx, pendingRequests, timeout);
+	const displayPath = persistRound1Packages(ctx.registryPath, ctx.groupId, packages);
+	updatePendingForRound2(ctx, nextResponseArids);
+	return {
+		packages,
+		nextResponseArids,
+		displayPath
+	};
+}
+/**
+* Update pending requests for round 2 (sequential path).
+*
+* Port of `update_pending_for_round2()` from cmd/dkg/coordinator/round1.rs lines 342-357.
+*/
+function updatePendingForRound2(ctx, nextResponseArids) {
+	const newPending = new PendingRequests();
+	for (const [xid, sendToArid] of nextResponseArids) newPending.addSendOnly(xid, sendToArid);
+	const groupRecord = ctx.registry.groupMut(ctx.groupId);
+	if (groupRecord === void 0) throw new Error("Group not found in registry");
+	groupRecord.setPendingRequests(newPending);
+	ctx.registry.save(ctx.registryPath);
+}
+/**
+* Build participant info for round 2 dispatch.
+*
+* Port of `build_round2_participant_info()` from cmd/dkg/coordinator/round1.rs lines 438-458.
+*/
+function buildRound2ParticipantInfo(registry, nextResponseArids) {
+	return nextResponseArids.map(([xid, sendToArid]) => {
+		const participant = registry.participant(xid);
+		if (participant === void 0) throw new Error(`Participant ${xid.urString()} not found in registry`);
+		return [
+			xid,
+			participant.xidDocument(),
+			sendToArid,
+			ARID.new()
+		];
+	});
+}
+/**
+* Update pending for round 2 collection (sequential path).
+*
+* Port of `update_pending_for_round2_collection()` from cmd/dkg/coordinator/round1.rs lines 460-475.
+*/
+function updatePendingForRound2Collection(ctx, participantInfo) {
+	const newPendingRequests = new PendingRequests();
+	for (const [xid, , , collectFromArid] of participantInfo) newPendingRequests.addCollectOnly(xid, collectFromArid);
+	const groupRecord = ctx.registry.groupMut(ctx.groupId);
+	if (groupRecord === void 0) throw new Error("Group not found in registry");
+	groupRecord.setPendingRequests(newPendingRequests);
+	ctx.registry.save(ctx.registryPath);
+}
+/**
+* Dispatch Round 2 requests sequentially.
+*
+* Port of `dispatch_round2_requests()` from cmd/dkg/coordinator/round1.rs lines 363-436.
+*/
+async function dispatchRound2Requests(ctx, collection, preview) {
+	const signerPrivateKeys = ctx.ownerDoc.inceptionPrivateKeys();
+	if (signerPrivateKeys === void 0) throw new Error("Coordinator XID document has no signing keys");
+	const validUntil = new Date(Date.now() + 3600 * 1e3);
+	const participantInfo = buildRound2ParticipantInfo(ctx.registry, collection.nextResponseArids);
+	if (isVerbose()) console.error(`Sending Round 2 requests to ${participantInfo.length} participants...`);
+	else console.error();
+	let previewOutput;
+	for (const [xid, recipientDoc, sendToArid, collectFromArid] of participantInfo) {
+		const participantName = ctx.registry.participant(xid)?.petName() ?? xid.urString();
+		const request = buildRound2RequestForParticipant(ctx.ownerDoc, ctx.groupId, collection.packages, collectFromArid);
+		if (preview && previewOutput === void 0) previewOutput = [participantName, request.toEnvelope(validUntil, signerPrivateKeys, void 0).urString()];
+		const sealedEnvelope = request.toEnvelope(validUntil, signerPrivateKeys, recipientDoc);
+		await putWithIndicator(ctx.client, sendToArid, sealedEnvelope, participantName, isVerbose());
+	}
+	updatePendingForRound2Collection(ctx, participantInfo);
+	return previewOutput;
+}
+/**
+* Print summary for sequential collection.
+*
+* Port of `print_summary()` from cmd/dkg/coordinator/round1.rs lines 481-506.
+*/
+function printSummary(collection, preview) {
+	if (preview !== void 0) {
+		const [participantName, ur] = preview;
+		if (isVerbose()) {
+			console.error(`# Round 2 preview for ${participantName}`);
+			console.error();
+		}
+		console.error(`Collected ${collection.packages.length} Round 1 packages to ${collection.displayPath} and sent ${collection.nextResponseArids.length} Round 2 requests.`);
+		console.log(ur);
+	} else if (isVerbose()) {
+		console.error();
+		console.error(`Collected ${collection.packages.length} Round 1 packages to ${collection.displayPath} and sent ${collection.nextResponseArids.length} Round 2 requests.`);
+	}
+}
+/**
+* Print summary for parallel collection.
+*
+* Port of `print_summary_parallel()` from cmd/dkg/coordinator/round1.rs lines 847-901.
+*/
+function printSummaryParallel$1(collection, displayPath, preview) {
+	if (collection.rejections.length > 0) {
+		console.error();
+		console.error("Rejections:");
+		for (const [xid, reason] of collection.rejections) console.error(`  ${xid.urString()}: ${reason}`);
+	}
+	if (collection.errors.length > 0) {
+		console.error();
+		console.error("Errors:");
+		for (const [xid, error] of collection.errors) console.error(`  ${xid.urString()}: ${error}`);
+	}
+	if (collection.timeouts.length > 0) {
+		console.error();
+		console.error("Timeouts:");
+		for (const xid of collection.timeouts) console.error(`  ${xid.urString()}`);
+	}
+	if (!collection.allSucceeded()) {
+		console.error();
+		bailWithCollectionSummary(collection);
+	}
+	if (preview !== void 0) {
+		const [participantName, ur] = preview;
+		if (isVerbose()) {
+			console.error(`# Round 2 preview for ${participantName}`);
+			console.error();
+		}
+		console.error(`Collected ${collection.successes.length} Round 1 packages to ${displayPath} and sent ${collection.successes.length} Round 2 requests.`);
+		console.log(ur);
+	} else if (isVerbose()) {
+		console.error();
+		console.error(`Collected ${collection.successes.length} Round 1 packages to ${displayPath} and sent ${collection.successes.length} Round 2 requests.`);
+	}
+}
+/**
+* Print collection summary and throw error.
+*
+* Port of `bail_with_collection_summary()` from cmd/dkg/coordinator/round1.rs lines 903-913.
+*/
+function bailWithCollectionSummary(collection) {
+	const msg = `Round 1 collection incomplete: ${collection.successes.length} succeeded, ${collection.rejections.length} rejected, ${collection.errors.length} errors, ${collection.timeouts.length} timeouts`;
+	console.error(msg);
+	throw new Error(msg);
+}
+/**
+* Execute the DKG coordinator round 1 command.
+*
+* Collects commitment packages from participants.
+*
+* Port of `CommandArgs::exec()` from cmd/dkg/coordinator/round1.rs lines 59-173.
+*/
+async function round1$4(client, options, cwd) {
+	const registryPath = resolveRegistryPath(options.registryPath, cwd);
+	const registry = Registry.load(registryPath);
+	const owner = registry.owner();
+	if (owner === void 0) throw new Error("Registry owner is required");
+	const ownerDoc = owner.xidDocument();
+	const groupId = parseAridUr(options.groupId);
+	const groupRecord = registry.group(groupId);
+	if (groupRecord === void 0) throw new Error(`Group ${options.groupId} not found in registry`);
+	validateCoordinator$3(groupRecord, owner);
+	const pendingRequests = groupRecord.pendingRequests();
+	if (pendingRequests.isEmpty()) throw new Error("No pending requests for this group. Round 1 may already be collected.");
+	if (options.parallel === true) {
+		const collection = await collectRound1Parallel(client, registry, pendingRequests, ownerDoc, groupId, options.timeoutSeconds);
+		const displayPath = persistRound1Packages(registryPath, groupId, collection.successes.map(([xid, data]) => [xid, data.package]));
+		updatePendingForRound2FromCollection(registry, registryPath, groupId, collection.successes);
+		printSummaryParallel$1(collection, displayPath, await dispatchRound2RequestsParallel(client, registry, registryPath, ownerDoc, groupId, collection.successes, options.preview ?? false));
+		return {
+			accepted: collection.successes.length,
+			rejected: collection.rejections.length,
+			errors: collection.errors.length,
+			timeouts: collection.timeouts.length
+		};
+	} else {
+		const ctx = {
+			client,
+			registryPath,
+			registry,
+			ownerDoc,
+			groupId
+		};
+		const collection = await collectRound1Responses(ctx, pendingRequests, options.timeoutSeconds);
+		printSummary(collection, await dispatchRound2Requests(ctx, collection, options.preview ?? false));
+		return {
+			accepted: collection.packages.length,
+			rejected: 0,
+			errors: 0,
+			timeouts: 0
+		};
+	}
+}
+
+//#endregion
+//#region src/cmd/dkg/coordinator/round2.ts
+/**
+* DKG coordinator round 2 command.
+*
+* Port of cmd/dkg/coordinator/round2.rs from frost-hubert-rust.
+*
+* @module
+*/
+/**
+* Validate that the owner is the coordinator of the group.
+*
+* Port of coordinator check from round2.rs lines 86-94.
+*/
+function validateCoordinator$2(groupRecord, ownerXid) {
+	if (groupRecord.coordinator().xid().urString() !== ownerXid.urString()) throw new Error(`Only the coordinator can collect Round 2 responses and send finalize packages. Coordinator: ${groupRecord.coordinator().xid().urString()}, Owner: ${ownerXid.urString()}`);
+}
+/**
+* Validate envelope and extract Round 2 data (for parallel fetch).
+*
+* Port of `validate_and_extract_round2_response()` from round2.rs lines 646-708.
+*/
+function validateAndExtractRound2Response(envelope, coordinatorKeys, expectedGroupId, expectedSender) {
+	const now = /* @__PURE__ */ new Date();
+	let sealed;
+	try {
+		sealed = SealedResponse.tryFromEncryptedEnvelope(envelope, void 0, now, coordinatorKeys);
+	} catch (err) {
+		return { rejected: `Failed to decrypt/parse response: ${err instanceof Error ? err.message : String(err)}` };
+	}
+	if (!sealed.isOk()) try {
+		return { rejected: `Participant reported error: ${sealed.error().optionalObjectForPredicate("reason")?.extractString() ?? "unknown reason"}` };
+	} catch {
+		return { rejected: "Participant reported error: unknown reason" };
+	}
+	let result;
+	try {
+		result = sealed.result();
+	} catch {
+		return { rejected: "Response has no result envelope" };
+	}
+	try {
+		result.checkSubjectUnit();
+		result.checkType("dkgRound2Response");
+	} catch (err) {
+		return { rejected: `Invalid response type: ${err instanceof Error ? err.message : String(err)}` };
+	}
+	try {
+		const groupId = result.objectForPredicate("group").extractSubject((cbor) => ARID.fromTaggedCbor(cbor));
+		if (groupId.urString() !== expectedGroupId.urString()) return { rejected: `Response group ID ${groupId.urString()} does not match expected ${expectedGroupId.urString()}` };
+	} catch (err) {
+		return { rejected: `Failed to extract group: ${err instanceof Error ? err.message : String(err)}` };
+	}
+	try {
+		const senderXid = result.objectForPredicate("participant").extractSubject((cbor) => XID.fromTaggedCbor(cbor));
+		if (senderXid.urString() !== expectedSender.urString()) return { rejected: `Response participant ${senderXid.urString()} does not match expected ${expectedSender.urString()}` };
+	} catch (err) {
+		return { rejected: `Failed to extract participant: ${err instanceof Error ? err.message : String(err)}` };
+	}
+	let nextResponseArid;
+	try {
+		nextResponseArid = result.objectForPredicate("response_arid").extractSubject((cbor) => ARID.fromTaggedCbor(cbor));
+	} catch (err) {
+		return { rejected: `Failed to extract response_arid: ${err instanceof Error ? err.message : String(err)}` };
+	}
+	const packages = [];
+	try {
+		const pkgEnvelopes = result.objectsForPredicate("round2Package");
+		for (const pkgEnv of pkgEnvelopes) {
+			const recipient = pkgEnv.objectForPredicate("recipient").extractSubject((cbor) => XID.fromTaggedCbor(cbor));
+			const pkgJsonStr = pkgEnv.extractString();
+			const pkg = JSON.parse(pkgJsonStr);
+			packages.push([recipient, pkg]);
+		}
+	} catch (err) {
+		return { rejected: `Failed to extract round2 packages: ${err instanceof Error ? err.message : String(err)}` };
+	}
+	return {
+		packages,
+		nextResponseArid
+	};
+}
+/**
+* Fetch a Round 2 response sequentially.
+*
+* Port of `fetch_round2_response()` from round2.rs lines 364-442.
+*/
+async function fetchRound2Response(client, arid, timeout, coordinatorKeys, expectedGroup, expectedSender) {
+	const envelope = await getWithIndicator(client, arid, expectedSender.urString(), timeout, isVerbose());
+	if (envelope === null || envelope === void 0) throw new Error("Response not found in Hubert storage");
+	const result = validateAndExtractRound2Response(envelope, coordinatorKeys, expectedGroup, expectedSender);
+	if ("rejected" in result) throw new Error(result.rejected);
+	return {
+		packages: result.packages,
+		nextResponseArid: result.nextResponseArid
+	};
+}
+/**
+* Collect Round 2 responses sequentially.
+*
+* Port of `collect_round2()` from round2.rs lines 216-357.
+*/
+async function collectRound2(client, registryPath, registry, coordinatorKeys, groupId, pendingRequests, timeout) {
+	if (isVerbose()) console.error(`Collecting Round 2 responses from ${pendingRequests.len()} participants...`);
+	const allPackages = /* @__PURE__ */ new Map();
+	const nextResponseArids = [];
+	const errors = [];
+	for (const [participantXid, collectFromArid] of pendingRequests.iterCollect()) {
+		const participantName = registry.participant(participantXid)?.petName() ?? participantXid.urString();
+		if (isVerbose()) console.error(`${participantName}...`);
+		try {
+			const collected = await fetchRound2Response(client, collectFromArid, timeout, coordinatorKeys, groupId, participantXid);
+			allPackages.set(participantXid.urString(), collected.packages);
+			nextResponseArids.push([participantXid, collected.nextResponseArid]);
+		} catch (err) {
+			if (isVerbose()) console.error(`error: ${err instanceof Error ? err.message : String(err)}`);
+			errors.push([participantXid, err instanceof Error ? err.message : String(err)]);
+		}
+	}
+	if (errors.length > 0) {
+		if (isVerbose()) {
+			console.error();
+			console.error(`Failed to collect from ${errors.length} participants:`);
+		}
+		for (const [xid, error] of errors) console.error(`  ${xid.urString()}: ${error}`);
+		throw new Error(`Round 2 collection incomplete: ${errors.length} of ${pendingRequests.len()} responses failed`);
+	}
+	const displayPath = persistRound2PackagesFromMap(registryPath, groupId, allPackages, nextResponseArids);
+	const newPending = new PendingRequests();
+	for (const [xid, sendToArid] of nextResponseArids) newPending.addSendOnly(xid, sendToArid);
+	const groupRecord = registry.group(groupId);
+	if (groupRecord === void 0) throw new Error("Group not found in registry");
+	groupRecord.setPendingRequests(newPending);
+	registry.save(registryPath);
+	return {
+		packages: allPackages,
+		nextResponseArids,
+		displayPath
+	};
+}
+/**
+* Persist Round 2 packages from a Map (sequential collection).
+*/
+function persistRound2PackagesFromMap(registryPath, groupId, allPackages, nextResponseArids) {
+	const stateDir = groupStateDir(registryPath, groupId.hex());
+	fs.mkdirSync(stateDir, { recursive: true });
+	const collectedPath = path.join(stateDir, "collected_round2.json");
+	const root = {};
+	for (const [senderUrString, packages] of allPackages) {
+		const senderMap = {};
+		const responseArid = nextResponseArids.find(([xid]) => xid.urString() === senderUrString)?.[1];
+		if (responseArid !== void 0) senderMap["response_arid"] = responseArid.urString();
+		const packagesJson = {};
+		for (const [recipient, pkg] of packages) packagesJson[recipient.urString()] = pkg;
+		senderMap["packages"] = packagesJson;
+		root[senderUrString] = senderMap;
+	}
+	fs.writeFileSync(collectedPath, JSON.stringify(root, null, 2));
+	const cwd = process.cwd();
+	if (collectedPath.startsWith(cwd)) return collectedPath.slice(cwd.length + 1);
+	return collectedPath;
+}
+/**
+* Collect Round 2 responses in parallel with progress display.
+*
+* Port of `collect_round2_parallel()` from round2.rs lines 607-643.
+*/
+async function collectRound2Parallel(client, registry, pendingRequests, coordinatorKeys, expectedGroupId, timeout) {
+	const requests = [];
+	for (const [xid, arid] of pendingRequests.iterCollect()) {
+		const name = registry.participant(xid)?.petName() ?? xid.urString();
+		requests.push([
+			xid,
+			arid,
+			name
+		]);
+	}
+	return parallelFetch(client, requests, (envelope, xid) => validateAndExtractRound2Response(envelope, coordinatorKeys, expectedGroupId, xid), parallelFetchConfigWithTimeout(timeout));
+}
+/**
+* Persist Round 2 packages from parallel collection results.
+*
+* Port of `persist_round2_packages()` from round2.rs lines 712-758.
+*/
+function persistRound2Packages(registryPath, groupId, successes) {
+	const stateDir = groupStateDir(registryPath, groupId.hex());
+	fs.mkdirSync(stateDir, { recursive: true });
+	const collectedPath = path.join(stateDir, "collected_round2.json");
+	const root = {};
+	for (const [sender, data] of successes) {
+		const senderMap = {};
+		senderMap["response_arid"] = data.nextResponseArid.urString();
+		const packagesJson = {};
+		for (const [recipient, pkg] of data.packages) packagesJson[recipient.urString()] = pkg;
+		senderMap["packages"] = packagesJson;
+		root[sender.urString()] = senderMap;
+	}
+	fs.writeFileSync(collectedPath, JSON.stringify(root, null, 2));
+	const cwd = process.cwd();
+	if (collectedPath.startsWith(cwd)) return collectedPath.slice(cwd.length + 1);
+	return collectedPath;
+}
+/**
+* Update pending requests from parallel collection results.
+*
+* Port of `update_pending_for_finalize_from_collection()` from round2.rs lines 761-777.
+*/
+function updatePendingForFinalizeFromCollection(registry, registryPath, groupId, successes) {
+	const newPending = new PendingRequests();
+	for (const [xid, data] of successes) newPending.addSendOnly(xid, data.nextResponseArid);
+	const groupRecord = registry.group(groupId);
+	if (groupRecord === void 0) throw new Error("Group not found in registry");
+	groupRecord.setPendingRequests(newPending);
+	registry.save(registryPath);
+}
+/**
+* Gather packages FOR a specific recipient (from all other senders).
+*
+* Port of `gather_packages_for_recipient()` from round2.rs lines 552-571.
+*/
+function gatherPackagesForRecipient(recipient, allPackages) {
+	const result = [];
+	for (const [senderUrString, packages] of allPackages) for (const [rcpt, pkg] of packages) if (rcpt.urString() === recipient.urString()) {
+		const { XID: XIDClass } = __require("@bcts/components");
+		const sender = XIDClass.fromURString(senderUrString);
+		result.push([sender, pkg]);
+	}
+	if (result.length === 0) throw new Error(`No round2 packages found for recipient ${recipient.urString()}`);
+	return result;
+}
+/**
+* Build a finalize request for a participant.
+*
+* Port of `build_finalize_request_for_participant()` from round2.rs lines 575-594.
+*/
+function buildFinalizeRequestForParticipant(sender, groupId, responseArid, packages) {
+	let request = SealedRequest.new("dkgFinalize", ARID.new(), sender).withParameter("group", groupId).withParameter("responseArid", responseArid);
+	for (const [pkgSender, pkg] of packages) {
+		const encoded = JSON.stringify(pkg);
+		const pkgEnvelope = Envelope.new(encoded).addAssertion("sender", pkgSender);
+		request = request.withParameter("round2Package", pkgEnvelope);
+	}
+	return request;
+}
+/**
+* Send finalize requests sequentially.
+*
+* Port of `send_finalize_requests()` from round2.rs lines 444-550.
+*/
+async function sendFinalizeRequests(client, registryPath, registry, coordinator, groupId, collection, preview) {
+	const signerPrivateKeys = coordinator.inceptionPrivateKeys();
+	if (signerPrivateKeys === void 0) throw new Error("Coordinator XID document has no signing keys");
+	const validUntil = new Date(Date.now() + 3600 * 1e3);
+	const participantInfo = [];
+	for (const [xid, sendToArid] of collection.nextResponseArids) {
+		const record = registry.participant(xid);
+		if (record === void 0) throw new Error(`Participant ${xid.urString()} not found in registry`);
+		const collectFromArid = ARID.new();
+		participantInfo.push([
+			xid,
+			record.xidDocument(),
+			sendToArid,
+			collectFromArid
+		]);
+	}
+	if (isVerbose()) console.error(`Sending finalize packages to ${participantInfo.length} participants...`);
+	else console.error();
+	let previewOutput;
+	for (const [xid, recipientDoc, sendToArid, collectFromArid] of participantInfo) {
+		const participantName = registry.participant(xid)?.petName() ?? xid.urString();
+		if (isVerbose()) console.error(`${participantName}...`);
+		const request = buildFinalizeRequestForParticipant(coordinator, groupId, collectFromArid, gatherPackagesForRecipient(xid, collection.packages));
+		if (preview && previewOutput === void 0) previewOutput = [participantName, request.toEnvelope(validUntil, signerPrivateKeys, void 0).urString()];
+		await putWithIndicator(client, sendToArid, request.toEnvelopeForRecipients(validUntil, signerPrivateKeys, [recipientDoc]), participantName, isVerbose());
+	}
+	const newPendingRequests = new PendingRequests();
+	for (const [xid, , , collectFromArid] of participantInfo) newPendingRequests.addCollectOnly(xid, collectFromArid);
+	const groupRecord = registry.group(groupId);
+	if (groupRecord === void 0) throw new Error("Group not found in registry");
+	groupRecord.setPendingRequests(newPendingRequests);
+	registry.save(registryPath);
+	return previewOutput;
+}
+/**
+* Dispatch finalize requests in parallel.
+*
+* Port of `dispatch_finalize_requests_parallel()` from round2.rs lines 780-900.
+*/
+async function dispatchFinalizeRequestsParallel(client, registry, registryPath, coordinator, groupId, successes, preview) {
+	const signerPrivateKeys = coordinator.inceptionPrivateKeys();
+	if (signerPrivateKeys === void 0) throw new Error("Coordinator XID document has no signing keys");
+	const validUntil = new Date(Date.now() + 3600 * 1e3);
+	const allPackages = /* @__PURE__ */ new Map();
+	for (const [xid, data] of successes) allPackages.set(xid.urString(), data.packages);
+	const messages = [];
+	const collectArids = [];
+	let previewOutput;
+	for (const [xid, data] of successes) {
+		const record = registry.participant(xid);
+		if (record === void 0) throw new Error(`Participant ${xid.urString()} not found in registry`);
+		const recipientDoc = record.xidDocument();
+		const participantName = record.petName() ?? xid.urString();
+		const collectFromArid = ARID.new();
+		collectArids.push([xid, collectFromArid]);
+		const request = buildFinalizeRequestForParticipant(coordinator, groupId, collectFromArid, gatherPackagesForRecipient(xid, allPackages));
+		if (preview && previewOutput === void 0) previewOutput = [participantName, request.toEnvelope(validUntil, signerPrivateKeys, void 0).urString()];
+		const sealedEnvelope = request.toEnvelopeForRecipients(validUntil, signerPrivateKeys, [recipientDoc]);
+		messages.push([
+			xid,
+			data.nextResponseArid,
+			sealedEnvelope,
+			participantName
+		]);
+	}
+	console.error();
+	const failures = (await parallelSend(client, messages, isVerbose())).filter(([, err]) => err !== null);
+	if (failures.length > 0) {
+		for (const [xid, error] of failures) if (error !== null) console.error(`Failed to send to ${xid.urString()}: ${error.message}`);
+		throw new Error(`Failed to send finalize requests to ${failures.length} participants`);
+	}
+	const newPendingRequests = new PendingRequests();
+	for (const [xid, collectFromArid] of collectArids) newPendingRequests.addCollectOnly(xid, collectFromArid);
+	const groupRecord = registry.group(groupId);
+	if (groupRecord === void 0) throw new Error("Group not found in registry");
+	groupRecord.setPendingRequests(newPendingRequests);
+	registry.save(registryPath);
+	return previewOutput;
+}
+/**
+* Print summary for parallel collection.
+*
+* Port of `print_summary_parallel()` from round2.rs lines 903-964.
+*/
+function printSummaryParallel(collection, displayPath, preview) {
+	if (collection.rejections.length > 0) {
+		console.error();
+		console.error("Rejections:");
+		for (const [xid, reason] of collection.rejections) console.error(`  ${xid.urString()}: ${reason}`);
+	}
+	if (collection.errors.length > 0) {
+		console.error();
+		console.error("Errors:");
+		for (const [xid, error] of collection.errors) console.error(`  ${xid.urString()}: ${error}`);
+	}
+	if (collection.timeouts.length > 0) {
+		console.error();
+		console.error("Timeouts:");
+		for (const xid of collection.timeouts) console.error(`  ${xid.urString()}`);
+	}
+	if (!collection.allSucceeded()) {
+		console.error();
+		console.error(`Round 2 collection incomplete: ${collection.successes.length} succeeded, ${collection.rejections.length} rejected, ${collection.errors.length} errors, ${collection.timeouts.length} timeouts`);
+		return;
+	}
+	if (preview !== void 0) {
+		const [participantName, ur] = preview;
+		if (isVerbose()) {
+			console.error(`# Finalize preview for ${participantName}`);
+			console.error();
+		}
+		console.error(`Collected ${collection.successes.length} Round 2 responses to ${displayPath} and sent ${collection.successes.length} finalize requests.`);
+		console.log(ur);
+	} else if (isVerbose()) {
+		console.error();
+		console.error(`Collected ${collection.successes.length} Round 2 responses to ${displayPath} and sent ${collection.successes.length} finalize requests.`);
+	}
+}
+/**
+* Execute the DKG coordinator round 2 command.
+*
+* Collects Round 2 responses and sends finalize packages.
+*
+* Port of `CommandArgs::exec()` from cmd/dkg/coordinator/round2.rs lines 59-203.
+*/
+async function round2$4(client, options, cwd) {
+	const registryPath = resolveRegistryPath(options.registryPath, cwd);
+	const registry = Registry.load(registryPath);
+	const owner = registry.owner();
+	if (owner === void 0) throw new Error("Registry owner is required");
+	const ownerDoc = owner.xidDocument();
+	const groupId = parseAridUr(options.groupId);
+	const groupRecord = registry.group(groupId);
+	if (groupRecord === void 0) throw new Error(`Group ${options.groupId} not found in registry`);
+	validateCoordinator$2(groupRecord, owner.xid());
+	const pendingRequests = groupRecord.pendingRequests();
+	if (pendingRequests.isEmpty()) throw new Error("No pending requests for this group. Did you run 'frost dkg coordinator round1'?");
+	const coordinatorKeys = ownerDoc.inceptionPrivateKeys();
+	if (coordinatorKeys === void 0) throw new Error("Coordinator XID document has no private keys");
+	if (options.parallel === true) {
+		const collection = await collectRound2Parallel(client, registry, pendingRequests, coordinatorKeys, groupId, options.timeoutSeconds);
+		const displayPath = persistRound2Packages(registryPath, groupId, collection.successes);
+		updatePendingForFinalizeFromCollection(registry, registryPath, groupId, collection.successes);
+		printSummaryParallel(collection, displayPath, await dispatchFinalizeRequestsParallel(client, registry, registryPath, ownerDoc, groupId, collection.successes, options.preview ?? false));
+		return {
+			accepted: collection.successes.length,
+			rejected: collection.rejections.length,
+			errors: collection.errors.length,
+			timeouts: collection.timeouts.length,
+			displayPath
+		};
+	} else {
+		const collection = await collectRound2(client, registryPath, registry, coordinatorKeys, groupId, pendingRequests, options.timeoutSeconds);
+		const preview = await sendFinalizeRequests(client, registryPath, registry, ownerDoc, groupId, collection, options.preview ?? false);
+		if (preview !== void 0) {
+			const [participantName, ur] = preview;
+			if (isVerbose()) {
+				console.error(`# Finalize preview for ${participantName}`);
+				console.error();
+			}
+			console.error(`Collected ${collection.packages.size} Round 2 responses to ${collection.displayPath} and sent ${collection.nextResponseArids.length} finalize requests.`);
+			console.log(ur);
+		} else if (isVerbose()) {
+			console.error();
+			console.error(`Collected ${collection.packages.size} Round 2 responses to ${collection.displayPath} and sent ${collection.nextResponseArids.length} finalize requests.`);
+		}
+		return {
+			accepted: collection.packages.size,
+			rejected: 0,
+			errors: 0,
+			timeouts: 0,
+			displayPath: collection.displayPath
+		};
+	}
+}
+
+//#endregion
+//#region src/cmd/dkg/coordinator/finalize.ts
+/**
+* DKG coordinator finalize command.
+*
+* Port of cmd/dkg/coordinator/finalize.rs from frost-hubert-rust.
+*
+* @module
+*/
+/**
+* Validate that the owner is the coordinator of the group.
+*
+* Port of coordinator check from finalize.rs lines 76-82.
+*/
+function validateCoordinator$1(groupRecord, ownerXid) {
+	if (groupRecord.coordinator().xid().urString() !== ownerXid.urString()) throw new Error(`Only the coordinator can collect finalize responses. Coordinator: ${groupRecord.coordinator().xid().urString()}, Owner: ${ownerXid.urString()}`);
+}
+/**
+* Validate envelope and extract finalize data (for parallel fetch).
+*
+* Port of `validate_and_extract_finalize_response()` from finalize.rs lines 407-466.
+*/
+function validateAndExtractFinalizeResponse(envelope, coordinatorKeys, expectedGroupId, expectedParticipant) {
+	const now = /* @__PURE__ */ new Date();
+	let sealed;
+	try {
+		sealed = SealedResponse.tryFromEncryptedEnvelope(envelope, void 0, now, coordinatorKeys);
+	} catch (err) {
+		return { rejected: `Failed to decrypt/parse response: ${err instanceof Error ? err.message : String(err)}` };
+	}
+	if (!sealed.isOk()) try {
+		return { rejected: `Participant reported error: ${sealed.error().optionalObjectForPredicate("reason")?.extractString() ?? "unknown reason"}` };
+	} catch {
+		return { rejected: "Participant reported error: unknown reason" };
+	}
+	let result;
+	try {
+		result = sealed.result();
+	} catch {
+		return { rejected: "Finalize response has no result" };
+	}
+	try {
+		result.checkSubjectUnit();
+		result.checkType("dkgFinalizeResponse");
+	} catch (err) {
+		return { rejected: `Invalid response type: ${err instanceof Error ? err.message : String(err)}` };
+	}
+	try {
+		const groupId = parseAridUr(result.objectForPredicate("group").extractString());
+		if (groupId.urString() !== expectedGroupId.urString()) return { rejected: `Group ${groupId.urString()} does not match expected ${expectedGroupId.urString()}` };
+	} catch (err) {
+		return { rejected: `Failed to extract group: ${err instanceof Error ? err.message : String(err)}` };
+	}
+	try {
+		const participantStr = result.objectForPredicate("participant").extractString();
+		const { XID: XIDClass } = __require("@bcts/components");
+		const participantXid = XIDClass.fromURString(participantStr);
+		if (participantXid.urString() !== expectedParticipant.urString()) return { rejected: `Participant ${participantXid.urString()} does not match expected ${expectedParticipant.urString()}` };
+	} catch (err) {
+		return { rejected: `Failed to extract participant: ${err instanceof Error ? err.message : String(err)}` };
+	}
+	let keyPackage;
+	let publicKeyPackage;
+	try {
+		const keyJsonStr = result.objectForPredicate("key_package").extractString();
+		keyPackage = JSON.parse(keyJsonStr);
+	} catch (err) {
+		return { rejected: `Failed to parse key_package: ${err instanceof Error ? err.message : String(err)}` };
+	}
+	try {
+		const pubJsonStr = result.objectForPredicate("public_key_package").extractString();
+		publicKeyPackage = JSON.parse(pubJsonStr);
+	} catch (err) {
+		return { rejected: `Failed to parse public_key_package: ${err instanceof Error ? err.message : String(err)}` };
+	}
+	return {
+		keyPackage,
+		publicKeyPackage
+	};
+}
+/**
+* Fetch a finalize response sequentially.
+*
+* Port of `fetch_finalize_response()` from finalize.rs lines 282-358.
+*/
+async function fetchFinalizeResponse(client, responseArid, timeout, coordinatorKeys, expectedGroup, expectedParticipant, participantName) {
+	const envelope = await getWithIndicator(client, responseArid, participantName, timeout, isVerbose());
+	if (envelope === null || envelope === void 0) throw new Error("Finalize response not found in Hubert storage");
+	const result = validateAndExtractFinalizeResponse(envelope, coordinatorKeys, expectedGroup, expectedParticipant);
+	if ("rejected" in result) throw new Error(result.rejected);
+	return {
+		participant: expectedParticipant,
+		keyPackage: result.keyPackage,
+		publicKeyPackage: result.publicKeyPackage
+	};
+}
+/**
+* Collect finalize responses in parallel with progress display.
+*
+* Port of `collect_finalize_parallel()` from finalize.rs lines 371-404.
+*/
+async function collectFinalizeParallel(client, registry, pendingRequests, coordinatorKeys, expectedGroupId, timeout) {
+	const requests = [];
+	for (const [xid, arid] of pendingRequests.iterCollect()) {
+		const name = registry.participant(xid)?.petName() ?? xid.urString();
+		requests.push([
+			xid,
+			arid,
+			name
+		]);
+	}
+	return parallelFetch(client, requests, (envelope, xid) => validateAndExtractFinalizeResponse(envelope, coordinatorKeys, expectedGroupId, xid), parallelFetchConfigWithTimeout(timeout));
+}
+/**
+* Finalize collection results: persist, update registry, print summary.
+*
+* Port of `finalize_collection_results()` from finalize.rs lines 469-590.
+*/
+function finalizeFinalizeCollectionResults(collection, registryPath, registry, groupId) {
+	if (collection.rejections.length > 0) {
+		console.error();
+		console.error("Rejections:");
+		for (const [xid, reason] of collection.rejections) console.error(`  ${xid.urString()}: ${reason}`);
+	}
+	if (collection.errors.length > 0) {
+		console.error();
+		console.error("Errors:");
+		for (const [xid, error] of collection.errors) console.error(`  ${xid.urString()}: ${error}`);
+	}
+	if (collection.timeouts.length > 0) {
+		console.error();
+		console.error("Timeouts:");
+		for (const xid of collection.timeouts) console.error(`  ${xid.urString()}`);
+	}
+	if (!collection.allSucceeded()) throw new Error(`Finalize collection incomplete: ${collection.successes.length} succeeded, ${collection.rejections.length} rejected, ${collection.errors.length} errors, ${collection.timeouts.length} timeouts`);
+	let groupVerifyingKey;
+	for (const [xid, data] of collection.successes) {
+		const pubKeyPkg = data.publicKeyPackage;
+		if (!pubKeyPkg.verifying_key) throw new Error(`Failed to extract verifying key for ${xid.urString()}: missing verifying_key field`);
+		let signingKey;
+		try {
+			signingKey = signingKeyFromVerifying(hexToBytes(pubKeyPkg.verifying_key));
+		} catch (err) {
+			throw new Error(`Failed to extract verifying key for ${xid.urString()}: ${err instanceof Error ? err.message : String(err)}`);
+		}
+		if (groupVerifyingKey !== void 0) {
+			if (groupVerifyingKey.urString() !== signingKey.urString()) throw new Error(`Group verifying key mismatch for participant ${xid.urString()}`);
+		} else groupVerifyingKey = signingKey;
+	}
+	const stateDir = groupStateDir(registryPath, groupId.hex());
+	fs.mkdirSync(stateDir, { recursive: true });
+	const collectedPath = path.join(stateDir, "collected_finalize.json");
+	const root = {};
+	for (const [xid, data] of collection.successes) root[xid.urString()] = {
+		key_package: data.keyPackage,
+		public_key_package: data.publicKeyPackage
+	};
+	fs.writeFileSync(collectedPath, JSON.stringify(root, null, 2));
+	const groupRecord = registry.group(groupId);
+	if (groupRecord === void 0) throw new Error("Group not found in registry");
+	if (groupVerifyingKey !== void 0) groupRecord.setVerifyingKey(groupVerifyingKey);
+	groupRecord.clearPendingRequests();
+	registry.save(registryPath);
+	if (isVerbose()) {
+		console.error();
+		console.error(`Collected ${collection.successes.length} finalize responses. Saved to ${collectedPath}`);
+		if (groupVerifyingKey !== void 0) console.error(groupVerifyingKey.urString());
+	} else if (groupVerifyingKey !== void 0) console.log(groupVerifyingKey.urString());
+	return groupVerifyingKey;
+}
+/**
+* Helper to convert hex string to bytes.
+*/
+function hexToBytes(hex) {
+	const bytes = new Uint8Array(hex.length / 2);
+	for (let i = 0; i < bytes.length; i++) bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+	return bytes;
+}
+/**
+* Execute the DKG coordinator finalize command.
+*
+* Collects finalize responses (key/public key packages) from all participants.
+*
+* Port of `finalize()` from cmd/dkg/coordinator/finalize.rs.
+*/
+async function finalize$2(client, options, cwd) {
+	const registryPath = resolveRegistryPath(options.registryPath, cwd);
+	const registry = Registry.load(registryPath);
+	const owner = registry.owner();
+	if (owner === void 0) throw new Error("Registry owner is required");
+	const groupId = parseAridUr(options.groupId);
+	const groupRecord = registry.group(groupId);
+	if (groupRecord === void 0) throw new Error(`Group ${options.groupId} not found in registry`);
+	validateCoordinator$1(groupRecord, owner.xid());
+	const pendingRequests = groupRecord.pendingRequests();
+	if (pendingRequests.isEmpty()) throw new Error("No pending requests for this group. Did you run 'frost dkg coordinator finalize send'?");
+	const coordinatorKeys = owner.xidDocument().inceptionPrivateKeys();
+	if (coordinatorKeys === void 0) throw new Error("Coordinator XID document has no private keys");
+	let verifyingKey;
+	let collected = 0;
+	let rejected = 0;
+	let errors = 0;
+	let timeouts = 0;
+	if (options.parallel === true) {
+		const collection = await collectFinalizeParallel(client, registry, pendingRequests, coordinatorKeys, groupId, options.timeoutSeconds);
+		verifyingKey = finalizeFinalizeCollectionResults(collection, registryPath, registry, groupId);
+		collected = collection.successes.length;
+		rejected = collection.rejections.length;
+		errors = collection.errors.length;
+		timeouts = collection.timeouts.length;
+	} else {
+		const collectedEntries = [];
+		const errorEntries = [];
+		let groupVerifyingKey;
+		if (isVerbose()) console.error(`Collecting finalize responses from ${pendingRequests.len()} participants...`);
+		for (const [participantXid, collectFromArid] of pendingRequests.iterCollect()) {
+			const name = registry.participant(participantXid)?.petName() ?? participantXid.urString();
+			try {
+				const entry = await fetchFinalizeResponse(client, collectFromArid, options.timeoutSeconds, coordinatorKeys, groupId, participantXid, name);
+				const pubKeyPkg = entry.publicKeyPackage;
+				if (!pubKeyPkg.verifying_key) throw new Error("missing verifying_key field");
+				const signingKey = signingKeyFromVerifying(hexToBytes(pubKeyPkg.verifying_key));
+				if (groupVerifyingKey !== void 0) {
+					if (groupVerifyingKey.urString() !== signingKey.urString()) {
+						if (isVerbose()) console.error("error: group verifying key mismatch");
+						errorEntries.push([participantXid, "Group verifying key mismatch across responses"]);
+						continue;
+					}
+				} else groupVerifyingKey = signingKey;
+				collectedEntries.push(entry);
+			} catch (err) {
+				if (isVerbose()) console.error(`error: ${err instanceof Error ? err.message : String(err)}`);
+				errorEntries.push([participantXid, err instanceof Error ? err.message : String(err)]);
+			}
+		}
+		if (errorEntries.length > 0) {
+			if (isVerbose()) {
+				console.error();
+				console.error(`Failed to collect from ${errorEntries.length} participants:`);
+				for (const [xid, error] of errorEntries) console.error(`  ${xid.urString()}: ${error}`);
+			}
+			throw new Error(`Finalize collection incomplete: ${errorEntries.length} of ${pendingRequests.len()} responses failed`);
+		}
+		const stateDir = groupStateDir(registryPath, groupId.hex());
+		fs.mkdirSync(stateDir, { recursive: true });
+		const collectedPath = path.join(stateDir, "collected_finalize.json");
+		const root = {};
+		for (const entry of collectedEntries) root[entry.participant.urString()] = {
+			key_package: entry.keyPackage,
+			public_key_package: entry.publicKeyPackage
+		};
+		fs.writeFileSync(collectedPath, JSON.stringify(root, null, 2));
+		const groupRecordMut = registry.group(groupId);
+		if (groupRecordMut === void 0) throw new Error("Group not found in registry");
+		if (groupVerifyingKey !== void 0) groupRecordMut.setVerifyingKey(groupVerifyingKey);
+		groupRecordMut.clearPendingRequests();
+		registry.save(registryPath);
+		if (isVerbose()) {
+			console.error();
+			console.error(`Collected ${collectedEntries.length} finalize responses. Saved to ${collectedPath}`);
+			if (groupVerifyingKey !== void 0) console.error(groupVerifyingKey.urString());
+		} else if (groupVerifyingKey !== void 0) console.log(groupVerifyingKey.urString());
+		verifyingKey = groupVerifyingKey;
+		collected = collectedEntries.length;
+		errors = errorEntries.length;
+	}
+	return {
+		verifyingKey: verifyingKey?.urString() ?? "",
+		collected,
+		rejected,
+		errors,
+		timeouts
+	};
+}
+
+//#endregion
+//#region src/cmd/dkg/coordinator/index.ts
+var coordinator_exports$1 = /* @__PURE__ */ __exportAll({
+	buildFinalizeRequestForParticipant: () => buildFinalizeRequestForParticipant,
+	collectRound2Parallel: () => collectRound2Parallel,
+	dispatchFinalizeRequestsParallel: () => dispatchFinalizeRequestsParallel,
+	finalize: () => finalize$2,
+	invite: () => invite$1,
+	persistRound2Packages: () => persistRound2Packages,
+	round1: () => round1$4,
+	round2: () => round2$4,
+	updatePendingForFinalizeFromCollection: () => updatePendingForFinalizeFromCollection,
+	validateAndExtractRound2Response: () => validateAndExtractRound2Response
+});
+
+//#endregion
+//#region src/cmd/dkg/participant/receive.ts
+/**
+* DKG participant receive command.
+*
+* Port of cmd/dkg/participant/receive.rs from frost-hubert-rust.
+*
+* @module
+*/
+/**
+* Resolve an invite envelope from either storage (ARID) or direct UR.
+*
+* Port of `resolve_invite_envelope()` from cmd/dkg/participant/receive.rs lines 122-152.
+*/
+async function resolveInviteEnvelope$1(selection, invite, timeout) {
+	if (selection !== void 0) {
+		try {
+			const arid = parseAridUr(invite);
+			const envelope = await getWithIndicator(await createStorageClient(selection), arid, "Invite", timeout, false);
+			if (envelope === null || envelope === void 0) throw new Error("Invite not found in Hubert storage");
+			return envelope;
+		} catch (e) {
+			if (e instanceof Error && e.message.includes("Invite not found in Hubert storage")) throw e;
+		}
+		if (timeout !== void 0) throw new Error("--timeout is only valid when retrieving invites from Hubert");
+		return parseEnvelopeUr(invite);
+	}
+	try {
+		parseAridUr(invite);
+		throw new Error("Hubert storage parameters are required to retrieve invites by ARID");
+	} catch (e) {
+		if (e instanceof Error && e.message.includes("Hubert storage parameters are required")) throw e;
+	}
+	return parseEnvelopeUr(invite);
+}
+/**
+* Decode and validate invite details from an envelope.
+*
+* Port of `decode_invite_details()` from cmd/dkg/participant/receive.rs lines 154-256.
+*/
+function decodeInviteDetails(invite, now, registry, recipient, expectedSender) {
+	const recipientPrivateKeys = recipient.inceptionPrivateKeys();
+	if (recipientPrivateKeys === void 0) throw new Error("Recipient XID document has no inception private keys");
+	const sealedRequest = SealedRequest.tryFromEnvelope(invite, void 0, now, recipientPrivateKeys);
+	const senderDocument = sealedRequest.sender();
+	if (expectedSender !== void 0) {
+		if (senderDocument.xid().urString() !== expectedSender.xid().urString()) throw new Error("Invite sender does not match expected sender");
+	} else {
+		const senderXid = senderDocument.xid();
+		const knownOwner = registry.owner()?.xidDocument().xid().urString() === senderXid.urString();
+		const knownParticipant = registry.participant(senderXid) !== void 0;
+		if (!knownOwner && !knownParticipant) throw new Error(`Invite sender not found in registry: ${senderXid.urString()}`);
+	}
+	if (!sealedRequest.request().function().equals(Function.fromString("dkgInvite"))) throw new Error("Unexpected invite function");
+	if (sealedRequest.extractObjectForParameter("validUntil") <= now) throw new Error("Invitation expired");
+	const minSigners = sealedRequest.extractObjectForParameter("minSigners");
+	sealedRequest.extractObjectForParameter("charter");
+	sealedRequest.extractObjectForParameter("group");
+	const participantObjects = sealedRequest.objectsForParameter("participant");
+	if (minSigners < 2) throw new Error("min_signers must be at least 2");
+	if (minSigners > participantObjects.length) throw new Error("min_signers exceeds participant count");
+	const participantDocs = [];
+	let responseArid;
+	const recipientXid = recipient.xid();
+	for (const participant of participantObjects) {
+		const xidDocumentEnvelope = participant.tryUnwrap();
+		const xidDocument = XIDDocument.fromEnvelope(xidDocumentEnvelope, void 0, XIDVerifySignature.Inception);
+		if (xidDocument.xid().urString() === recipientXid.urString()) responseArid = participant.objectForPredicate("response_arid").decryptToRecipient(recipientPrivateKeys).extractSubject((cbor) => ARID.fromTaggedCbor(cbor));
+		participantDocs.push(xidDocument);
+	}
+	const invitation = DkgInvitation.fromInvite(invite, now, expectedSender, recipient);
+	if (responseArid === void 0) throw new Error("Invite does not include a response ARID for this recipient");
+	return {
+		invitation,
+		participants: participantDocs
+	};
+}
+/**
+* Resolve a sender XID document from the registry by UR or pet name.
+*
+* Port of `resolve_sender()` usage in receive.rs for expected sender.
+*/
+function resolveSenderXidDocument$1(registry, raw) {
+	try {
+		const xid = XID.fromURString(raw.trim());
+		const record = registry.participant(xid);
+		if (record) return record.xidDocument();
+		const owner = registry.owner();
+		if (owner?.xid().urString() === xid.urString()) return owner.xidDocument();
+		throw new Error(`Sender with XID ${xid.urString()} not found in registry`);
+	} catch {
+		const result = registry.participantByPetName(raw.trim());
+		if (result) {
+			const [, record] = result;
+			return record.xidDocument();
+		}
+		const owner = registry.owner();
+		if (owner?.petName() === raw.trim()) return owner.xidDocument();
+		throw new Error(`Sender '${raw}' not found in registry`);
+	}
+}
+/**
+* Execute the DKG participant receive command.
+*
+* Fetches and validates a DKG invite from the coordinator.
+*
+* Port of `receive()` from cmd/dkg/participant/receive.rs.
+*/
+async function receive$1(_client, options, cwd) {
+	if (options.storageSelection === void 0 && options.timeoutSeconds !== void 0) throw new Error("--timeout requires Hubert storage parameters");
+	const registryPath = resolveRegistryPath(options.registryPath, cwd);
+	const registry = Registry.load(registryPath);
+	const owner = registry.owner();
+	if (!owner) throw new Error("Registry owner with private keys is required");
+	const expectedSender = options.sender ? resolveSenderXidDocument$1(registry, options.sender) : void 0;
+	const inviteEnvelope = await resolveInviteEnvelope$1(options.storageSelection, options.invite, options.timeoutSeconds);
+	const details = decodeInviteDetails(inviteEnvelope, CborDate.now().datetime(), registry, owner.xidDocument(), expectedSender);
+	const participantNames = participantNamesFromRegistry(registry, details.participants, owner.xid(), owner.petName());
+	const coordinatorName = resolveSenderName$1(registry, details.invitation.sender());
+	const stateDir = dkgStateDir(registryPath, details.invitation.groupId().hex());
+	fs.mkdirSync(stateDir, { recursive: true });
+	const validUntilStr = details.invitation.validUntil().toString();
+	const receiveState = {
+		group: details.invitation.groupId().urString(),
+		request_id: details.invitation.requestId().urString(),
+		response_arid: details.invitation.responseArid().urString(),
+		valid_until: validUntilStr,
+		min_signers: details.invitation.minSigners(),
+		charter: details.invitation.charter(),
+		sender: details.invitation.sender().xid().urString()
+	};
+	fs.writeFileSync(path.join(stateDir, "receive.json"), JSON.stringify(receiveState, null, 2));
+	let envelopeUr;
+	if (options.noEnvelope !== true) {
+		envelopeUr = inviteEnvelope.urString();
+		console.log(envelopeUr);
+	}
+	if (options.info === true) {
+		console.error(`Charter: ${details.invitation.charter()}`);
+		console.error(`Min signers: ${details.invitation.minSigners()}`);
+		if (coordinatorName !== void 0) console.error(`Coordinator: ${coordinatorName}`);
+		console.error(`Participants: ${participantNames.join(", ")}`);
+	}
+	if (options.verbose === true) {
+		console.log(`Group ID: ${details.invitation.groupId().urString()}`);
+		console.log(`Min signers: ${details.invitation.minSigners()}`);
+		console.log(`Charter: ${details.invitation.charter()}`);
+		console.log(`Valid until: ${String(details.invitation.validUntil())}`);
+		console.log(`Response ARID: ${details.invitation.responseArid().urString()}`);
+	}
+	const resultValidUntilStr = details.invitation.validUntil().toString();
+	return {
+		groupId: details.invitation.groupId().urString(),
+		requestId: details.invitation.requestId().urString(),
+		minSigners: details.invitation.minSigners(),
+		charter: details.invitation.charter(),
+		validUntil: resultValidUntilStr,
+		responseArid: details.invitation.responseArid().urString(),
+		envelopeUr,
+		coordinatorName,
+		participantNames
+	};
+}
+
+//#endregion
+//#region src/cmd/dkg/participant/round1.ts
+/**
+* DKG participant round 1 command.
+*
+* Port of cmd/dkg/participant/round1.rs from frost-hubert-rust.
+*
+* @module
+*/
+/**
+* Resolve an invite envelope from either storage (ARID) or direct UR.
+*
+* Port of `resolve_invite_envelope()` from cmd/dkg/participant/round1.rs lines 256-288.
+*/
+async function resolveInviteEnvelope(selection, invite, timeout) {
+	if (selection !== void 0) {
+		try {
+			const arid = parseAridUr(invite);
+			const envelope = await getWithIndicator(await createStorageClient(selection), arid, "Invite", timeout, false);
+			if (envelope === null || envelope === void 0) throw new Error("Invite not found in Hubert storage");
+			return envelope;
+		} catch (e) {
+			if (e instanceof Error && e.message.includes("Invite not found in Hubert storage")) throw e;
+		}
+		if (timeout !== void 0) throw new Error("--timeout is only valid when retrieving invites from Hubert");
+		return parseEnvelopeUr(invite);
+	}
+	try {
+		parseAridUr(invite);
+		throw new Error("Hubert storage parameters are required to retrieve invites by ARID");
+	} catch (e) {
+		if (e instanceof Error && e.message.includes("Hubert storage parameters are required")) throw e;
+	}
+	return parseEnvelopeUr(invite);
+}
+/**
+* Build the response body envelope.
+*
+* Port of `build_response_body()` from cmd/dkg/participant/round1.rs lines 290-308.
+*/
+function buildResponseBody$4(groupId, participant, responseArid, round1Package) {
+	let envelope = Envelope.unit().addType("dkgRound1Response").addAssertion("group", groupId).addAssertion("participant", participant).addAssertion("response_arid", responseArid);
+	if (round1Package !== void 0) {
+		const packageJson = serde.round1PackageToJson(round1Package);
+		const jsonStr = globalThis.JSON.stringify(packageJson);
+		const jsonBytes = new TextEncoder().encode(jsonStr);
+		const jsonWrapper = JSON$1.fromData(jsonBytes);
+		envelope = envelope.addAssertion("round1_package", jsonWrapper);
+	}
+	return envelope;
+}
+/**
+* Serialize round 1 secret package to JSON-compatible format.
+*
+* The @frosts/ed25519 serde module doesn't provide a serializer for SecretPackage,
+* so we manually serialize it here.
+*/
+function serializeRound1SecretPackage(secret) {
+	const serializedCoefficients = secret.coefficients().map((c) => bytesToHex(Ed25519Sha512.serializeScalar(c)));
+	const commitmentCoefficients = secret.commitment.serialize().map((c) => bytesToHex(c));
+	return {
+		header: serde.DEFAULT_HEADER,
+		identifier: bytesToHex(secret.identifier.serialize()),
+		coefficients: serializedCoefficients,
+		commitment: commitmentCoefficients,
+		min_signers: secret.minSigners,
+		max_signers: secret.maxSigners
+	};
+}
+/**
+* Persist round 1 state to disk.
+*
+* Port of `persist_round1_state()` from cmd/dkg/participant/round1.rs lines 310-337.
+*/
+function persistRound1State(registryPath, groupId, round1Secret, round1Package) {
+	const dir = groupStateDir(registryPath, groupId.hex());
+	fs.mkdirSync(dir, { recursive: true });
+	const secretPath = path.join(dir, "round1_secret.json");
+	const packagePath = path.join(dir, "round1_package.json");
+	const secretJson = serializeRound1SecretPackage(round1Secret);
+	const packageJson = serde.round1PackageToJson(round1Package);
+	fs.writeFileSync(secretPath, globalThis.JSON.stringify(secretJson, null, 2));
+	fs.writeFileSync(packagePath, globalThis.JSON.stringify(packageJson, null, 2));
+	return new ContributionPaths({
+		round1Secret: secretPath,
+		round1Package: packagePath,
+		round2Secret: void 0,
+		keyPackage: void 0
+	});
+}
+/**
+* Execute the DKG participant round 1 command.
+*
+* Responds to the DKG invite with commitment packages.
+*
+* Port of `CommandArgs::exec()` from cmd/dkg/participant/round1.rs lines 66-254.
+*/
+async function round1$3(_client, options, cwd) {
+	if (options.storageSelection === void 0 && options.timeoutSeconds !== void 0) throw new Error("--timeout requires Hubert storage parameters");
+	if (options.storageSelection !== void 0 && options.preview === true) throw new Error("--preview cannot be used with Hubert storage options");
+	const registryPath = resolveRegistryPath(options.registryPath, cwd);
+	const registry = Registry.load(registryPath);
+	const owner = registry.owner();
+	if (!owner) throw new Error("Registry owner with private keys is required");
+	let expectedSender;
+	if (options.sender !== void 0) expectedSender = resolveSenderXidDocument(registry, options.sender);
+	const nextResponseArid = options.responseArid !== void 0 ? parseAridUr(options.responseArid) : ARID.new();
+	const details = decodeInviteDetails(await resolveInviteEnvelope(options.storageSelection, options.invite, options.timeoutSeconds), CborDate.now().datetime(), registry, owner.xidDocument(), expectedSender);
+	const sortedParticipants = [...details.participants].sort((a, b) => a.xid().urString().localeCompare(b.xid().urString()));
+	const ownerIndex = sortedParticipants.findIndex((doc) => doc.xid().urString() === owner.xid().urString());
+	if (ownerIndex === -1) throw new Error("Invite does not include the registry owner");
+	const identifierIndex = ownerIndex + 1;
+	if (identifierIndex > 65535) throw new Error("Too many participants for identifiers");
+	const identifier = identifierFromU16(identifierIndex);
+	const total = sortedParticipants.length;
+	if (total > 65535) throw new Error("Too many participants for FROST identifiers");
+	const minSigners = details.invitation.minSigners();
+	if (minSigners > 65535) throw new Error("min_signers does not fit into identifier space");
+	const groupParticipants = buildGroupParticipants(registry, owner, sortedParticipants);
+	const coordinator = groupParticipantFromRegistry(registry, owner, details.invitation.sender());
+	const isPosting = options.storageSelection !== void 0;
+	let responseBody;
+	let contributions;
+	if (options.rejectReason === void 0 && isPosting) {
+		const [round1Secret, round1Package] = dkgPart1(identifier, total, minSigners, createRng());
+		contributions = persistRound1State(registryPath, details.invitation.groupId(), round1Secret, round1Package);
+		responseBody = buildResponseBody$4(details.invitation.groupId(), owner.xid(), nextResponseArid, round1Package);
+		const groupRecord = new GroupRecord(details.invitation.charter(), details.invitation.minSigners(), coordinator, groupParticipants);
+		groupRecord.setContributions(contributions);
+		groupRecord.setListeningAtArid(nextResponseArid);
+		registry.recordGroup(details.invitation.groupId(), groupRecord);
+		registry.save(registryPath);
+	} else if (options.rejectReason === void 0) {
+		const [, round1Package] = dkgPart1(identifier, total, minSigners, createRng());
+		responseBody = buildResponseBody$4(details.invitation.groupId(), owner.xid(), nextResponseArid, round1Package);
+	} else responseBody = buildResponseBody$4(details.invitation.groupId(), owner.xid(), nextResponseArid, void 0);
+	const signerPrivateKeys = owner.xidDocument().inceptionPrivateKeys();
+	if (signerPrivateKeys === void 0) throw new Error("Owner XID document has no signing keys");
+	let sealed;
+	if (options.rejectReason !== void 0) {
+		const errorBody = Envelope.new("dkgInviteReject").addAssertion("group", details.invitation.groupId()).addAssertion("response_arid", nextResponseArid).addAssertion("reason", options.rejectReason);
+		sealed = SealedResponse.newFailure(details.invitation.requestId(), owner.xidDocument()).withError(errorBody).withState(nextResponseArid);
+	} else sealed = SealedResponse.newSuccess(details.invitation.requestId(), owner.xidDocument()).withResult(responseBody).withState(nextResponseArid);
+	const peerContinuation = details.invitation.peerContinuation();
+	if (peerContinuation !== void 0) sealed = sealed.withPeerContinuation(peerContinuation);
+	if (options.storageSelection !== void 0) {
+		const responseEnvelope = sealed.toEnvelope(details.invitation.validUntil(), signerPrivateKeys, details.invitation.sender());
+		const responseTarget = details.invitation.responseArid();
+		await putWithIndicator(await createStorageClient(options.storageSelection), responseTarget, responseEnvelope, "Round 1 Response", options.verbose ?? false);
+		if (options.verbose === true) {
+			console.log(`Sent round 1 response`);
+			console.log(`Listening at: ${nextResponseArid.urString()}`);
+		}
+		return {
+			accepted: options.rejectReason === void 0,
+			listeningArid: nextResponseArid.urString()
+		};
+	} else if (options.preview === true) {
+		const envelopeUr = sealed.toEnvelope(void 0, signerPrivateKeys, void 0).urString();
+		console.log(envelopeUr);
+		return {
+			accepted: options.rejectReason === void 0,
+			envelopeUr
+		};
+	} else {
+		const envelopeUr = sealed.toEnvelope(details.invitation.validUntil(), signerPrivateKeys, details.invitation.sender()).urString();
+		console.log(envelopeUr);
+		return {
+			accepted: options.rejectReason === void 0,
+			envelopeUr
+		};
+	}
+}
+/**
+* Resolve a sender XID document from the registry by UR or pet name.
+*/
+function resolveSenderXidDocument(registry, raw) {
+	try {
+		const xid = XID.fromURString(raw.trim());
+		const record = registry.participant(xid);
+		if (record) return record.xidDocument();
+		const owner = registry.owner();
+		if (owner?.xid().urString() === xid.urString()) return owner.xidDocument();
+		throw new Error(`Sender with XID ${xid.urString()} not found in registry`);
+	} catch {
+		const result = registry.participantByPetName(raw.trim());
+		if (result) {
+			const [, record] = result;
+			return record.xidDocument();
+		}
+		const owner = registry.owner();
+		if (owner?.petName() === raw.trim()) return owner.xidDocument();
+		throw new Error(`Sender '${raw}' not found in registry`);
+	}
+}
+
+//#endregion
+//#region src/cmd/dkg/participant/round2.ts
+/**
+* DKG participant round 2 command.
+*
+* Port of cmd/dkg/participant/round2.rs from frost-hubert-rust.
+*
+* @module
+*/
+/**
+* Load persisted round 1 state from disk.
+*
+* Port of round1_secret loading from cmd/dkg/participant/round2.rs lines 86-97.
+*/
+function loadRound1State(registryPath, groupId) {
+	const packagesDir = groupStateDir(registryPath, groupId.hex());
+	const round1SecretPath = path.join(packagesDir, "round1_secret.json");
+	if (!fs.existsSync(round1SecretPath)) throw new Error(`Round 1 secret not found at ${round1SecretPath}. Did you respond to the invite?`);
+	const secretJson = JSON.parse(fs.readFileSync(round1SecretPath, "utf-8"));
+	const coefficients = secretJson.coefficients.map((hex) => Ed25519Sha512.deserializeScalar(hexToBytes$1(hex)));
+	const commitment = new VerifiableSecretSharingCommitment(Ed25519Sha512, secretJson.commitment.map((hex) => CoefficientCommitment.deserialize(Ed25519Sha512, hexToBytes$1(hex))));
+	const idBytes = hexToBytes$1(secretJson.identifier);
+	let identifierU16 = 1;
+	if (idBytes.length >= 2) identifierU16 = idBytes[0] | idBytes[1] << 8;
+	if (identifierU16 === 0) identifierU16 = 1;
+	const parsedIdentifier = identifierFromU16(identifierU16);
+	const secretPackage = new round1.SecretPackage(Ed25519Sha512, parsedIdentifier, coefficients, commitment, secretJson.min_signers, secretJson.max_signers);
+	const round1PackagePath = path.join(packagesDir, "round1_package.json");
+	const packageJson = JSON.parse(fs.readFileSync(round1PackagePath, "utf-8"));
+	return {
+		secretPackage,
+		ourRound1Package: serde.round1PackageFromJson(packageJson)
+	};
+}
+/**
+* Validate the round 2 request from the coordinator.
+*
+* Port of request validation from cmd/dkg/participant/round2.rs lines 118-158.
+*/
+function validateRound2Request(sealedRequest, groupId, expectedCoordinator) {
+	if (!sealedRequest.function().equals(Function.fromString("dkgRound2"))) throw new Error(`Unexpected request function: ${sealedRequest.function().toString()}`);
+	if (sealedRequest.sender().xid().urString() !== expectedCoordinator.urString()) throw new Error(`Unexpected request sender: ${sealedRequest.sender().xid().urString()} (expected coordinator ${expectedCoordinator.urString()})`);
+	const requestGroupIdEnvelope = sealedRequest.objectForParameter("group");
+	if (requestGroupIdEnvelope === void 0) throw new Error("Request missing group parameter");
+	const requestGroupId = requestGroupIdEnvelope.extractSubject((cbor) => ARID.fromTaggedCbor(cbor));
+	if (requestGroupId.urString() !== groupId.urString()) throw new Error(`Request group ID ${requestGroupId.urString()} does not match expected ${groupId.urString()}`);
+	const responseAridEnvelope = sealedRequest.objectForParameter("responseArid");
+	if (responseAridEnvelope === void 0) throw new Error("Request missing responseArid parameter");
+	return responseAridEnvelope.extractSubject((cbor) => ARID.fromTaggedCbor(cbor));
+}
+/**
+* Extract round 1 packages from the request and convert to Map<Identifier, Package>.
+*
+* Port of `extract_round1_packages()` from cmd/dkg/participant/round2.rs lines 291-366.
+*/
+function extractRound1Packages(request, groupRecord, ownerXid) {
+	const sortedXids = groupRecord.participants().map((p) => p.xid());
+	const ownerUrString = ownerXid.urString();
+	if (!sortedXids.some((xid) => xid.urString() === ownerUrString)) sortedXids.push(ownerXid);
+	sortedXids.sort((a, b) => a.urString().localeCompare(b.urString()));
+	const deduped = [];
+	for (const xid of sortedXids) if (deduped.length === 0 || deduped[deduped.length - 1].urString() !== xid.urString()) deduped.push(xid);
+	const xidToIdentifier = /* @__PURE__ */ new Map();
+	for (let i = 0; i < deduped.length; i++) {
+		const identifier = identifierFromU16(i + 1);
+		xidToIdentifier.set(deduped[i].urString(), identifier);
+	}
+	const myXidStr = ownerXid.urString();
+	const packages = /* @__PURE__ */ new Map();
+	const packagesByXid = [];
+	const packageEnvelopes = request.objectsForParameter("round1Package");
+	for (const packageEnvelope of packageEnvelopes) {
+		const participantEnvelope = packageEnvelope.objectForPredicate("participant");
+		if (participantEnvelope === void 0) throw new Error("round1Package missing participant predicate");
+		const participantXid = participantEnvelope.extractSubject((cbor) => XID.fromTaggedCbor(cbor));
+		if (participantXid.urString() === myXidStr) continue;
+		const packageJson = packageEnvelope.extractSubject((cbor) => JSON$1.fromTaggedCbor(cbor));
+		const packageData = JSON.parse(new TextDecoder().decode(packageJson.toData()));
+		const pkg = serde.round1PackageFromJson(packageData);
+		const identifier = xidToIdentifier.get(participantXid.urString());
+		if (identifier === void 0) throw new Error(`Unknown participant XID in round1Package: ${participantXid.urString()}`);
+		packages.set(identifier, pkg);
+		packagesByXid.push([participantXid, pkg]);
+	}
+	const expectedPackages = xidToIdentifier.size - 1;
+	if (packages.size !== expectedPackages) throw new Error(`Expected ${expectedPackages} Round 1 packages, found ${packages.size}`);
+	return [packages, packagesByXid];
+}
+/**
+* Build the response body containing Round 2 packages.
+*
+* Port of `build_response_body()` from cmd/dkg/participant/round2.rs lines 373-425.
+*/
+function buildResponseBody$3(groupId, participantXid, responseArid, round2Packages, groupRecord) {
+	const sortedXids = groupRecord.participants().map((p) => p.xid());
+	const participantUrString = participantXid.urString();
+	if (!sortedXids.some((xid) => xid.urString() === participantUrString)) sortedXids.push(participantXid);
+	sortedXids.sort((a, b) => a.urString().localeCompare(b.urString()));
+	const deduped = [];
+	for (const xid of sortedXids) if (deduped.length === 0 || deduped[deduped.length - 1].urString() !== xid.urString()) deduped.push(xid);
+	const identifierToXid = /* @__PURE__ */ new Map();
+	for (let i = 0; i < deduped.length; i++) {
+		const identifier = identifierFromU16(i + 1);
+		identifierToXid.set(identifierToHex(identifier), deduped[i]);
+	}
+	let envelope = Envelope.unit().addType("dkgRound2Response").addAssertion("group", groupId).addAssertion("participant", participantXid).addAssertion("response_arid", responseArid);
+	for (const [identifier, pkg] of round2Packages) {
+		const idHex = identifierToHex(identifier);
+		const recipientXid = identifierToXid.get(idHex);
+		if (recipientXid === void 0) throw new Error("Unknown identifier in round2_packages");
+		const serialized = serializeDkgRound2Package(pkg);
+		const jsonStr = JSON.stringify(serialized);
+		const jsonBytes = new TextEncoder().encode(jsonStr);
+		const jsonWrapper = JSON$1.fromData(jsonBytes);
+		const packageEnvelope = Envelope.new(jsonWrapper).addAssertion("recipient", recipientXid);
+		envelope = envelope.addAssertion("round2Package", packageEnvelope);
+	}
+	return envelope;
+}
+/**
+* Serialize round 2 secret package to JSON format for persistence.
+*
+* The format matches what finalize.ts expects to deserialize.
+*/
+function serializeRound2SecretPackage(secret, participantIndex) {
+	const commitmentCoefficients = secret.commitment.serialize().map((c) => bytesToHex(c));
+	const secretShare = bytesToHex(Ed25519Sha512.serializeScalar(secret.secretShare()));
+	return {
+		identifier: participantIndex,
+		commitment: { coefficients: commitmentCoefficients },
+		secretShare,
+		minSigners: secret.minSigners,
+		maxSigners: secret.maxSigners
+	};
+}
+/**
+* Persist round 2 state to disk.
+*
+* Port of round 2 secret persistence from cmd/dkg/participant/round2.rs lines 229-251.
+*/
+function persistRound2State(registryPath, groupId, round2Secret, round1PackagesByXid, participantIndex) {
+	const packagesDir = groupStateDir(registryPath, groupId.hex());
+	fs.mkdirSync(packagesDir, { recursive: true });
+	const round2SecretPath = path.join(packagesDir, "round2_secret.json");
+	const round2SecretJson = serializeRound2SecretPackage(round2Secret, participantIndex);
+	fs.writeFileSync(round2SecretPath, JSON.stringify(round2SecretJson, null, 2));
+	const round1PackagesPath = path.join(packagesDir, "collected_round1.json");
+	const round1Json = {};
+	for (const [xid, pkg] of round1PackagesByXid) {
+		const packageJson = serde.round1PackageToJson(pkg);
+		round1Json[xid.urString()] = packageJson;
+	}
+	fs.writeFileSync(round1PackagesPath, JSON.stringify(round1Json, null, 2));
+	return round2SecretPath;
+}
+/**
+* Execute the DKG participant round 2 command.
+*
+* Responds to the Round 2 request from the coordinator, runs FROST DKG part2
+* to generate Round 2 packages, and posts the response back.
+*
+* Port of `CommandArgs::exec()` from cmd/dkg/participant/round2.rs lines 55-288.
+*/
+async function round2$3(_client, options, cwd) {
+	if (options.storageSelection === void 0) throw new Error("Hubert storage is required for round2");
+	const registryPath = resolveRegistryPath(options.registryPath, cwd);
+	const registry = Registry.load(registryPath);
+	const owner = registry.owner();
+	if (owner === void 0) throw new Error("Registry owner is required");
+	const groupId = parseAridUr(options.groupId);
+	const groupRecord = registry.group(groupId);
+	if (groupRecord === void 0) throw new Error("Group not found in registry");
+	const listeningAtArid = groupRecord.listeningAtArid();
+	if (listeningAtArid === void 0) throw new Error("No listening ARID for this group. Did you respond to the invite?");
+	const round1State = loadRound1State(registryPath, groupId);
+	if (isVerbose() || options.verbose === true) console.error("Fetching Round 2 request from Hubert...");
+	const client = await createStorageClient(options.storageSelection);
+	const requestEnvelope = await getWithIndicator(client, listeningAtArid, "Round 2 request", options.timeoutSeconds, options.verbose ?? false);
+	if (requestEnvelope === null || requestEnvelope === void 0) throw new Error("Round 2 request not found in Hubert storage");
+	const ownerPrivateKeys = owner.xidDocument().inceptionPrivateKeys();
+	if (ownerPrivateKeys === void 0) throw new Error("Owner XID document has no private keys");
+	const now = CborDate.now().datetime();
+	const sealedRequest = SealedRequest.tryFromEnvelope(requestEnvelope, void 0, now, ownerPrivateKeys);
+	const responseArid = validateRound2Request(sealedRequest, groupId, groupRecord.coordinator().xid());
+	const [round1Packages, round1PackagesByXid] = extractRound1Packages(sealedRequest, groupRecord, owner.xid());
+	if (isVerbose() || options.verbose === true) console.error(`Received ${round1Packages.size} Round 1 packages. Running DKG part2...`);
+	const nextResponseArid = ARID.new();
+	const round1PackagesHex = /* @__PURE__ */ new Map();
+	for (const [id, pkg] of round1Packages) round1PackagesHex.set(identifierToHex(id), pkg);
+	const [round2Secret, round2Packages] = dkgPart2(round1State.secretPackage, round1PackagesHex);
+	if (isVerbose() || options.verbose === true) console.error(`Generated ${round2Packages.size} Round 2 packages.`);
+	const round2PackagesById = /* @__PURE__ */ new Map();
+	for (const [idHex, pkg] of round2Packages) for (const [id] of round1Packages) if (identifierToHex(id) === idHex) {
+		round2PackagesById.set(id, pkg);
+		break;
+	}
+	const responseBody = buildResponseBody$3(groupId, owner.xid(), nextResponseArid, round2PackagesById, groupRecord);
+	const signerPrivateKeys = owner.xidDocument().inceptionPrivateKeys();
+	if (signerPrivateKeys === void 0) throw new Error("Owner XID document has no signing keys");
+	const coordinatorXid = groupRecord.coordinator().xid();
+	const coordinatorRecord = registry.participant(coordinatorXid);
+	let coordinatorDoc;
+	if (coordinatorRecord !== void 0) coordinatorDoc = coordinatorRecord.xidDocument();
+	else if (owner.xid().urString() === coordinatorXid.urString()) coordinatorDoc = owner.xidDocument();
+	else throw new Error(`Coordinator ${coordinatorXid.urString()} not found in registry`);
+	const peerContinuation = sealedRequest.peerContinuation();
+	let sealed = SealedResponse.newSuccess(sealedRequest.id(), owner.xidDocument()).withResult(responseBody);
+	if (peerContinuation !== void 0) sealed = sealed.withPeerContinuation(peerContinuation);
+	if (options.preview === true) {
+		const envelopeUr = sealed.toEnvelope(void 0, signerPrivateKeys, void 0).urString();
+		console.log(envelopeUr);
+		return {
+			listeningArid: nextResponseArid.urString(),
+			envelopeUr
+		};
+	}
+	const sortedXids = groupRecord.participants().map((p) => p.xid().urString());
+	const ownerXidStr = owner.xid().urString();
+	if (!sortedXids.includes(ownerXidStr)) sortedXids.push(ownerXidStr);
+	sortedXids.sort();
+	const round2SecretPath = persistRound2State(registryPath, groupId, round2Secret, round1PackagesByXid, sortedXids.indexOf(ownerXidStr) + 1);
+	await putWithIndicator(client, responseArid, sealed.toEnvelope(void 0, signerPrivateKeys, coordinatorDoc), "Round 2 Response", options.verbose ?? false);
+	const updatedGroupRecord = registry.group(groupId);
+	if (updatedGroupRecord !== void 0) {
+		const contributions = updatedGroupRecord.contributions();
+		contributions.round2Secret = round2SecretPath;
+		updatedGroupRecord.setContributions(contributions);
+		updatedGroupRecord.setListeningAtArid(nextResponseArid);
+		registry.save(registryPath);
+	}
+	if (isVerbose() || options.verbose === true) console.error(`Posted Round 2 response to ${responseArid.urString()}`);
+	return { listeningArid: nextResponseArid.urString() };
+}
+
+//#endregion
+//#region src/cmd/dkg/participant/finalize.ts
+/**
+* DKG participant finalize command.
+*
+* Port of cmd/dkg/participant/finalize.rs from frost-hubert-rust.
+*
+* @module
+*/
+/**
+* Load persisted round 2 state from disk.
+*
+* Port of round2_secret loading from cmd/dkg/participant/finalize.rs lines 82-106.
+*/
+function loadRound2State(registryPath, groupId) {
+	const stateDir = groupStateDir(registryPath, groupId.hex());
+	const round2SecretPath = path.join(stateDir, "round2_secret.json");
+	if (!fs.existsSync(round2SecretPath)) throw new Error(`Round 2 secret not found at ${round2SecretPath}. Did you run round2?`);
+	const secretJson = JSON.parse(fs.readFileSync(round2SecretPath, "utf-8"));
+	const identifier = identifierFromU16(secretJson.identifier);
+	const commitment = new VerifiableSecretSharingCommitment(Ed25519Sha512, secretJson.commitment.coefficients.map((hex) => CoefficientCommitment.deserialize(Ed25519Sha512, hexToBytes$1(hex))));
+	const secretShareScalar = Ed25519Sha512.deserializeScalar(hexToBytes$1(secretJson.secretShare));
+	const secretPackage = new round2.SecretPackage(Ed25519Sha512, identifier, commitment, secretShareScalar, secretJson.minSigners, secretJson.maxSigners);
+	const round1Path = path.join(stateDir, "collected_round1.json");
+	if (!fs.existsSync(round1Path)) throw new Error(`Round 1 packages not found at ${round1Path}. Did you receive earlier phases?`);
+	const round1Json = JSON.parse(fs.readFileSync(round1Path, "utf-8"));
+	const round1Packages = /* @__PURE__ */ new Map();
+	for (const [xidStr, value] of Object.entries(round1Json)) {
+		const packageJson = value;
+		const pkg = serde.round1PackageFromJson(packageJson);
+		round1Packages.set(xidStr, pkg);
+	}
+	return {
+		secretPackage,
+		round1Packages
+	};
+}
+/**
+* Validate the finalize request from the coordinator.
+*
+* Port of request validation from cmd/dkg/participant/finalize.rs lines 139-161.
+*/
+function validateFinalizeRequest(sealedRequest, groupId, expectedCoordinator) {
+	if (!sealedRequest.function().equals(Function.fromString("dkgFinalize"))) throw new Error(`Unexpected request function: ${sealedRequest.function().toString()}`);
+	if (sealedRequest.sender().xid().urString() !== expectedCoordinator.urString()) throw new Error(`Unexpected request sender: ${sealedRequest.sender().xid().urString()} (expected coordinator ${expectedCoordinator.urString()})`);
+	const requestGroupIdEnvelope = sealedRequest.objectForParameter("group");
+	if (requestGroupIdEnvelope === void 0) throw new Error("Request missing group parameter");
+	const requestGroupId = requestGroupIdEnvelope.extractSubject((cbor) => ARID.fromTaggedCbor(cbor));
+	if (requestGroupId.urString() !== groupId.urString()) throw new Error(`Request group ID ${requestGroupId.urString()} does not match expected ${groupId.urString()}`);
+	const responseAridEnvelope = sealedRequest.objectForParameter("responseArid");
+	if (responseAridEnvelope === void 0) throw new Error("Request missing responseArid parameter");
+	return responseAridEnvelope.extractSubject((cbor) => ARID.fromTaggedCbor(cbor));
+}
+/**
+* Extract round 2 packages from the finalize request.
+*
+* Port of round2 package extraction from cmd/dkg/participant/finalize.rs lines 209-229.
+*/
+function extractFinalizePackages(request, groupRecord, ownerXid) {
+	const sortedXids = groupRecord.participants().map((p) => p.xid());
+	const ownerUrString = ownerXid.urString();
+	if (!sortedXids.some((xid) => xid.urString() === ownerUrString)) sortedXids.push(ownerXid);
+	sortedXids.sort((a, b) => a.urString().localeCompare(b.urString()));
+	const deduped = [];
+	for (const xid of sortedXids) if (deduped.length === 0 || deduped[deduped.length - 1].urString() !== xid.urString()) deduped.push(xid);
+	const xidToIdentifier = /* @__PURE__ */ new Map();
+	for (let i = 0; i < deduped.length; i++) {
+		const identifier = identifierFromU16(i + 1);
+		xidToIdentifier.set(deduped[i].urString(), identifier);
+	}
+	const myXidStr = ownerXid.urString();
+	const packages = /* @__PURE__ */ new Map();
+	const packageEnvelopes = request.objectsForParameter("round2Package");
+	for (const packageEnvelope of packageEnvelopes) {
+		const senderEnvelope = packageEnvelope.objectForPredicate("sender");
+		if (senderEnvelope === void 0) throw new Error("round2Package missing sender predicate");
+		const senderXid = senderEnvelope.extractSubject((cbor) => XID.fromTaggedCbor(cbor));
+		if (senderXid.urString() === myXidStr) continue;
+		const identifier = xidToIdentifier.get(senderXid.urString());
+		if (identifier === void 0) throw new Error(`Unknown sender XID in round2Package: ${senderXid.urString()}`);
+		const packageJson = packageEnvelope.extractSubject((cbor) => JSON$1.fromTaggedCbor(cbor));
+		const packageData = JSON.parse(new TextDecoder().decode(packageJson.toData()));
+		const pkg = serde.round2PackageFromJson(packageData);
+		packages.set(identifierToHex(identifier), pkg);
+	}
+	return packages;
+}
+/**
+* Build the response body for the finalize response.
+*
+* Port of `build_response_body()` from cmd/dkg/participant/finalize.rs lines 344-359.
+*/
+function buildResponseBody$2(groupId, participantXid, keyPackage, publicKeyPackage) {
+	const keyPackageJson = serializeKeyPackage(keyPackage);
+	const publicKeyPackageJson = serializePublicKeyPackage(publicKeyPackage);
+	const keyJsonBytes = new TextEncoder().encode(JSON.stringify(keyPackageJson));
+	const keyJsonWrapper = JSON$1.fromData(keyJsonBytes);
+	const pubJsonBytes = new TextEncoder().encode(JSON.stringify(publicKeyPackageJson));
+	const pubJsonWrapper = JSON$1.fromData(pubJsonBytes);
+	return Envelope.unit().addType("dkgFinalizeResponse").addAssertion("group", groupId).addAssertion("participant", participantXid).addAssertion("key_package", keyJsonWrapper).addAssertion("public_key_package", pubJsonWrapper);
+}
+/**
+* Persist finalize state (key packages) to disk.
+*
+* Port of key package persistence from cmd/dkg/participant/finalize.rs lines 251-257.
+*/
+function persistFinalizeState(registryPath, groupId, keyPackage, publicKeyPackage) {
+	const stateDir = groupStateDir(registryPath, groupId.hex());
+	fs.mkdirSync(stateDir, { recursive: true });
+	const serializedKeyPackage = serializeKeyPackage(keyPackage);
+	const keyPackagePath = path.join(stateDir, "key_package.json");
+	fs.writeFileSync(keyPackagePath, JSON.stringify(serializedKeyPackage, null, 2));
+	const serializedPublicKeyPackage = serializePublicKeyPackage(publicKeyPackage);
+	const publicKeyPackagePath = path.join(stateDir, "public_key_package.json");
+	fs.writeFileSync(publicKeyPackagePath, JSON.stringify(serializedPublicKeyPackage, null, 2));
+	return {
+		keyPackagePath,
+		publicKeyPackagePath
+	};
+}
+/**
+* Execute the DKG participant finalize command.
+*
+* Responds to the finalize request from the coordinator, runs FROST DKG part3
+* to generate the final key package, and posts the response back.
+*
+* Port of `CommandArgs::exec()` from cmd/dkg/participant/finalize.rs lines 52-341.
+*/
+async function finalize$1(_client, options, cwd) {
+	if (options.storageSelection === void 0) throw new Error("Hubert storage is required for finalize respond");
+	const registryPath = resolveRegistryPath(options.registryPath, cwd);
+	const registry = Registry.load(registryPath);
+	const owner = registry.owner();
+	if (owner === void 0) throw new Error("Registry owner is required");
+	const groupId = parseAridUr(options.groupId);
+	const groupRecord = registry.group(groupId);
+	if (groupRecord === void 0) throw new Error("Group not found in registry");
+	const listeningAtArid = groupRecord.listeningAtArid();
+	if (listeningAtArid === void 0) throw new Error("No listening ARID for this group. Did you receive finalize send?");
+	const round2State = loadRound2State(registryPath, groupId);
+	if (isVerbose() || options.verbose === true) console.error("Fetching finalize request from Hubert...");
+	const client = await createStorageClient(options.storageSelection);
+	const requestEnvelope = await getWithIndicator(client, listeningAtArid, "Finalize request", options.timeoutSeconds, options.verbose ?? false);
+	if (requestEnvelope === null || requestEnvelope === void 0) throw new Error("Finalize request not found in Hubert storage");
+	const ownerPrivateKeys = owner.xidDocument().inceptionPrivateKeys();
+	if (ownerPrivateKeys === void 0) throw new Error("Owner XID document has no private keys");
+	const now = CborDate.now().datetime();
+	const sealedRequest = SealedRequest.tryFromEnvelope(requestEnvelope, void 0, now, ownerPrivateKeys);
+	const responseArid = validateFinalizeRequest(sealedRequest, groupId, groupRecord.coordinator().xid());
+	const sortedXids = groupRecord.participants().map((p) => p.xid());
+	const ownerUrString = owner.xid().urString();
+	if (!sortedXids.some((xid) => xid.urString() === ownerUrString)) sortedXids.push(owner.xid());
+	sortedXids.sort((a, b) => a.urString().localeCompare(b.urString()));
+	const deduped = [];
+	for (const xid of sortedXids) if (deduped.length === 0 || deduped[deduped.length - 1].urString() !== xid.urString()) deduped.push(xid);
+	const xidToIdentifier = /* @__PURE__ */ new Map();
+	for (let i = 0; i < deduped.length; i++) {
+		const identifier = identifierFromU16(i + 1);
+		xidToIdentifier.set(deduped[i].urString(), identifier);
+	}
+	const round1PackagesById = /* @__PURE__ */ new Map();
+	for (const [xidStr, pkg] of round2State.round1Packages) {
+		if (xidStr === ownerUrString) continue;
+		const identifier = xidToIdentifier.get(xidStr);
+		if (identifier === void 0) throw new Error(`Unknown participant XID ${xidStr}`);
+		round1PackagesById.set(identifierToHex(identifier), pkg);
+	}
+	const round2PackagesById = extractFinalizePackages(sealedRequest, groupRecord, owner.xid());
+	if (isVerbose() || options.verbose === true) console.error(`Received ${round2PackagesById.size} Round 2 packages. Running DKG part3...`);
+	const [keyPackage, publicKeyPackage] = await dkgPart3(round2State.secretPackage, round1PackagesById, round2PackagesById);
+	const verifyingKeyBytes = publicKeyPackage.verifyingKey;
+	const groupVerifyingKey = signingKeyFromVerifying(verifyingKeyBytes);
+	if (isVerbose() || options.verbose === true) console.error("Generated key package and public key package.");
+	const { keyPackagePath, publicKeyPackagePath } = persistFinalizeState(registryPath, groupId, keyPackage, publicKeyPackage);
+	const responseBody = buildResponseBody$2(groupId, owner.xid(), keyPackage, publicKeyPackage);
+	const signerPrivateKeys = owner.xidDocument().inceptionPrivateKeys();
+	if (signerPrivateKeys === void 0) throw new Error("Owner XID document has no signing keys");
+	const coordinatorXid = groupRecord.coordinator().xid();
+	const coordinatorRecord = registry.participant(coordinatorXid);
+	let coordinatorDoc;
+	if (coordinatorRecord !== void 0) coordinatorDoc = coordinatorRecord.xidDocument();
+	else if (owner.xid().urString() === coordinatorXid.urString()) coordinatorDoc = owner.xidDocument();
+	else throw new Error(`Coordinator ${coordinatorXid.urString()} not found in registry`);
+	const peerContinuation = sealedRequest.peerContinuation();
+	let sealed = SealedResponse.newSuccess(sealedRequest.id(), owner.xidDocument()).withResult(responseBody);
+	if (peerContinuation !== void 0) sealed = sealed.withPeerContinuation(peerContinuation);
+	if (options.preview === true) {
+		if (isVerbose() || options.verbose === true) {
+			const verifyingKeyWithUrString = groupVerifyingKey;
+			if (typeof verifyingKeyWithUrString.urString === "function") console.error(verifyingKeyWithUrString.urString());
+		}
+		const unsealedEnvelope = sealed.toEnvelope(void 0, signerPrivateKeys, void 0);
+		console.log(unsealedEnvelope.urString());
+		return {
+			verifyingKey: bytesToHex(verifyingKeyBytes),
+			keyPackagePath,
+			publicKeyPackagePath
+		};
+	}
+	await putWithIndicator(client, responseArid, sealed.toEnvelope(void 0, signerPrivateKeys, coordinatorDoc), "Finalize Response", options.verbose ?? false);
+	const updatedGroupRecord = registry.group(groupId);
+	if (updatedGroupRecord !== void 0) {
+		const contributions = updatedGroupRecord.contributions();
+		contributions.keyPackage = keyPackagePath;
+		updatedGroupRecord.setContributions(contributions);
+		updatedGroupRecord.clearListeningAtArid();
+		const recordWithVerifyingKey = updatedGroupRecord;
+		if (typeof recordWithVerifyingKey.setVerifyingKey === "function") recordWithVerifyingKey.setVerifyingKey(groupVerifyingKey);
+		registry.save(registryPath);
+	}
+	const verifyingKeyHex = bytesToHex(verifyingKeyBytes);
+	if (isVerbose() || options.verbose === true) {
+		console.error(`Posted finalize response to ${responseArid.urString()}`);
+		const verifyingKeyWithUrString = groupVerifyingKey;
+		if (typeof verifyingKeyWithUrString.urString === "function") console.error(verifyingKeyWithUrString.urString());
+	} else {
+		const verifyingKeyWithUrString = groupVerifyingKey;
+		if (typeof verifyingKeyWithUrString.urString === "function") console.log(verifyingKeyWithUrString.urString());
+	}
+	return {
+		verifyingKey: verifyingKeyHex,
+		keyPackagePath,
+		publicKeyPackagePath
+	};
+}
+
+//#endregion
+//#region src/cmd/dkg/participant/index.ts
+var participant_exports$1 = /* @__PURE__ */ __exportAll({
+	decodeInviteDetails: () => decodeInviteDetails,
+	finalize: () => finalize$1,
+	receive: () => receive$1,
+	resolveInviteEnvelope: () => resolveInviteEnvelope$1,
+	round1: () => round1$3,
+	round2: () => round2$3
+});
+
+//#endregion
+//#region src/cmd/dkg/index.ts
+var dkg_exports = /* @__PURE__ */ __exportAll({
+	buildGroupParticipants: () => buildGroupParticipants,
+	coordinator: () => coordinator_exports$1,
+	dkgStateDir: () => dkgStateDir,
+	formatNameWithOwnerMarker: () => formatNameWithOwnerMarker,
+	groupParticipantFromRegistry: () => groupParticipantFromRegistry,
+	groupStateDir: () => groupStateDir,
+	parseAridUr: () => parseAridUr,
+	parseEnvelopeUr: () => parseEnvelopeUr,
+	participant: () => participant_exports$1,
+	participantNamesFromRegistry: () => participantNamesFromRegistry,
+	resolveParticipants: () => resolveParticipants,
+	resolveSender: () => resolveSender,
+	resolveSenderName: () => resolveSenderName$1,
+	signingKeyFromVerifying: () => signingKeyFromVerifying
+});
+
+//#endregion
+//#region src/cmd/sign/common.ts
+/**
+* Common utilities for sign commands.
+*
+* Port of cmd/sign/common.rs from frost-hubert-rust.
+*
+* @module
+*/
+/**
+* Get the signing state directory for a group (without session).
+*
+* Path: `{registry_dir}/group-state/{group_id.hex()}/signing`
+*
+* Port of `signing_state_dir_for_group()` from cmd/sign/common.rs.
+*/
+function signingStateDirForGroup(registryPath, groupIdHex) {
+	return `${groupStateDir(registryPath, groupIdHex)}/signing`;
+}
+/**
+* Get the signing state directory for a given registry path, group ID, and session ID.
+*
+* Path: `{registry_dir}/group-state/{group_id.hex()}/signing/{session_id.hex()}`
+*
+* Port of `signing_state_dir()` from cmd/sign/common.rs.
+*/
+function signingStateDir(registryPath, groupIdHex, sessionIdHex) {
+	return `${signingStateDirForGroup(registryPath, groupIdHex)}/${sessionIdHex}`;
+}
+/**
+* Content wrapper for signFinalize events.
+*
+* This wraps an envelope with a unit subject and type assertion
+* "signFinalize", implementing the traits required by SealedEvent<T>.
+*
+* Port of `struct SignFinalizeContent` from cmd/sign/common.rs.
+*/
+var SignFinalizeContent = class SignFinalizeContent {
+	_envelope;
+	constructor(envelope) {
+		this._envelope = envelope;
+	}
+	/**
+	* Creates a new SignFinalizeContent with a unit subject and type assertion.
+	*
+	* Port of `SignFinalizeContent::new()` from cmd/sign/common.rs.
+	*/
+	static new() {
+		return new SignFinalizeContent(Envelope.unit().addType("signFinalize"));
+	}
+	/**
+	* Adds an assertion to the content envelope.
+	*
+	* Port of `SignFinalizeContent::add_assertion()` from cmd/sign/common.rs.
+	*/
+	addAssertion(predicate, object) {
+		return new SignFinalizeContent(this._envelope.addAssertion(predicate, object));
+	}
+	/**
+	* Returns the inner envelope.
+	*
+	* Port of `SignFinalizeContent::envelope()` from cmd/sign/common.rs.
+	*/
+	envelope() {
+		return this._envelope;
+	}
+	/**
+	* Creates a SignFinalizeContent from an envelope with validation.
+	*
+	* Validates that the envelope has a unit subject and type "signFinalize".
+	*
+	* Port of `TryFrom<Envelope> for SignFinalizeContent` from cmd/sign/common.rs.
+	*/
+	static fromEnvelope(envelope) {
+		envelope.checkSubjectUnit();
+		envelope.checkType("signFinalize");
+		return new SignFinalizeContent(envelope);
+	}
+	/**
+	* Converts this SignFinalizeContent to an Envelope.
+	*
+	* Port of `From<SignFinalizeContent> for Envelope` from cmd/sign/common.rs.
+	*/
+	toEnvelope() {
+		return this._envelope;
+	}
+};
+
+//#endregion
+//#region src/cmd/sign/coordinator/invite.ts
+/**
+* Sign coordinator invite command.
+*
+* Port of cmd/sign/coordinator/invite.rs from frost-hubert-rust.
+*
+* @module
+*/
+/**
+* Create new session ARIDs for all participants.
+*
+* Port of `SessionArids::new()` from cmd/sign/coordinator/invite.rs lines 158-173.
+*/
+function createSessionArids(participants) {
+	const commitArids = /* @__PURE__ */ new Map();
+	const shareArids = /* @__PURE__ */ new Map();
+	for (const participant of participants) {
+		const xidKey = participant.xid().urString();
+		commitArids.set(xidKey, ARID.new());
+		shareArids.set(xidKey, ARID.new());
+	}
+	return {
+		sessionId: ARID.new(),
+		startArid: ARID.new(),
+		commitArids,
+		shareArids
+	};
+}
+/**
+* Validate that the owner is the coordinator of the group.
+*
+* Port of `validate_coordinator()` from cmd/sign/coordinator/invite.rs lines 179-192.
+*/
+function validateCoordinator(groupRecord, owner) {
+	if (groupRecord.coordinator().xid().urString() !== owner.xid().urString()) throw new Error(`Only the coordinator can start signing. Coordinator: ${groupRecord.coordinator().xid().urString()}, Owner: ${owner.xid().urString()}`);
+}
+/**
+* Gather XIDDocuments for all participants from the registry.
+*
+* Port of `gather_recipient_documents()` from cmd/sign/coordinator/invite.rs lines 198-222.
+*/
+function gatherRecipientDocuments(participants, owner, registry) {
+	const recipientDocs = [];
+	for (const participant of participants) {
+		const xid = participant.xid();
+		if (xid.urString() === owner.xid().urString()) recipientDocs.push(owner.xidDocument());
+		else {
+			const record = registry.participant(xid);
+			if (record === void 0) throw new Error(`Participant ${xid.urString()} not found in registry`);
+			recipientDocs.push(record.xidDocument());
+		}
+	}
+	return recipientDocs;
+}
+/**
+* Build the sign invite request.
+*
+* Port of `build_sign_invite_request()` from cmd/sign/coordinator/invite.rs lines 239-284.
+*/
+function buildSignInviteRequest(ctx) {
+	let request = SealedRequest.new("signInvite", ctx.arids.sessionId, ctx.owner.xidDocument()).withParameter("group", ctx.groupId).withParameter("session", ctx.arids.sessionId).withParameter("target", ctx.targetEnvelope).withParameter("minSigners", ctx.groupRecord.minSigners()).withDate(/* @__PURE__ */ new Date()).withParameter("validUntil", CborDate.fromDatetime(ctx.validUntil));
+	for (const participant of ctx.participants) {
+		const xid = participant.xid();
+		const xidKey = xid.urString();
+		let participantDoc;
+		if (xidKey === ctx.owner.xid().urString()) participantDoc = ctx.owner.xidDocument();
+		else {
+			const record = ctx.registry.participant(xid);
+			if (record === void 0) throw new Error("Participant not found in registry");
+			participantDoc = record.xidDocument();
+		}
+		const encryptionKey = participantDoc.encryptionKey();
+		if (encryptionKey === void 0) throw new Error("Participant XID document has no encryption key");
+		const responseArid = ctx.arids.commitArids.get(xidKey);
+		if (responseArid === void 0) throw new Error("commit ARID not found for participant");
+		const encryptedResponseArid = responseArid.toEnvelope().encryptToRecipient(encryptionKey);
+		const participantEntry = Envelope.new(xid).addAssertion("response_arid", encryptedResponseArid);
+		request = request.withParameter("participant", participantEntry);
+	}
+	return request;
+}
+/**
+* Build the session state JSON for persistence.
+*
+* Port of `build_session_state_json()` from cmd/sign/coordinator/invite.rs lines 290-346.
+*/
+function buildSessionStateJson(arids, groupId, groupRecord, participants, targetEnvelope) {
+	const participantsMap = {};
+	for (const participant of participants) {
+		const xidKey = participant.xid().urString();
+		const commitArid = arids.commitArids.get(xidKey);
+		const shareArid = arids.shareArids.get(xidKey);
+		if (commitArid === void 0 || shareArid === void 0) throw new Error("ARID not found for participant");
+		participantsMap[xidKey] = {
+			commit_arid: commitArid.urString(),
+			share_arid: shareArid.urString()
+		};
+	}
+	return {
+		session_id: arids.sessionId.urString(),
+		start_arid: arids.startArid.urString(),
+		group: groupId.urString(),
+		min_signers: groupRecord.minSigners(),
+		participants: participantsMap,
+		target: targetEnvelope.urString()
+	};
+}
+/**
+* Persist the session state to disk.
+*
+* Port of `persist_session_state()` from cmd/sign/coordinator/invite.rs lines 348-356.
+*/
+function persistSessionState(signingDir, stateJson) {
+	fs.mkdirSync(signingDir, { recursive: true });
+	const startStatePath = path.join(signingDir, "start.json");
+	fs.writeFileSync(startStatePath, JSON.stringify(stateJson, null, 2));
+}
+/**
+* Load an envelope from a file path.
+*
+* Port of `load_envelope_from_path()` from cmd/sign/coordinator/invite.rs lines 385-392.
+*/
+function loadEnvelopeFromPath(filePath) {
+	if (!fs.existsSync(filePath)) throw new Error(`Failed to read target envelope from ${filePath}`);
+	const trimmed = fs.readFileSync(filePath, "utf-8").trim();
+	try {
+		return Envelope.fromURString(trimmed);
+	} catch (e) {
+		throw new Error(`Failed to load target envelope from ${filePath}: ${String(e)}`);
+	}
+}
+/**
+* Execute the sign coordinator invite command.
+*
+* Invites participants to sign a target envelope.
+*
+* Port of `CommandArgs::exec()` from cmd/sign/coordinator/invite.rs lines 44-144.
+*/
+async function invite(client, options, cwd) {
+	if (client !== void 0 && options.preview === true) throw new Error("--preview cannot be used with Hubert storage options");
+	const registryPath = resolveRegistryPath(options.registryPath, cwd);
+	const registry = Registry.load(registryPath);
+	const owner = registry.owner();
+	if (owner === void 0) throw new Error("Registry owner is required");
+	const groupId = parseAridUr(options.groupId);
+	const groupRecord = registry.group(groupId);
+	if (groupRecord === void 0) throw new Error(`Group ${options.groupId} not found in registry`);
+	validateCoordinator(groupRecord, owner);
+	const targetEnvelope = loadEnvelopeFromPath(path.resolve(cwd, options.targetFile));
+	const participants = groupRecord.participants();
+	const recipientDocs = gatherRecipientDocuments(participants, owner, registry);
+	const signerKeys = owner.xidDocument().inceptionPrivateKeys();
+	if (signerKeys === void 0) throw new Error("Coordinator XID document has no signing keys");
+	const sessionArids = createSessionArids(participants);
+	const validDays = options.validDays ?? 1 / 24;
+	const validUntil = new Date(Date.now() + validDays * 24 * 60 * 60 * 1e3);
+	const request = buildSignInviteRequest({
+		arids: sessionArids,
+		groupId,
+		targetEnvelope,
+		groupRecord,
+		owner,
+		registry,
+		participants,
+		validUntil
+	});
+	const stateJson = buildSessionStateJson(sessionArids, groupId, groupRecord, participants, targetEnvelope);
+	const recipientRefs = recipientDocs;
+	const sealedEnvelope = request.toEnvelopeForRecipients(validUntil, signerKeys, recipientRefs);
+	if (options.preview === true) {
+		const unsealed = request.toEnvelope(void 0, signerKeys, void 0);
+		console.log(unsealed.urString());
+		return {
+			sessionId: sessionArids.sessionId.urString(),
+			startArid: sessionArids.startArid.urString()
+		};
+	}
+	persistSessionState(signingStateDir(registryPath, groupId.hex(), sessionArids.sessionId.hex()), stateJson);
+	if (client === void 0) throw new Error("Hubert storage is required for sign start");
+	await putWithIndicator(client, sessionArids.startArid, sealedEnvelope, "Signing invite", options.verbose ?? false);
+	if (options.verbose === true) {
+		console.log(`Session ID: ${sessionArids.sessionId.urString()}`);
+		console.log(`Start ARID: ${sessionArids.startArid.urString()}`);
+	}
+	console.log(sessionArids.startArid.urString());
+	return {
+		sessionId: sessionArids.sessionId.urString(),
+		startArid: sessionArids.startArid.urString()
+	};
+}
+
+//#endregion
+//#region src/cmd/sign/coordinator/round1.ts
+/**
+* Sign coordinator round 1 command.
+*
+* Port of cmd/sign/coordinator/round1.rs from frost-hubert-rust.
+*
+* @module
+*/
+/**
+* Load the start state for a signing session.
+*
+* Port of `load_start_state()` from cmd/sign/coordinator/round1.rs.
+*/
+function loadStartState$1(registryPath, sessionId, groupHint) {
+	const base = path.dirname(registryPath);
+	const groupStateDir = path.join(base, "group-state");
+	const candidatePaths = [];
+	let groupDirs;
+	if (groupHint !== void 0) groupDirs = [[groupHint, path.join(groupStateDir, groupHint.hex())]];
+	else {
+		groupDirs = [];
+		if (fs.existsSync(groupStateDir)) {
+			for (const entry of fs.readdirSync(groupStateDir, { withFileTypes: true })) if (entry.isDirectory()) {
+				const dirName = entry.name;
+				if (dirName.length === 64 && /^[0-9a-fA-F]+$/.test(dirName)) {
+					const groupId = ARID.fromHex(dirName);
+					groupDirs.push([groupId, path.join(groupStateDir, dirName)]);
+				}
+			}
+		}
+	}
+	for (const [groupId, groupDir] of groupDirs) {
+		const candidate = path.join(groupDir, "signing", sessionId.hex(), "start.json");
+		if (fs.existsSync(candidate)) candidatePaths.push([groupId, candidate]);
+	}
+	if (candidatePaths.length === 0) throw new Error("No sign start state found; run `frost sign coordinator start` first");
+	if (candidatePaths.length > 1) throw new Error("Multiple signing sessions found; specify --group to disambiguate");
+	const [groupId, statePath] = candidatePaths[0];
+	const raw = JSON.parse(fs.readFileSync(statePath, "utf-8"));
+	const getStr = (key) => {
+		const value = raw[key];
+		if (typeof value !== "string") throw new Error(`Missing or invalid ${key} in start.json`);
+		return value;
+	};
+	const sessionInState = parseAridUr(getStr("session_id"));
+	const groupInState = parseAridUr(getStr("group"));
+	if (sessionInState.hex() !== sessionId.hex()) throw new Error(`start.json session ${sessionInState.urString()} does not match requested session ${sessionId.urString()}`);
+	if (groupInState.hex() !== groupId.hex()) throw new Error(`start.json group ${groupInState.urString()} does not match directory group ${groupId.urString()}`);
+	const targetUr = getStr("target");
+	const participantsVal = raw["participants"];
+	if (participantsVal === void 0 || typeof participantsVal !== "object") throw new Error("Missing participants in start.json");
+	const participants = /* @__PURE__ */ new Map();
+	for (const [xidStr, value] of Object.entries(participantsVal)) {
+		const xid = XID.fromURString(xidStr);
+		if (typeof value !== "object" || value === null) throw new Error("Participant entry is not an object in start.json");
+		const commitAridStr = value["commit_arid"];
+		const shareAridStr = value["share_arid"];
+		if (typeof commitAridStr !== "string") throw new Error("Missing commit_arid in start.json");
+		if (typeof shareAridStr !== "string") throw new Error("Missing share_arid in start.json");
+		participants.set(xid.urString(), {
+			commitArid: parseAridUr(commitAridStr),
+			shareArid: parseAridUr(shareAridStr)
+		});
+	}
+	return {
+		groupId,
+		targetUr,
+		participants
+	};
+}
+/**
+* Validate and extract data from a sign commit response.
+*
+* Port of `validate_and_extract_sign_round1_response()` from cmd/sign/coordinator/round1.rs.
+*/
+function validateAndExtractCommitResponse(envelope, coordinatorKeys, expectedSender, expectedSessionId) {
+	const now = /* @__PURE__ */ new Date();
+	const sealedResponse = SealedResponse.tryFromEncryptedEnvelope(envelope, void 0, now, coordinatorKeys);
+	if (!sealedResponse.sender().xid().equals(expectedSender)) throw new Error(`Unexpected response sender: ${sealedResponse.sender().xid().urString()} (expected ${expectedSender.urString()})`);
+	if (sealedResponse.isErr()) {
+		const errorEnvelope = sealedResponse.error();
+		let reason = "unknown reason";
+		try {
+			const reasonEnv = errorEnvelope.objectForPredicate("reason");
+			if (reasonEnv !== void 0) reason = reasonEnv.extractString();
+		} catch {}
+		throw new Error(`Participant rejected signInvite: ${reason}`);
+	}
+	const result = sealedResponse.result();
+	result.checkSubjectUnit();
+	result.checkType("signRound1Response");
+	const responseSession = result.tryObjectForPredicate("session", (cbor) => ARID.fromTaggedCbor(cbor));
+	if (responseSession.hex() !== expectedSessionId.hex()) throw new Error(`Response session ${responseSession.urString()} does not match expected ${expectedSessionId.urString()}`);
+	const commitmentsJson = result.tryObjectForPredicate("commitments", (cbor) => JSON$1.fromTaggedCbor(cbor));
+	return {
+		commitments: JSON.parse(new TextDecoder().decode(commitmentsJson.toData())),
+		nextRequestArid: result.tryObjectForPredicate("response_arid", (cbor) => ARID.fromTaggedCbor(cbor))
+	};
+}
+/**
+* Collect signing commitments in parallel.
+*
+* Port of `collect_sign_round1_parallel()` from cmd/sign/coordinator/round1.rs.
+*/
+async function collectCommitmentsParallel(client, registry, startState, coordinator, sessionId, timeout) {
+	const requests = [];
+	for (const [xidStr, state] of startState.participants) {
+		const xid = XID.fromURString(xidStr);
+		const name = registry.participant(xid)?.petName() ?? xid.urString();
+		requests.push([
+			xid,
+			state.commitArid,
+			name
+		]);
+	}
+	const coordinatorKeys = coordinator.inceptionPrivateKeys();
+	if (coordinatorKeys === void 0) throw new Error("Missing coordinator private keys");
+	return parallelFetch(client, requests, (envelope, xid) => {
+		try {
+			return validateAndExtractCommitResponse(envelope, coordinatorKeys, xid, sessionId);
+		} catch (e) {
+			return { rejected: e instanceof Error ? e.message : String(e) };
+		}
+	}, { timeoutSeconds: timeout });
+}
+/**
+* Build a sign share request for a participant.
+*
+* Port of `build_sign_share_request()` from cmd/sign/coordinator/round1.rs.
+*/
+function buildShareRequestForParticipant(sender, _groupId, sessionId, responseArid, commitments) {
+	let request = SealedRequest.new("signRound2", sessionId, sender).withParameter("session", sessionId).withParameter("response_arid", responseArid);
+	for (const [xidStr, commits] of commitments) {
+		const xid = XID.fromURString(xidStr);
+		const commitsJson = JSON$1.fromData(new TextEncoder().encode(JSON.stringify(commits)));
+		const entry = Envelope.new(xid).addAssertion("commitments", commitsJson.taggedCborData());
+		request = request.withParameter("commitment", entry);
+	}
+	return request;
+}
+/**
+* Dispatch share requests to participants in parallel.
+*
+* Port of parallel dispatch logic from cmd/sign/coordinator/round1.rs.
+*/
+async function dispatchShareRequestsParallel(client, registry, owner, startState, sessionId, collection, commitments, previewShare, verbose) {
+	const signerKeys = owner.xidDocument().inceptionPrivateKeys();
+	if (signerKeys === void 0) throw new Error("Coordinator XID document has no signing keys");
+	const validUntil = new Date(Date.now() + 3600 * 1e3);
+	const messages = [];
+	let previewPrinted = false;
+	for (const [xid, data] of collection.successes) {
+		const xidStr = xid.urString();
+		const participantState = startState.participants.get(xidStr);
+		if (participantState === void 0) throw new Error(`Participant ${xidStr} not found in start state`);
+		const participantName = registry.participant(xid)?.petName() ?? xidStr;
+		let recipientDoc;
+		if (xid.urString() === owner.xid().urString()) recipientDoc = owner.xidDocument();
+		else {
+			const record = registry.participant(xid);
+			if (record === void 0) throw new Error(`Participant ${xidStr} not found in registry`);
+			recipientDoc = record.xidDocument();
+		}
+		const request = buildShareRequestForParticipant(owner.xidDocument(), startState.groupId, sessionId, participantState.shareArid, commitments);
+		if (previewShare === true && !previewPrinted) {
+			const preview = request.toEnvelope(validUntil, signerKeys, void 0);
+			console.log(`# signRound2 preview for ${xidStr}`);
+			console.log(preview.format());
+			previewPrinted = true;
+		}
+		const sealedEnvelope = request.toEnvelopeForRecipients(validUntil, signerKeys, [recipientDoc]);
+		messages.push([
+			xid,
+			data.nextRequestArid,
+			sealedEnvelope,
+			participantName
+		]);
+	}
+	console.error();
+	return parallelSend(client, messages, verbose);
+}
+/**
+* Persist collected commitments to disk.
+*
+* Port of commitments persistence logic from cmd/sign/coordinator/round1.rs.
+*/
+function persistCommitments(registryPath, groupId, sessionId, startState, commitments) {
+	const signingDir = signingStateDir(registryPath, groupId.hex(), sessionId.hex());
+	fs.mkdirSync(signingDir, { recursive: true });
+	const commitmentsPath = path.join(signingDir, "commitments.json");
+	const commitmentsJson = {};
+	for (const [xidStr, commits] of commitments) {
+		const participantState = startState.participants.get(xidStr);
+		if (participantState === void 0) throw new Error(`Participant ${xidStr} not found in start state`);
+		commitmentsJson[xidStr] = {
+			commitments: commits,
+			share_arid: participantState.shareArid.urString()
+		};
+	}
+	const root = {
+		group: groupId.urString(),
+		session: sessionId.urString(),
+		target: startState.targetUr,
+		commitments: commitmentsJson
+	};
+	fs.writeFileSync(commitmentsPath, JSON.stringify(root, null, 2));
+	return commitmentsPath;
+}
+/**
+* Update pending requests in the registry for share phase.
+*
+* Note: In the Rust implementation, the registry doesn't track pending ARIDs
+* directly on participant records. The pending state is managed through the
+* start.json and commitments.json files in the signing state directory.
+*
+* This function is provided for API compatibility but currently does nothing.
+*/
+function updatePendingForShare(_registry, _collection, _startState) {}
+/**
+* Execute the sign coordinator round 1 command.
+*
+* Collects signing commitments from participants.
+*
+* Port of `round1()` from cmd/sign/coordinator/round1.rs.
+*/
+async function round1$2(client, options, cwd) {
+	const registryPath = resolveRegistryPath(options.registryPath, cwd);
+	const registry = Registry.load(registryPath);
+	const owner = registry.owner();
+	if (owner === void 0) throw new Error("Registry owner is required");
+	const sessionId = parseAridUr(options.sessionId);
+	const startState = loadStartState$1(registryPath, sessionId, options.groupId !== void 0 ? parseAridUr(options.groupId) : void 0);
+	const groupId = startState.groupId;
+	const groupRecord = registry.group(groupId);
+	if (groupRecord === void 0) throw new Error("Group not found in registry");
+	if (groupRecord.coordinator().xid().urString() !== owner.xid().urString()) throw new Error(`Only the coordinator can collect signInvite responses. Coordinator: ${groupRecord.coordinator().xid().urString()}, Owner: ${owner.xid().urString()}`);
+	if (options.parallel === true) {
+		const collection = await collectCommitmentsParallel(client, registry, startState, owner.xidDocument(), sessionId, options.timeoutSeconds);
+		if (collection.rejections.length > 0) {
+			console.error();
+			console.error("Rejections:");
+			for (const [xid, reason] of collection.rejections) console.error(`  ${xid.urString()}: ${reason}`);
+		}
+		if (collection.errors.length > 0) {
+			console.error();
+			console.error("Errors:");
+			for (const [xid, error] of collection.errors) console.error(`  ${xid.urString()}: ${error}`);
+		}
+		if (collection.timeouts.length > 0) {
+			console.error();
+			console.error("Timeouts:");
+			for (const xid of collection.timeouts) console.error(`  ${xid.urString()}`);
+		}
+		if (!collection.allSucceeded()) throw new Error(`Sign commit collection incomplete: ${collection.successes.length} succeeded, ${collection.rejections.length} rejected, ${collection.errors.length} errors, ${collection.timeouts.length} timeouts`);
+		const commitments = /* @__PURE__ */ new Map();
+		for (const [xid, data] of collection.successes) commitments.set(xid.urString(), data.commitments);
+		const commitmentsPath = persistCommitments(registryPath, groupId, sessionId, startState, commitments);
+		const failures = (await dispatchShareRequestsParallel(client, registry, owner, startState, sessionId, collection, commitments, options.previewShare, options.verbose)).filter(([_, err]) => err !== null);
+		if (failures.length > 0) {
+			for (const [xid, error] of failures) if (error !== null) console.error(`Failed to send to ${xid.urString()}: ${error.message}`);
+			throw new Error(`Failed to send signRound2 requests to ${failures.length} participants`);
+		}
+		/* @__PURE__ */ updatePendingForShare(registry, collection, startState);
+		const displayPath = path.relative(cwd, commitmentsPath) || commitmentsPath;
+		if (isVerbose() || options.verbose === true) {
+			console.error();
+			console.error(`Collected ${collection.successes.length} signInvite responses. Saved to ${displayPath}`);
+			console.error(`Dispatched ${collection.successes.length} signRound2 requests.`);
+		}
+		return {
+			accepted: collection.successes.length,
+			rejected: collection.rejections.length,
+			errors: collection.errors.length,
+			timeouts: collection.timeouts.length
+		};
+	} else {
+		if (isVerbose() || options.verbose === true) console.error(`Collecting signInvite responses for session ${sessionId.urString()} from ${startState.participants.size} participants...`);
+		const commitments = /* @__PURE__ */ new Map();
+		const sendToArids = /* @__PURE__ */ new Map();
+		const errors = [];
+		const coordinatorKeys = owner.xidDocument().inceptionPrivateKeys();
+		if (coordinatorKeys === void 0) throw new Error("Coordinator XID document has no inception private keys");
+		for (const [xidStr, participantState] of startState.participants) {
+			const xid = XID.fromURString(xidStr);
+			const participantName = registry.participant(xid)?.petName() ?? xidStr;
+			try {
+				const envelope = await client.get(participantState.commitArid, options.timeoutSeconds);
+				if (envelope === void 0) throw new Error("Response not found in Hubert storage");
+				const data = validateAndExtractCommitResponse(envelope, coordinatorKeys, xid, sessionId);
+				commitments.set(xidStr, data.commitments);
+				sendToArids.set(xidStr, data.nextRequestArid);
+				if (isVerbose() || options.verbose === true) console.error(`  ✓ ${participantName}`);
+			} catch (e) {
+				errors.push([xid, e instanceof Error ? e.message : String(e)]);
+				if (isVerbose() || options.verbose === true) console.error(`  ✗ ${participantName}: ${e instanceof Error ? e.message : String(e)}`);
+			}
+		}
+		if (errors.length > 0) throw new Error(`Sign commit collection incomplete: ${errors.length} of ${startState.participants.size} responses failed`);
+		if (commitments.size !== startState.participants.size) {
+			const missing = [];
+			for (const xidStr of startState.participants.keys()) if (!commitments.has(xidStr)) missing.push(xidStr);
+			throw new Error(`Missing signInvite responses from: ${missing.join(", ")}`);
+		}
+		const commitmentsPath = persistCommitments(registryPath, groupId, sessionId, startState, commitments);
+		const signerKeys = owner.xidDocument().inceptionPrivateKeys();
+		if (signerKeys === void 0) throw new Error("Owner XID document has no inception private keys");
+		const validUntil = new Date(Date.now() + 3600 * 1e3);
+		if (isVerbose() || options.verbose === true) console.error(`Dispatching signRound2 requests to ${sendToArids.size} participants...`);
+		else console.error();
+		let previewPrinted = false;
+		for (const [xidStr, sendToArid] of sendToArids) {
+			const xid = XID.fromURString(xidStr);
+			const participantState = startState.participants.get(xidStr);
+			if (participantState === void 0) throw new Error(`Participant state not found for ${xidStr}`);
+			const participantName = registry.participant(xid)?.petName() ?? xidStr;
+			let recipientDoc;
+			if (xidStr === owner.xid().urString()) recipientDoc = owner.xidDocument();
+			else {
+				const record = registry.participant(xid);
+				if (record === void 0) throw new Error(`Participant ${xidStr} not found in registry`);
+				recipientDoc = record.xidDocument();
+			}
+			const request = buildShareRequestForParticipant(owner.xidDocument(), groupId, sessionId, participantState.shareArid, commitments);
+			if (options.previewShare === true && !previewPrinted) {
+				const preview = request.toEnvelope(validUntil, signerKeys, void 0);
+				console.log(`# signRound2 preview for ${xidStr}`);
+				console.log(preview.format());
+				previewPrinted = true;
+			}
+			const sealedEnvelope = request.toEnvelopeForRecipients(validUntil, signerKeys, [recipientDoc]);
+			await client.put(sendToArid, sealedEnvelope);
+			if (isVerbose() || options.verbose === true) console.error(`  ✓ ${participantName}`);
+		}
+		const displayPath = path.relative(cwd, commitmentsPath) || commitmentsPath;
+		if (isVerbose() || options.verbose === true) {
+			console.error();
+			console.error(`Collected ${commitments.size} signInvite responses. Saved to ${displayPath}`);
+			console.error(`Dispatched ${commitments.size} signRound2 requests.`);
+		}
+		return {
+			accepted: commitments.size,
+			rejected: 0,
+			errors: errors.length,
+			timeouts: 0
+		};
+	}
+}
+
+//#endregion
+//#region src/cmd/sign/coordinator/round2.ts
+/**
+* Sign coordinator round 2 command.
+*
+* Port of cmd/sign/coordinator/round2.rs from frost-hubert-rust.
+*
+* @module
+*/
+/**
+* Validate envelope and extract signature share data (for parallel fetch).
+*
+* Port of `validate_and_extract_share_response()` from cmd/sign/coordinator/round2.rs.
+*/
+function validateAndExtractShareResponse(envelope, _coordinatorKeys, expectedSender, expectedSessionId) {
+	try {
+		envelope.checkSubjectUnit();
+		envelope.checkType("signRound2Response");
+		const sessionObjects = envelope.objectsForPredicate("session");
+		if (sessionObjects.length === 0) return { rejected: "Missing session in response" };
+		const responseSession = ARID.fromTaggedCbor(sessionObjects[0].subject().tryLeaf());
+		if (responseSession.urString() !== expectedSessionId.urString()) return { rejected: `Response session ${responseSession.urString()} does not match expected ${expectedSessionId.urString()}` };
+		const participantObjects = envelope.objectsForPredicate("participant");
+		if (participantObjects.length === 0) return { rejected: "Missing participant in response" };
+		const participantXid = XID.fromTaggedCbor(participantObjects[0].subject().tryLeaf());
+		if (participantXid.urString() !== expectedSender.urString()) return { rejected: `Unexpected response sender: ${participantXid.urString()} (expected ${expectedSender.urString()})` };
+		const shareObjects = envelope.objectsForPredicate("signature_share");
+		if (shareObjects.length === 0) return { rejected: "Missing signature_share in response" };
+		const signatureShareJson = JSON$1.fromTaggedCbor(shareObjects[0].subject().tryLeaf());
+		const signatureShare = deserializeSignatureShare(JSON.parse(signatureShareJson.toString()).share);
+		const responseAridObjects = envelope.objectsForPredicate("response_arid");
+		if (responseAridObjects.length === 0) return { rejected: "Missing response_arid in response" };
+		return {
+			signatureShare,
+			finalizeArid: ARID.fromTaggedCbor(responseAridObjects[0].subject().tryLeaf())
+		};
+	} catch (error) {
+		return { rejected: `Failed to parse response: ${error instanceof Error ? error.message : String(error)}` };
+	}
+}
+/**
+* Collect signature shares in parallel with progress display.
+*
+* Port of `collect_shares_parallel()` from cmd/sign/coordinator/round2.rs.
+*/
+async function collectSharesParallel(client, registry, commitmentsState, coordinator, sessionId, timeoutSeconds) {
+	const requests = [];
+	for (const [xidUr, entry] of commitmentsState.commitments) {
+		const xid = XID.fromURString(xidUr);
+		const name = registry.participant(xid)?.petName() ?? xid.urString();
+		requests.push([
+			xid,
+			entry.shareArid,
+			name
+		]);
+	}
+	const coordinatorKeys = coordinator.inceptionPrivateKeys();
+	if (!coordinatorKeys) throw new Error("Coordinator XID document has no inception private keys");
+	const session = sessionId;
+	return parallelFetch(client, requests, (envelope, xid) => {
+		return validateAndExtractShareResponse(envelope, coordinatorKeys, xid, session);
+	}, {
+		timeoutSeconds,
+		verbose: false
+	});
+}
+/**
+* Build a finalize event containing all signature shares.
+*
+* Port of `build_finalize_event()` from cmd/sign/coordinator/round2.rs.
+*/
+function buildFinalizeEvent(_sender, sessionId, signatureSharesByXid) {
+	let content = SignFinalizeContent.new().addAssertion("session", sessionId);
+	for (const [xidUr, share] of signatureSharesByXid) {
+		const xid = XID.fromURString(xidUr);
+		const shareHex = serializeSignatureShare(share);
+		const shareJson = JSON$1.fromString(JSON.stringify({ share: shareHex }));
+		const entry = Envelope.new(xid).addAssertion("share", shareJson);
+		content = content.addAssertion("signature_share", entry);
+	}
+	return content;
+}
+/**
+* Aggregate signature shares and verify the result.
+*
+* Port of signature aggregation logic from cmd/sign/coordinator/round2.rs.
+*/
+function aggregateAndVerifySignature$1(signingCommitments, signatureSharesByIdentifier, publicKeyPackage, targetDigest) {
+	const signatureBytes = serializeSignature(aggregateSignatures(createSigningPackage(signingCommitments, targetDigest), signatureSharesByIdentifier, publicKeyPackage));
+	if (signatureBytes.length !== 64) throw new Error("Aggregated signature is not 64 bytes");
+	const signature = Signature.ed25519FromData(signatureBytes);
+	return {
+		signature,
+		signatureUr: signature.urString()
+	};
+}
+/**
+* Persist final signing state to disk.
+*
+* Port of `persist_final_state()` from cmd/sign/coordinator/round2.rs.
+*/
+function persistSigningState(registryPath, groupId, sessionId, signature, signatureSharesByXid, finalizeArids) {
+	const dir = signingStateDir(registryPath, groupId.hex(), sessionId.hex());
+	fs.mkdirSync(dir, { recursive: true });
+	const sharesJson = {};
+	for (const [xidUr, share] of signatureSharesByXid) sharesJson[xidUr] = { share: serializeSignatureShare(share) };
+	const finalizeJson = {};
+	for (const [xidUr, arid] of finalizeArids) finalizeJson[xidUr] = arid.urString();
+	const root = {
+		group: groupId.urString(),
+		session: sessionId.urString(),
+		signature: signature.urString(),
+		signature_shares: sharesJson,
+		finalize_arids: finalizeJson
+	};
+	fs.writeFileSync(path.join(dir, "final.json"), JSON.stringify(root, null, 2));
+}
+/**
+* Load start state from disk.
+*
+* Port of `load_start_state()` from cmd/sign/coordinator/round2.rs.
+*/
+function loadStartState(registryPath, sessionId, groupHint) {
+	const base = path.dirname(registryPath);
+	const groupStateDir = path.join(base, "group-state");
+	const candidatePaths = [];
+	let groupDirs;
+	if (groupHint) groupDirs = [[groupHint, path.join(groupStateDir, groupHint.hex())]];
+	else {
+		groupDirs = [];
+		if (fs.existsSync(groupStateDir)) {
+			for (const entry of fs.readdirSync(groupStateDir, { withFileTypes: true })) if (entry.isDirectory() && entry.name.length === 64 && /^[0-9a-f]+$/i.test(entry.name)) {
+				const groupId = ARID.fromHex(entry.name);
+				groupDirs.push([groupId, path.join(groupStateDir, entry.name)]);
+			}
+		}
+	}
+	for (const [groupId, groupDir] of groupDirs) {
+		const candidate = path.join(groupDir, "signing", sessionId.hex(), "start.json");
+		if (fs.existsSync(candidate)) candidatePaths.push([groupId, candidate]);
+	}
+	if (candidatePaths.length === 0) throw new Error("No sign start state found; run `frost sign coordinator start` first");
+	if (candidatePaths.length > 1) throw new Error("Multiple signing sessions found; specify --group to disambiguate");
+	const [groupId, statePath] = candidatePaths[0];
+	const raw = JSON.parse(fs.readFileSync(statePath, "utf-8"));
+	const getStr = (key) => {
+		const value = raw[key];
+		if (typeof value !== "string") throw new Error(`Missing or invalid ${key} in start.json`);
+		return value;
+	};
+	const sessionInState = parseAridUr(getStr("session_id"));
+	const groupInState = parseAridUr(getStr("group"));
+	if (sessionInState.urString() !== sessionId.urString()) throw new Error(`start.json session ${sessionInState.urString()} does not match requested session ${sessionId.urString()}`);
+	if (groupInState.urString() !== groupId.urString()) throw new Error(`start.json group ${groupInState.urString()} does not match directory group ${groupId.urString()}`);
+	const minSigners = raw["min_signers"];
+	if (typeof minSigners !== "number") throw new Error("Missing min_signers in start.json");
+	const participantsVal = raw["participants"];
+	if (!participantsVal || typeof participantsVal !== "object") throw new Error("Missing participants in start.json");
+	const participants = [];
+	for (const xidStr of Object.keys(participantsVal)) participants.push(XID.fromURString(xidStr));
+	participants.sort((a, b) => a.urString().localeCompare(b.urString()));
+	return {
+		groupId,
+		minSigners,
+		participants,
+		targetUr: getStr("target")
+	};
+}
+/**
+* Load commitments state from disk.
+*
+* Port of `load_commitments_state()` from cmd/sign/coordinator/round2.rs.
+*/
+function loadCommitmentsState(registryPath, groupId, sessionId) {
+	const dir = signingStateDir(registryPath, groupId.hex(), sessionId.hex());
+	const statePath = path.join(dir, "commitments.json");
+	if (!fs.existsSync(statePath)) throw new Error(`Commitments not found at ${statePath}. Run \`frost sign coordinator collect\` first`);
+	const raw = JSON.parse(fs.readFileSync(statePath, "utf-8"));
+	const getStr = (key) => {
+		const value = raw[key];
+		if (typeof value !== "string") throw new Error(`Missing or invalid ${key} in commitments.json`);
+		return value;
+	};
+	const sessionInState = parseAridUr(getStr("session"));
+	if (sessionInState.urString() !== sessionId.urString()) throw new Error(`commitments.json session ${sessionInState.urString()} does not match requested session ${sessionId.urString()}`);
+	const commitmentsVal = raw["commitments"];
+	if (!commitmentsVal || typeof commitmentsVal !== "object") throw new Error("Missing commitments map in commitments.json");
+	const commitments = /* @__PURE__ */ new Map();
+	for (const [xidStr, value] of Object.entries(commitmentsVal)) {
+		const obj = value;
+		const commitValue = obj["commitments"];
+		if (!commitValue) throw new Error("Missing commitments value in commitments.json");
+		const commitmentsDeserialized = deserializeSigningCommitments(commitValue);
+		const shareAridRaw = obj["share_arid"];
+		if (typeof shareAridRaw !== "string") throw new Error("Missing share_arid in commitments.json");
+		const shareArid = parseAridUr(shareAridRaw);
+		commitments.set(xidStr, {
+			commitments: commitmentsDeserialized,
+			shareArid
+		});
+	}
+	return { commitments };
+}
+/**
+* Load public key package from collected_finalize.json.
+*
+* Port of `load_public_key_package()` from cmd/sign/coordinator/round2.rs.
+*/
+function loadPublicKeyPackage$1(registryPath, groupId) {
+	const base = path.dirname(registryPath);
+	const pkgPath = path.join(base, "group-state", groupId.hex(), "collected_finalize.json");
+	if (!fs.existsSync(pkgPath)) throw new Error(`collected_finalize.json not found at ${pkgPath}. Run \`frost dkg coordinator finalize collect\` first`);
+	const raw = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+	const firstEntry = Object.values(raw)[0];
+	if (!firstEntry) throw new Error("collected_finalize.json is empty");
+	const publicKeyValue = firstEntry["public_key_package"];
+	if (!publicKeyValue) throw new Error("public_key_package missing in collected_finalize.json");
+	return deserializePublicKeyPackage(publicKeyValue);
+}
+/**
+* Build a map from XID to FROST identifier.
+*
+* Port of `xid_identifier_map()` from cmd/sign/coordinator/round2.rs.
+*/
+function xidIdentifierMap$2(participants) {
+	const map = /* @__PURE__ */ new Map();
+	for (let i = 0; i < participants.length; i++) {
+		const identifier = identifierFromU16(i + 1);
+		map.set(participants[i].urString(), identifier);
+	}
+	return map;
+}
+/**
+* Build signing commitments with identifiers.
+*
+* Port of `commitments_with_identifiers()` from cmd/sign/coordinator/round2.rs.
+*/
+function commitmentsWithIdentifiers$2(commitments, xidToIdentifier) {
+	const mapped = /* @__PURE__ */ new Map();
+	for (const [xidUr, entry] of commitments) {
+		const identifier = xidToIdentifier.get(xidUr);
+		if (!identifier) throw new Error(`Unknown participant ${xidUr}`);
+		mapped.set(identifier, entry.commitments);
+	}
+	return mapped;
+}
+/**
+* Execute the sign coordinator round 2 command.
+*
+* Collects signature shares, aggregates the signature, and posts finalize packages.
+*
+* Port of `CommandArgs::exec()` from cmd/sign/coordinator/round2.rs.
+*/
+async function round2$2(client, options, cwd) {
+	const registryPath = resolveRegistryPath(options.registryPath, cwd);
+	const registry = Registry.load(registryPath);
+	const owner = registry.owner();
+	if (!owner) throw new Error("Registry owner is required");
+	const sessionId = parseAridUr(options.sessionId);
+	const startState = loadStartState(registryPath, sessionId, options.groupId ? parseAridUr(options.groupId) : void 0);
+	const groupId = startState.groupId;
+	const groupRecord = registry.group(groupId);
+	if (!groupRecord) throw new Error("Group not found in registry");
+	if (groupRecord.coordinator().xid().urString() !== owner.xid().urString()) throw new Error(`Only the coordinator can finalize signing. Coordinator: ${groupRecord.coordinator().xid().urString()}, Owner: ${owner.xid().urString()}`);
+	const commitmentsState = loadCommitmentsState(registryPath, groupId, sessionId);
+	const xidToIdentifier = xidIdentifierMap$2(startState.participants);
+	let signatureSharesByIdentifier;
+	let signatureSharesByXid;
+	let finalizeArids;
+	if (options.parallel === true) {
+		const collection = await collectSharesParallel(client, registry, commitmentsState, owner.xidDocument(), sessionId, options.timeoutSeconds);
+		if (!collection.allSucceeded()) {
+			if (collection.rejections.length > 0) {
+				console.error("\nRejections:");
+				for (const [xid, reason] of collection.rejections) console.error(`  ${xid.urString()}: ${reason}`);
+			}
+			if (collection.errors.length > 0) {
+				console.error("\nErrors:");
+				for (const [xid, error] of collection.errors) console.error(`  ${xid.urString()}: ${error}`);
+			}
+			if (collection.timeouts.length > 0) {
+				console.error("\nTimeouts:");
+				for (const xid of collection.timeouts) console.error(`  ${xid.urString()}`);
+			}
+			throw new Error(`Signature share collection incomplete: ${collection.successes.length} succeeded, ${collection.rejections.length} rejected, ${collection.errors.length} errors, ${collection.timeouts.length} timeouts`);
+		}
+		signatureSharesByIdentifier = /* @__PURE__ */ new Map();
+		signatureSharesByXid = /* @__PURE__ */ new Map();
+		finalizeArids = /* @__PURE__ */ new Map();
+		for (const [xid, data] of collection.successes) {
+			const xidUr = xid.urString();
+			const identifier = xidToIdentifier.get(xidUr);
+			if (!identifier) throw new Error("Identifier mapping missing for participant");
+			signatureSharesByIdentifier.set(identifier, data.signatureShare);
+			signatureSharesByXid.set(xidUr, data.signatureShare);
+			finalizeArids.set(xidUr, data.finalizeArid);
+		}
+	} else {
+		if (options.verbose === true) console.error(`Collecting signature shares for session ${sessionId.urString()} from ${commitmentsState.commitments.size} participants...`);
+		signatureSharesByIdentifier = /* @__PURE__ */ new Map();
+		signatureSharesByXid = /* @__PURE__ */ new Map();
+		finalizeArids = /* @__PURE__ */ new Map();
+		for (const [xidUr, entry] of commitmentsState.commitments) {
+			const xid = XID.fromURString(xidUr);
+			const participantName = registry.participant(xid)?.petName() ?? xid.urString();
+			const identifier = xidToIdentifier.get(xidUr);
+			if (!identifier) throw new Error("Identifier mapping missing for participant");
+			const envelope = await client.get(entry.shareArid, options.timeoutSeconds);
+			if (!envelope) throw new Error(`Signature share response not found for ${participantName}`);
+			const coordinatorKeys = owner.xidDocument().inceptionPrivateKeys();
+			if (!coordinatorKeys) throw new Error("Coordinator XID document has no inception private keys");
+			const result = validateAndExtractShareResponse(envelope, coordinatorKeys, xid, sessionId);
+			if ("rejected" in result) throw new Error(`Participant rejected signRound2: ${result.rejected}`);
+			signatureSharesByIdentifier.set(identifier, result.signatureShare);
+			signatureSharesByXid.set(xidUr, result.signatureShare);
+			finalizeArids.set(xidUr, result.finalizeArid);
+		}
+	}
+	if (signatureSharesByIdentifier.size < startState.minSigners) throw new Error(`Only collected ${signatureSharesByIdentifier.size} signature shares, need at least ${startState.minSigners}`);
+	const signingCommitments = commitmentsWithIdentifiers$2(commitmentsState.commitments, xidToIdentifier);
+	const targetDigest = Envelope.fromURString(startState.targetUr).subject().digest().data();
+	const publicKeyPackage = loadPublicKeyPackage$1(registryPath, groupId);
+	const verifyingKey = signingKeyFromVerifying(publicKeyPackage.verifyingKey);
+	const { signature, signatureUr } = aggregateAndVerifySignature$1(signingCommitments, signatureSharesByIdentifier, publicKeyPackage, targetDigest);
+	if (verifyingKey.verify(signature, targetDigest) !== true) throw new Error("Aggregated signature failed verification against target digest");
+	const signedEnvelopeUr = Envelope.fromURString(startState.targetUr).addAssertion("signed", signature).urString();
+	persistSigningState(registryPath, groupId, sessionId, signature, signatureSharesByXid, finalizeArids);
+	if (options.verbose === true) {
+		console.error();
+		console.error(`Aggregated signature for session ${sessionId.urString()} and prepared ${finalizeArids.size} finalize packages.`);
+		console.error("Signature verified against target and group key.");
+	}
+	if (!owner.xidDocument().inceptionPrivateKeys()) throw new Error("Coordinator XID document has no signing keys");
+	if (options.verbose === true) console.error(`Dispatching finalize packages to ${finalizeArids.size} participants...`);
+	else console.error();
+	const messages = [];
+	let previewPrinted = false;
+	for (const [xidUr, finalizeArid] of finalizeArids) {
+		const participantXid = XID.fromURString(xidUr);
+		const participant = registry.participant(participantXid);
+		const participantName = participant?.petName() ?? xidUr;
+		if (!(xidUr === owner.xid().urString() ? owner.xidDocument() : participant?.xidDocument())) throw new Error(`Participant ${xidUr} not found in registry`);
+		const event = buildFinalizeEvent(owner.xidDocument(), sessionId, signatureSharesByXid);
+		if (options.previewFinalize === true && !previewPrinted) {
+			console.log(`# signFinalize preview for ${participantXid.urString()}`);
+			console.log(event.envelope().format());
+			previewPrinted = true;
+		}
+		const sealed = event.envelope();
+		messages.push([
+			participantXid,
+			finalizeArid,
+			sealed,
+			participantName
+		]);
+	}
+	if (options.parallel === true) {
+		console.error();
+		const results = await parallelSend(client, messages, options.verbose === true);
+		const errors = [];
+		for (const [xid, result] of results) if (result !== null) {
+			const name = registry.participant(xid)?.petName() ?? xid.urString();
+			errors.push(`${name}: ${result.message}`);
+		}
+		if (errors.length > 0) throw new Error(`Failed to send finalize packages: ${errors.join("; ")}`);
+	} else for (const [_xid, finalizeArid, sealed, participantName] of messages) await putWithIndicator(client, finalizeArid, sealed, participantName, options.verbose ?? false);
+	console.log(signatureUr);
+	console.log(signedEnvelopeUr);
+	return {
+		signature: signatureUr,
+		signedEnvelope: signedEnvelopeUr,
+		accepted: signatureSharesByIdentifier.size,
+		rejected: 0,
+		errors: 0,
+		timeouts: 0
+	};
+}
+
+//#endregion
+//#region src/cmd/sign/coordinator/index.ts
+var coordinator_exports = /* @__PURE__ */ __exportAll({
+	buildSessionStateJson: () => buildSessionStateJson,
+	buildShareRequestForParticipant: () => buildShareRequestForParticipant,
+	buildSignInviteRequest: () => buildSignInviteRequest,
+	collectCommitmentsParallel: () => collectCommitmentsParallel,
+	createSessionArids: () => createSessionArids,
+	dispatchShareRequestsParallel: () => dispatchShareRequestsParallel,
+	gatherRecipientDocuments: () => gatherRecipientDocuments,
+	invite: () => invite,
+	loadEnvelopeFromPath: () => loadEnvelopeFromPath,
+	persistCommitments: () => persistCommitments,
+	persistSessionState: () => persistSessionState,
+	round1: () => round1$2,
+	round2: () => round2$2,
+	updatePendingForShare: () => updatePendingForShare,
+	validateAndExtractCommitResponse: () => validateAndExtractCommitResponse,
+	validateCoordinator: () => validateCoordinator
+});
+
+//#endregion
+//#region src/cmd/sign/participant/receive.ts
+/**
+* Sign participant receive command.
+*
+* Port of cmd/sign/participant/receive.rs from frost-hubert-rust.
+*
+* @module
+*/
+/**
+* Resolve sender from XID UR or pet name in registry.
+*
+* Port of `resolve_sender()` from cmd/dkg/common.rs lines 76-94.
+*/
+function resolveSenderFromInput(registry, input) {
+	const trimmed = input.trim();
+	if (trimmed === "") throw new Error("Sender is required");
+	try {
+		const { XID: XIDClass } = __require("@bcts/components");
+		const xid = XIDClass.fromURString(trimmed);
+		const record = registry.participant(xid);
+		if (!record) throw new Error(`Sender with XID ${xid.urString()} not found`);
+		return record.xidDocument();
+	} catch {
+		const result = registry.participantByPetName(trimmed);
+		if (!result) throw new Error(`Sender with pet name '${trimmed}' not found`);
+		return result[1].xidDocument();
+	}
+}
+/**
+* Resolve sign invite from ARID or envelope UR.
+*
+* Port of `resolve_sign_request()` from cmd/sign/participant/receive.rs lines 250-284.
+*/
+async function resolveSignInviteEnvelope(client, selection, request, timeout) {
+	if (selection !== void 0 && client !== void 0) {
+		try {
+			const envelope = await getWithIndicator(client, parseAridUr(request), "Sign invite", timeout, false);
+			if (envelope === void 0 || envelope === null) throw new Error("signInvite request not found in Hubert storage");
+			return envelope;
+		} catch {}
+		if (timeout !== void 0) throw new Error("--timeout is only valid when retrieving requests from Hubert");
+		return parseEnvelopeUr(request);
+	}
+	try {
+		parseAridUr(request);
+		throw new Error("Hubert storage parameters are required to retrieve requests by ARID");
+	} catch (e) {
+		if (e instanceof Error && e.message.includes("Hubert storage parameters")) throw e;
+	}
+	return parseEnvelopeUr(request);
+}
+/**
+* Get display name for sender from registry.
+*
+* Port of `resolve_sender_name()` from cmd/dkg/common.rs lines 96-116.
+*/
+function resolveSenderName(registry, senderXid) {
+	const owner = registry.owner();
+	if (owner?.xid().urString() === senderXid.urString()) return formatNameWithOwnerMarker(owner.petName() ?? senderXid.urString(), true);
+	const record = registry.participant(senderXid);
+	if (record) return formatNameWithOwnerMarker(record.petName() ?? record.xid().urString(), false);
+}
+/**
+* Format participant names with owner marker.
+*
+* Port of `format_participant_names()` from cmd/sign/participant/receive.rs lines 286-309.
+*/
+function formatParticipantNames(registry, participants, owner) {
+	return participants.map((xid) => {
+		const isOwner = xid.urString() === owner.xid().urString();
+		let name;
+		if (isOwner) name = owner.petName() ?? xid.urString();
+		else name = registry.participant(xid)?.petName() ?? xid.urString();
+		return formatNameWithOwnerMarker(name, isOwner);
+	});
+}
+/**
+* Execute the sign participant receive command.
+*
+* Fetches and validates a sign invite from the coordinator.
+*
+* Port of `CommandArgs::exec()` from cmd/sign/participant/receive.rs lines 56-247.
+*/
+async function receive(client, selection, options, cwd) {
+	if (selection === void 0 && options.timeoutSeconds !== void 0) throw new Error("--timeout requires Hubert storage parameters");
+	const registryPath = resolveRegistryPath(options.registryPath, cwd);
+	const registry = Registry.load(registryPath);
+	const owner = registry.owner();
+	if (!owner) throw new Error("Registry owner with private keys is required");
+	let expectedSender;
+	if (options.sender !== void 0 && options.sender !== "") expectedSender = resolveSenderFromInput(registry, options.sender);
+	const envelope = await resolveSignInviteEnvelope(client, selection, options.request, options.timeoutSeconds);
+	const now = CborDate.now();
+	const recipientKeys = owner.xidDocument().inceptionPrivateKeys();
+	if (recipientKeys === null || recipientKeys === void 0) throw new Error("Owner XID document has no inception private keys");
+	const { SealedRequest: SealedRequestClass } = __require("@bcts/gstp");
+	const sealedRequest = SealedRequestClass.tryFromEnvelope(envelope, void 0, now, recipientKeys);
+	const senderXid = sealedRequest.sender().xid();
+	if (expectedSender !== void 0) {
+		if (senderXid.urString() !== expectedSender.xid().urString()) throw new Error(`Request sender does not match expected sender (got ${senderXid.urString()}, expected ${expectedSender.xid().urString()})`);
+	} else {
+		const knownOwner = owner.xid().urString() === senderXid.urString();
+		const knownParticipant = registry.participant(senderXid) !== void 0;
+		if (!knownOwner && !knownParticipant) throw new Error(`Request sender not found in registry: ${senderXid.urString()}`);
+	}
+	const { Function: FunctionClass } = __require("@bcts/envelope");
+	const requestFunction = sealedRequest.function();
+	const expectedFunction = FunctionClass.from("signInvite");
+	if (!(requestFunction.equals !== void 0 ? requestFunction.equals(expectedFunction) : String(requestFunction) === String(expectedFunction))) throw new Error(`Unexpected request function: ${String(requestFunction)}`);
+	if (sealedRequest.extractObjectForParameter("validUntil") <= now) throw new Error("signInvite request has expired");
+	const groupId = sealedRequest.extractObjectForParameter("group");
+	const sessionId = sealedRequest.extractObjectForParameter("session");
+	const minSigners = Number(sealedRequest.extractObjectForParameter("minSigners"));
+	const participantEntries = sealedRequest.objectsForParameter("participant");
+	const participants = [];
+	let responseArid;
+	for (const entry of participantEntries) {
+		const xid = entry.extractSubject();
+		if (xid.urString() === owner.xid().urString()) responseArid = entry.objectForPredicate("response_arid").decryptToRecipient(recipientKeys).extractSubject();
+		participants.push(xid);
+	}
+	if (participants.length === 0) throw new Error("signInvite request contains no participants");
+	if (minSigners < 2) throw new Error("minSigners must be at least 2");
+	if (minSigners > participants.length) throw new Error("minSigners exceeds participant count");
+	if (!participants.some((p) => p.urString() === owner.xid().urString())) throw new Error("signInvite request does not include this participant");
+	if (responseArid === void 0) throw new Error("signInvite request missing response ARID");
+	participants.sort((a, b) => a.urString().localeCompare(b.urString()));
+	const targetEnvelope = sealedRequest.objectForParameter("target");
+	const coordinatorName = resolveSenderName(registry, senderXid) ?? senderXid.urString();
+	const participantNames = formatParticipantNames(registry, participants, owner);
+	console.log(`Group: ${groupId.urString()}`);
+	console.log(`Coordinator: ${coordinatorName}`);
+	console.log(`Min signers: ${minSigners}`);
+	console.log(`Participants: ${participantNames.join(", ")}`);
+	console.log("Target:");
+	console.log(targetEnvelope.format());
+	console.log(sessionId.urString());
+	const stateDir = signingStateDir(registryPath, groupId.hex(), sessionId.hex());
+	fs.mkdirSync(stateDir, { recursive: true });
+	const root = {
+		request_envelope: envelope.urString(),
+		group: groupId.urString(),
+		session: sessionId.urString(),
+		coordinator: senderXid.urString(),
+		min_signers: minSigners,
+		response_arid: responseArid.urString(),
+		participants: participants.map((xid) => xid.urString()),
+		target: targetEnvelope.urString()
+	};
+	fs.writeFileSync(path.join(stateDir, "sign_receive.json"), JSON.stringify(root, null, 2));
+	return {
+		sessionId: sessionId.urString(),
+		groupId: groupId.urString(),
+		targetUr: targetEnvelope.urString(),
+		coordinatorName,
+		minSigners,
+		participantNames
+	};
+}
+
+//#endregion
+//#region src/cmd/sign/participant/round1.ts
+/**
+* Sign participant round 1 command.
+*
+* Port of cmd/sign/participant/round1.rs from frost-hubert-rust.
+*
+* @module
+*/
+/**
+* Load receive state from persisted sign_receive.json.
+*
+* Port of `load_receive_state()` from cmd/sign/participant/round1.rs lines 285-411.
+*/
+function loadReceiveState$2(registryPath, sessionId, groupHint, registry) {
+	const base = path.dirname(registryPath);
+	const groupStateDir = path.join(base, "group-state");
+	let groupDirs;
+	if (groupHint !== void 0) groupDirs = [[groupHint, path.join(groupStateDir, groupHint.hex())]];
+	else {
+		groupDirs = [];
+		if (fs.existsSync(groupStateDir)) {
+			for (const entry of fs.readdirSync(groupStateDir, { withFileTypes: true })) if (entry.isDirectory()) {
+				const dirName = entry.name;
+				if (dirName.length === 64 && /^[0-9a-fA-F]+$/.test(dirName)) {
+					const groupId = ARID.fromHex(dirName);
+					groupDirs.push([groupId, path.join(groupStateDir, dirName)]);
+				}
+			}
+		}
+	}
+	const candidates = [];
+	for (const [groupId, groupDir] of groupDirs) {
+		const candidate = path.join(groupDir, "signing", sessionId.hex(), "sign_receive.json");
+		if (fs.existsSync(candidate)) candidates.push([groupId, candidate]);
+	}
+	if (candidates.length === 0) throw new Error("No sign_receive.json found for this session; run `frost sign participant receive` first");
+	if (candidates.length > 1) throw new Error("Multiple groups contain this session; use --group to disambiguate");
+	const [groupId, filePath] = candidates[0];
+	const raw = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+	const sessionInState = parseAridUr(raw.session);
+	if (sessionInState.urString() !== sessionId.urString()) throw new Error(`Session ${sessionInState.urString()} in sign_receive.json does not match requested session ${sessionId.urString()}`);
+	const responseArid = parseAridUr(raw.response_arid);
+	const targetUr = raw.target;
+	const coordinatorUr = raw.coordinator;
+	const coordinatorXid = XID.fromURString(coordinatorUr);
+	let coordinatorDoc;
+	const participantRecord = registry.participant(coordinatorXid);
+	if (participantRecord !== null && participantRecord !== void 0) coordinatorDoc = participantRecord.xidDocument();
+	else {
+		const owner = registry.owner();
+		if (owner?.xid().urString() === coordinatorXid.urString()) coordinatorDoc = owner.xidDocument();
+		else throw new Error(`Coordinator ${coordinatorXid.urString()} not found in registry and cannot resolve encryption key`);
+	}
+	const requestEnvelope = Envelope.fromURString(raw.request_envelope);
+	const participants = raw.participants.map((s) => XID.fromURString(s));
+	return {
+		groupId,
+		coordinatorDoc,
+		responseArid,
+		targetUr,
+		participants,
+		requestEnvelope
+	};
+}
+/**
+* Validate the commit request from persisted state.
+*
+* Port of request validation in `CommandArgs::exec()` from cmd/sign/participant/round1.rs lines 100-138.
+*/
+function validateCommitRequest(receiveState, sessionId, ownerXid, ownerPrivateKeys) {
+	const now = CborDate.now();
+	const sealedRequest = SealedRequest.tryFromEnvelope(receiveState.requestEnvelope, void 0, now.datetime(), ownerPrivateKeys);
+	if (!sealedRequest.request().function().equals(Function.fromString("signInvite"))) throw new Error(`Unexpected request function: ${String(sealedRequest.request().function())}`);
+	if (sealedRequest.request().id().urString() !== sessionId.urString()) throw new Error(`Session ID mismatch (state ${sessionId.urString()}, request ${sealedRequest.request().id().urString()})`);
+	const requestGroup = sealedRequest.extractObjectForParameter("group");
+	if (requestGroup.urString() !== receiveState.groupId.urString()) throw new Error(`Group ID mismatch (state ${receiveState.groupId.urString()}, request ${requestGroup.urString()})`);
+	if (!receiveState.participants.map((p) => p.urString()).includes(ownerXid.urString())) throw new Error("Persisted signInvite request does not include this participant");
+	return sealedRequest;
+}
+/**
+* Build the response body envelope.
+*
+* Port of response body building from cmd/sign/participant/round1.rs lines 191-195.
+*/
+function buildResponseBody$1(sessionId, commitments, responseArid) {
+	const serializedCommitments = serializeSigningCommitments(commitments);
+	const jsonStr = JSON.stringify(serializedCommitments);
+	const jsonBytes = new TextEncoder().encode(jsonStr);
+	const commitmentsJson = JSON$1.fromData(jsonBytes);
+	return Envelope.unit().addType("signRound1Response").addAssertion("session", sessionId).addAssertion("commitments", commitmentsJson.taggedCborData()).addAssertion("response_arid", responseArid);
+}
+/**
+* Persist commit state (nonces and commitments) to disk.
+*
+* Port of `persist_commit_state()` from cmd/sign/participant/round1.rs lines 413-461.
+*/
+function persistCommitState(registryPath, groupId, sessionId, receiveState, signingNonces, signingCommitments, targetEnvelope, nextShareArid) {
+	const dir = signingStateDir(registryPath, groupId.hex(), sessionId.hex());
+	fs.mkdirSync(dir, { recursive: true });
+	const serializedNonces = serializeSigningNonces(signingNonces);
+	const serializedCommitments = serializeSigningCommitments(signingCommitments);
+	const commitState = {
+		session: sessionId.urString(),
+		response_arid: receiveState.responseArid.urString(),
+		next_share_arid: nextShareArid.urString(),
+		target: targetEnvelope.urString(),
+		signing_nonces: serializedNonces,
+		signing_commitments: serializedCommitments
+	};
+	fs.writeFileSync(path.join(dir, "commit.json"), JSON.stringify(commitState, null, 2));
+}
+/**
+* Execute the sign participant round 1 command.
+*
+* Responds to the sign invite with signing commitments.
+*
+* Port of `CommandArgs::exec()` from cmd/sign/participant/round1.rs lines 58-273.
+*/
+async function round1$1(_client, options, cwd) {
+	if (options.storageSelection === void 0 && options.preview !== true) throw new Error("Hubert storage is required for sign commit");
+	if (options.storageSelection !== void 0 && options.preview === true) throw new Error("--preview cannot be used with Hubert storage options");
+	const registryPath = resolveRegistryPath(options.registryPath, cwd);
+	const registry = Registry.load(registryPath);
+	const owner = registry.owner();
+	if (!owner) throw new Error("Registry owner is required");
+	const sessionId = parseAridUr(options.sessionId);
+	const receiveState = loadReceiveState$2(registryPath, sessionId, options.groupId !== void 0 ? parseAridUr(options.groupId) : void 0, registry);
+	const groupId = receiveState.groupId;
+	const groupRecord = registry.group(groupId);
+	if (groupRecord === null || groupRecord === void 0) throw new Error("Group not found in registry");
+	const ownerKeys = owner.xidDocument().inceptionPrivateKeys();
+	if (ownerKeys === void 0) throw new Error("Owner XID document has no private keys");
+	const sealedRequest = validateCommitRequest(receiveState, sessionId, owner.xid(), ownerKeys);
+	const contributions = groupRecord.contributions();
+	if (contributions === null || contributions === void 0) throw new Error("Key package path not found; did you finish DKG?");
+	const keyPackagePath = contributions.keyPackage;
+	if (keyPackagePath === void 0) throw new Error("Key package path not found; did you finish DKG?");
+	const keyPackage = deserializeKeyPackage(JSON.parse(fs.readFileSync(keyPackagePath, "utf-8")).key_package);
+	const targetEnvelope = Envelope.fromURString(receiveState.targetUr);
+	const signerPrivateKeys = owner.xidDocument().inceptionPrivateKeys();
+	if (signerPrivateKeys === void 0) throw new Error("Owner XID document has no signing keys");
+	let sealedResponse;
+	let nextShareArid;
+	if (options.rejectReason !== void 0) {
+		const errorBody = Envelope.new("signCommitReject").addAssertion("group", groupId).addAssertion("session", sessionId).addAssertion("reason", options.rejectReason);
+		sealedResponse = SealedResponse.newFailure(sealedRequest.request().id(), owner.xidDocument()).withError(errorBody).withPeerContinuation(sealedRequest.peerContinuation());
+	} else {
+		const [signingNonces, signingCommitments] = signingRound1(keyPackage, createRng());
+		const nextShare = ARID.new();
+		nextShareArid = nextShare;
+		const responseBody = buildResponseBody$1(sessionId, signingCommitments, nextShare);
+		if (options.preview !== true) {
+			persistCommitState(registryPath, groupId, sessionId, receiveState, signingNonces, signingCommitments, targetEnvelope, nextShare);
+			const groupRecordMut = registry.group(groupId);
+			if (groupRecordMut !== null && groupRecordMut !== void 0) {
+				groupRecordMut.setListeningAtArid(nextShare);
+				registry.save(registryPath);
+			}
+		}
+		sealedResponse = SealedResponse.newSuccess(sealedRequest.request().id(), owner.xidDocument()).withResult(responseBody).withPeerContinuation(sealedRequest.peerContinuation());
+	}
+	if (options.preview === true) {
+		const envelopeUr = sealedResponse.toEnvelope(void 0, signerPrivateKeys, void 0).urString();
+		console.log(envelopeUr);
+		return {
+			accepted: options.rejectReason === void 0,
+			envelopeUr
+		};
+	}
+	const validUntil = new Date(Date.now() + 3600 * 1e3);
+	const responseEnvelope = sealedResponse.toEnvelope(validUntil, signerPrivateKeys, receiveState.coordinatorDoc);
+	if (options.storageSelection === void 0) throw new Error("Storage selection is required to post response");
+	const client = await createStorageClient(options.storageSelection);
+	if (options.verbose === true) console.error(`Posting signInvite response to ${receiveState.responseArid.urString()}`);
+	await putWithIndicator(client, receiveState.responseArid, responseEnvelope, "Commitments", options.verbose ?? false);
+	if (options.rejectReason !== void 0) {
+		const groupRecordMut = registry.group(groupId);
+		if (groupRecordMut !== null && groupRecordMut !== void 0) {
+			groupRecordMut.clearListeningAtArid();
+			registry.save(registryPath);
+		}
+	}
+	const result = { accepted: options.rejectReason === void 0 };
+	if (nextShareArid !== void 0) result.listeningArid = nextShareArid.urString();
+	return result;
+}
+
+//#endregion
+//#region src/cmd/sign/participant/round2.ts
+/**
+* Sign participant round 2 command.
+*
+* Port of cmd/sign/participant/round2.rs from frost-hubert-rust.
+*
+* @module
+*/
+/**
+* Load receive state from sign_receive.json.
+*
+* Port of `load_receive_state()` from cmd/sign/participant/round2.rs.
+*/
+function loadReceiveState$1(registryPath, sessionId, groupHint) {
+	const base = path.dirname(registryPath);
+	const groupStateDir = path.join(base, "group-state");
+	let groupDirs;
+	if (groupHint) groupDirs = [[groupHint, path.join(groupStateDir, groupHint.hex())]];
+	else {
+		groupDirs = [];
+		if (fs.existsSync(groupStateDir)) {
+			for (const entry of fs.readdirSync(groupStateDir, { withFileTypes: true })) if (entry.isDirectory() && entry.name.length === 64 && /^[0-9a-f]+$/i.test(entry.name)) {
+				const groupId = ARID.fromHex(entry.name);
+				groupDirs.push([groupId, path.join(groupStateDir, entry.name)]);
+			}
+		}
+	}
+	const candidates = [];
+	for (const [groupId, groupDir] of groupDirs) {
+		const candidate = path.join(groupDir, "signing", sessionId.hex(), "sign_receive.json");
+		if (fs.existsSync(candidate)) candidates.push([groupId, candidate]);
+	}
+	if (candidates.length === 0) throw new Error("No sign_receive.json found for this session; run `frost sign participant receive` first");
+	if (candidates.length > 1) throw new Error("Multiple groups contain this session; use --group to disambiguate");
+	const [groupId, statePath] = candidates[0];
+	const raw = JSON.parse(fs.readFileSync(statePath, "utf-8"));
+	const getStr = (key) => {
+		const value = raw[key];
+		if (typeof value !== "string") throw new Error(`Missing or invalid ${key} in sign_receive.json`);
+		return value;
+	};
+	const sessionInState = parseAridUr(getStr("session"));
+	if (sessionInState.urString() !== sessionId.urString()) throw new Error(`Session ${sessionInState.urString()} in sign_receive.json does not match requested session ${sessionId.urString()}`);
+	const groupInState = parseAridUr(getStr("group"));
+	if (groupInState.urString() !== groupId.urString()) throw new Error(`Group ${groupInState.urString()} in sign_receive.json does not match directory group ${groupId.urString()}`);
+	const participantsVal = raw["participants"];
+	if (!participantsVal || !Array.isArray(participantsVal)) throw new Error("Missing participants in sign_receive.json");
+	const participants = [];
+	for (const entry of participantsVal) {
+		if (typeof entry !== "string") throw new Error("Invalid participant entry in sign_receive.json");
+		participants.push(XID.fromURString(entry));
+	}
+	const minSigners = raw["min_signers"];
+	if (typeof minSigners !== "number") throw new Error("Missing min_signers in sign_receive.json");
+	return {
+		groupId,
+		participants,
+		minSigners,
+		targetUr: getStr("target")
+	};
+}
+/**
+* Load commit state from commit.json (includes nonces).
+*
+* Port of `load_commit_state()` from cmd/sign/participant/round2.rs.
+*/
+function loadCommitState(registryPath, groupId, sessionId) {
+	const dir = signingStateDir(registryPath, groupId.hex(), sessionId.hex());
+	const statePath = path.join(dir, "commit.json");
+	if (!fs.existsSync(statePath)) throw new Error(`Commit state not found at ${statePath}. Run \`frost sign participant commit\` first.`);
+	const raw = JSON.parse(fs.readFileSync(statePath, "utf-8"));
+	const getStr = (key) => {
+		const value = raw[key];
+		if (typeof value !== "string") throw new Error(`Missing or invalid ${key} in commit.json`);
+		return value;
+	};
+	const sessionInState = parseAridUr(getStr("session"));
+	if (sessionInState.urString() !== sessionId.urString()) throw new Error(`Session ${sessionInState.urString()} in commit.json does not match requested session ${sessionId.urString()}`);
+	const nextShareArid = parseAridUr(getStr("next_share_arid"));
+	const targetUr = getStr("target");
+	const noncesRaw = raw["signing_nonces"];
+	if (!noncesRaw) throw new Error("Missing signing_nonces in commit.json");
+	const hidingNonce = Nonce.deserialize(Ed25519Sha512, serde.hexToBytes(noncesRaw["hiding"]));
+	const bindingNonce = Nonce.deserialize(Ed25519Sha512, serde.hexToBytes(noncesRaw["binding"]));
+	const signingNonces = SigningNonces.fromNonces(Ed25519Sha512, hidingNonce, bindingNonce);
+	const commitmentsRaw = raw["signing_commitments"];
+	if (!commitmentsRaw) throw new Error("Missing signing_commitments in commit.json");
+	return {
+		nextShareArid,
+		targetUr,
+		signingNonces,
+		signingCommitments: deserializeSigningCommitments(commitmentsRaw)
+	};
+}
+/**
+* Validate the incoming GSTP request.
+*
+* Port of request validation logic from cmd/sign/participant/round2.rs.
+*/
+function validateShareRequest(sealedRequest, sessionId, expectedCoordinator) {
+	const expectedFunction = Function.fromString("signRound2");
+	if (sealedRequest.function().equals(expectedFunction) !== true) throw new Error(`Unexpected request function: ${String(sealedRequest.function())}`);
+	if (sealedRequest.id().urString() !== sessionId.urString()) throw new Error(`Session ID mismatch (request ${sealedRequest.id().urString()}, expected ${sessionId.urString()})`);
+	if (sealedRequest.sender().xid().urString() !== expectedCoordinator.urString()) throw new Error(`Unexpected request sender: ${sealedRequest.sender().xid().urString()} (expected coordinator ${expectedCoordinator.urString()})`);
+}
+/**
+* Extract all commitments from the signRound2 request.
+*
+* Port of `parse_commitments()` from cmd/sign/participant/round2.rs.
+*/
+function extractCommitments(sealedRequest, receiveState) {
+	const commitments = /* @__PURE__ */ new Map();
+	const commitmentObjects = sealedRequest.objectsForParameter("commitment");
+	for (const entry of commitmentObjects) {
+		const xid = XID.fromTaggedCbor(entry.subject().tryLeaf());
+		const commitmentsObjects = entry.objectsForPredicate("commitments");
+		if (commitmentsObjects.length === 0) throw new Error(`Missing commitments for participant ${xid.urString()}`);
+		const commitmentsJson = JSON$1.fromTaggedCbor(commitmentsObjects[0].subject().tryLeaf());
+		const signingCommitments = deserializeSigningCommitments(JSON.parse(commitmentsJson.asStr()));
+		const xidUr = xid.urString();
+		if (commitments.has(xidUr)) throw new Error(`Duplicate commitments for participant ${xidUr}`);
+		commitments.set(xidUr, signingCommitments);
+	}
+	if (commitments.size === 0) throw new Error("signRound2 request contains no commitments");
+	const expectedSet = new Set(receiveState.participants.map((p) => p.urString()));
+	const actualSet = new Set(commitments.keys());
+	const missing = [];
+	const extra = [];
+	for (const xid of expectedSet) if (!actualSet.has(xid)) missing.push(xid);
+	for (const xid of actualSet) if (!expectedSet.has(xid)) extra.push(xid);
+	if (missing.length > 0 || extra.length > 0) throw new Error(`signRound2 commitments do not match session participants (missing: ${missing.join(", ")}; extra: ${extra.join(", ")})`);
+	return commitments;
+}
+/**
+* Build a map from XID to FROST identifier (sorted participant order).
+*
+* Port of `xid_identifier_map()` from cmd/sign/participant/round2.rs.
+*/
+function xidIdentifierMap$1(participants) {
+	const map = /* @__PURE__ */ new Map();
+	for (let i = 0; i < participants.length; i++) {
+		const identifier = identifierFromU16(i + 1);
+		map.set(participants[i].urString(), identifier);
+	}
+	return map;
+}
+/**
+* Build signing commitments with identifiers.
+*
+* Port of `commitments_with_identifiers()` from cmd/sign/participant/round2.rs.
+*/
+function commitmentsWithIdentifiers$1(commitments, xidToIdentifier) {
+	const mapped = /* @__PURE__ */ new Map();
+	for (const [xidUr, commits] of commitments) {
+		const identifier = xidToIdentifier.get(xidUr);
+		if (!identifier) throw new Error(`Unknown participant ${xidUr}`);
+		mapped.set(identifier, commits);
+	}
+	return mapped;
+}
+/**
+* Build the signRound2Response body envelope.
+*
+* Port of response body construction from cmd/sign/participant/round2.rs.
+*/
+function buildResponseBody(sessionId, signatureShare, finalizeArid) {
+	const shareHex = serializeSignatureShare(signatureShare);
+	const shareJson = JSON$1.fromString(JSON.stringify({ share: shareHex }));
+	return Envelope.unit().addType("signRound2Response").addAssertion("session", sessionId).addAssertion("signature_share", shareJson).addAssertion("response_arid", finalizeArid);
+}
+/**
+* Persist share state to share.json.
+*
+* Port of `persist_share_state()` from cmd/sign/participant/round2.rs.
+*/
+function persistShareState(registryPath, groupId, sessionId, responseArid, finalizeArid, signatureShare, commitments) {
+	const dir = signingStateDir(registryPath, groupId.hex(), sessionId.hex());
+	fs.mkdirSync(dir, { recursive: true });
+	const commitmentsJson = {};
+	for (const [xidUr, commits] of commitments) commitmentsJson[xidUr] = serializeSigningCommitments(commits);
+	const root = {
+		session: sessionId.urString(),
+		response_arid: responseArid.urString(),
+		finalize_arid: finalizeArid.urString(),
+		signature_share: { share: serializeSignatureShare(signatureShare) },
+		commitments: commitmentsJson
+	};
+	fs.writeFileSync(path.join(dir, "share.json"), JSON.stringify(root, null, 2));
+}
+/**
+* Execute the sign participant round 2 command.
+*
+* Receives round 2 request and sends signature share.
+*
+* Port of `CommandArgs::exec()` from cmd/sign/participant/round2.rs.
+*/
+async function round2$1(client, options, cwd) {
+	const registryPath = resolveRegistryPath(options.registryPath, cwd);
+	const registry = Registry.load(registryPath);
+	const owner = registry.owner();
+	if (!owner) throw new Error("Registry owner is required");
+	const ownerXidDocument = owner.xidDocument();
+	const sessionId = parseAridUr(options.sessionId);
+	const receiveState = loadReceiveState$1(registryPath, sessionId, options.groupId ? parseAridUr(options.groupId) : void 0);
+	const groupId = receiveState.groupId;
+	const groupRecord = registry.group(groupId);
+	if (!groupRecord) throw new Error("Group not found in registry");
+	if (groupRecord.minSigners() !== receiveState.minSigners) throw new Error(`Session min_signers ${receiveState.minSigners} does not match registry ${groupRecord.minSigners()}`);
+	const registryParticipants = new Set(groupRecord.participants().map((p) => p.xid().urString()));
+	const sessionParticipants = new Set(receiveState.participants.map((p) => p.urString()));
+	if (registryParticipants.size !== sessionParticipants.size || ![...registryParticipants].every((p) => sessionParticipants.has(p))) throw new Error("Session participants do not match registry group participants");
+	if (!sessionParticipants.has(owner.xid().urString())) throw new Error("This participant is not part of the signing session");
+	const listeningAtArid = groupRecord.listeningAtArid();
+	if (!listeningAtArid) throw new Error("No listening ARID for signRound2. Did you run `frost sign participant commit`?");
+	const commitState = loadCommitState(registryPath, groupId, sessionId);
+	if (commitState.nextShareArid.urString() !== listeningAtArid.urString()) throw new Error(`Listening ARID in registry (${listeningAtArid.urString()}) does not match persisted commit state (${commitState.nextShareArid.urString()})`);
+	if (commitState.targetUr !== receiveState.targetUr) throw new Error("Target envelope in commit state does not match persisted signInvite request");
+	const keyPackagePath = groupRecord.contributions().keyPackage;
+	if (!keyPackagePath) throw new Error("Key package path not found; did you finish DKG?");
+	const keyPackage = deserializeKeyPackage(JSON.parse(fs.readFileSync(keyPackagePath, "utf-8")).key_package);
+	const finalizeArid = ARID.new();
+	const targetDigest = Envelope.fromURString(receiveState.targetUr).subject().digest();
+	if (options.verbose === true) console.error("Fetching signRound2 request from Hubert...");
+	const requestEnvelope = await getWithIndicator(client, listeningAtArid, "signRound2 request", options.timeoutSeconds, options.verbose ?? false);
+	if (!requestEnvelope) throw new Error("signRound2 request not found in Hubert storage");
+	const signerPrivateKeys = ownerXidDocument.inceptionPrivateKeys();
+	if (!signerPrivateKeys) throw new Error("Owner XID document has no private keys");
+	const { SealedRequest: SealedRequestClass } = __require("@bcts/gstp");
+	const now = CborDate.now();
+	const sealedRequest = SealedRequestClass.tryFromEnvelope(requestEnvelope, void 0, now, signerPrivateKeys);
+	const expectedCoordinator = groupRecord.coordinator().xid();
+	validateShareRequest(sealedRequest, sessionId, expectedCoordinator);
+	const responseArid = sealedRequest.extractObjectForParameter("response_arid");
+	const commitmentsByXid = extractCommitments(sealedRequest, receiveState);
+	const myCommitments = commitmentsByXid.get(owner.xid().urString());
+	if (!myCommitments) throw new Error("signRound2 request missing commitments for this participant");
+	const myCommitmentsSerialized = serializeSigningCommitments(myCommitments);
+	const storedCommitmentsSerialized = serializeSigningCommitments(commitState.signingCommitments);
+	if (myCommitmentsSerialized.hiding !== storedCommitmentsSerialized.hiding || myCommitmentsSerialized.binding !== storedCommitmentsSerialized.binding) throw new Error("signRound2 request commitments do not match locally stored commitments");
+	const xidToIdentifier = xidIdentifierMap$1(receiveState.participants);
+	if (!xidToIdentifier.get(owner.xid().urString())) throw new Error("Identifier for participant not found");
+	if (keyPackage.minSigners !== receiveState.minSigners) throw new Error(`Key package min_signers ${keyPackage.minSigners} does not match session ${receiveState.minSigners}`);
+	if (commitmentsByXid.size < receiveState.minSigners) throw new Error(`signRound2 request contained ${commitmentsByXid.size} commitments but requires at least ${receiveState.minSigners} signers`);
+	const signatureShare = signingRound2(createSigningPackage(commitmentsWithIdentifiers$1(commitmentsByXid, xidToIdentifier), targetDigest.data()), commitState.signingNonces, keyPackage);
+	const responseBody = buildResponseBody(sessionId, signatureShare, finalizeArid);
+	const { SealedResponse: SealedResponseClass } = __require("@bcts/gstp");
+	const sealedResponse = SealedResponseClass.newSuccess(sealedRequest.id(), ownerXidDocument).withResult(responseBody);
+	if (options.preview === true) {
+		const unsealed = sealedResponse.toEnvelope(void 0, signerPrivateKeys, void 0);
+		console.log(unsealed.urString());
+		return { listeningArid: finalizeArid.urString() };
+	}
+	let coordinatorDoc;
+	if (expectedCoordinator.urString() === owner.xid().urString()) coordinatorDoc = ownerXidDocument;
+	else {
+		const coordinatorRecord = registry.participant(expectedCoordinator);
+		if (!coordinatorRecord) throw new Error(`Coordinator ${expectedCoordinator.urString()} not found in registry`);
+		coordinatorDoc = coordinatorRecord.xidDocument();
+	}
+	const expiry = CborDate.withDurationFromNow(3600);
+	await putWithIndicator(client, responseArid, sealedResponse.toEnvelope(expiry, signerPrivateKeys, coordinatorDoc), "Signature Share", options.verbose ?? false);
+	persistShareState(registryPath, groupId, sessionId, responseArid, finalizeArid, signatureShare, commitmentsByXid);
+	const groupRecordMutable = registry.group(groupId);
+	if (groupRecordMutable) {
+		groupRecordMutable.setListeningAtArid(finalizeArid);
+		registry.save(registryPath);
+	}
+	if (options.verbose === true) console.error(`Posted signature share to ${responseArid.urString()}`);
+	return { listeningArid: finalizeArid.urString() };
+}
+
+//#endregion
+//#region src/cmd/sign/participant/finalize.ts
+/**
+* Sign participant finalize command.
+*
+* Port of cmd/sign/participant/finalize.rs from frost-hubert-rust.
+*
+* @module
+*/
+/**
+* Load the receive state for a signing session.
+*
+* Searches for sign_receive.json in group-state directories.
+*
+* Port of `load_receive_state()` from cmd/sign/participant/finalize.rs.
+*/
+function loadReceiveState(registryPath, sessionId, groupHint) {
+	const base = path.dirname(registryPath);
+	const groupStateDir = path.join(base, "group-state");
+	const groupDirs = [];
+	if (groupHint !== void 0) groupDirs.push([groupHint, path.join(groupStateDir, groupHint.hex())]);
+	else if (fs.existsSync(groupStateDir)) {
+		for (const entry of fs.readdirSync(groupStateDir, { withFileTypes: true })) if (entry.isDirectory()) {
+			const name = entry.name;
+			if (name.length === 64 && /^[0-9a-f]+$/i.test(name)) {
+				const groupId = ARID.fromHex(name);
+				groupDirs.push([groupId, path.join(groupStateDir, name)]);
+			}
+		}
+	}
+	const candidates = [];
+	for (const [groupId, groupDir] of groupDirs) {
+		const candidate = path.join(groupDir, "signing", sessionId.hex(), "sign_receive.json");
+		if (fs.existsSync(candidate)) candidates.push([groupId, candidate]);
+	}
+	if (candidates.length === 0) throw new Error("No sign_receive.json found for this session; run `frost sign participant receive` first");
+	if (candidates.length > 1) throw new Error("Multiple groups contain this session; use --group to disambiguate");
+	const [groupId, filePath] = candidates[0];
+	const raw = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+	const getStr = (key) => {
+		const val = raw[key];
+		if (typeof val !== "string") throw new Error(`Missing or invalid ${key} in sign_receive.json`);
+		return val;
+	};
+	const sessionInState = parseAridUr(getStr("session"));
+	if (sessionInState.hex() !== sessionId.hex()) throw new Error(`Session ${sessionInState.urString()} in sign_receive.json does not match requested session ${sessionId.urString()}`);
+	const groupInState = parseAridUr(getStr("group"));
+	if (groupInState.hex() !== groupId.hex()) throw new Error(`Group ${groupInState.urString()} in sign_receive.json does not match directory group ${groupId.urString()}`);
+	const coordinator = XID.fromURString(getStr("coordinator"));
+	const participantsVal = raw["participants"];
+	if (!Array.isArray(participantsVal)) throw new Error("Missing participants in sign_receive.json");
+	const participants = [];
+	for (const entry of participantsVal) {
+		if (typeof entry !== "string") throw new Error("Invalid participant entry in sign_receive.json");
+		participants.push(XID.fromURString(entry));
+	}
+	const minSignersVal = raw["min_signers"];
+	if (typeof minSignersVal !== "number") throw new Error("Missing min_signers in sign_receive.json");
+	const minSigners = minSignersVal;
+	const targetUr = getStr("target");
+	participants.sort((a, b) => a.urString().localeCompare(b.urString()));
+	return {
+		groupId,
+		coordinator,
+		participants,
+		minSigners,
+		targetUr
+	};
+}
+/**
+* Load the share state for a signing session.
+*
+* Port of `load_share_state()` from cmd/sign/participant/finalize.rs.
+*/
+function loadShareState(registryPath, groupId, sessionId) {
+	const dir = signingStateDir(registryPath, groupId.hex(), sessionId.hex());
+	const filePath = path.join(dir, "share.json");
+	if (!fs.existsSync(filePath)) throw new Error(`Signature share state not found at ${filePath}. Run \`frost sign participant share\` first.`);
+	const raw = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+	const getStr = (key) => {
+		const val = raw[key];
+		if (typeof val !== "string") throw new Error(`Missing or invalid ${key} in share.json`);
+		return val;
+	};
+	const sessionInState = parseAridUr(getStr("session"));
+	if (sessionInState.hex() !== sessionId.hex()) throw new Error(`Session ${sessionInState.urString()} in share.json does not match requested session ${sessionId.urString()}`);
+	const finalizeArid = parseAridUr(getStr("finalize_arid"));
+	const signatureShare = deserializeSignatureShare(getStr("signature_share"));
+	const commitmentsVal = raw["commitments"];
+	if (typeof commitmentsVal !== "object" || commitmentsVal === null) throw new Error("Missing commitments map in share.json");
+	const commitments = /* @__PURE__ */ new Map();
+	for (const [xidStr, value] of Object.entries(commitmentsVal)) {
+		const commits = deserializeSigningCommitments(value);
+		commitments.set(xidStr, commits);
+	}
+	return {
+		finalizeArid,
+		signatureShare,
+		commitments
+	};
+}
+/**
+* Validate that session state is consistent with registry and owner.
+*
+* Port of `validate_session_state()` from cmd/sign/participant/finalize.rs.
+*/
+function validateSessionState(receiveState, groupRecord, owner) {
+	if (receiveState.coordinator.urString() !== groupRecord.coordinator().xid().urString()) throw new Error("Coordinator in session state does not match registry");
+	const ownerXidStr = owner.xid().urString();
+	if (!receiveState.participants.some((p) => p.urString() === ownerXidStr)) throw new Error("This participant is not part of the signing session");
+	if (groupRecord.minSigners() !== receiveState.minSigners) throw new Error(`Session min_signers ${receiveState.minSigners} does not match registry ${groupRecord.minSigners()}`);
+}
+/**
+* Validate share state against receive state and registry.
+*
+* Port of `validate_share_state()` from cmd/sign/participant/finalize.rs.
+*/
+function validateShareState(shareState, receiveState, groupRecord) {
+	const listeningAtArid = groupRecord.listeningAtArid();
+	if (listeningAtArid === void 0) throw new Error("No listening ARID for signFinalize. Did you run `frost sign participant share`?");
+	if (shareState.finalizeArid.hex() !== listeningAtArid.hex()) throw new Error(`Registry listening ARID (${listeningAtArid.urString()}) does not match persisted finalize ARID (${shareState.finalizeArid.urString()})`);
+	const commitParticipants = new Set(shareState.commitments.keys());
+	const sessionParticipants = new Set(receiveState.participants.map((p) => p.urString()));
+	if (commitParticipants.size !== sessionParticipants.size) throw new Error("Commitments do not match session participants");
+	for (const p of commitParticipants) if (!sessionParticipants.has(p)) throw new Error("Commitments do not match session participants");
+}
+/**
+* Validate the finalize event.
+*
+* Port of `validate_finalize_event()` from cmd/sign/participant/finalize.rs.
+*/
+function validateFinalizeEvent(sealedEvent, sessionId, groupRecord) {
+	const sessionEnvelope = sealedEvent.content().objectForPredicate("session");
+	if (sessionEnvelope === void 0) throw new Error("Missing session in finalize event");
+	const eventSession = ARID.fromTaggedCbor(sessionEnvelope.subject().tryLeaf());
+	if (eventSession.hex() !== sessionId.hex()) throw new Error(`Event session ${eventSession.urString()} does not match expected ${sessionId.urString()}`);
+	const expectedCoordinator = groupRecord.coordinator().xid();
+	if (sealedEvent.sender().xid().urString() !== expectedCoordinator.urString()) throw new Error(`Unexpected event sender: ${sealedEvent.sender().xid().urString()} (expected coordinator ${expectedCoordinator.urString()})`);
+}
+/**
+* Validate signature shares from the finalize event.
+*
+* Port of `validate_signature_shares()` from cmd/sign/participant/finalize.rs.
+*/
+function validateSignatureShares(signatureSharesByXid, receiveState, _shareState, owner) {
+	if (signatureSharesByXid.size < receiveState.minSigners) throw new Error(`Finalize package contains ${signatureSharesByXid.size} signature shares but requires at least ${receiveState.minSigners}`);
+	const sharesParticipants = new Set(signatureSharesByXid.keys());
+	const sessionParticipants = new Set(receiveState.participants.map((p) => p.urString()));
+	if (sharesParticipants.size !== sessionParticipants.size) throw new Error("Signature share set does not match session participants");
+	for (const p of sharesParticipants) if (!sessionParticipants.has(p)) throw new Error("Signature share set does not match session participants");
+	const ownerXidStr = owner.xid().urString();
+	if (signatureSharesByXid.get(ownerXidStr) === void 0) throw new Error("Finalize package is missing this participant's signature share");
+}
+/**
+* Fetch and parse the finalize event from storage.
+*
+* Port of `fetch_finalize_event()` from cmd/sign/participant/finalize.rs.
+*/
+async function fetchFinalizeEvent(client, finalizeArid, timeout, owner) {
+	if (isVerbose()) console.error("Fetching finalize package from Hubert...");
+	const finalizeEnvelope = await getWithIndicator(client, finalizeArid, "Finalize package", timeout, isVerbose());
+	if (finalizeEnvelope === null || finalizeEnvelope === void 0) throw new Error("Finalize package not found in Hubert storage");
+	const signerKeys = owner.xidDocument().inceptionPrivateKeys();
+	if (signerKeys === void 0) throw new Error("Owner XID document has no inception private keys");
+	return SealedEvent.tryFromEnvelope(finalizeEnvelope, void 0, void 0, signerKeys, (env) => {
+		SignFinalizeContent.fromEnvelope(env);
+		return env;
+	});
+}
+/**
+* Parse signature shares from the finalize event.
+*
+* Port of `parse_signature_shares()` from cmd/sign/participant/finalize.rs.
+*/
+function parseSignatureShares(event) {
+	const contentEnvelope = event.content();
+	const shares = /* @__PURE__ */ new Map();
+	const entries = contentEnvelope.objectsForPredicate("signature_share");
+	for (const entry of entries) {
+		const xid = XID.fromTaggedCbor(entry.subject().tryLeaf());
+		const shareEnvelope = entry.objectForPredicate("share");
+		if (shareEnvelope === void 0) throw new Error("Missing share in signature_share entry");
+		const share = deserializeSignatureShare(shareEnvelope.extractString());
+		const xidStr = xid.urString();
+		if (shares.has(xidStr)) throw new Error(`Duplicate signature share for participant ${xidStr}`);
+		shares.set(xidStr, share);
+	}
+	if (shares.size === 0) throw new Error("Finalize package contains no signature shares");
+	return shares;
+}
+/**
+* Build a mapping from XID to FROST identifier.
+*
+* Port of `xid_identifier_map()` from cmd/sign/participant/finalize.rs.
+*/
+function xidIdentifierMap(participants) {
+	const map = /* @__PURE__ */ new Map();
+	for (let i = 0; i < participants.length; i++) {
+		const xid = participants[i];
+		const identifier = identifierFromU16(i + 1);
+		map.set(xid.urString(), identifier);
+	}
+	return map;
+}
+/**
+* Convert commitments from XID-keyed to Identifier-keyed map.
+*
+* Port of `commitments_with_identifiers()` from cmd/sign/participant/finalize.rs.
+*/
+function commitmentsWithIdentifiers(commitments, xidToIdentifier) {
+	const mapped = /* @__PURE__ */ new Map();
+	for (const [xidStr, commits] of commitments) {
+		const identifier = xidToIdentifier.get(xidStr);
+		if (identifier === void 0) throw new Error(`Unknown participant ${xidStr}`);
+		mapped.set(identifier, commits);
+	}
+	return mapped;
+}
+/**
+* Convert signature shares from XID-keyed to Identifier-keyed map.
+*
+* Port of `signature_shares_with_identifiers()` from cmd/sign/participant/finalize.rs.
+*/
+function signatureSharesWithIdentifiers(shares, xidToIdentifier) {
+	const mapped = /* @__PURE__ */ new Map();
+	for (const [xidStr, share] of shares) {
+		const identifier = xidToIdentifier.get(xidStr);
+		if (identifier === void 0) throw new Error(`Unknown participant ${xidStr}`);
+		mapped.set(identifier, share);
+	}
+	return mapped;
+}
+/**
+* Load the public key package for a group.
+*
+* Port of `load_public_key_package()` from cmd/sign/participant/finalize.rs.
+*/
+function loadPublicKeyPackage(registryPath, groupId) {
+	const base = path.dirname(registryPath);
+	const directPath = path.join(base, "group-state", groupId.hex(), "public_key_package.json");
+	if (fs.existsSync(directPath)) {
+		const raw = JSON.parse(fs.readFileSync(directPath, "utf-8"));
+		return {
+			package: deserializePublicKeyPackage(raw),
+			verifyingKeyHex: raw.verifyingKey
+		};
+	}
+	const collectedPath = path.join(base, "group-state", groupId.hex(), "collected_finalize.json");
+	if (fs.existsSync(collectedPath)) {
+		const raw = JSON.parse(fs.readFileSync(collectedPath, "utf-8"));
+		const firstEntry = Object.values(raw)[0];
+		if (firstEntry === void 0) throw new Error("collected_finalize.json is empty");
+		const publicKeyValue = firstEntry["public_key_package"];
+		if (publicKeyValue === void 0) throw new Error("public_key_package missing in collected_finalize.json");
+		return {
+			package: deserializePublicKeyPackage(publicKeyValue),
+			verifyingKeyHex: publicKeyValue.verifyingKey
+		};
+	}
+	throw new Error(`Public key package not found for group ${groupId.urString()}; run finalize respond/collect first`);
+}
+/**
+* Aggregate signature shares and verify the result.
+*
+* Port of `aggregate_and_verify_signature()` from cmd/sign/participant/finalize.rs.
+*/
+function aggregateAndVerifySignature(registryPath, groupId, participants, commitments, signatureSharesByXid, targetEnvelope, targetDigest) {
+	const xidToIdentifier = xidIdentifierMap(participants);
+	const signingPackage = createSigningPackage(commitmentsWithIdentifiers(commitments, xidToIdentifier), targetDigest.data());
+	const signatureSharesByIdentifier = signatureSharesWithIdentifiers(signatureSharesByXid, xidToIdentifier);
+	const { package: publicKeyPackage, verifyingKeyHex } = loadPublicKeyPackage(registryPath, groupId);
+	const verifyingKey = signingKeyFromVerifying(hexToBytes$1(verifyingKeyHex));
+	const sigBytes = serializeSignature(aggregateSignatures(signingPackage, signatureSharesByIdentifier, publicKeyPackage));
+	if (sigBytes.length !== 64) throw new Error("Aggregated signature is not 64 bytes");
+	const finalSignature = Signature.ed25519FromData(sigBytes);
+	if (!verifyingKey.verify(finalSignature, targetDigest.data())) throw new Error("Aggregated signature failed verification against target digest");
+	const signedEnvelope = targetEnvelope.addAssertion("signed", finalSignature);
+	signedEnvelope.verifySignatureFrom(verifyingKey);
+	return [
+		finalSignature,
+		signedEnvelope,
+		verifyingKey
+	];
+}
+/**
+* Update the registry verifying key if needed.
+*
+* Port of `update_registry_verifying_key()` from cmd/sign/participant/finalize.rs.
+*/
+function updateRegistryVerifyingKey(registry, registryPath, groupId, verifyingKey, groupRecord) {
+	const existing = groupRecord.verifyingKey();
+	if (existing !== void 0) {
+		if (existing.urString() !== verifyingKey.urString()) throw new Error("Registry verifying key does not match finalize package");
+	} else {
+		const mutableGroup = registry.group(groupId);
+		if (mutableGroup === void 0) throw new Error("Group not found in registry");
+		mutableGroup.setVerifyingKey(verifyingKey);
+		registry.save(registryPath);
+	}
+}
+/**
+* Persist the final state to disk.
+*
+* Port of `persist_final_state()` from cmd/sign/participant/finalize.rs.
+*/
+function persistFinalState(registryPath, groupId, sessionId, signature, signedEnvelope, signatureShares, shareState) {
+	const dir = signingStateDir(registryPath, groupId.hex(), sessionId.hex());
+	fs.mkdirSync(dir, { recursive: true });
+	const finalPath = path.join(dir, "final.json");
+	let root = {};
+	if (fs.existsSync(finalPath)) root = JSON.parse(fs.readFileSync(finalPath, "utf-8"));
+	const sharesJson = {};
+	for (const [xidStr, share] of signatureShares) sharesJson[xidStr] = serializeSignatureShare(share);
+	const commitmentsJson = {};
+	for (const [xidStr, commits] of shareState.commitments) commitmentsJson[xidStr] = serializeSigningCommitments(commits);
+	root["group"] = groupId.urString();
+	root["session"] = sessionId.urString();
+	root["signature"] = signature.urString();
+	root["signature_shares"] = sharesJson;
+	root["commitments"] = commitmentsJson;
+	root["finalize_arid"] = shareState.finalizeArid.urString();
+	root["signed_target"] = signedEnvelope.urString();
+	fs.writeFileSync(finalPath, JSON.stringify(root, null, 2));
+}
+/**
+* Execute the sign participant finalize command.
+*
+* Receives the finalize event with aggregated signature.
+*
+* Port of `finalize()` from cmd/sign/participant/finalize.rs.
+*/
+async function finalize(client, options, cwd) {
+	const registryPath = resolveRegistryPath(options.registryPath, cwd);
+	const registry = Registry.load(registryPath);
+	const owner = registry.owner();
+	if (owner === void 0) throw new Error("Registry owner is required");
+	const sessionId = parseAridUr(options.sessionId);
+	const receiveState = loadReceiveState(registryPath, sessionId, options.groupId !== void 0 && options.groupId !== "" ? parseAridUr(options.groupId) : void 0);
+	const groupId = receiveState.groupId;
+	const groupRecord = registry.group(groupId);
+	if (groupRecord === void 0) throw new Error("Group not found in registry");
+	validateSessionState(receiveState, groupRecord, owner);
+	const shareState = loadShareState(registryPath, groupId, sessionId);
+	validateShareState(shareState, receiveState, groupRecord);
+	const sealedEvent = await fetchFinalizeEvent(client, shareState.finalizeArid, options.timeoutSeconds, owner);
+	validateFinalizeEvent(sealedEvent, sessionId, groupRecord);
+	const signatureSharesByXid = parseSignatureShares(sealedEvent);
+	validateSignatureShares(signatureSharesByXid, receiveState, shareState, owner);
+	const targetEnvelope = Envelope.fromURString(receiveState.targetUr);
+	const targetDigest = targetEnvelope.subject().digest();
+	const [finalSignature, signedEnvelope, verifyingKey] = aggregateAndVerifySignature(registryPath, groupId, receiveState.participants, shareState.commitments, signatureSharesByXid, targetEnvelope, targetDigest);
+	updateRegistryVerifyingKey(registry, registryPath, groupId, verifyingKey, groupRecord);
+	persistFinalState(registryPath, groupId, sessionId, finalSignature, signedEnvelope, signatureSharesByXid, shareState);
+	const mutableGroupRecord = registry.group(groupId);
+	if (mutableGroupRecord !== void 0) {
+		mutableGroupRecord.clearListeningAtArid();
+		registry.save(registryPath);
+	}
+	const signatureStr = finalSignature.urString();
+	const signedEnvelopeStr = signedEnvelope.urString();
+	if (options.verbose === true) {
+		console.log(signatureStr);
+		console.log(signedEnvelopeStr);
+	}
+	return {
+		signature: signatureStr,
+		signedEnvelope: signedEnvelopeStr
+	};
+}
+
+//#endregion
+//#region src/cmd/sign/participant/index.ts
+var participant_exports = /* @__PURE__ */ __exportAll({
+	finalize: () => finalize,
+	receive: () => receive,
+	round1: () => round1$1,
+	round2: () => round2$1
+});
+
+//#endregion
+//#region src/cmd/sign/index.ts
+var sign_exports = /* @__PURE__ */ __exportAll({
+	SignFinalizeContent: () => SignFinalizeContent,
+	coordinator: () => coordinator_exports,
+	participant: () => participant_exports,
+	signingStateDir: () => signingStateDir,
+	signingStateDirForGroup: () => signingStateDirForGroup
+});
+
+//#endregion
+export { setVerbose as C, isVerbose as S, parallelFetchConfigWithTimeout as _, CollectionResult as a, putWithIndicator as b, buildFetchRequests as c, fetchStatusError as d, fetchStatusPending as f, parallelFetch as g, fetchStatusTimeout as h, createStorageClient as i, directionEmoji as l, fetchStatusSuccess as m, dkg_exports as n, DEFAULT_TIMEOUT_SECONDS as o, fetchStatusRejected as p, checkAridExists as r, Direction as s, sign_exports as t, emptyCollectionResult as u, parallelSend as v, groupStateDir as x, getWithIndicator as y };
+//# sourceMappingURL=cmd-C8pmNd28.mjs.map