@bcts/xid 1.0.0-alpha.21 → 1.0.0-alpha.23

package/dist/index.mjs

@@ -2,7 +2,6 @@ import { PrivateKeyBase, PrivateKeys, PublicKeys, Reference, Salt, XID, XID as X
 import { ALLOW, ATTACHMENT_RAW, CAPABILITY, DELEGATE, DENY, DEREFERENCE_VIA, EDGE_RAW, ENDPOINT, KEY, NAME, NICKNAME, PRIVATE_KEY, PRIVILEGE_ACCESS, PRIVILEGE_ALL, PRIVILEGE_AUTH, PRIVILEGE_BURN, PRIVILEGE_DELEGATE, PRIVILEGE_ELECT, PRIVILEGE_ELIDE, PRIVILEGE_ENCRYPT, PRIVILEGE_ISSUE, PRIVILEGE_REVOKE, PRIVILEGE_SIGN, PRIVILEGE_TRANSFER, PRIVILEGE_UPDATE, PRIVILEGE_VERIFY, PROVENANCE, PROVENANCE_GENERATOR, SALT, SERVICE } from "@bcts/known-values";
 import { Attachments, Attachments as Attachments$1, Edges, Edges as Edges$1, Envelope } from "@bcts/envelope";
 import { ProvenanceMark, ProvenanceMarkGenerator, ProvenanceMarkResolution } from "@bcts/provenance-mark";
-
 //#region src/error.ts
 /**
 * Copyright © 2023-2026 Blockchain Commons, LLC
@@ -59,180 +58,177 @@ var XIDError = class XIDError extends Error {
 	* Returned when attempting to add a duplicate item.
 	*/
 	static duplicate(item) {
-		return new XIDError(XIDErrorCode.DUPLICATE, `duplicate item: ${item}`);
+		return new XIDError("DUPLICATE", `duplicate item: ${item}`);
 	}
 	/**
 	* Returned when an item is not found.
 	*/
 	static notFound(item) {
-		return new XIDError(XIDErrorCode.NOT_FOUND, `item not found: ${item}`);
+		return new XIDError("NOT_FOUND", `item not found: ${item}`);
 	}
 	/**
 	* Returned when an item is still referenced by other items.
 	*/
 	static stillReferenced(item) {
-		return new XIDError(XIDErrorCode.STILL_REFERENCED, `item is still referenced: ${item}`);
+		return new XIDError("STILL_REFERENCED", `item is still referenced: ${item}`);
 	}
 	/**
 	* Returned when a value is invalid or empty.
 	*/
 	static emptyValue(field) {
-		return new XIDError(XIDErrorCode.EMPTY_VALUE, `invalid or empty value: ${field}`);
+		return new XIDError("EMPTY_VALUE", `invalid or empty value: ${field}`);
 	}
 	/**
 	* Returned when an unknown privilege is encountered.
 	*/
 	static unknownPrivilege() {
-		return new XIDError(XIDErrorCode.UNKNOWN_PRIVILEGE, "unknown privilege");
+		return new XIDError("UNKNOWN_PRIVILEGE", "unknown privilege");
 	}
 	/**
 	* Returned when the XID is invalid.
 	*/
 	static invalidXid() {
-		return new XIDError(XIDErrorCode.INVALID_XID, "invalid XID");
+		return new XIDError("INVALID_XID", "invalid XID");
 	}
 	/**
 	* Returned when the inception key is missing.
 	*/
 	static missingInceptionKey() {
-		return new XIDError(XIDErrorCode.MISSING_INCEPTION_KEY, "missing inception key");
+		return new XIDError("MISSING_INCEPTION_KEY", "missing inception key");
 	}
 	/**
 	* Returned when the resolution method is invalid.
 	*/
 	static invalidResolutionMethod() {
-		return new XIDError(XIDErrorCode.INVALID_RESOLUTION_METHOD, "invalid resolution method");
+		return new XIDError("INVALID_RESOLUTION_METHOD", "invalid resolution method");
 	}
 	/**
 	* Returned when multiple provenance marks are found.
 	*/
 	static multipleProvenanceMarks() {
-		return new XIDError(XIDErrorCode.MULTIPLE_PROVENANCE_MARKS, "multiple provenance marks");
+		return new XIDError("MULTIPLE_PROVENANCE_MARKS", "multiple provenance marks");
 	}
 	/**
 	* Returned when an unexpected predicate is encountered.
 	*/
 	static unexpectedPredicate(predicate) {
-		return new XIDError(XIDErrorCode.UNEXPECTED_PREDICATE, `unexpected predicate: ${predicate}`);
+		return new XIDError("UNEXPECTED_PREDICATE", `unexpected predicate: ${predicate}`);
 	}
 	/**
 	* Returned when unexpected nested assertions are found.
 	*/
 	static unexpectedNestedAssertions() {
-		return new XIDError(XIDErrorCode.UNEXPECTED_NESTED_ASSERTIONS, "unexpected nested assertions");
+		return new XIDError("UNEXPECTED_NESTED_ASSERTIONS", "unexpected nested assertions");
 	}
 	/**
 	* Returned when a service has no permissions.
 	*/
 	static noPermissions(uri) {
-		return new XIDError(XIDErrorCode.NO_PERMISSIONS, `no permissions in service '${uri}'`);
+		return new XIDError("NO_PERMISSIONS", `no permissions in service '${uri}'`);
 	}
 	/**
 	* Returned when a service has no key or delegate references.
 	*/
 	static noReferences(uri) {
-		return new XIDError(XIDErrorCode.NO_REFERENCES, `no key or delegate references in service '${uri}'`);
+		return new XIDError("NO_REFERENCES", `no key or delegate references in service '${uri}'`);
 	}
 	/**
 	* Returned when an unknown key reference is found in a service.
 	*/
 	static unknownKeyReference(reference, uri) {
-		return new XIDError(XIDErrorCode.UNKNOWN_KEY_REFERENCE, `unknown key reference ${reference} in service '${uri}'`);
+		return new XIDError("UNKNOWN_KEY_REFERENCE", `unknown key reference ${reference} in service '${uri}'`);
 	}
 	/**
 	* Returned when an unknown delegate reference is found in a service.
 	*/
 	static unknownDelegateReference(reference, uri) {
-		return new XIDError(XIDErrorCode.UNKNOWN_DELEGATE_REFERENCE, `unknown delegate reference ${reference} in service '${uri}'`);
+		return new XIDError("UNKNOWN_DELEGATE_REFERENCE", `unknown delegate reference ${reference} in service '${uri}'`);
 	}
 	/**
 	* Returned when a key is not found in the XID document.
 	*/
 	static keyNotFoundInDocument(key) {
-		return new XIDError(XIDErrorCode.KEY_NOT_FOUND_IN_DOCUMENT, `key not found in XID document: ${key}`);
+		return new XIDError("KEY_NOT_FOUND_IN_DOCUMENT", `key not found in XID document: ${key}`);
 	}
 	/**
 	* Returned when a delegate is not found in the XID document.
 	*/
 	static delegateNotFoundInDocument(delegate) {
-		return new XIDError(XIDErrorCode.DELEGATE_NOT_FOUND_IN_DOCUMENT, `delegate not found in XID document: ${delegate}`);
+		return new XIDError("DELEGATE_NOT_FOUND_IN_DOCUMENT", `delegate not found in XID document: ${delegate}`);
 	}
 	/**
 	* Returned when the password is invalid.
 	*/
 	static invalidPassword() {
-		return new XIDError(XIDErrorCode.INVALID_PASSWORD, "invalid password");
+		return new XIDError("INVALID_PASSWORD", "invalid password");
 	}
 	/**
 	* Returned when the envelope is not signed.
 	*/
 	static envelopeNotSigned() {
-		return new XIDError(XIDErrorCode.ENVELOPE_NOT_SIGNED, "envelope is not signed");
+		return new XIDError("ENVELOPE_NOT_SIGNED", "envelope is not signed");
 	}
 	/**
 	* Returned when signature verification fails.
 	*/
 	static signatureVerificationFailed() {
-		return new XIDError(XIDErrorCode.SIGNATURE_VERIFICATION_FAILED, "signature verification failed");
+		return new XIDError("SIGNATURE_VERIFICATION_FAILED", "signature verification failed");
 	}
 	/**
 	* Returned when there is no provenance mark to advance.
 	*/
 	static noProvenanceMark() {
-		return new XIDError(XIDErrorCode.NO_PROVENANCE_MARK, "no provenance mark to advance");
+		return new XIDError("NO_PROVENANCE_MARK", "no provenance mark to advance");
 	}
 	/**
 	* Returned when document already has generator but external generator was provided.
 	*/
 	static generatorConflict() {
-		return new XIDError(XIDErrorCode.GENERATOR_CONFLICT, "document already has generator, cannot provide external generator");
+		return new XIDError("GENERATOR_CONFLICT", "document already has generator, cannot provide external generator");
 	}
 	/**
 	* Returned when document does not have generator but needs one.
 	*/
 	static noGenerator() {
-		return new XIDError(XIDErrorCode.NO_GENERATOR, "document does not have generator, must provide external generator");
+		return new XIDError("NO_GENERATOR", "document does not have generator, must provide external generator");
 	}
 	/**
 	* Returned when generator chain ID doesn't match.
 	*/
 	static chainIdMismatch(expected, actual) {
-		const expectedHex = Array.from(expected).map((b) => b.toString(16).padStart(2, "0")).join("");
-		const actualHex = Array.from(actual).map((b) => b.toString(16).padStart(2, "0")).join("");
-		return new XIDError(XIDErrorCode.CHAIN_ID_MISMATCH, `generator chain ID mismatch: expected ${expectedHex}, got ${actualHex}`);
+		return new XIDError("CHAIN_ID_MISMATCH", `generator chain ID mismatch: expected ${Array.from(expected).map((b) => b.toString(16).padStart(2, "0")).join("")}, got ${Array.from(actual).map((b) => b.toString(16).padStart(2, "0")).join("")}`);
 	}
 	/**
 	* Returned when generator sequence doesn't match.
 	*/
 	static sequenceMismatch(expected, actual) {
-		return new XIDError(XIDErrorCode.SEQUENCE_MISMATCH, `generator sequence mismatch: expected ${expected}, got ${actual}`);
+		return new XIDError("SEQUENCE_MISMATCH", `generator sequence mismatch: expected ${expected}, got ${actual}`);
 	}
 	/**
 	* Envelope parsing error wrapper.
 	*/
 	static envelopeParsing(cause) {
-		return new XIDError(XIDErrorCode.ENVELOPE_PARSING, "envelope parsing error", cause);
+		return new XIDError("ENVELOPE_PARSING", "envelope parsing error", cause);
 	}
 	/**
 	* Component error wrapper.
 	*/
 	static component(cause) {
-		return new XIDError(XIDErrorCode.COMPONENT, "component error", cause);
+		return new XIDError("COMPONENT", "component error", cause);
 	}
 	/**
 	* CBOR error wrapper.
 	*/
 	static cbor(cause) {
-		return new XIDError(XIDErrorCode.CBOR, "CBOR error", cause);
+		return new XIDError("CBOR", "CBOR error", cause);
 	}
 	/**
 	* Provenance mark error wrapper.
 	*/
 	static provenanceMark(cause) {
-		return new XIDError(XIDErrorCode.PROVENANCE_MARK, "provenance mark error", cause);
+		return new XIDError("PROVENANCE_MARK", "provenance mark error", cause);
 	}
 };
