@bcts/frost-hubert 1.0.0-alpha.21 → 1.0.0-alpha.23

package/dist/registry/index.cjs

@@ -1,14 +1,807 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_registry_impl = require('../registry-impl-C7w4awTv.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_chunk = require("../chunk-CZWwpsFl.cjs");
+let _bcts_components = require("@bcts/components");
+let _bcts_envelope = require("@bcts/envelope");
+let _bcts_xid = require("@bcts/xid");
+let _bcts_uniform_resources = require("@bcts/uniform-resources");
+let node_fs = require("node:fs");
+node_fs = require_chunk.__toESM(node_fs, 1);
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path, 1);
+//#region src/registry/group-record.ts
+/**
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
+*
+*
+* Group record for the registry.
+*
+* Port of registry/group_record.rs from frost-hubert-rust.
+*
+* @module
+*/
+/**
+* A participant in a group.
+*
+* Port of `struct GroupParticipant` from group_record.rs lines 9-13.
+*/
+var GroupParticipant = class GroupParticipant {
+	_xid;
+	constructor(xid) {
+		this._xid = xid;
+	}
+	xid() {
+		return this._xid;
+	}
+	toJSON() {
+		return this._xid.urString();
+	}
+	static fromJSON(value) {
+		return new GroupParticipant(_bcts_components.XID.fromURString(value));
+	}
+};
+/**
+* Contribution paths for DKG state files.
+*
+* Port of `struct ContributionPaths` from group_record.rs lines 21-29.
+*/
+var ContributionPaths = class ContributionPaths {
+	round1Secret;
+	round1Package;
+	round2Secret;
+	keyPackage;
+	constructor(init) {
+		if (init !== void 0) {
+			this.round1Secret = init.round1Secret;
+			this.round1Package = init.round1Package;
+			this.round2Secret = init.round2Secret;
+			this.keyPackage = init.keyPackage;
+		}
+	}
+	/**
+	* Merge missing fields from another ContributionPaths.
+	*
+	* Port of `ContributionPaths::merge_missing()` from group_record.rs lines 32-45.
+	*/
+	mergeMissing(other) {
+		this.round1Secret ??= other.round1Secret;
+		this.round1Package ??= other.round1Package;
+		this.round2Secret ??= other.round2Secret;
+		this.keyPackage ??= other.keyPackage;
+	}
+	/**
+	* Check if all fields are empty.
+	*
+	* Port of `ContributionPaths::is_empty()` from group_record.rs lines 47-53.
+	*/
+	isEmpty() {
+		return this.round1Secret === void 0 && this.round1Package === void 0 && this.round2Secret === void 0 && this.keyPackage === void 0;
+	}
+	toJSON() {
+		const obj = {};
+		if (this.round1Secret !== void 0) obj["round1_secret"] = this.round1Secret;
+		if (this.round1Package !== void 0) obj["round1_package"] = this.round1Package;
+		if (this.round2Secret !== void 0) obj["round2_secret"] = this.round2Secret;
+		if (this.keyPackage !== void 0) obj["key_package"] = this.keyPackage;
+		return obj;
+	}
+	static fromJSON(json) {
+		return new ContributionPaths({
+			round1Secret: json["round1_secret"],
+			round1Package: json["round1_package"],
+			round2Secret: json["round2_secret"],
+			keyPackage: json["key_package"]
+		});
+	}
+};
+/**
+* Tracks pending communication with participants (coordinator-side).
+*
+* Port of `struct PendingRequests` from group_record.rs lines 71-75.
+*/
+var PendingRequests = class PendingRequests {
+	requests = [];
+	/**
+	* Add a pending request where we only know where to collect from.
+	*
+	* Port of `PendingRequests::add_collect_only()` from group_record.rs lines 90-99.
+	*/
+	addCollectOnly(participant, collectFromArid) {
+		this.requests.push({
+			participant,
+			sendToArid: void 0,
+			collectFromArid
+		});
+	}
+	/**
+	* Add a pending request where we know where to send AND where to collect.
+	*
+	* Port of `PendingRequests::add_send_and_collect()` from group_record.rs lines 103-115.
+	*/
+	addSendAndCollect(participant, sendToArid, collectFromArid) {
+		this.requests.push({
+			participant,
+			sendToArid,
+			collectFromArid
+		});
+	}
+	/**
+	* Add a pending request where we only know where to send.
+	*
+	* Port of `PendingRequests::add_send_only()` from group_record.rs lines 118-127.
+	*/
+	addSendOnly(participant, sendToArid) {
+		this.requests.push({
+			participant,
+			sendToArid,
+			collectFromArid: sendToArid
+		});
+	}
+	/**
+	* Check if there are no pending requests.
+	*
+	* Port of `PendingRequests::is_empty()` from group_record.rs line 129.
+	*/
+	isEmpty() {
+		return this.requests.length === 0;
+	}
+	/**
+	* Get the number of pending requests.
+	*
+	* Port of `PendingRequests::len()` from group_record.rs line 165.
+	*/
+	len() {
+		return this.requests.length;
+	}
+	/**
+	* Iterate over (participant, collectFromArid) pairs.
+	*
+	* Port of `PendingRequests::iter_collect()` from group_record.rs lines 132-138.
+	*/
+	*iterCollect() {
+		for (const r of this.requests) yield [r.participant, r.collectFromArid];
+	}
+	/**
+	* Iterate over (participant, sendToArid) pairs.
+	*
+	* Port of `PendingRequests::iter_send()` from group_record.rs lines 141-150.
+	*/
+	*iterSend() {
+		for (const r of this.requests) {
+			if (r.sendToArid === void 0) throw new Error("send_to_arid not set for this request");
+			yield [r.participant, r.sendToArid];
+		}
+	}
+	/**
+	* Iterate over full (participant, sendToArid, collectFromArid) tuples.
+	*
+	* Port of `PendingRequests::iter_full()` from group_record.rs lines 153-163.
+	*/
+	*iterFull() {
+		for (const r of this.requests) yield [
+			r.participant,
+			r.sendToArid,
+			r.collectFromArid
+		];
+	}
+	toJSON() {
+		return this.requests.map((r) => ({
+			participant: r.participant.urString(),
+			send_to_arid: r.sendToArid?.urString(),
+			collect_from_arid: r.collectFromArid.urString()
+		}));
+	}
+	static fromJSON(json) {
+		const pr = new PendingRequests();
+		for (const entry of json) {
+			const participant = _bcts_components.XID.fromURString(entry["participant"]);
+			const sendToArid = entry["send_to_arid"] !== void 0 && entry["send_to_arid"] !== "" ? _bcts_components.ARID.fromURString(entry["send_to_arid"]) : void 0;
+			const collectFromArid = _bcts_components.ARID.fromURString(entry["collect_from_arid"]);
+			pr.requests.push({
+				participant,
+				sendToArid,
+				collectFromArid
+			});
+		}
+		return pr;
+	}
+};
+/**
+* Record of a DKG group.
+*
+* Port of `struct GroupRecord` from group_record.rs lines 168-186.
+*/
+var GroupRecord = class GroupRecord {
+	_charter;
+	_minSigners;
+	_coordinator;
+	_participants;
+	_contributions;
+	_listeningAtArid;
+	_pendingRequests;
+	_verifyingKey;
+	constructor(charter, minSigners, coordinator, participants) {
+		this._charter = charter;
+		this._minSigners = minSigners;
+		this._coordinator = coordinator;
+		this._participants = participants;
+		this._contributions = new ContributionPaths();
+		this._listeningAtArid = void 0;
+		this._pendingRequests = new PendingRequests();
+		this._verifyingKey = void 0;
+	}
+	coordinator() {
+		return this._coordinator;
+	}
+	participants() {
+		return this._participants;
+	}
+	minSigners() {
+		return this._minSigners;
+	}
+	charter() {
+		return this._charter;
+	}
+	contributions() {
+		return this._contributions;
+	}
+	setContributions(contributions) {
+		this._contributions = contributions;
+	}
+	mergeContributions(other) {
+		this._contributions.mergeMissing(other);
+	}
+	listeningAtArid() {
+		return this._listeningAtArid;
+	}
+	setListeningAtArid(arid) {
+		this._listeningAtArid = arid;
+	}
+	clearListeningAtArid() {
+		this._listeningAtArid = void 0;
+	}
+	pendingRequests() {
+		return this._pendingRequests;
+	}
+	setPendingRequests(requests) {
+		this._pendingRequests = requests;
+	}
+	clearPendingRequests() {
+		this._pendingRequests = new PendingRequests();
+	}
+	/**
+	* Check if the config matches another group record.
+	*
+	* Port of `GroupRecord::config_matches()` from group_record.rs lines 247-253.
+	*/
+	configMatches(other) {
+		return this._charter === other._charter && this._minSigners === other._minSigners && this._coordinator.xid().toString() === other._coordinator.xid().toString() && this._participants.length === other._participants.length && this._participants.every((p, i) => p.xid().toString() === other._participants[i].xid().toString());
+	}
+	verifyingKey() {
+		return this._verifyingKey;
+	}
+	setVerifyingKey(key) {
+		this._verifyingKey = key;
+	}
+	toJSON() {
+		const obj = {
+			charter: this._charter,
+			min_signers: this._minSigners,
+			coordinator: this._coordinator.toJSON(),
+			participants: this._participants.map((p) => p.toJSON())
+		};
+		if (!this._contributions.isEmpty()) obj["contributions"] = this._contributions.toJSON();
+		if (this._listeningAtArid !== void 0) obj["listening_at_arid"] = this._listeningAtArid.urString();
+		if (!this._pendingRequests.isEmpty()) obj["pending_requests"] = this._pendingRequests.toJSON();
+		if (this._verifyingKey !== void 0) obj["verifying_key"] = this._verifyingKey.urString();
+		return obj;
+	}
+	static fromJSON(json) {
+		const charter = json["charter"];
+		const minSigners = json["min_signers"];
+		const record = new GroupRecord(charter, minSigners, GroupParticipant.fromJSON(json["coordinator"]), json["participants"].map((p) => GroupParticipant.fromJSON(p)));
+		if (json["contributions"] !== void 0) record._contributions = ContributionPaths.fromJSON(json["contributions"]);
+		if (json["listening_at_arid"] !== void 0) record._listeningAtArid = _bcts_components.ARID.fromURString(json["listening_at_arid"]);
+		if (json["pending_requests"] !== void 0) record._pendingRequests = PendingRequests.fromJSON(json["pending_requests"]);
+		if (json["verifying_key"] !== void 0) record._verifyingKey = _bcts_components.SigningPublicKey.fromURString(json["verifying_key"]);
+		return record;
+	}
+};
+//#endregion
+//#region src/registry/owner-record.ts
+/**
+* Record of the registry owner (coordinator).
+*
+* Port of `struct OwnerRecord` from owner_record.rs lines 13-17.
+*/
+var OwnerRecord = class OwnerRecord {
+	_xidDocumentUr;
+	_xidDocument;
+	_petName;
+	constructor(xidDocumentUr, xidDocument, petName) {
+		this._xidDocumentUr = xidDocumentUr;
+		this._xidDocument = xidDocument;
+		this._petName = petName;
+	}
+	/**
+	* Create an owner record from a signed XID UR string.
+	*
+	* Port of `OwnerRecord::from_signed_xid_ur()` from owner_record.rs lines 20-32.
+	*/
+	static fromSignedXidUr(xidDocumentUr, petName) {
+		const [raw, document] = parseRelaxedXidDocument(xidDocumentUr);
+		if (document.inceptionPrivateKeys() === void 0) throw new Error("Owner XID document must include private keys");
+		return new OwnerRecord(raw, document, petName);
+	}
+	/**
+	* Get the XID of the owner.
+	*
+	* Port of `OwnerRecord::xid()` from owner_record.rs line 34.
+	*/
+	xid() {
+		return this._xidDocument.xid();
+	}
+	/**
+	* Get the XID document of the owner.
+	*
+	* Port of `OwnerRecord::xid_document()` from owner_record.rs line 36.
+	*/
+	xidDocument() {
+		return this._xidDocument;
+	}
+	/**
+	* Get the UR string of the XID document.
+	*
+	* Port of `OwnerRecord::xid_document_ur()` from owner_record.rs line 38.
+	*/
+	xidDocumentUr() {
+		return this._xidDocumentUr;
+	}
+	/**
+	* Get the pet name of the owner.
+	*
+	* Port of `OwnerRecord::pet_name()` from owner_record.rs line 40.
+	*/
+	petName() {
+		return this._petName;
+	}
+	/**
+	* Serialize to JSON object.
+	*/
+	toJSON() {
+		const obj = { xid_document: this._xidDocumentUr };
+		if (this._petName !== void 0) obj["pet_name"] = this._petName;
+		return obj;
+	}
+	/**
+	* Deserialize from JSON object.
+	*/
+	static fromJSON(json) {
+		const xidDocumentUr = json["xid_document"];
+		const petName = json["pet_name"];
+		return OwnerRecord.fromSignedXidUr(xidDocumentUr, petName);
+	}
+};
+/**
+* Parse a XID document with relaxed validation (no signature verification).
+*
+* Port of `parse_relaxed_xid_document()` from owner_record.rs lines 144-165.
+*/
+function parseRelaxedXidDocument(xidDocumentUr) {
+	const sanitized = sanitizeXidUr$1(xidDocumentUr);
+	const ur = _bcts_uniform_resources.UR.fromURString(sanitized);
+	if (ur.urTypeStr() !== "xid" && ur.urTypeStr() !== "envelope") throw new Error(`Expected a ur:xid document, found ur:${ur.urTypeStr()}`);
+	const envelopeCbor = ur.cbor();
+	let envelope;
+	try {
+		envelope = _bcts_envelope.Envelope.fromTaggedCbor(envelopeCbor);
+	} catch {
+		envelope = _bcts_envelope.Envelope.fromUntaggedCbor(envelopeCbor);
+	}
+	return [sanitized, _bcts_xid.XIDDocument.fromEnvelope(envelope, void 0, _bcts_xid.XIDVerifySignature.None)];
+}
+/**
+* Sanitize XID UR input.
+*
+* Port of `sanitize_xid_ur()` from owner_record.rs lines 167-174.
+*/
+function sanitizeXidUr$1(input) {
+	const trimmed = input.trim();
+	if (trimmed.length === 0) throw new Error("XID document is required");
+	return trimmed;
+}
+//#endregion
+//#region src/registry/participant-record.ts
+/**
+* Record of a participant in the registry.
+*
+* Port of `struct ParticipantRecord` from participant_record.rs lines 12-17.
+*/
+var ParticipantRecord = class ParticipantRecord {
+	_xidDocumentUr;
+	_xidDocument;
+	_publicKeys;
+	_petName;
+	constructor(xidDocumentUr, xidDocument, publicKeys, petName) {
+		this._xidDocumentUr = xidDocumentUr;
+		this._xidDocument = xidDocument;
+		this._publicKeys = publicKeys;
+		this._petName = petName;
+	}
+	/**
+	* Create a participant record from a signed XID UR string.
+	*
+	* Port of `ParticipantRecord::from_signed_xid_ur()` from participant_record.rs lines 20-26.
+	*/
+	static fromSignedXidUr(xidDocumentUr, petName) {
+		const [raw, document] = parseSignedXidDocument(xidDocumentUr);
+		return ParticipantRecord.buildFromParts(document, raw, petName);
+	}
+	/**
+	* Get the pet name of the participant.
+	*
+	* Port of `ParticipantRecord::pet_name()` from participant_record.rs line 28.
+	*/
+	petName() {
+		return this._petName;
+	}
+	/**
+	* Get the public keys of the participant.
+	*
+	* Port of `ParticipantRecord::public_keys()` from participant_record.rs line 29.
+	*/
+	publicKeys() {
+		return this._publicKeys;
+	}
+	/**
+	* Get the XID of the participant.
+	*
+	* Port of `ParticipantRecord::xid()` from participant_record.rs line 30.
+	*/
+	xid() {
+		return this._xidDocument.xid();
+	}
+	/**
+	* Get the XID document of the participant.
+	*
+	* Port of `ParticipantRecord::xid_document()` from participant_record.rs line 31.
+	*/
+	xidDocument() {
+		return this._xidDocument;
+	}
+	/**
+	* Get the UR string of the XID document.
+	*
+	* Port of `ParticipantRecord::xid_document_ur()` from participant_record.rs line 32.
+	*/
+	xidDocumentUr() {
+		return this._xidDocumentUr;
+	}
+	/**
+	* Build from constituent parts.
+	*
+	* Port of `ParticipantRecord::build_from_parts()` from participant_record.rs lines 34-49.
+	*/
+	static buildFromParts(document, xidDocumentUr, petName) {
+		const inceptionKey = document.inceptionKey();
+		if (inceptionKey === void 0) throw new Error("XID document missing inception key");
+		return new ParticipantRecord(xidDocumentUr, document, inceptionKey.publicKeys(), petName);
+	}
+	/**
+	* Recreate from serialized data.
+	*
+	* Port of `ParticipantRecord::recreate_from_serialized()` from participant_record.rs lines 51-57.
+	*/
+	static recreateFromSerialized(xidDocumentUr, petName) {
+		const [raw, document] = parseSignedXidDocument(xidDocumentUr);
+		return ParticipantRecord.buildFromParts(document, raw, petName);
+	}
+	/**
+	* Serialize to JSON object.
+	*/
+	toJSON() {
+		const obj = { xid_document: this._xidDocumentUr };
+		if (this._petName !== void 0) obj["pet_name"] = this._petName;
+		return obj;
+	}
+	/**
+	* Deserialize from JSON object.
+	*/
+	static fromJSON(json) {
+		const xidDocumentUr = json["xid_document"];
+		const petName = json["pet_name"];
+		return ParticipantRecord.recreateFromSerialized(xidDocumentUr, petName);
+	}
+};
+/**
+* Parse a signed XID document from a UR string.
+*
+* Port of `parse_signed_xid_document()` from participant_record.rs lines 170-194.
+*/
+function parseSignedXidDocument(xidDocumentUr) {
+	const sanitized = sanitizeXidUr(xidDocumentUr);
+	const ur = _bcts_uniform_resources.UR.fromURString(sanitized);
+	if (ur.urTypeStr() !== "xid" && ur.urTypeStr() !== "envelope") throw new Error(`Expected a ur:xid document, found ur:${ur.urTypeStr()}`);
+	const envelopeCbor = ur.cbor();
+	let envelope;
+	try {
+		envelope = _bcts_envelope.Envelope.fromTaggedCbor(envelopeCbor);
+	} catch {
+		envelope = _bcts_envelope.Envelope.fromUntaggedCbor(envelopeCbor);
+	}
+	return [sanitized, _bcts_xid.XIDDocument.fromEnvelope(envelope, void 0, _bcts_xid.XIDVerifySignature.Inception)];
+}
+/**
+* Sanitize XID UR input.
+*
+* Port of `sanitize_xid_ur()` from participant_record.rs lines 196-203.
+*/
+function sanitizeXidUr(input) {
+	const trimmed = input.trim();
+	if (trimmed.length === 0) throw new Error("XID document is required");
+	return trimmed;
+}
+//#endregion
+//#region src/registry/registry-impl.ts
+/**
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
+*
+*
+* Registry implementation for managing participants and groups.
+*
+* Port of registry/registry_impl.rs from frost-hubert-rust.
+*
+* @module
+*/
+/**
+* Outcome of adding a participant to the registry.
+*
+* Port of `enum AddOutcome` from registry_impl.rs.
+*/
+let AddOutcome = /* @__PURE__ */ function(AddOutcome) {
+	/** Participant was already present in the registry */
+	AddOutcome["AlreadyPresent"] = "already_present";
+	/** Participant was successfully inserted */
+	AddOutcome["Inserted"] = "inserted";
+	return AddOutcome;
+}({});
+/**
+* Outcome of setting the owner in the registry.
+*
+* Port of `enum OwnerOutcome` from registry_impl.rs.
+*/
+let OwnerOutcome = /* @__PURE__ */ function(OwnerOutcome) {
+	/** Owner was already present in the registry */
+	OwnerOutcome["AlreadyPresent"] = "already_present";
+	/** Owner was successfully inserted */
+	OwnerOutcome["Inserted"] = "inserted";
+	return OwnerOutcome;
+}({});
+/**
+* Outcome of recording a group in the registry.
+*
+* Port of `enum GroupOutcome` from registry_impl.rs.
+*/
+let GroupOutcome = /* @__PURE__ */ function(GroupOutcome) {
+	/** Group was successfully inserted as new */
+	GroupOutcome["Inserted"] = "inserted";
+	/** Group already existed and was updated (contributions merged) */
+	GroupOutcome["Updated"] = "updated";
+	return GroupOutcome;
+}({});
+/**
+* Registry for managing participants and groups.
+*
+* Port of `struct Registry` from registry_impl.rs lines 22-26.
+*/
+var Registry = class Registry {
+	_owner;
+	_participants;
+	_groups;
+	constructor() {
+		this._owner = void 0;
+		this._participants = /* @__PURE__ */ new Map();
+		this._groups = /* @__PURE__ */ new Map();
+	}
+	/**
+	* Get the owner record.
+	*/
+	owner() {
+		return this._owner;
+	}
+	/**
+	* Set the owner record.
+	*
+	* Returns the outcome indicating whether the owner was already present or newly inserted.
+	*
+	* Port of `Registry::set_owner()` from registry_impl.rs.
+	*/
+	setOwner(owner) {
+		const petName = owner.petName();
+		if (petName !== void 0) {
+			if (this.participantByPetName(petName)?.[1].petName() === petName) throw new Error(`Pet name '${petName}' already used by a participant`);
+		}
+		if (this._owner === void 0) {
+			this._owner = owner;
+			return "inserted";
+		}
+		const existing = this._owner;
+		const existingXidUr = existing.xid().urString();
+		const ownerXidUr = owner.xid().urString();
+		if (existingXidUr === ownerXidUr && existing.xidDocumentUr() === owner.xidDocumentUr() && existing.petName() === owner.petName()) return "already_present";
+		if (existingXidUr === ownerXidUr) {
+			if (existing.xidDocumentUr() !== owner.xidDocumentUr()) throw new Error("Owner already exists with different keys");
+			this._owner = owner;
+			return "inserted";
+		}
+		throw new Error(`Owner already recorded for ${existing.xid().toString()}`);
+	}
+	/**
+	* Get all participants.
+	*/
+	participants() {
+		return this._participants;
+	}
+	/**
+	* Get a participant by XID.
+	*/
+	participant(xid) {
+		return this._participants.get(xid.urString());
+	}
+	/**
+	* Add a participant.
+	*
+	* Returns the outcome indicating whether the participant was already present or newly inserted.
+	*/
+	addParticipant(xid, record) {
+		const xidUr = xid.urString();
+		if (this._participants.has(xidUr)) return "already_present";
+		const petName = record.petName();
+		if (petName !== void 0 && this.petNameExists(petName)) throw new Error(`Pet name "${petName}" is already used by another participant`);
+		this._participants.set(xidUr, record);
+		return "inserted";
+	}
+	/**
+	* Check if a pet name is already used.
+	*/
+	petNameExists(petName) {
+		for (const record of this._participants.values()) if (record.petName() === petName) return true;
+		return false;
+	}
+	/**
+	* Find a participant by pet name.
+	*
+	* Port of `Registry::participant_by_pet_name()` from registry_impl.rs.
+	*/
+	participantByPetName(petName) {
+		for (const record of this._participants.values()) if (record.petName() === petName) return [record.xid(), record];
+	}
+	/**
+	* Get all groups.
+	*/
+	groups() {
+		return this._groups;
+	}
+	/**
+	* Get a group by ARID.
+	*/
+	group(arid) {
+		return this._groups.get(arid.hex());
+	}
+	/**
+	* Get a mutable reference to a group by ARID.
+	*/
+	groupMut(arid) {
+		return this._groups.get(arid.hex());
+	}
+	/**
+	* Record a group in the registry.
+	*
+	* If the group already exists:
+	* - Validates that the config matches
+	* - Merges contributions from the new record
+	* - Updates verifying key if not already set
+	*
+	* Port of `Registry::record_group()` from registry_impl.rs.
+	*/
+	recordGroup(groupId, record) {
+		const key = groupId.hex();
+		const existing = this._groups.get(key);
+		if (existing !== void 0) {
+			if (!existing.configMatches(record)) throw new Error(`Group ${groupId.hex()} already exists with a different configuration`);
+			existing.mergeContributions(record.contributions());
+			const existingKey = existing.verifyingKey();
+			const recordKey = record.verifyingKey();
+			if (existingKey === void 0 && recordKey !== void 0) existing.setVerifyingKey(recordKey);
+			else if (existingKey !== void 0 && recordKey !== void 0 && existingKey.urString() !== recordKey.urString()) throw new Error(`Group ${groupId.hex()} already exists with a different verifying key`);
+			return "updated";
+		}
+		this._groups.set(key, record);
+		return "inserted";
+	}
+	/**
+	* Add a group (simple variant without merge logic).
+	*
+	* @deprecated Use recordGroup() for proper merge behavior.
+	*/
+	addGroup(arid, record) {
+		this._groups.set(arid.hex(), record);
+	}
+	/**
+	* Load a registry from a file.
+	*/
+	static load(filePath) {
+		if (!node_fs.existsSync(filePath)) return new Registry();
+		const content = node_fs.readFileSync(filePath, "utf-8");
+		const json = JSON.parse(content);
+		return Registry.fromJSON(json);
+	}
+	/**
+	* Save the registry to a file.
+	*/
+	save(filePath) {
+		const dir = node_path.dirname(filePath);
+		if (!node_fs.existsSync(dir)) node_fs.mkdirSync(dir, { recursive: true });
+		const json = this.toJSON();
+		node_fs.writeFileSync(filePath, JSON.stringify(json, null, 2));
+	}
+	/**
+	* Serialize to JSON object.
+	*/
+	toJSON() {
+		const participants = {};
+		for (const [xidUr, record] of this._participants) participants[xidUr] = record.toJSON();
+		const groups = {};
+		for (const [aridHex, record] of this._groups) groups[aridHex] = record.toJSON();
+		const obj = {
+			groups,
+			participants
+		};
+		if (this._owner !== void 0) obj["owner"] = this._owner.toJSON();
+		return obj;
+	}
+	/**
+	* Deserialize from JSON object.
+	*/
+	static fromJSON(json) {
+		const registry = new Registry();
+		if (json["owner"] !== void 0) registry._owner = OwnerRecord.fromJSON(json["owner"]);
+		const participantsJson = json["participants"];
+		if (participantsJson !== void 0) for (const [, recordJson] of Object.entries(participantsJson)) {
+			const record = ParticipantRecord.fromJSON(recordJson);
+			registry._participants.set(record.xid().urString(), record);
+		}
+		const groupsJson = json["groups"];
+		if (groupsJson !== void 0) for (const [aridHex, recordJson] of Object.entries(groupsJson)) {
+			const record = GroupRecord.fromJSON(recordJson);
+			registry._groups.set(aridHex, record);
+		}
+		return registry;
+	}
+};
+/**
+* Resolve the registry file path from a given argument.
+*
+* Port of `resolve_registry_path()` from registry/mod.rs lines 49-78.
+*/
+function resolveRegistryPath(registryArg, cwd) {
+	if (registryArg === void 0 || registryArg === "") return node_path.join(cwd, "registry.json");
+	if (registryArg.endsWith("/") || registryArg.endsWith(node_path.sep)) return node_path.join(cwd, registryArg, "registry.json");
+	if (!registryArg.includes("/") && !registryArg.includes(node_path.sep)) return node_path.join(cwd, registryArg);
+	return node_path.resolve(cwd, registryArg);
+}
+//#endregion
+exports.AddOutcome = AddOutcome;
+exports.ContributionPaths = ContributionPaths;
+exports.GroupOutcome = GroupOutcome;
+exports.GroupParticipant = GroupParticipant;
+exports.GroupRecord = GroupRecord;
+exports.OwnerOutcome = OwnerOutcome;
+exports.OwnerRecord = OwnerRecord;
+exports.ParticipantRecord = ParticipantRecord;
+exports.PendingRequests = PendingRequests;
+exports.Registry = Registry;
+exports.resolveRegistryPath = resolveRegistryPath;
 
-exports.AddOutcome = require_registry_impl.AddOutcome;
-exports.ContributionPaths = require_registry_impl.ContributionPaths;
-exports.GroupOutcome = require_registry_impl.GroupOutcome;
-exports.GroupParticipant = require_registry_impl.GroupParticipant;
-exports.GroupRecord = require_registry_impl.GroupRecord;
-exports.OwnerOutcome = require_registry_impl.OwnerOutcome;
-exports.OwnerRecord = require_registry_impl.OwnerRecord;
-exports.ParticipantRecord = require_registry_impl.ParticipantRecord;
-exports.PendingRequests = require_registry_impl.PendingRequests;
-exports.Registry = require_registry_impl.Registry;
-exports.resolveRegistryPath = require_registry_impl.resolveRegistryPath;
+//# sourceMappingURL=index.cjs.map