@bcts/known-values 1.0.0-alpha.10

package/dist/index.mjs

@@ -0,0 +1,912 @@
+import { MajorType, cbor, cborData, decodeCbor } from "@bcts/dcbor";
+import { KNOWN_VALUE } from "@bcts/components";
+
+//#region src/known-value.ts
+/**
+* A value in a namespace of unsigned integers that represents a stand-alone
+* ontological concept.
+*
+* Known Values provide a compact, deterministic way to represent commonly used
+* ontological concepts such as relationships between entities, classes of
+* entities, properties, or enumerated values. They are particularly useful as
+* predicates in Gordian Envelope assertions, offering a more compact and
+* deterministic alternative to URIs. However, known values are not exclusive
+* to Gordian Envelopes and can be used in any context where a compact, unique
+* identifier for a concept is needed.
+*
+* A Known Value is represented as a 64-bit unsigned integer with an optional
+* human-readable name. This approach ensures:
+*
+* - **Compact binary representation** - Each Known Value requires only 1-9
+*   bytes depending on value range
+* - **Deterministic encoding** - Every concept has exactly one valid binary
+*   representation
+* - **Enhanced security** - Eliminates URI manipulation vulnerabilities
+* - **Standardized semantics** - Values are registered in a central registry
+*
+* While Known Values are most commonly used as predicates in assertions, they
+* can appear in any position in an Envelope (subject, predicate, or object).
+*
+* @example
+* ```typescript
+* import { KnownValue } from '@bcts/known-values';
+*
+* // Create a Known Value with a numeric value
+* const knownValue = new KnownValue(42);
+* console.log(knownValue.value()); // 42
+*
+* // Create a Known Value with a name
+* const namedValue = new KnownValue(1, 'isA');
+* console.log(namedValue.value()); // 1
+* console.log(namedValue.name()); // "isA"
+*
+* // CBOR encoding
+* const cbor = namedValue.taggedCbor();
+* const bytes = namedValue.toCborData();
+*
+* // CBOR decoding
+* const decoded = KnownValue.fromTaggedCbor(cbor);
+* const decodedFromBytes = KnownValue.fromCborData(bytes);
+*
+* // Use a pre-defined Known Value from the registry
+* import { IS_A } from '@bcts/known-values';
+* console.log(IS_A.value()); // 1
+* console.log(IS_A.name()); // "isA"
+* ```
+*
+* @specification
+*
+* Known Values are defined in
+* [BCR-2023-002](https://github.com/BlockchainCommons/Research/blob/master/papers/bcr-2023-002-known-value.md)
+* and implemented as an Envelope extension in
+* [BCR-2023-003](https://github.com/BlockchainCommons/Research/blob/master/papers/bcr-2023-003-envelope-known-value.md).
+*/
+/**
+* The numeric value for the CBOR tag used for Known Values.
+* This is Tag 40000 as defined in the Blockchain Commons registry.
+*/
+const TAG_KNOWN_VALUE = KNOWN_VALUE.value;
+/**
+* The CBOR tag used for Known Values.
+* This is Tag 40000 as defined in the Blockchain Commons registry.
+*/
+const KNOWN_VALUE_TAG = KNOWN_VALUE;
+var KnownValue = class KnownValue {
+	_value;
+	_assignedName;
+	/**
+	* Creates a new KnownValue with the given numeric value and optional name.
+	*
+	* @param value - The numeric value (number or bigint). Numbers are converted to bigint internally.
+	* @param assignedName - Optional human-readable name for the value
+	*
+	* @example
+	* ```typescript
+	* const knownValue = new KnownValue(42);
+	* console.log(knownValue.value()); // 42
+	*
+	* const namedValue = new KnownValue(1, 'isA');
+	* console.log(namedValue.name()); // "isA"
+	*
+	* // Using bigint for large values
+	* const largeValue = new KnownValue(9007199254740993n);
+	* ```
+	*/
+	constructor(value, assignedName) {
+		this._value = typeof value === "bigint" ? value : BigInt(value);
+		this._assignedName = assignedName;
+	}
+	/**
+	* Returns the numeric value of the KnownValue.
+	*
+	* This is the raw unsigned integer that identifies the concept.
+	* Returns a number for backward compatibility. For values > MAX_SAFE_INTEGER,
+	* use `valueBigInt()`.
+	*
+	* @example
+	* ```typescript
+	* import { IS_A, NOTE } from '@bcts/known-values';
+	* console.log(IS_A.value()); // 1
+	* console.log(NOTE.value()); // 4
+	* ```
+	*/
+	value() {
+		if (this._value > BigInt(Number.MAX_SAFE_INTEGER)) throw new RangeError(`KnownValue ${this._value} exceeds MAX_SAFE_INTEGER. Use valueBigInt() instead.`);
+		return Number(this._value);
+	}
+	/**
+	* Returns the numeric value of the KnownValue as a bigint.
+	*
+	* Use this for values that may exceed Number.MAX_SAFE_INTEGER (2^53-1).
+	*
+	* @example
+	* ```typescript
+	* const largeValue = new KnownValue(9007199254740993n);
+	* console.log(largeValue.valueBigInt()); // 9007199254740993n
+	* ```
+	*/
+	valueBigInt() {
+		return this._value;
+	}
+	/**
+	* Returns the assigned name of the KnownValue, if one exists.
+	*
+	* @example
+	* ```typescript
+	* const namedValue = new KnownValue(1, 'isA');
+	* console.log(namedValue.assignedName()); // "isA"
+	*
+	* const unnamedValue = new KnownValue(42);
+	* console.log(unnamedValue.assignedName()); // undefined
+	* ```
+	*/
+	assignedName() {
+		return this._assignedName;
+	}
+	/**
+	* Returns a human-readable name for the KnownValue.
+	*
+	* If the KnownValue has an assigned name, that name is returned.
+	* Otherwise, the string representation of the numeric value is returned.
+	*
+	* @example
+	* ```typescript
+	* const namedValue = new KnownValue(1, 'isA');
+	* console.log(namedValue.name()); // "isA"
+	*
+	* const unnamedValue = new KnownValue(42);
+	* console.log(unnamedValue.name()); // "42"
+	* ```
+	*/
+	name() {
+		return this._assignedName ?? this._value.toString();
+	}
+	/**
+	* Compares this KnownValue with another for equality.
+	* Equality is based solely on the numeric value, ignoring the name.
+	*
+	* @param other - The KnownValue to compare with
+	* @returns true if the values are equal
+	*
+	* @example
+	* ```typescript
+	* const kv1 = new KnownValue(1, 'isA');
+	* const kv2 = new KnownValue(1, 'different');
+	* console.log(kv1.equals(kv2)); // true (same value, different name)
+	* ```
+	*/
+	equals(other) {
+		return this._value === other._value;
+	}
+	/**
+	* Hash code based on the numeric value.
+	* Useful for using KnownValue in hash-based collections.
+	*/
+	hashCode() {
+		return Number(this._value & BigInt(4294967295));
+	}
+	/**
+	* String representation of the KnownValue.
+	*
+	* If a name is assigned, the name is displayed. Otherwise, the numeric value
+	* is displayed.
+	*/
+	toString() {
+		return this.name();
+	}
+	/**
+	* Returns the CBOR tags associated with KnownValue.
+	*
+	* The primary tag is TAG_KNOWN_VALUE (201).
+	*
+	* @returns Array containing the KnownValue tag
+	*/
+	cborTags() {
+		return [KNOWN_VALUE_TAG];
+	}
+	/**
+	* Returns the untagged CBOR encoding of this KnownValue.
+	*
+	* The untagged representation is simply the unsigned integer value.
+	*
+	* @returns CBOR representation of the value (unsigned integer)
+	*/
+	untaggedCbor() {
+		return cbor(this._value);
+	}
+	/**
+	* Returns the tagged CBOR encoding of this KnownValue.
+	*
+	* This wraps the unsigned integer value with tag 201.
+	*
+	* @returns Tagged CBOR representation
+	*
+	* @example
+	* ```typescript
+	* const kv = new KnownValue(1, 'isA');
+	* const tagged = kv.taggedCbor();
+	* console.log(tagged.toHex()); // "d8c901" (tag 201, value 1)
+	* ```
+	*/
+	taggedCbor() {
+		return cbor({
+			tag: TAG_KNOWN_VALUE,
+			value: this._value
+		});
+	}
+	/**
+	* Returns the tagged CBOR encoding as binary data.
+	*
+	* @returns Binary CBOR representation
+	*
+	* @example
+	* ```typescript
+	* const kv = new KnownValue(1, 'isA');
+	* const bytes = kv.toCborData();
+	* // bytes is Uint8Array containing the CBOR encoding
+	* ```
+	*/
+	toCborData() {
+		return cborData(this.taggedCbor());
+	}
+	/**
+	* Alias for `toCborData()` to match the dcbor interface.
+	*/
+	taggedCborData() {
+		return this.toCborData();
+	}
+	/**
+	* Creates a KnownValue from untagged CBOR (an unsigned integer).
+	* Instance method for interface compliance.
+	*
+	* @param cborValue - The CBOR value (must be an unsigned integer)
+	* @returns A new KnownValue
+	* @throws {Error} If the CBOR is not an unsigned integer
+	*/
+	fromUntaggedCbor(cborValue) {
+		return KnownValue.fromUntaggedCbor(cborValue);
+	}
+	/**
+	* Creates a KnownValue from tagged CBOR (tag 201).
+	* Instance method for interface compliance.
+	*
+	* @param cborValue - The tagged CBOR value
+	* @returns A new KnownValue
+	* @throws {Error} If the CBOR is not properly tagged or contains invalid data
+	*/
+	fromTaggedCbor(cborValue) {
+		return KnownValue.fromTaggedCbor(cborValue);
+	}
+	/**
+	* Creates a KnownValue from untagged CBOR (an unsigned integer).
+	*
+	* @param cborValue - The CBOR value (must be an unsigned integer)
+	* @returns A new KnownValue
+	* @throws {Error} If the CBOR is not an unsigned integer
+	*
+	* @example
+	* ```typescript
+	* const cborValue = cbor(42);
+	* const kv = KnownValue.fromUntaggedCbor(cborValue);
+	* console.log(kv.value()); // 42
+	* ```
+	*/
+	static fromUntaggedCbor(cborValue) {
+		if (cborValue.type !== MajorType.Unsigned) throw new Error(`Expected unsigned integer for KnownValue, got major type ${cborValue.type}`);
+		const numValue = cborValue.value;
+		return new KnownValue(typeof numValue === "bigint" ? numValue : BigInt(numValue));
+	}
+	/**
+	* Creates a KnownValue from tagged CBOR (tag 201).
+	*
+	* @param cborValue - The tagged CBOR value
+	* @returns A new KnownValue
+	* @throws {Error} If the CBOR is not properly tagged or contains invalid data
+	*
+	* @example
+	* ```typescript
+	* const kv = KnownValue.fromTaggedCbor(taggedCborValue);
+	* ```
+	*/
+	static fromTaggedCbor(cborValue) {
+		if (cborValue.type !== MajorType.Tagged) throw new Error(`Expected tagged CBOR for KnownValue, got major type ${cborValue.type}`);
+		const tag = cborValue.tag;
+		if (tag !== BigInt(TAG_KNOWN_VALUE) && tag !== TAG_KNOWN_VALUE) throw new Error(`Expected tag ${TAG_KNOWN_VALUE} for KnownValue, got ${tag}`);
+		return KnownValue.fromUntaggedCbor(cborValue.value);
+	}
+	/**
+	* Creates a KnownValue from binary CBOR data.
+	*
+	* @param data - Binary CBOR data (must be a tagged KnownValue)
+	* @returns A new KnownValue
+	* @throws {Error} If the data cannot be decoded or is not a valid KnownValue
+	*
+	* @example
+	* ```typescript
+	* const bytes = new Uint8Array([0xd8, 0xc9, 0x01]); // tag 201, value 1
+	* const kv = KnownValue.fromCborData(bytes);
+	* console.log(kv.value()); // 1
+	* ```
+	*/
+	static fromCborData(data) {
+		const cborValue = decodeCbor(data);
+		return KnownValue.fromTaggedCbor(cborValue);
+	}
+	/**
+	* Creates a KnownValue from a CBOR value, automatically detecting
+	* whether it's tagged or untagged.
+	*
+	* @param cborValue - The CBOR value (tagged or untagged)
+	* @returns A new KnownValue
+	* @throws {Error} If the CBOR cannot be converted to a KnownValue
+	*
+	* @example
+	* ```typescript
+	* // Works with both tagged and untagged
+	* const kv1 = KnownValue.fromCbor(cbor(42));
+	* const kv2 = KnownValue.fromCbor(taggedCborValue);
+	* ```
+	*/
+	static fromCbor(cborValue) {
+		if (cborValue.type === MajorType.Tagged) return KnownValue.fromTaggedCbor(cborValue);
+		return KnownValue.fromUntaggedCbor(cborValue);
+	}
+};
+
+//#endregion
+//#region src/known-values-store.ts
+/**
+* A store that maps between Known Values and their assigned names.
+*
+* The `KnownValuesStore` provides a bidirectional mapping between:
+* - Numeric values (bigint) and their corresponding KnownValue instances
+* - String names and their corresponding KnownValue instances
+*
+* This enables efficient lookup in both directions, making it possible to:
+* - Find the name for a given numeric value
+* - Find the numeric value for a given name
+* - Retrieve complete KnownValue instances by either name or value
+*
+* The store is typically populated with predefined Known Values from the
+* registry, but can also be extended with custom values.
+*
+* @example
+* ```typescript
+* import { KnownValuesStore, IS_A, NOTE, SIGNED } from '@bcts/known-values';
+*
+* // Create a store with predefined Known Values
+* const store = new KnownValuesStore([IS_A, NOTE, SIGNED]);
+*
+* // Look up a Known Value by name
+* const isA = store.knownValueNamed('isA');
+* console.log(isA?.value()); // 1
+*
+* // Look up a name for a raw value
+* const name = store.name(new KnownValue(3));
+* console.log(name); // "signed"
+*
+* // Insert a custom Known Value
+* const customStore = store.clone();
+* customStore.insert(new KnownValue(100, 'customValue'));
+* console.log(customStore.knownValueNamed('customValue')?.value()); // 100
+* ```
+*/
+var KnownValuesStore = class KnownValuesStore {
+	knownValuesByRawValue;
+	knownValuesByAssignedName;
+	/**
+	* Creates a new KnownValuesStore with the provided Known Values.
+	*
+	* This constructor takes an iterable of KnownValue instances and
+	* populates the store with them, creating mappings from both raw
+	* values and names to the corresponding KnownValue instances.
+	*
+	* @param knownValues - Iterable of KnownValue instances to populate the store
+	*
+	* @example
+	* ```typescript
+	* import { KnownValuesStore, IS_A, NOTE, SIGNED } from '@bcts/known-values';
+	*
+	* // Create a store with predefined Known Values
+	* const store = new KnownValuesStore([IS_A, NOTE, SIGNED]);
+	*
+	* // Look up Known Values
+	* console.log(store.knownValueNamed('isA')?.value()); // 1
+	* console.log(store.knownValueNamed('note')?.value()); // 4
+	* ```
+	*/
+	constructor(knownValues = []) {
+		this.knownValuesByRawValue = /* @__PURE__ */ new Map();
+		this.knownValuesByAssignedName = /* @__PURE__ */ new Map();
+		for (const knownValue of knownValues) this._insert(knownValue);
+	}
+	/**
+	* Inserts a KnownValue into the store.
+	*
+	* If the KnownValue has an assigned name, it will be indexed by both its
+	* raw value and its name. If a KnownValue with the same raw value or name
+	* already exists in the store, it will be replaced.
+	*
+	* @param knownValue - The KnownValue to insert
+	*
+	* @example
+	* ```typescript
+	* import { KnownValuesStore, KnownValue } from '@bcts/known-values';
+	*
+	* const store = new KnownValuesStore();
+	* store.insert(new KnownValue(100, 'customValue'));
+	* console.log(store.knownValueNamed('customValue')?.value()); // 100
+	* ```
+	*/
+	insert(knownValue) {
+		this._insert(knownValue);
+	}
+	/**
+	* Returns the assigned name for a KnownValue, if present in the store.
+	*
+	* @param knownValue - The KnownValue to look up
+	* @returns The assigned name, or undefined if not found
+	*
+	* @example
+	* ```typescript
+	* import { KnownValuesStore, IS_A } from '@bcts/known-values';
+	*
+	* const store = new KnownValuesStore([IS_A]);
+	* console.log(store.assignedName(IS_A)); // "isA"
+	* console.log(store.assignedName(new KnownValue(999))); // undefined
+	* ```
+	*/
+	assignedName(knownValue) {
+		return this.knownValuesByRawValue.get(knownValue.valueBigInt())?.assignedName();
+	}
+	/**
+	* Returns a human-readable name for a KnownValue.
+	*
+	* If the KnownValue has an assigned name in the store, that name is
+	* returned. Otherwise, the KnownValue's default name (which may be its
+	* numeric value as a string) is returned.
+	*
+	* @param knownValue - The KnownValue to get the name for
+	* @returns The name (assigned or numeric)
+	*
+	* @example
+	* ```typescript
+	* import { KnownValuesStore, IS_A } from '@bcts/known-values';
+	*
+	* const store = new KnownValuesStore([IS_A]);
+	* console.log(store.name(IS_A)); // "isA"
+	* console.log(store.name(new KnownValue(999))); // "999"
+	* ```
+	*/
+	name(knownValue) {
+		return this.assignedName(knownValue) ?? knownValue.name();
+	}
+	/**
+	* Looks up a KnownValue by its assigned name.
+	*
+	* Returns the KnownValue if found, or undefined if no KnownValue
+	* with the given name exists in the store.
+	*
+	* @param assignedName - The name to look up
+	* @returns The KnownValue, or undefined if not found
+	*
+	* @example
+	* ```typescript
+	* import { KnownValuesStore, IS_A } from '@bcts/known-values';
+	*
+	* const store = new KnownValuesStore([IS_A]);
+	*
+	* const isA = store.knownValueNamed('isA');
+	* console.log(isA?.value()); // 1
+	*
+	* console.log(store.knownValueNamed('nonexistent')); // undefined
+	* ```
+	*/
+	knownValueNamed(assignedName) {
+		return this.knownValuesByAssignedName.get(assignedName);
+	}
+	/**
+	* Looks up a KnownValue by its raw numeric value.
+	*
+	* @param rawValue - The numeric value to look up (number or bigint)
+	* @returns The KnownValue, or undefined if not found
+	*
+	* @example
+	* ```typescript
+	* import { KnownValuesStore, IS_A } from '@bcts/known-values';
+	*
+	* const store = new KnownValuesStore([IS_A]);
+	* const isA = store.knownValueForValue(1);
+	* console.log(isA?.name()); // "isA"
+	* ```
+	*/
+	knownValueForValue(rawValue) {
+		const key = typeof rawValue === "bigint" ? rawValue : BigInt(rawValue);
+		return this.knownValuesByRawValue.get(key);
+	}
+	/**
+	* Retrieves a KnownValue for a raw value, using a store if provided.
+	*
+	* This static method allows looking up a KnownValue by its raw numeric
+	* value:
+	* - If a store is provided and contains a mapping for the raw value, that
+	*   KnownValue is returned
+	* - Otherwise, a new KnownValue with no assigned name is created and
+	*   returned
+	*
+	* @param rawValue - The numeric value to look up (number or bigint)
+	* @param knownValues - Optional store to search in
+	* @returns The KnownValue from the store or a new unnamed KnownValue
+	*
+	* @example
+	* ```typescript
+	* import { KnownValuesStore, IS_A } from '@bcts/known-values';
+	*
+	* const store = new KnownValuesStore([IS_A]);
+	*
+	* // Known value from store
+	* const isA = KnownValuesStore.knownValueForRawValue(1, store);
+	* console.log(isA.name()); // "isA"
+	*
+	* // Unknown value creates a new KnownValue
+	* const unknown = KnownValuesStore.knownValueForRawValue(999, store);
+	* console.log(unknown.name()); // "999"
+	*
+	* // No store provided also creates a new KnownValue
+	* const unknown2 = KnownValuesStore.knownValueForRawValue(1, undefined);
+	* console.log(unknown2.name()); // "1"
+	* ```
+	*/
+	static knownValueForRawValue(rawValue, knownValues) {
+		if (knownValues !== void 0) {
+			const value = knownValues.knownValueForValue(rawValue);
+			if (value !== void 0) return value;
+		}
+		return new KnownValue(rawValue);
+	}
+	/**
+	* Attempts to find a KnownValue by its name, using a store if provided.
+	*
+	* This static method allows looking up a KnownValue by its name:
+	* - If a store is provided and contains a mapping for the name, that
+	*   KnownValue is returned
+	* - Otherwise, undefined is returned
+	*
+	* @param name - The name to look up
+	* @param knownValues - Optional store to search in
+	* @returns The KnownValue if found, or undefined
+	*
+	* @example
+	* ```typescript
+	* import { KnownValuesStore, IS_A } from '@bcts/known-values';
+	*
+	* const store = new KnownValuesStore([IS_A]);
+	*
+	* // Known value from store
+	* const isA = KnownValuesStore.knownValueForName('isA', store);
+	* console.log(isA?.value()); // 1
+	*
+	* // Unknown name returns undefined
+	* console.log(KnownValuesStore.knownValueForName('unknown', store)); // undefined
+	*
+	* // No store provided also returns undefined
+	* console.log(KnownValuesStore.knownValueForName('isA', undefined)); // undefined
+	* ```
+	*/
+	static knownValueForName(name, knownValues) {
+		return knownValues?.knownValueNamed(name);
+	}
+	/**
+	* Returns a human-readable name for a KnownValue, using a store if provided.
+	*
+	* This static method allows getting a name for a KnownValue:
+	* - If a store is provided and contains a mapping for the KnownValue, its
+	*   assigned name is returned
+	* - Otherwise, the KnownValue's default name (which may be its numeric
+	*   value as a string) is returned
+	*
+	* @param knownValue - The KnownValue to get the name for
+	* @param knownValues - Optional store to use for lookup
+	* @returns The name (assigned or numeric)
+	*
+	* @example
+	* ```typescript
+	* import { KnownValuesStore, IS_A } from '@bcts/known-values';
+	*
+	* const store = new KnownValuesStore([IS_A]);
+	*
+	* // Known value from store
+	* let name = KnownValuesStore.nameForKnownValue(IS_A, store);
+	* console.log(name); // "isA"
+	*
+	* // Unknown value in store uses KnownValue's name method
+	* name = KnownValuesStore.nameForKnownValue(new KnownValue(999), store);
+	* console.log(name); // "999"
+	*
+	* // No store provided also uses KnownValue's name method
+	* name = KnownValuesStore.nameForKnownValue(IS_A, undefined);
+	* console.log(name); // "isA"
+	* ```
+	*/
+	static nameForKnownValue(knownValue, knownValues) {
+		if (knownValues !== void 0) {
+			const assignedName = knownValues.assignedName(knownValue);
+			if (assignedName !== void 0 && assignedName !== "") return assignedName;
+		}
+		return knownValue.name();
+	}
+	/**
+	* Creates a shallow clone of this store.
+	*
+	* @returns A new KnownValuesStore with the same entries
+	*/
+	clone() {
+		const cloned = new KnownValuesStore();
+		cloned.knownValuesByRawValue = new Map(this.knownValuesByRawValue);
+		cloned.knownValuesByAssignedName = new Map(this.knownValuesByAssignedName);
+		return cloned;
+	}
+	/**
+	* Internal helper method to insert a KnownValue into the store's maps.
+	*/
+	_insert(knownValue) {
+		this.knownValuesByRawValue.set(knownValue.valueBigInt(), knownValue);
+		const assignedName = knownValue.assignedName();
+		if (assignedName !== void 0 && assignedName !== "") this.knownValuesByAssignedName.set(assignedName, knownValue);
+	}
+};
+
+//#endregion
+//#region src/known-values-registry.ts
+const UNIT = new KnownValue(0, "");
+const IS_A = new KnownValue(1, "isA");
+const ID = new KnownValue(2, "id");
+const SIGNED = new KnownValue(3, "signed");
+const NOTE = new KnownValue(4, "note");
+const HAS_RECIPIENT = new KnownValue(5, "hasRecipient");
+const SSKR_SHARE = new KnownValue(6, "sskrShare");
+const CONTROLLER = new KnownValue(7, "controller");
+const KEY = new KnownValue(8, "key");
+const DEREFERENCE_VIA = new KnownValue(9, "dereferenceVia");
+const ENTITY = new KnownValue(10, "entity");
+const NAME = new KnownValue(11, "name");
+const LANGUAGE = new KnownValue(12, "language");
+const ISSUER = new KnownValue(13, "issuer");
+const HOLDER = new KnownValue(14, "holder");
+const SALT = new KnownValue(15, "salt");
+const DATE = new KnownValue(16, "date");
+const UNKNOWN_VALUE = new KnownValue(17, "Unknown");
+const VERSION_VALUE = new KnownValue(18, "version");
+const HAS_SECRET = new KnownValue(19, "hasSecret");
+const DIFF_EDITS = new KnownValue(20, "edits");
+const VALID_FROM = new KnownValue(21, "validFrom");
+const VALID_UNTIL = new KnownValue(22, "validUntil");
+const POSITION = new KnownValue(23, "position");
+const NICKNAME = new KnownValue(24, "nickname");
+const ATTACHMENT = new KnownValue(50, "attachment");
+const VENDOR = new KnownValue(51, "vendor");
+const CONFORMS_TO = new KnownValue(52, "conformsTo");
+const ALLOW = new KnownValue(60, "allow");
+const DENY = new KnownValue(61, "deny");
+const ENDPOINT = new KnownValue(62, "endpoint");
+const DELEGATE = new KnownValue(63, "delegate");
+const PROVENANCE = new KnownValue(64, "provenance");
+const PRIVATE_KEY = new KnownValue(65, "privateKey");
+const SERVICE = new KnownValue(66, "service");
+const CAPABILITY = new KnownValue(67, "capability");
+const PROVENANCE_GENERATOR = new KnownValue(68, "provenanceGenerator");
+const PRIVILEGE_ALL = new KnownValue(70, "All");
+const PRIVILEGE_AUTH = new KnownValue(71, "Auth");
+const PRIVILEGE_SIGN = new KnownValue(72, "Sign");
+const PRIVILEGE_ENCRYPT = new KnownValue(73, "Encrypt");
+const PRIVILEGE_ELIDE = new KnownValue(74, "Elide");
+const PRIVILEGE_ISSUE = new KnownValue(75, "Issue");
+const PRIVILEGE_ACCESS = new KnownValue(76, "Access");
+const PRIVILEGE_DELEGATE = new KnownValue(80, "Delegate");
+const PRIVILEGE_VERIFY = new KnownValue(81, "Verify");
+const PRIVILEGE_UPDATE = new KnownValue(82, "Update");
+const PRIVILEGE_TRANSFER = new KnownValue(83, "Transfer");
+const PRIVILEGE_ELECT = new KnownValue(84, "Elect");
+const PRIVILEGE_BURN = new KnownValue(85, "Burn");
+const PRIVILEGE_REVOKE = new KnownValue(86, "Revoke");
+const BODY = new KnownValue(100, "body");
+const RESULT = new KnownValue(101, "result");
+const ERROR = new KnownValue(102, "error");
+const OK_VALUE = new KnownValue(103, "OK");
+const PROCESSING_VALUE = new KnownValue(104, "Processing");
+const SENDER = new KnownValue(105, "sender");
+const SENDER_CONTINUATION = new KnownValue(106, "senderContinuation");
+const RECIPIENT_CONTINUATION = new KnownValue(107, "recipientContinuation");
+const CONTENT = new KnownValue(108, "content");
+const SEED_TYPE = new KnownValue(200, "Seed");
+const PRIVATE_KEY_TYPE = new KnownValue(201, "PrivateKey");
+const PUBLIC_KEY_TYPE = new KnownValue(202, "PublicKey");
+const MASTER_KEY_TYPE = new KnownValue(203, "MasterKey");
+const ASSET = new KnownValue(300, "asset");
+const BITCOIN_VALUE = new KnownValue(301, "BTC");
+const ETHEREUM_VALUE = new KnownValue(302, "ETH");
+const TEZOS_VALUE = new KnownValue(303, "XTZ");
+const NETWORK = new KnownValue(400, "network");
+const MAIN_NET_VALUE = new KnownValue(401, "MainNet");
+const TEST_NET_VALUE = new KnownValue(402, "TestNet");
+const BIP32_KEY_TYPE = new KnownValue(500, "BIP32Key");
+const CHAIN_CODE = new KnownValue(501, "chainCode");
+const DERIVATION_PATH_TYPE = new KnownValue(502, "DerivationPath");
+const PARENT_PATH = new KnownValue(503, "parent");
+const CHILDREN_PATH = new KnownValue(504, "children");
+const PARENT_FINGERPRINT = new KnownValue(505, "parentFingerprint");
+const PSBT_TYPE = new KnownValue(506, "PSBT");
+const OUTPUT_DESCRIPTOR_TYPE = new KnownValue(507, "OutputDescriptor");
+const OUTPUT_DESCRIPTOR = new KnownValue(508, "outputDescriptor");
+const GRAPH = new KnownValue(600, "graph");
+const SOURCE_TARGET_GRAPH = new KnownValue(601, "SourceTargetGraph");
+const PARENT_CHILD_GRAPH = new KnownValue(602, "ParentChildGraph");
+const DIGRAPH = new KnownValue(603, "Digraph");
+const ACYCLIC_GRAPH = new KnownValue(604, "AcyclicGraph");
+const MULTIGRAPH = new KnownValue(605, "Multigraph");
+const PSEUDOGRAPH = new KnownValue(606, "Pseudograph");
+const GRAPH_FRAGMENT = new KnownValue(607, "GraphFragment");
+const DAG = new KnownValue(608, "DAG");
+const TREE = new KnownValue(609, "Tree");
+const FOREST = new KnownValue(610, "Forest");
+const COMPOUND_GRAPH = new KnownValue(611, "CompoundGraph");
+const HYPERGRAPH = new KnownValue(612, "Hypergraph");
+const DIHYPERGRAPH = new KnownValue(613, "Dihypergraph");
+const NODE = new KnownValue(700, "node");
+const EDGE = new KnownValue(701, "edge");
+const SOURCE = new KnownValue(702, "source");
+const TARGET = new KnownValue(703, "target");
+const PARENT = new KnownValue(704, "parent");
+const CHILD = new KnownValue(705, "child");
+/**
+* A lazily initialized singleton that holds the global registry of known
+* values.
+*
+* This class provides thread-safe, lazy initialization of the global
+* KnownValuesStore that contains all the predefined Known Values in the
+* registry. The store is created only when first accessed, and subsequent
+* accesses reuse the same instance.
+*
+* This is used internally by the crate and should not typically be needed by
+* users of the API, who should access Known Values through the constants
+* exposed in the `known_values` module.
+*/
+var LazyKnownValues = class {
+	_data;
+	/**
+	* Gets the global KnownValuesStore, initializing it if necessary.
+	*
+	* This method guarantees that initialization occurs exactly once.
+	*/
+	get() {
+		this._data ??= new KnownValuesStore([
+			UNIT,
+			IS_A,
+			ID,
+			SIGNED,
+			NOTE,
+			HAS_RECIPIENT,
+			SSKR_SHARE,
+			CONTROLLER,
+			KEY,
+			DEREFERENCE_VIA,
+			ENTITY,
+			NAME,
+			LANGUAGE,
+			ISSUER,
+			HOLDER,
+			SALT,
+			DATE,
+			UNKNOWN_VALUE,
+			VERSION_VALUE,
+			HAS_SECRET,
+			DIFF_EDITS,
+			VALID_FROM,
+			VALID_UNTIL,
+			POSITION,
+			NICKNAME,
+			ATTACHMENT,
+			VENDOR,
+			CONFORMS_TO,
+			ALLOW,
+			DENY,
+			ENDPOINT,
+			DELEGATE,
+			PROVENANCE,
+			PRIVATE_KEY,
+			SERVICE,
+			CAPABILITY,
+			PROVENANCE_GENERATOR,
+			PRIVILEGE_ALL,
+			PRIVILEGE_AUTH,
+			PRIVILEGE_SIGN,
+			PRIVILEGE_ENCRYPT,
+			PRIVILEGE_ELIDE,
+			PRIVILEGE_ISSUE,
+			PRIVILEGE_ACCESS,
+			PRIVILEGE_DELEGATE,
+			PRIVILEGE_VERIFY,
+			PRIVILEGE_UPDATE,
+			PRIVILEGE_TRANSFER,
+			PRIVILEGE_ELECT,
+			PRIVILEGE_BURN,
+			PRIVILEGE_REVOKE,
+			BODY,
+			RESULT,
+			ERROR,
+			OK_VALUE,
+			PROCESSING_VALUE,
+			SENDER,
+			SENDER_CONTINUATION,
+			RECIPIENT_CONTINUATION,
+			CONTENT,
+			SEED_TYPE,
+			PRIVATE_KEY_TYPE,
+			PUBLIC_KEY_TYPE,
+			MASTER_KEY_TYPE,
+			ASSET,
+			BITCOIN_VALUE,
+			ETHEREUM_VALUE,
+			TEZOS_VALUE,
+			NETWORK,
+			MAIN_NET_VALUE,
+			TEST_NET_VALUE,
+			BIP32_KEY_TYPE,
+			CHAIN_CODE,
+			DERIVATION_PATH_TYPE,
+			PARENT_PATH,
+			CHILDREN_PATH,
+			PARENT_FINGERPRINT,
+			PSBT_TYPE,
+			OUTPUT_DESCRIPTOR_TYPE,
+			OUTPUT_DESCRIPTOR,
+			GRAPH,
+			SOURCE_TARGET_GRAPH,
+			PARENT_CHILD_GRAPH,
+			DIGRAPH,
+			ACYCLIC_GRAPH,
+			MULTIGRAPH,
+			PSEUDOGRAPH,
+			GRAPH_FRAGMENT,
+			DAG,
+			TREE,
+			FOREST,
+			COMPOUND_GRAPH,
+			HYPERGRAPH,
+			DIHYPERGRAPH,
+			NODE,
+			EDGE,
+			SOURCE,
+			TARGET,
+			PARENT,
+			CHILD
+		]);
+		return this._data;
+	}
+};
+/**
+* The global registry of Known Values.
+*
+* This static instance provides access to all standard Known Values defined in
+* the registry specification. It is lazily initialized on first access.
+*
+* Most users should not need to interact with this directly, as the predefined
+* Known Values are exposed as constants in the `known_values` module.
+*
+* @example
+* ```typescript
+* import { KNOWN_VALUES } from '@bcts/known-values';
+*
+* // Access the global store
+* const knownValues = KNOWN_VALUES.get();
+*
+* // Look up a Known Value by name
+* const isA = knownValues.knownValueNamed('isA');
+* console.log(isA?.value()); // 1
+* ```
+*/
+const KNOWN_VALUES = new LazyKnownValues();
+
+//#endregion
+export { ACYCLIC_GRAPH, ALLOW, ASSET, ATTACHMENT, BIP32_KEY_TYPE, BITCOIN_VALUE, BODY, CAPABILITY, CHAIN_CODE, CHILD, CHILDREN_PATH, COMPOUND_GRAPH, CONFORMS_TO, CONTENT, CONTROLLER, DAG, DATE, DELEGATE, DENY, DEREFERENCE_VIA, DERIVATION_PATH_TYPE, DIFF_EDITS, DIGRAPH, DIHYPERGRAPH, EDGE, ENDPOINT, ENTITY, ERROR, ETHEREUM_VALUE, FOREST, GRAPH, GRAPH_FRAGMENT, HAS_RECIPIENT, HAS_SECRET, HOLDER, HYPERGRAPH, ID, ISSUER, IS_A, KEY, KNOWN_VALUES, KNOWN_VALUE_TAG, KnownValue, KnownValuesStore, LANGUAGE, LazyKnownValues, MAIN_NET_VALUE, MASTER_KEY_TYPE, MULTIGRAPH, NAME, NETWORK, NICKNAME, NODE, NOTE, OK_VALUE, OUTPUT_DESCRIPTOR, OUTPUT_DESCRIPTOR_TYPE, PARENT, PARENT_CHILD_GRAPH, PARENT_FINGERPRINT, PARENT_PATH, POSITION, PRIVATE_KEY, PRIVATE_KEY_TYPE, 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, PROCESSING_VALUE, PROVENANCE, PROVENANCE_GENERATOR, PSBT_TYPE, PSEUDOGRAPH, PUBLIC_KEY_TYPE, RECIPIENT_CONTINUATION, RESULT, SALT, SEED_TYPE, SENDER, SENDER_CONTINUATION, SERVICE, SIGNED, SOURCE, SOURCE_TARGET_GRAPH, SSKR_SHARE, TAG_KNOWN_VALUE, TARGET, TEST_NET_VALUE, TEZOS_VALUE, TREE, UNIT, UNKNOWN_VALUE, VALID_FROM, VALID_UNTIL, VENDOR, VERSION_VALUE };
+//# sourceMappingURL=index.mjs.map