-
 //#endregion
 //#region src/privilege.ts
 /**
@@ -286,20 +282,20 @@ let Privilege = /* @__PURE__ */ function(Privilege) {
 */
 function privilegeToKnownValue(privilege) {
 	switch (privilege) {
-		case Privilege.All: return PRIVILEGE_ALL;
-		case Privilege.Auth: return PRIVILEGE_AUTH;
-		case Privilege.Sign: return PRIVILEGE_SIGN;
-		case Privilege.Encrypt: return PRIVILEGE_ENCRYPT;
-		case Privilege.Elide: return PRIVILEGE_ELIDE;
-		case Privilege.Issue: return PRIVILEGE_ISSUE;
-		case Privilege.Access: return PRIVILEGE_ACCESS;
-		case Privilege.Delegate: return PRIVILEGE_DELEGATE;
-		case Privilege.Verify: return PRIVILEGE_VERIFY;
-		case Privilege.Update: return PRIVILEGE_UPDATE;
-		case Privilege.Transfer: return PRIVILEGE_TRANSFER;
-		case Privilege.Elect: return PRIVILEGE_ELECT;
-		case Privilege.Burn: return PRIVILEGE_BURN;
-		case Privilege.Revoke: return PRIVILEGE_REVOKE;
+		case "All": return PRIVILEGE_ALL;
+		case "Auth": return PRIVILEGE_AUTH;
+		case "Sign": return PRIVILEGE_SIGN;
+		case "Encrypt": return PRIVILEGE_ENCRYPT;
+		case "Elide": return PRIVILEGE_ELIDE;
+		case "Issue": return PRIVILEGE_ISSUE;
+		case "Access": return PRIVILEGE_ACCESS;
+		case "Delegate": return PRIVILEGE_DELEGATE;
+		case "Verify": return PRIVILEGE_VERIFY;
+		case "Update": return PRIVILEGE_UPDATE;
+		case "Transfer": return PRIVILEGE_TRANSFER;
+		case "Elect": return PRIVILEGE_ELECT;
+		case "Burn": return PRIVILEGE_BURN;
+		case "Revoke": return PRIVILEGE_REVOKE;
 		default: throw XIDError.unknownPrivilege();
 	}
 }
@@ -308,20 +304,20 @@ function privilegeToKnownValue(privilege) {
 */
 function privilegeFromKnownValue(knownValue) {
 	switch (knownValue.value()) {
-		case PRIVILEGE_ALL.value(): return Privilege.All;
-		case PRIVILEGE_AUTH.value(): return Privilege.Auth;
-		case PRIVILEGE_SIGN.value(): return Privilege.Sign;
-		case PRIVILEGE_ENCRYPT.value(): return Privilege.Encrypt;
-		case PRIVILEGE_ELIDE.value(): return Privilege.Elide;
-		case PRIVILEGE_ISSUE.value(): return Privilege.Issue;
-		case PRIVILEGE_ACCESS.value(): return Privilege.Access;
-		case PRIVILEGE_DELEGATE.value(): return Privilege.Delegate;
-		case PRIVILEGE_VERIFY.value(): return Privilege.Verify;
-		case PRIVILEGE_UPDATE.value(): return Privilege.Update;
-		case PRIVILEGE_TRANSFER.value(): return Privilege.Transfer;
-		case PRIVILEGE_ELECT.value(): return Privilege.Elect;
-		case PRIVILEGE_BURN.value(): return Privilege.Burn;
-		case PRIVILEGE_REVOKE.value(): return Privilege.Revoke;
+		case PRIVILEGE_ALL.value(): return "All";
+		case PRIVILEGE_AUTH.value(): return "Auth";
+		case PRIVILEGE_SIGN.value(): return "Sign";
+		case PRIVILEGE_ENCRYPT.value(): return "Encrypt";
+		case PRIVILEGE_ELIDE.value(): return "Elide";
+		case PRIVILEGE_ISSUE.value(): return "Issue";
+		case PRIVILEGE_ACCESS.value(): return "Access";
+		case PRIVILEGE_DELEGATE.value(): return "Delegate";
+		case PRIVILEGE_VERIFY.value(): return "Verify";
+		case PRIVILEGE_UPDATE.value(): return "Update";
+		case PRIVILEGE_TRANSFER.value(): return "Transfer";
+		case PRIVILEGE_ELECT.value(): return "Elect";
+		case PRIVILEGE_BURN.value(): return "Burn";
+		case PRIVILEGE_REVOKE.value(): return "Revoke";
 		default: throw XIDError.unknownPrivilege();
 	}
 }
@@ -339,7 +335,6 @@ function privilegeFromEnvelope(envelope) {
 	if (envelopeCase.type !== "knownValue") throw XIDError.unknownPrivilege();
 	return privilegeFromKnownValue(envelopeCase.value);
 }
-
 //#endregion
 //#region src/permissions.ts
 /**
@@ -358,24 +353,45 @@ function privilegeFromEnvelope(envelope) {
 * Helper methods for HasPermissions implementers.
 */
 const HasPermissionsMixin = {
+	/**
+	* Get the set of allowed privileges.
+	*/
 	allow(obj) {
 		return obj.permissions().allow;
 	},
+	/**
+	* Get the set of denied privileges.
+	*/
 	deny(obj) {
 		return obj.permissions().deny;
 	},
+	/**
+	* Add an allowed privilege.
+	*/
 	addAllow(obj, privilege) {
 		obj.permissionsMut().allow.add(privilege);
 	},
+	/**
+	* Add a denied privilege.
+	*/
 	addDeny(obj, privilege) {
 		obj.permissionsMut().deny.add(privilege);
 	},
+	/**
+	* Remove an allowed privilege.
+	*/
 	removeAllow(obj, privilege) {
 		obj.permissionsMut().allow.delete(privilege);
 	},
+	/**
+	* Remove a denied privilege.
+	*/
 	removeDeny(obj, privilege) {
 		obj.permissionsMut().deny.delete(privilege);
 	},
+	/**
+	* Clear all permissions.
+	*/
 	clearAllPermissions(obj) {
 		obj.permissionsMut().allow.clear();
 		obj.permissionsMut().deny.clear();
@@ -402,7 +418,7 @@ var Permissions = class Permissions {
 	*/
 	static newAllowAll() {
 		const allow = /* @__PURE__ */ new Set();
-		allow.add(Privilege.All);
+		allow.add("All");
 		return new Permissions(allow);
 	}
 	/**
@@ -448,14 +464,14 @@ var Permissions = class Permissions {
 	* Check if a specific privilege is allowed.
 	*/
 	isAllowed(privilege) {
-		if (this.deny.has(privilege) || this.deny.has(Privilege.All)) return false;
-		return this.allow.has(privilege) || this.allow.has(Privilege.All);
+		if (this.deny.has(privilege) || this.deny.has("All")) return false;
+		return this.allow.has(privilege) || this.allow.has("All");
 	}
 	/**
 	* Check if a specific privilege is denied.
 	*/
 	isDenied(privilege) {
-		return this.deny.has(privilege) || this.deny.has(Privilege.All);
+		return this.deny.has(privilege) || this.deny.has("All");
 	}
 	permissions() {
 		return this;
@@ -479,7 +495,6 @@ var Permissions = class Permissions {
 		return new Permissions(new Set(this.allow), new Set(this.deny));
 	}
 };
-
 //#endregion
 //#region src/name.ts
 /**
@@ -496,12 +511,15 @@ var Permissions = class Permissions {
 /**
 * Helper methods for HasNickname implementers.
 */
-const HasNicknameMixin = { addNickname(obj, name) {
+const HasNicknameMixin = { 
+/**
+* Add a nickname, throwing if one already exists or is empty.
+*/
+addNickname(obj, name) {
 	if (obj.nickname() !== "") throw XIDError.duplicate("nickname");
 	if (name === "") throw XIDError.emptyValue("nickname");
 	obj.setNickname(name);
 } };
-
 //#endregion
 //#region src/shared.ts
 /**
@@ -566,7 +584,6 @@ var Shared = class Shared {
 		return new Shared(this.value);
 	}
 };
-
 //#endregion
 //#region src/key.ts
 /**
@@ -739,7 +756,7 @@ var Key = class Key {
 	/**
 	* Convert to envelope with specified options.
 	*/
-	intoEnvelopeOpt(privateKeyOptions = XIDPrivateKeyOptions.Omit) {
+	intoEnvelopeOpt(privateKeyOptions = "Omit") {
 		let envelope = Envelope.new(this._publicKeys.taggedCborData());
 		if (this._privateKeyData !== void 0) {
 			const { data, salt } = this._privateKeyData;
@@ -747,17 +764,17 @@ var Key = class Key {
 				envelope = envelope.addAssertion(kv$3(PRIVATE_KEY), data.envelope);
 				envelope = envelope.addAssertion(kv$3(SALT), salt.toData());
 			} else if (data.type === "decrypted") switch (typeof privateKeyOptions === "object" ? privateKeyOptions.type : privateKeyOptions) {
-				case XIDPrivateKeyOptions.Include:
+				case "Include":
 					envelope = envelope.addAssertion(kv$3(PRIVATE_KEY), data.privateKeys.taggedCborData());
 					envelope = envelope.addAssertion(kv$3(SALT), salt.toData());
 					break;
-				case XIDPrivateKeyOptions.Elide: {
+				case "Elide": {
 					const elidedAssertion = Envelope.newAssertion(kv$3(PRIVATE_KEY), data.privateKeys.taggedCborData()).elide();
 					envelope = envelope.addAssertionEnvelope(elidedAssertion);
 					envelope = envelope.addAssertion(kv$3(SALT), salt.toData());
 					break;
 				}
-				case XIDPrivateKeyOptions.Encrypt:
+				case "Encrypt":
 					if (typeof privateKeyOptions === "object") {
 						const privateKeysEnvelope = Envelope.new(data.privateKeys.taggedCborData());
 						const method = privateKeyOptions.method ?? defaultKeyDerivationMethod();
@@ -766,7 +783,6 @@ var Key = class Key {
 						envelope = envelope.addAssertion(kv$3(SALT), salt.toData());
 					}
 					break;
-				case XIDPrivateKeyOptions.Omit:
 				default: break;
 			}
 		}
@@ -776,7 +792,7 @@ var Key = class Key {
 		return envelope;
 	}
 	intoEnvelope() {
-		return this.intoEnvelopeOpt(XIDPrivateKeyOptions.Omit);
+		return this.intoEnvelopeOpt("Omit");
 	}
 	/**
 	* Try to extract a Key from an envelope, optionally with password for decryption.
@@ -901,7 +917,6 @@ var Key = class Key {
 		} : void 0, this._nickname, new Set(this._endpoints), this._permissions.clone());
 	}
 };
-
 //#endregion
 //#region src/service.ts
 /**
@@ -1155,7 +1170,6 @@ function hexToBytes(hex) {
 function bytesToHex(bytes) {
 	return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
-
 //#endregion
 //#region src/delegate.ts
 let XIDDocumentClass = null;
@@ -1241,7 +1255,6 @@ var Delegate = class Delegate {
 		return new Delegate(Shared.new(this._controller.read().clone()), this._permissions.clone());
 	}
 };
-
 //#endregion
 //#region src/provenance.ts
 /**
@@ -1415,7 +1428,7 @@ var Provenance = class Provenance {
 	/**
 	* Convert to envelope with specified options.
 	*/
-	intoEnvelopeOpt(generatorOptions = XIDGeneratorOptions.Omit) {
+	intoEnvelopeOpt(generatorOptions = "Omit") {
 		let envelope = Envelope.new(this._mark.toCborData());
 		if (this._generator !== void 0) {
 			const { data, salt } = this._generator;
@@ -1423,20 +1436,20 @@ var Provenance = class Provenance {
 				envelope = envelope.addAssertion(kv$1(PROVENANCE_GENERATOR), data.envelope);
 				envelope = envelope.addAssertion(kv$1(SALT), salt.toData());
 			} else if (data.type === "decrypted") switch (typeof generatorOptions === "object" ? generatorOptions.type : generatorOptions) {
-				case XIDGeneratorOptions.Include: {
+				case "Include": {
 					const generatorBytes = encodeGeneratorJSON(data.generator.toJSON());
 					envelope = envelope.addAssertion(kv$1(PROVENANCE_GENERATOR), generatorBytes);
 					envelope = envelope.addAssertion(kv$1(SALT), salt.toData());
 					break;
 				}
-				case XIDGeneratorOptions.Elide: {
+				case "Elide": {
 					const generatorBytes2 = encodeGeneratorJSON(data.generator.toJSON());
 					const elidedAssertion = Envelope.newAssertion(kv$1(PROVENANCE_GENERATOR), generatorBytes2).elide();
 					envelope = envelope.addAssertionEnvelope(elidedAssertion);
 					envelope = envelope.addAssertion(kv$1(SALT), salt.toData());
 					break;
 				}
-				case XIDGeneratorOptions.Encrypt:
+				case "Encrypt":
 					if (typeof generatorOptions === "object") {
 						const generatorBytes3 = encodeGeneratorJSON(data.generator.toJSON());
 						const wrapped = Envelope.new(generatorBytes3).wrap();
@@ -1446,14 +1459,13 @@ var Provenance = class Provenance {
 						envelope = envelope.addAssertion(kv$1(SALT), salt.toData());
 					}
 					break;
-				case XIDGeneratorOptions.Omit:
 				default: break;
 			}
 		}
 		return envelope;
 	}
 	intoEnvelope() {
-		return this.intoEnvelopeOpt(XIDGeneratorOptions.Omit);
+		return this.intoEnvelopeOpt("Omit");
 	}
 	/**
 	* Try to extract a Provenance from an envelope, optionally with password for decryption.
@@ -1540,7 +1552,6 @@ var Provenance = class Provenance {
 		} : void 0);
 	}
 };
-
 //#endregion
 //#region src/xid-document.ts
 /**
@@ -1775,7 +1786,7 @@ var XIDDocument = class XIDDocument {
 	* Extract inception private keys from an envelope (convenience static method).
 	*/
 	static extractInceptionPrivateKeysFromEnvelope(envelope, password) {
-		return XIDDocument.fromEnvelope(envelope, password, XIDVerifySignature.None).inceptionPrivateKeys();
+		return XIDDocument.fromEnvelope(envelope, password, "None").inceptionPrivateKeys();
 	}
 	/**
 	* Get the private key envelope for a specific key, optionally decrypting it.
@@ -2053,7 +2064,7 @@ var XIDDocument = class XIDDocument {
 	/**
 	* Convert to envelope with options.
 	*/
-	toEnvelope(privateKeyOptions = XIDPrivateKeyOptions.Omit, generatorOptions = XIDGeneratorOptions.Omit, signingOptions = { type: "none" }) {
+	toEnvelope(privateKeyOptions = "Omit", generatorOptions = "Omit", signingOptions = { type: "none" }) {
 		let envelope = Envelope.newLeaf(this._xid.taggedCbor());
 		for (const method of this._resolutionMethods) envelope = envelope.addAssertion(kv(DEREFERENCE_VIA), method);
 		for (const key of this._keys.values()) envelope = envelope.addAssertion(kv(KEY), key.intoEnvelopeOpt(privateKeyOptions));
@@ -2088,10 +2099,10 @@ var XIDDocument = class XIDDocument {
 	/**
 	* Extract an XIDDocument from an envelope.
 	*/
-	static fromEnvelope(envelope, password, verifySignature = XIDVerifySignature.None) {
+	static fromEnvelope(envelope, password, verifySignature = "None") {
 		const envelopeExt = envelope;
 		switch (verifySignature) {
-			case XIDVerifySignature.None: {
+			case "None": {
 				const subject = envelopeExt.subject();
 				const envelopeToParse = subject.isWrapped() ? subject.tryUnwrap() : envelope;
 				const attachments = Attachments$1.fromEnvelope(envelopeToParse);
@@ -2101,7 +2112,7 @@ var XIDDocument = class XIDDocument {
 				doc._edges = edges;
 				return doc;
 			}
-			case XIDVerifySignature.Inception: {
+			case "Inception": {
 				if (!envelopeExt.subject().isWrapped()) throw XIDError.envelopeNotSigned();
 				const unwrapped = envelopeExt.tryUnwrap();
 				const attachments = Attachments$1.fromEnvelope(unwrapped);
@@ -2176,13 +2187,13 @@ var XIDDocument = class XIDDocument {
 	* Create a signed envelope.
 	*/
 	toSignedEnvelope(signingKey) {
-		return this.toSignedEnvelopeOpt(signingKey, XIDPrivateKeyOptions.Omit);
+		return this.toSignedEnvelopeOpt(signingKey, "Omit");
 	}
 	/**
 	* Create a signed envelope with private key options.
 	*/
-	toSignedEnvelopeOpt(signingKey, privateKeyOptions = XIDPrivateKeyOptions.Omit) {
-		return this.toEnvelope(privateKeyOptions, XIDGeneratorOptions.Omit, { type: "none" }).sign(signingKey);
+	toSignedEnvelopeOpt(signingKey, privateKeyOptions = "Omit") {
+		return this.toEnvelope(privateKeyOptions, "Omit", { type: "none" }).sign(signingKey);
 	}
 	/**
 	* Get the reference for this document.
@@ -2234,7 +2245,7 @@ var XIDDocument = class XIDDocument {
 	* Try to extract from envelope (alias for fromEnvelope with default options).
 	*/
 	static tryFromEnvelope(envelope) {
-		return XIDDocument.fromEnvelope(envelope, void 0, XIDVerifySignature.None);
+		return XIDDocument.fromEnvelope(envelope, void 0, "None");
 	}
 };
 registerXIDDocumentClass(XIDDocument);
@@ -2243,11 +2254,10 @@ function bytesEqual(a, b) {
 	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
 	return true;
 }
-
 //#endregion
 //#region src/index.ts
 const VERSION = "1.0.0-alpha.3";
-
 //#endregion
 export { Attachments, Delegate, Edges, HasNicknameMixin, HasPermissionsMixin, Key, Permissions, Privilege, Provenance, Service, Shared, VERSION, XID, XIDDocument, XIDError, XIDErrorCode, XIDGeneratorOptions, XIDPrivateKeyOptions, XIDVerifySignature, privilegeFromEnvelope, privilegeFromKnownValue, privilegeToEnvelope, privilegeToKnownValue, registerXIDDocumentClass };
+
 //# sourceMappingURL=index.mjs.map