@bcts/dcbor 1.0.0-beta.3 → 1.0.0-beta.4

package/dist/index.mjs

@@ -4186,13 +4186,19 @@ const tagWithStaticName = (value, name) => ({
 	name
 });
 /**
+* Compare two tag values for equality, normalizing `number` vs `bigint`.
+* A raw `===` would treat `100n` and `100` as unequal, so a large tag that
+* decoded to a `bigint` wouldn't match the same value written as a `number`.
+*/
+const tagValuesEqual = (a, b) => {
+	if (typeof a === "bigint" || typeof b === "bigint") return BigInt(a) === BigInt(b);
+	return a === b;
+};
+/**
 * Compare two tags for equality. Mirrors Rust's `PartialEq for Tag`, which
 * compares by `value` only and ignores the optional `name`.
 */
-const tagsEqual = (a, b) => {
-	if (typeof a.value === "bigint" || typeof b.value === "bigint") return BigInt(a.value) === BigInt(b.value);
-	return a.value === b.value;
-};
+const tagsEqual = (a, b) => tagValuesEqual(a.value, b.value);
 /**
 * Get the string representation of a tag.
 * Internal function used for error messages.
@@ -4611,6 +4617,33 @@ var import_byte_data = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((
 const hasFract = (n) => {
 	return n % 1 !== 0;
 };
+const U64_MAX_BIG = 18446744073709551615n;
+const I64_MAX_BIG = 9223372036854775807n;
+const I64_MIN_BIG = -9223372036854775808n;
+/**
+* Truncate a float to u64 with Rust's saturating `as u64` semantics: NaN and
+* negatives clamp to 0, values at or above 2^64 clamp to u64::MAX. This lets the
+* exact-float checks below mirror Rust's `(f as u64) == source` round-trip, where
+* u64::MAX rounds to 2^64 in float but saturates back to u64::MAX.
+*/
+const saturateFloatToU64 = (f) => {
+	if (Number.isNaN(f)) return 0n;
+	const t = Math.trunc(f);
+	if (t <= 0) return 0n;
+	const big = BigInt(t);
+	return big > U64_MAX_BIG ? U64_MAX_BIG : big;
+};
+/**
+* Truncate a float to i64 with Rust's saturating `as i64` semantics: NaN clamps
+* to 0, values clamp to i64::MAX or i64::MIN at the bounds.
+*/
+const saturateFloatToI64 = (f) => {
+	if (Number.isNaN(f)) return 0n;
+	const big = BigInt(Math.trunc(f));
+	if (big > I64_MAX_BIG) return I64_MAX_BIG;
+	if (big < I64_MIN_BIG) return I64_MIN_BIG;
+	return big;
+};
 /**
 * Exact conversions for i128 (JavaScript bigint).
 */
@@ -4774,6 +4807,55 @@ var ExactU64 = class {
 		return source <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(source) : source;
 	}
 };
+/**
+* Exact conversions for f64 (double precision float).
+*/
+var ExactF64 = class {
+	static exactFromF16(source) {
+		if (Number.isNaN(source)) return NaN;
+		return source;
+	}
+	static exactFromF32(source) {
+		if (Number.isNaN(source)) return NaN;
+		return source;
+	}
+	static exactFromF64(source) {
+		if (Number.isNaN(source)) return NaN;
+		return source;
+	}
+	static exactFromU64(source) {
+		const srcBig = typeof source === "bigint" ? source : BigInt(source);
+		const n = Number(srcBig);
+		if (!Number.isFinite(n)) return void 0;
+		return saturateFloatToU64(n) === srcBig ? n : void 0;
+	}
+	static exactFromI64(source) {
+		const srcBig = typeof source === "bigint" ? source : BigInt(source);
+		const n = Number(srcBig);
+		if (!Number.isFinite(n)) return void 0;
+		return saturateFloatToI64(n) === srcBig ? n : void 0;
+	}
+	static exactFromU128(source) {
+		const n = Number(source);
+		return BigInt(Math.trunc(n)) === source ? n : void 0;
+	}
+	static exactFromI128(source) {
+		if (source < -9223372036854775808n || source > 9223372036854775807n) return;
+		const absSource = source < 0n ? -source : source;
+		if (absSource <= 4503599627370495n) return Number(source);
+		const trailingZeros = countTrailingZeros(absSource);
+		if (trailingZeros >= 53 && trailingZeros <= 63) return Number(source);
+	}
+};
+const countTrailingZeros = (n) => {
+	if (n === 0n) return 0;
+	let count = 0;
+	while ((n & 1n) === 0n) {
+		count++;
+		n = n >> 1n;
+	}
+	return count;
+};
 //#endregion
 //#region src/float.ts
 /**
@@ -4882,11 +4964,11 @@ const f64CborData = (value) => {
 		const i128 = ExactI128.exactFromF64(n);
 		if (i128 !== void 0) {
 			const i = ExactU64.exactFromI128(-1n - i128);
-			if (i !== void 0) return encodeVarInt(typeof i === "bigint" ? Number(i) : i, MajorType.Negative);
+			if (i !== void 0) return encodeVarInt(i, MajorType.Negative);
 		}
 	}
 	const u = ExactU64.exactFromF64(n);
-	if (u !== void 0) return encodeVarInt(typeof u === "bigint" ? Number(u) : u, MajorType.Unsigned);
+	if (u !== void 0) return encodeVarInt(u, MajorType.Unsigned);
 	if (Number.isNaN(value)) return CBOR_NAN;
 	const buffer = /* @__PURE__ */ new ArrayBuffer(8);
 	new DataView(buffer).setFloat64(0, n, false);
@@ -4904,8 +4986,8 @@ const f32CborData = (value) => {
 	const f = binary16ToNumber(numberToBinary16(n));
 	if (f === n) return f16CborData(f);
 	if (n < 0) {
-		const u = ExactU64.exactFromF32(-1 - n);
-		if (u !== void 0) return encodeVarInt(typeof u === "bigint" ? Number(u) : u, MajorType.Negative);
+		const u = ExactU64.exactFromF32(Math.fround(-1 - n));
+		if (u !== void 0) return encodeVarInt(u, MajorType.Negative);
 	}
 	const u = ExactU32.exactFromF32(n);
 	if (u !== void 0) return encodeVarInt(u, MajorType.Unsigned);
@@ -4923,7 +5005,7 @@ const f16CborData = (value) => {
 	const n = value;
 	if (n < 0) {
 		const u = ExactU64.exactFromF64(-1 - n);
-		if (u !== void 0) return encodeVarInt(typeof u === "bigint" ? Number(u) : u, MajorType.Negative);
+		if (u !== void 0) return encodeVarInt(u, MajorType.Negative);
 	}
 	const u = ExactU16.exactFromF64(n);
 	if (u !== void 0) return encodeVarInt(u, MajorType.Unsigned);
@@ -4931,6 +5013,31 @@ const f16CborData = (value) => {
 	const bytes = numberToBinary16(value);
 	return new Uint8Array([249, ...bytes]);
 };
+/**
+* Render a float to its diagnostic string, matching Rust's `Simple` Display.
+*
+* Finite non-zero values with magnitude in [1e-4, 1e16) print in decimal with
+* at least one fractional digit (whole values get a trailing `.0`); everything
+* else prints in exponential form. Zero prints as `0.0`/`-0.0`.
+*
+* JS already produces the same shortest round-tripping digits; we only fix up
+* the notation threshold, the `e+` → `e` exponent, and the `.0` suffix.
+*
+* @param value - The float value
+* @returns Rust-`Display`-compatible string
+*/
+const floatDisplayString = (value) => {
+	if (Number.isNaN(value)) return "NaN";
+	if (!Number.isFinite(value)) return value > 0 ? "Infinity" : "-Infinity";
+	if (value === 0) return Object.is(value, -0) ? "-0.0" : "0.0";
+	const abs = Math.abs(value);
+	if (abs >= 1e-4 && abs < 0x2386f26fc10000) {
+		let str = String(value);
+		if (!str.includes(".")) str = `${str}.0`;
+		return str;
+	}
+	return value.toExponential().replace("e+", "e");
+};
 //#endregion
 //#region src/varint.ts
 /**
@@ -5195,6 +5302,34 @@ const getGlobalTagsStore = () => {
 	globalTagsStore ??= new TagsStore();
 	return globalTagsStore;
 };
+/**
+* Execute a function with access to the global tags store.
+*
+* @template T - Return type of the action function
+* @param action - Function to execute with the tags store
+* @returns Result of the action function
+*
+* @example
+* ```typescript
+* const tagName = withTags(store => store.nameForValue(1));
+* console.log(tagName); // 'date'
+* ```
+*/
+const withTags = (action) => {
+	return action(getGlobalTagsStore());
+};
+/**
+* Execute a function with mutable access to the global tags store.
+*
+* This is an alias for withTags() for consistency with Rust API.
+*
+* @template T - Return type of the action function
+* @param action - Function to execute with the tags store
+* @returns Result of the action function
+*/
+const withTagsMut = (action) => {
+	return action(getGlobalTagsStore());
+};
 //#endregion
 //#region src/dump.ts
 /**
@@ -5398,7 +5533,7 @@ function dumpItems(cbor, level, opts) {
 			if (simple.type === "True") note = "true";
 			else if (simple.type === "False") note = "false";
 			else if (simple.type === "Null") note = "null";
-			else if (simple.type === "Float") note = `${simple.value}`;
+			else if (simple.type === "Float") note = floatDisplayString(simple.value);
 			else note = "simple";
 			items.push(new DumpItem(level, [data], note));
 			break;
@@ -5625,7 +5760,7 @@ function item_tagged(tag, content, opts) {
 		if (summarizer !== void 0) {
 			const result = summarizer(content, opts.flat ?? false);
 			if (result.ok) return item(result.value);
-			return item(`<error: ${result.error.type === "Custom" ? result.error.message : result.error.type === "WrongTag" ? `expected CBOR tag ${result.error.expected.value}, but got ${result.error.actual.value}` : result.error.type}>`);
+			return item(`<error: ${errorToString(result.error)}>`);
 		}
 	}
 	let comment;
@@ -5648,7 +5783,7 @@ function formatBytes(value) {
 	return `h'${bytesToHex(value)}'`;
 }
 function formatText(value) {
-	return `"${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t")}"`;
+	return `"${value.replace(/"/g, "\\\"")}"`;
 }
 function formatSimple(value) {
 	switch (value.type) {
@@ -5659,20 +5794,11 @@ function formatSimple(value) {
 	}
 }
 /**
-* Format a finite CBOR float to match Rust `Simple::format!("{:?}", v)`.
-*
-* - `1.0` → `"1.0"` (Rust Debug). JS `String(1.0)` gives `"1"` so we append `.0`.
-* - `1.5` → `"1.5"`.
-* - `1e100` → `"1e100"` (Rust uses no `+` sign in the exponent). JS uses `1e+100`.
-* - Specials (NaN / ±Infinity) produce the exact Rust strings.
+* Format a CBOR float for diagnostic output. Shared with the hex-dump
+* annotation path; see {@link floatDisplayString}.
 */
 function formatFloat(value) {
-	if (Number.isNaN(value)) return "NaN";
-	if (!Number.isFinite(value)) return value > 0 ? "Infinity" : "-Infinity";
-	let str = String(value);
-	str = str.replace(/e\+/, "e");
-	if (!str.includes(".") && !str.includes("e")) str = `${str}.0`;
-	return str;
+	return floatDisplayString(value);
 }
 function resolveTagsStore(tags) {
 	if (tags === "none") return void 0;
@@ -5762,7 +5888,7 @@ function at(data, index) {
 	return data.getUint8(index);
 }
 function from(data, index) {
-	return new DataView(data.buffer, data.byteOffset + index);
+	return new DataView(data.buffer, data.byteOffset + index, data.byteLength - index);
 }
 function range(data, start, end) {
 	return new DataView(data.buffer, data.byteOffset + start, end - start);
@@ -5866,7 +5992,15 @@ function decodeCborInternal(data) {
 			const textLen = value;
 			if (typeof textLen === "bigint") throw new CborError({ type: "OutOfRange" });
 			const textBuf = parseBytes(from(data, varIntLen), textLen);
-			const text = new TextDecoder().decode(textBuf);
+			let text;
+			try {
+				text = new TextDecoder("utf-8", { fatal: true }).decode(textBuf);
+			} catch (e) {
+				throw new CborError({
+					type: "InvalidUtf8",
+					message: e instanceof Error ? e.message : String(e)
+				});
+			}
 			if (text.normalize("NFC") !== text) throw new CborError({ type: "NonCanonicalString" });
 			return {
 				cbor: attachMethods({
@@ -6245,9 +6379,12 @@ const asBoolean = (cbor) => {
 * @returns Float or undefined
 */
 const asFloat = (cbor) => {
-	if (cbor.type !== MajorType.Simple) return;
-	const simple = cbor.value;
-	if (isFloat$1(simple)) return simple.value;
+	if (cbor.type === MajorType.Unsigned) return ExactF64.exactFromU64(cbor.value);
+	if (cbor.type === MajorType.Negative) {
+		const f = ExactF64.exactFromU64(cbor.value);
+		return f === void 0 ? void 0 : -1 - f;
+	}
+	if (cbor.type === MajorType.Simple) return isFloat$1(cbor.value) ? cbor.value.value : void 0;
 };
 /**
 * Extract any numeric value (integer or float).
@@ -6368,9 +6505,13 @@ const expectBoolean = (cbor) => {
 * @throws {CborError} With type 'WrongType' if cbor is not a float
 */
 const expectFloat = (cbor) => {
-	const value = asFloat(cbor);
-	if (value === void 0) throw new CborError({ type: "WrongType" });
-	return value;
+	if (cbor.type === MajorType.Unsigned || cbor.type === MajorType.Negative) {
+		const value = asFloat(cbor);
+		if (value === void 0) throw new CborError({ type: "OutOfRange" });
+		return value;
+	}
+	if (cbor.type === MajorType.Simple && isFloat$1(cbor.value)) return cbor.value.value;
+	throw new CborError({ type: "WrongType" });
 };
 /**
 * Extract any numeric value, throwing if type doesn't match.
@@ -6508,7 +6649,7 @@ const tagContent = (cbor) => {
 */
 const hasTag = (cbor, tag) => {
 	if (cbor.type !== MajorType.Tagged) return false;
-	return cbor.tag === tag;
+	return tagValuesEqual(cbor.tag, tag);
 };
 /**
 * Extract content if has specific tag.
@@ -6518,7 +6659,7 @@ const hasTag = (cbor, tag) => {
 * @returns Tagged content or undefined
 */
 const getTaggedContent = (cbor, tag) => {
-	if (cbor.type === MajorType.Tagged && cbor.tag === tag) return cbor.value;
+	if (cbor.type === MajorType.Tagged && tagValuesEqual(cbor.tag, tag)) return cbor.value;
 };
 /**
 * Extract content if has specific tag, throwing if not.
@@ -6533,7 +6674,7 @@ const getTaggedContent = (cbor, tag) => {
 */
 const expectTaggedContent = (cbor, tag) => {
 	if (cbor.type !== MajorType.Tagged) throw new CborError({ type: "WrongType" });
-	if (cbor.tag !== tag) throw new CborError({
+	if (!tagValuesEqual(cbor.tag, tag)) throw new CborError({
 		type: "WrongTag",
 		expected: { value: tag },
 		actual: { value: cbor.tag }
@@ -6773,15 +6914,13 @@ var CborMap = class CborMap {
 	* Matches Rust's Map::insert_next().
 	*/
 	setNext(key, value) {
-		const lastEntry = this._dict.max();
-		if (lastEntry === void 0) {
-			this.set(key, value);
-			return;
-		}
 		const keyCbor = cbor(key);
 		const newKey = cborData(keyCbor);
 		if (this._dict.has(newKey)) throw new CborError({ type: "DuplicateMapKey" });
-		if (lexicographicallyCompareBytes(newKey, this._makeKey(lastEntry.key)) <= 0) throw new CborError({ type: "MisorderedMapKey" });
+		const greatest = this._dict.store.max();
+		if (greatest !== void 0) {
+			if (lexicographicallyCompareBytes(newKey, greatest.key) <= 0) throw new CborError({ type: "MisorderedMapKey" });
+		}
 		this._dict.set(newKey, {
 			key: keyCbor,
 			value: cbor(value)
@@ -7135,15 +7274,27 @@ const cbor = (value) => {
 			value: -Infinity
 		}
 	};
-	else if (typeof value === "number" && !Number.isSafeInteger(value)) result = {
-		isCbor: true,
-		type: MajorType.Simple,
-		value: {
-			type: "Float",
-			value
-		}
-	};
-	else if (typeof value === "bigint" && (value > 18446744073709551615n || value < -18446744073709551616n)) throw new CborError({ type: "OutOfRange" });
+	else if (typeof value === "number" && !Number.isSafeInteger(value)) {
+		const big = BigInt(value);
+		if (big >= 0n && big <= 18446744073709551615n) result = {
+			isCbor: true,
+			type: MajorType.Unsigned,
+			value: big
+		};
+		else if (big < 0n && big >= -18446744073709551616n) result = {
+			isCbor: true,
+			type: MajorType.Negative,
+			value: -big - 1n
+		};
+		else result = {
+			isCbor: true,
+			type: MajorType.Simple,
+			value: {
+				type: "Float",
+				value
+			}
+		};
+	} else if (typeof value === "bigint" && (value > 18446744073709551615n || value < -18446744073709551616n)) throw new CborError({ type: "OutOfRange" });
 	else if (value < 0) if (typeof value === "bigint") result = {
 		isCbor: true,
 		type: MajorType.Negative,
@@ -7494,7 +7645,7 @@ const attachMethods = (obj) => {
 		expectTag(expectedTag) {
 			if (this.type !== MajorType.Tagged) throw new CborError({ type: "WrongType" });
 			const expected = typeof expectedTag === "object" && "value" in expectedTag ? expectedTag : { value: expectedTag };
-			if (this.tag !== expected.value) throw new CborError({
+			if (!tagValuesEqual(this.tag, expected.value)) throw new CborError({
 				type: "WrongTag",
 				expected,
 				actual: { value: this.tag }
@@ -7507,7 +7658,7 @@ const attachMethods = (obj) => {
 		validateTag(expectedTags) {
 			if (this.type !== MajorType.Tagged) throw new CborError({ type: "WrongType" });
 			const tagValue = this.tag;
-			const matchingTag = expectedTags.find((t) => t.value === tagValue);
+			const matchingTag = expectedTags.find((t) => tagValuesEqual(t.value, tagValue));
 			if (matchingTag === void 0) throw new CborError({
 				type: "WrongTag",
 				expected: expectedTags[0],
@@ -7589,807 +7740,1265 @@ const Cbor = {
 	}
 };
 //#endregion
-//#region src/cbor-tagged-encodable.ts
-/**
-* Copyright © 2023-2026 Blockchain Commons, LLC
-* Copyright © 2025-2026 Parity Technologies
-*
-*
-* Tagged CBOR encoding support.
-*
-* This module provides the `CborTaggedEncodable` interface, which enables types to
-* be encoded as tagged CBOR values.
-*
-* CBOR tags provide semantic information about the encoded data. For example,
-* tag 1 is used for dates, indicating that the value should be interpreted
-* as a timestamp. The dCBOR library ensures these tags are encoded
-* deterministically.
-*
-* This interface enables seamless encoding of TypeScript types to properly tagged CBOR
-* values.
-*
-* @module cbor-tagged-encodable
-*/
-/**
-* Helper function to create tagged CBOR from an encodable object.
-*
-* Uses the first tag from cborTags().
-*
-* @param encodable - Object implementing CborTaggedEncodable
-* @returns Tagged CBOR value
-*/
-const createTaggedCbor = (encodable) => {
-	const tags = encodable.cborTags();
-	if (tags.length === 0) throw new CborError({
-		type: "Custom",
-		message: "No tags defined for this type"
-	});
-	const tag = tags[0];
-	if (tag === void 0) throw new CborError({
-		type: "Custom",
-		message: "Tag is undefined"
-	});
-	const untagged = encodable.untaggedCbor();
-	return attachMethods({
-		isCbor: true,
-		type: MajorType.Tagged,
-		tag: tag.value,
-		value: untagged
-	});
-};
-/**
-* Default `taggedCborData()` implementation — `taggedCbor().toData()`.
-*
-* Mirrors Rust's default `tagged_cbor_data()` impl on
-* `CBORTaggedEncodable`. TypeScript interfaces don't carry method bodies,
-* so this helper plays the role of the Rust trait default; concrete types
-* call it from their own `taggedCborData()` if they don't need to override.
-*/
-const taggedCborData = (encodable) => encodable.taggedCbor().toData();
-//#endregion
-//#region src/cbor-tagged-decodable.ts
-/**
-* Copyright © 2023-2026 Blockchain Commons, LLC
-* Copyright © 2025-2026 Parity Technologies
-*
-*
-* Tagged CBOR decoding support.
-*
-* This module provides the `CborTaggedDecodable` interface, which enables types to
-* be decoded from tagged CBOR values.
-*
-* Tagged CBOR values include semantic information about how to interpret the
-* data. This interface allows TypeScript types to verify that incoming CBOR data has the
-* expected tag(s) and to decode the data appropriately.
-*
-* @module cbor-tagged-decodable
-*/
-/**
-* Helper function to validate that a CBOR value has one of the expected tags.
-*
-* @param cbor - CBOR value to validate
-* @param expectedTags - Array of valid tags
-* @returns The matching tag
-* @throws Error if the value is not tagged or has an unexpected tag
-*/
-const validateTag = (cbor, expectedTags) => {
-	if (cbor.type !== MajorType.Tagged) throw new CborError({ type: "WrongType" });
-	const tagValue = cbor.tag;
-	const matchingTag = expectedTags.find((t) => t.value === tagValue);
-	if (matchingTag === void 0) throw new CborError({
-		type: "WrongTag",
-		expected: expectedTags[0],
-		actual: { value: tagValue }
-	});
-	return matchingTag;
-};
-/**
-* Helper function to extract the content from a tagged CBOR value.
-*
-* @param cbor - Tagged CBOR value
-* @returns The untagged content
-* @throws Error if the value is not tagged
-*/
-const extractTaggedContent = (cbor) => {
-	if (cbor.type !== MajorType.Tagged) throw new CborError({ type: "WrongType" });
-	return cbor.value;
-};
-/**
-* Default `fromTaggedCborData()` implementation — `decodeCbor(data)` then
-* delegate to the decodable's `fromTaggedCbor()`.
-*
-* Mirrors Rust's default `from_tagged_cbor_data` impl on
-* `CBORTaggedDecodable`.
-*/
-function fromTaggedCborData(decodable, data) {
-	return decodable.fromTaggedCbor(decodeCbor(data));
-}
-/**
-* Default `fromUntaggedCborData()` implementation — `decodeCbor(data)`
-* then delegate to the decodable's `fromUntaggedCbor()`.
-*
-* Mirrors Rust's default `from_untagged_cbor_data` impl on
-* `CBORTaggedDecodable`.
-*/
-function fromUntaggedCborData(decodable, data) {
-	return decodable.fromUntaggedCbor(decodeCbor(data));
-}
-//#endregion
-//#region src/date.ts
+//#region src/set.ts
 /**
 * Copyright © 2023-2026 Blockchain Commons, LLC
 * Copyright © 2025-2026 Parity Technologies
 *
 *
-* Date/time support for CBOR with tag(1) encoding.
-*
-* A CBOR-friendly representation of a date and time.
-*
-* The `CborDate` type provides a wrapper around JavaScript's native `Date` that
-* supports encoding and decoding to/from CBOR with tag 1, following the CBOR
-* date/time standard specified in RFC 8949.
+* Set data structure for CBOR.
 *
-* When encoded to CBOR, dates are represented as tag 1 followed by a numeric
-* value representing the number of seconds since (or before) the Unix epoch
-* (1970-01-01T00:00:00Z). The numeric value can be a positive or negative
-* integer, or a floating-point value for dates with fractional seconds.
+* A Set encodes to a plain (untagged) array of unique elements in canonical
+* ascending CBOR-byte order. There's no tag-258 here: this matches Rust
+* dcbor's `From<Set> for CBOR`, which emits an untagged array.
 *
-* @module date
+* @module set
 */
 /**
-* A CBOR-friendly representation of a date and time.
-*
-* The `CborDate` type provides a wrapper around JavaScript's native `Date` that
-* supports encoding and decoding to/from CBOR with tag 1, following the CBOR
-* date/time standard specified in RFC 8949.
-*
-* When encoded to CBOR, dates are represented as tag 1 followed by a numeric
-* value representing the number of seconds since (or before) the Unix epoch
-* (1970-01-01T00:00:00Z). The numeric value can be a positive or negative
-* integer, or a floating-point value for dates with fractional seconds.
-*
-* # Features
+* CBOR Set type, encoded as a plain (untagged) array.
 *
-* - Supports UTC dates with optional fractional seconds
-* - Provides convenient constructors for common date creation patterns
-* - Implements the `CborTagged`, `CborTaggedEncodable`, and
-*   `CborTaggedDecodable` interfaces
-* - Supports arithmetic operations with durations and between dates
+* Internally uses a CborMap to ensure unique elements with deterministic ordering.
+* Elements are ordered by their CBOR encoding (lexicographic byte order).
 *
 * @example
 * ```typescript
-* import { CborDate } from './date';
-*
-* // Create a date from a timestamp (seconds since Unix epoch)
-* const date = CborDate.fromTimestamp(1675854714.0);
+* // Create set
+* const set = CborSet.fromArray([1, 2, 3]);
+* const set2 = CborSet.fromSet(new Set([1, 2, 3]));
 *
-* // Create a date from year, month, day
-* const date2 = CborDate.fromYmd(2023, 2, 8);
+* // Add elements
+* set.insert(4);
+* set.insert(2); // Duplicate, no effect
 *
-* // Convert to CBOR
-* const cborValue = date.taggedCbor();
+* // Check membership
+* console.log(set.contains(2)); // true
+* console.log(set.contains(99)); // false
 *
-* // Decode from CBOR
-* const decoded = CborDate.fromTaggedCbor(cborValue);
+* // Encode to CBOR (untagged array)
+* const c = set.toCbor();
 * ```
 */
-var CborDate = class CborDate {
-	/**
-	* Canonical timestamp in seconds since the Unix epoch as a JS `number`
-	* (`f64`). dCBOR encodes Date (tag 1) as a numeric value in seconds, so
-	* keeping `_seconds` as the source of truth avoids the millisecond-only
-	* round-trip precision loss that going through a JS `Date` instance
-	* introduced in earlier versions of this port.
-	*
-	* f64 still bounds the achievable precision (~16 decimal digits, so
-	* roughly microseconds for current epoch values); Rust's
-	* `chrono::DateTime<Utc>` retains nanoseconds in memory but encodes
-	* to the same f64 over the wire, so the *encode/decode round-trip* is
-	* byte-identical.
-	*/
-	_seconds;
+var CborSet = class CborSet {
+	_map;
+	constructor() {
+		this._map = new CborMap();
+	}
 	/**
-	* Creates a new `CborDate` from the given JavaScript `Date`.
-	*
-	* This method creates a new `CborDate` instance by wrapping a
-	* JavaScript `Date`.
+	* Create CborSet from array.
 	*
-	* @param dateTime - A `Date` instance to wrap
+	* Duplicates are automatically removed.
 	*
-	* @returns A new `CborDate` instance
+	* @param items - Array of items to add to the set
+	* @returns New CborSet instance
 	*
 	* @example
 	* ```typescript
-	* const datetime = new Date();
-	* const date = CborDate.fromDatetime(datetime);
+	* const set = CborSet.fromArray([1, 2, 3, 2, 1]);
+	* console.log(set.size); // 3
 	* ```
 	*/
-	static fromDatetime(dateTime) {
-		const instance = new CborDate();
-		instance._seconds = dateTime.getTime() / 1e3;
-		return instance;
+	static fromArray(items) {
+		const set = new CborSet();
+		for (const item of items) set.insert(item);
+		return set;
 	}
 	/**
-	* Creates a new `CborDate` from year, month, and day components.
-	*
-	* This method creates a new `CborDate` with the time set to 00:00:00 UTC.
-	*
-	* @param year - The year component (e.g., 2023)
-	* @param month - The month component (1-12)
-	* @param day - The day component (1-31)
+	* Create CborSet from JavaScript Set.
 	*
-	* @returns A new `CborDate` instance
+	* @param items - JavaScript Set of items
+	* @returns New CborSet instance
 	*
 	* @example
 	* ```typescript
-	* // Create February 8, 2023
-	* const date = CborDate.fromYmd(2023, 2, 8);
+	* const jsSet = new Set([1, 2, 3]);
+	* const cborSet = CborSet.fromSet(jsSet);
 	* ```
+	*/
+	static fromSet(items) {
+		return CborSet.fromArray(Array.from(items));
+	}
+	/**
+	* Create CborSet from iterable.
 	*
-	* @throws Error if the provided components do not form a valid date.
+	* @param items - Iterable of items
+	* @returns New CborSet instance
 	*/
-	static fromYmd(year, month, day) {
-		const dt = new Date(Date.UTC(year, month - 1, day, 0, 0, 0, 0));
-		return CborDate.fromDatetime(dt);
+	static fromIterable(items) {
+		return CborSet.fromArray(Array.from(items));
 	}
 	/**
-	* Creates a new `CborDate` from year, month, day, hour, minute, and second
-	* components.
+	* Insert an element into the set.
 	*
-	* @param year - The year component (e.g., 2023)
-	* @param month - The month component (1-12)
-	* @param day - The day component (1-31)
-	* @param hour - The hour component (0-23)
-	* @param minute - The minute component (0-59)
-	* @param second - The second component (0-59)
+	* If the element already exists, has no effect.
 	*
-	* @returns A new `CborDate` instance
+	* @param value - Value to insert
 	*
 	* @example
 	* ```typescript
-	* // Create February 8, 2023, 15:30:45 UTC
-	* const date = CborDate.fromYmdHms(2023, 2, 8, 15, 30, 45);
+	* const set = new CborSet();
+	* set.insert(1);
+	* set.insert(2);
+	* set.insert(1); // No effect, already exists
 	* ```
-	*
-	* @throws Error if the provided components do not form a valid date and time.
 	*/
-	static fromYmdHms(year, month, day, hour, minute, second) {
-		const dt = new Date(Date.UTC(year, month - 1, day, hour, minute, second, 0));
-		return CborDate.fromDatetime(dt);
+	insert(value) {
+		const cborValue = encodeCborValue(value);
+		this._map.set(cborValue, cborValue);
 	}
 	/**
-	* Creates a new `CborDate` from seconds since (or before) the Unix epoch.
+	* Insert an element that must sort strictly after every element inserted so
+	* far (canonical CBOR-byte order). The decoder uses this to reject
+	* misordered or duplicate elements.
 	*
-	* This method creates a new `CborDate` representing the specified number of
-	* seconds since the Unix epoch (1970-01-01T00:00:00Z). Negative values
-	* represent times before the epoch.
+	* Mirrors Rust `Set::insert_next` (`pub(crate)`); exposed here because
+	* TypeScript has no crate-private visibility.
 	*
-	* @param secondsSinceUnixEpoch - Seconds from the Unix epoch (positive or
-	*   negative), which can include a fractional part for sub-second
-	*   precision
+	* @throws CborError of type `MisorderedMap` if `value` would not preserve
+	*   strict ascending CBOR-byte order, or `DuplicateMapKey` for an exact
+	*   repeat.
+	*/
+	insertNext(value) {
+		const cborValue = encodeCborValue(value);
+		this._map.setNext(cborValue, cborValue);
+	}
+	/**
+	* Check if set contains an element.
 	*
-	* @returns A new `CborDate` instance
+	* @param value - Value to check
+	* @returns true if element is in the set
 	*
 	* @example
 	* ```typescript
-	* // Create a date from a timestamp
-	* const date = CborDate.fromTimestamp(1675854714.0);
-	*
-	* // Create a date one second before the Unix epoch
-	* const beforeEpoch = CborDate.fromTimestamp(-1.0);
-	*
-	* // Create a date with fractional seconds
-	* const withFraction = CborDate.fromTimestamp(1675854714.5);
+	* const set = CborSet.fromArray([1, 2, 3]);
+	* console.log(set.contains(2)); // true
+	* console.log(set.contains(99)); // false
 	* ```
 	*/
-	static fromTimestamp(secondsSinceUnixEpoch) {
-		const instance = new CborDate();
-		instance._seconds = secondsSinceUnixEpoch;
-		return instance;
+	contains(value) {
+		const cborValue = encodeCborValue(value);
+		return this._map.has(cborValue);
 	}
 	/**
-	* Creates a new `CborDate` from a string containing an ISO-8601 (RFC-3339)
-	* date (with or without time).
-	*
-	* This method parses a string representation of a date or date-time in
-	* ISO-8601/RFC-3339 format and creates a new `CborDate` instance. It
-	* supports both full date-time strings (e.g., "2023-02-08T15:30:45Z")
-	* and date-only strings (e.g., "2023-02-08").
-	*
-	* @param value - A string containing a date or date-time in ISO-8601/RFC-3339
-	*   format
-	*
-	* @returns A new `CborDate` instance if parsing succeeds
+	* Remove an element from the set.
 	*
-	* @throws Error if the string cannot be parsed as a valid date or date-time
+	* @param value - Value to remove
+	* @returns true if element was removed, false if not found
 	*
 	* @example
 	* ```typescript
-	* // Parse a date-time string
-	* const date = CborDate.fromString("2023-02-08T15:30:45Z");
-	*
-	* // Parse a date-only string (time will be set to 00:00:00)
-	* const date2 = CborDate.fromString("2023-02-08");
+	* const set = CborSet.fromArray([1, 2, 3]);
+	* set.delete(2); // Returns true
+	* set.delete(99); // Returns false
 	* ```
 	*/
-	static fromString(value) {
-		const dt = new Date(value);
-		if (isNaN(dt.getTime())) throw new CborError({
-			type: "InvalidDate",
-			message: "Invalid date string"
-		});
-		return CborDate.fromDatetime(dt);
+	delete(value) {
+		const cborValue = encodeCborValue(value);
+		return this._map.delete(cborValue);
 	}
 	/**
-	* Creates a new `CborDate` containing the current date and time.
-	*
-	* @returns A new `CborDate` instance representing the current UTC date and time
+	* Remove all elements from the set.
+	*/
+	clear() {
+		this._map.clear();
+	}
+	/**
+	* Get the number of elements in the set.
 	*
-	* @example
-	* ```typescript
-	* const now = CborDate.now();
-	* ```
+	* @returns Number of elements
 	*/
-	static now() {
-		return CborDate.fromDatetime(/* @__PURE__ */ new Date());
+	get size() {
+		return this._map.size;
 	}
 	/**
-	* Creates a new `CborDate` containing the current date and time plus the given
-	* duration.
+	* Check if the set is empty.
 	*
-	* @param durationMs - The duration in milliseconds to add to the current time
+	* @returns true if set has no elements
+	*/
+	isEmpty() {
+		return this._map.size === 0;
+	}
+	/**
+	* Create a new set containing elements in this set or the other set.
 	*
-	* @returns A new `CborDate` instance representing the current UTC date and time plus
-	* the duration
+	* @param other - Other set
+	* @returns New set with union of elements
 	*
 	* @example
 	* ```typescript
-	* // Get a date 1 hour from now
-	* const oneHourLater = CborDate.withDurationFromNow(3600 * 1000);
+	* const set1 = CborSet.fromArray([1, 2, 3]);
+	* const set2 = CborSet.fromArray([3, 4, 5]);
+	* const union = set1.union(set2);
+	* // union contains [1, 2, 3, 4, 5]
 	* ```
 	*/
-	static withDurationFromNow(durationMs) {
-		const future = new Date((/* @__PURE__ */ new Date()).getTime() + durationMs);
-		return CborDate.fromDatetime(future);
+	union(other) {
+		const result = new CborSet();
+		for (const value of this) result.insert(extractCbor(value));
+		for (const value of other) result.insert(extractCbor(value));
+		return result;
 	}
 	/**
-	* Returns the underlying JavaScript `Date` object.
-	*
-	* This method provides access to the wrapped JavaScript `Date`
-	* instance.
+	* Create a new set containing elements in both this set and the other set.
 	*
-	* @returns The wrapped `Date` instance
+	* @param other - Other set
+	* @returns New set with intersection of elements
 	*
 	* @example
 	* ```typescript
-	* const date = CborDate.now();
-	* const datetime = date.datetime();
-	* const year = datetime.getFullYear();
+	* const set1 = CborSet.fromArray([1, 2, 3]);
+	* const set2 = CborSet.fromArray([2, 3, 4]);
+	* const intersection = set1.intersection(set2);
+	* // intersection contains [2, 3]
 	* ```
 	*/
-	datetime() {
-		return /* @__PURE__ */ new Date(this._seconds * 1e3);
+	intersection(other) {
+		const result = new CborSet();
+		for (const value of this) {
+			const extracted = extractCbor(value);
+			if (other.contains(extracted)) result.insert(extracted);
+		}
+		return result;
 	}
 	/**
-	* Returns the `CborDate` as the number of seconds since the Unix epoch.
-	*
-	* This method converts the date to a floating-point number representing
-	* the number of seconds since the Unix epoch (1970-01-01T00:00:00Z).
-	* Negative values represent times before the epoch. The fractional
-	* part represents sub-second precision.
+	* Create a new set containing elements in this set but not in the other set.
 	*
-	* @returns Seconds since the Unix epoch as a `number`
+	* @param other - Other set
+	* @returns New set with difference of elements
 	*
 	* @example
 	* ```typescript
-	* const date = CborDate.fromYmd(2023, 2, 8);
-	* const timestamp = date.timestamp();
+	* const set1 = CborSet.fromArray([1, 2, 3]);
+	* const set2 = CborSet.fromArray([2, 3, 4]);
+	* const diff = set1.difference(set2);
+	* // diff contains [1]
 	* ```
 	*/
-	timestamp() {
-		return this._seconds;
+	difference(other) {
+		const result = new CborSet();
+		for (const value of this) {
+			const extracted = extractCbor(value);
+			if (!other.contains(extracted)) result.insert(extracted);
+		}
+		return result;
 	}
 	/**
-	* Add seconds to this date.
+	* Check if this set is a subset of another set.
 	*
-	* @param seconds - Seconds to add (can be fractional)
-	* @returns New CborDate instance
+	* @param other - Other set
+	* @returns true if all elements of this set are in the other set
+	*/
+	isSubsetOf(other) {
+		for (const value of this) if (!other.contains(extractCbor(value))) return false;
+		return true;
+	}
+	/**
+	* Check if this set is a superset of another set.
 	*
-	* @example
-	* ```typescript
-	* const date = CborDate.fromYmd(2022, 3, 21);
-	* const tomorrow = date.add(24 * 60 * 60);
-	* ```
+	* @param other - Other set
+	* @returns true if all elements of the other set are in this set
 	*/
-	add(seconds) {
-		return CborDate.fromTimestamp(this.timestamp() + seconds);
+	isSupersetOf(other) {
+		return other.isSubsetOf(this);
 	}
 	/**
-	* Subtract seconds from this date.
+	* Iterate over elements in the set.
 	*
-	* @param seconds - Seconds to subtract (can be fractional)
-	* @returns New CborDate instance
+	* Elements are returned in deterministic order (by CBOR encoding).
 	*
 	* @example
 	* ```typescript
-	* const date = CborDate.fromYmd(2022, 3, 21);
-	* const yesterday = date.subtract(24 * 60 * 60);
+	* const set = CborSet.fromArray([3, 1, 2]);
+	* for (const value of set) {
+	*   console.log(extractCbor(value));
+	* }
 	* ```
 	*/
-	subtract(seconds) {
-		return CborDate.fromTimestamp(this.timestamp() - seconds);
+	*[Symbol.iterator]() {
+		for (const [_, value] of this._map) yield value;
 	}
 	/**
-	* Get the difference in seconds between this date and another.
+	* Get all values as an array.
 	*
-	* @param other - Other CborDate to compare with
-	* @returns Difference in seconds (this - other)
+	* @returns Array of CBOR values in deterministic order
 	*
 	* @example
 	* ```typescript
-	* const date1 = CborDate.fromYmd(2022, 3, 22);
-	* const date2 = CborDate.fromYmd(2022, 3, 21);
-	* const diff = date1.difference(date2);
-	* // Returns 86400 (one day in seconds)
+	* const set = CborSet.fromArray([3, 1, 2]);
+	* const values = set.values();
+	* // Values in deterministic order
 	* ```
 	*/
-	difference(other) {
-		return this.timestamp() - other.timestamp();
+	values() {
+		return Array.from(this);
 	}
 	/**
-	* Implementation of the `CborTagged` interface for `CborDate`.
+	* Execute a function for each element.
 	*
-	* This implementation specifies that `CborDate` values are tagged with CBOR tag 1,
-	* which is the standard CBOR tag for date/time values represented as seconds
-	* since the Unix epoch per RFC 8949.
+	* @param callback - Function to call for each element
 	*
-	* @returns A vector containing tag 1
+	* @example
+	* ```typescript
+	* set.forEach(value => {
+	*   console.log(extractCbor(value));
+	* });
+	* ```
 	*/
-	cborTags() {
-		return [createTag(1, "date")];
+	forEach(callback) {
+		for (const value of this) callback(value);
 	}
 	/**
-	* Implementation of the `CborTaggedEncodable` interface for `CborDate`.
+	* Encode the set as an (untagged) CBOR array of its elements, in canonical
+	* ascending CBOR-byte order. Matches Rust `From<Set> for CBOR`.
 	*
-	* Converts this `CborDate` to an untagged CBOR value.
-	*
-	* The date is converted to a numeric value representing the number of
-	* seconds since the Unix epoch. This value may be an integer or a
-	* floating-point number, depending on whether the date has fractional
-	* seconds.
-	*
-	* @returns A CBOR value representing the timestamp
+	* @returns CBOR array
 	*/
 	untaggedCbor() {
-		return cbor(this.timestamp());
-	}
-	/**
-	* Converts this `CborDate` to a tagged CBOR value with tag 1.
-	*
-	* @returns Tagged CBOR value
-	*/
-	taggedCbor() {
-		return createTaggedCbor(this);
+		return cbor(this.values());
 	}
 	/**
-	* Implementation of the `CborTaggedDecodable` interface for `CborDate`.
-	*
-	* Creates a `CborDate` from an untagged CBOR value.
-	*
-	* The CBOR value must be a numeric value (integer or floating-point)
-	* representing the number of seconds since the Unix epoch.
-	*
-	* @param cbor - The untagged CBOR value
+	* Decode a CborSet from a CBOR array into this instance.
 	*
-	* @returns This CborDate instance (mutated)
+	* Mirrors Rust `Set::try_from_vec`, calling `insert_next` per item, so the
+	* array must already be in strict ascending CBOR-byte order with no
+	* duplicates (else `MisorderedMapKey`/`DuplicateMapKey`).
 	*
-	* @throws Error if the CBOR value is not a valid timestamp
+	* @param c - CBOR array value
+	* @returns this
+	* @throws CborError of type `WrongType` if `c` is not an array.
 	*/
-	fromUntaggedCbor(cbor) {
-		let timestamp;
-		switch (cbor.type) {
-			case MajorType.Unsigned:
-				timestamp = typeof cbor.value === "number" ? cbor.value : Number(cbor.value);
-				break;
-			case MajorType.Negative:
-				if (typeof cbor.value === "bigint") timestamp = Number(-cbor.value - 1n);
-				else timestamp = -cbor.value - 1;
-				break;
-			case MajorType.Simple:
-				if (cbor.value.type === "Float") timestamp = cbor.value.value;
-				else throw new CborError({ type: "WrongType" });
-				break;
-			default: throw new CborError({ type: "WrongType" });
-		}
-		this._seconds = timestamp;
+	fromUntaggedCbor(c) {
+		if (c.type !== MajorType.Array) throw new CborError({ type: "WrongType" });
+		this.clear();
+		for (const value of c.value) this.insertNext(extractCbor(value));
 		return this;
 	}
 	/**
-	* Creates a `CborDate` from a tagged CBOR value with tag 1.
-	*
-	* @param cbor - Tagged CBOR value
+	* Decode a CborSet from a CBOR array.
 	*
-	* @returns This CborDate instance (mutated)
-	*
-	* @throws Error if the CBOR value has the wrong tag or cannot be decoded
+	* @param c - CBOR array value
+	* @returns Decoded CborSet instance
 	*/
-	fromTaggedCbor(cbor) {
-		validateTag(cbor, this.cborTags());
-		const content = extractTaggedContent(cbor);
-		return this.fromUntaggedCbor(content);
+	static fromCbor(c) {
+		return new CborSet().fromUntaggedCbor(c);
 	}
 	/**
-	* Static method to create a CborDate from tagged CBOR.
+	* Convert to CBOR array (untagged).
 	*
-	* @param cbor - Tagged CBOR value
-	* @returns New CborDate instance
+	* @returns CBOR array
 	*/
-	static fromTaggedCbor(cbor) {
-		return new CborDate().fromTaggedCbor(cbor);
+	toCbor() {
+		return this.untaggedCbor();
 	}
 	/**
-	* Static method to create a CborDate from untagged CBOR.
+	* Convert to encoded CBOR bytes.
 	*
-	* @param cbor - Untagged CBOR value
-	* @returns New CborDate instance
+	* @returns Encoded CBOR bytes
 	*/
-	static fromUntaggedCbor(cbor) {
-		return new CborDate().fromUntaggedCbor(cbor);
+	toBytes() {
+		return cborData(this.untaggedCbor());
 	}
 	/**
-	* Implementation of the `toString` method for `CborDate`.
-	*
-	* This implementation provides a string representation of a `CborDate` in ISO-8601
-	* format. For dates with time exactly at midnight (00:00:00), only the date
-	* part is shown. For other times, a full date-time string is shown.
+	* Convert to JavaScript Set.
 	*
-	* @returns String representation in ISO-8601 format
+	* @returns JavaScript Set with extracted values
 	*
 	* @example
 	* ```typescript
-	* // A date at midnight will display as just the date
-	* const date = CborDate.fromYmd(2023, 2, 8);
-	* // Returns "2023-02-08"
-	* console.log(date.toString());
-	*
-	* // A date with time will display as date and time
-	* const date2 = CborDate.fromYmdHms(2023, 2, 8, 15, 30, 45);
-	* // Returns "2023-02-08T15:30:45.000Z"
-	* console.log(date2.toString());
+	* const cborSet = CborSet.fromArray([1, 2, 3]);
+	* const jsSet = cborSet.toSet();
+	* console.log(jsSet.has(1)); // true
 	* ```
 	*/
-	toString() {
-		const dt = /* @__PURE__ */ new Date(this._seconds * 1e3);
-		if (!(dt.getUTCHours() !== 0 || dt.getUTCMinutes() !== 0 || dt.getUTCSeconds() !== 0)) {
-			const datePart = dt.toISOString().split("T")[0];
-			if (datePart === void 0) throw new CborError({
-				type: "Custom",
-				message: "Invalid ISO string format"
-			});
-			return datePart;
-		} else return dt.toISOString().replace(/\.\d{3}Z$/, "Z");
+	toSet() {
+		const result = /* @__PURE__ */ new Set();
+		for (const value of this) result.add(extractCbor(value));
+		return result;
 	}
 	/**
-	* Compare two dates for equality.
+	* Convert to JavaScript Array.
 	*
-	* @param other - Other CborDate to compare
-	* @returns true if dates represent the same moment in time
+	* @returns Array with extracted values
 	*/
-	equals(other) {
-		return this._seconds === other._seconds;
+	toArray() {
+		return Array.from(this.toSet());
 	}
 	/**
-	* Compare two dates.
+	* Get diagnostic notation for the set.
 	*
-	* @param other - Other CborDate to compare
-	* @returns -1 if this < other, 0 if equal, 1 if this > other
+	* @returns String representation
+	*
+	* @example
+	* ```typescript
+	* const set = CborSet.fromArray([1, 2, 3]);
+	* console.log(set.diagnostic); // "[1, 2, 3]"
+	* ```
 	*/
-	compare(other) {
-		if (this._seconds < other._seconds) return -1;
-		if (this._seconds > other._seconds) return 1;
-		return 0;
+	get diagnostic() {
+		return `[${this.values().map((v) => {
+			const extracted = extractCbor(v);
+			if (typeof extracted === "string") return `"${extracted}"`;
+			return String(extracted);
+		}).join(", ")}]`;
 	}
 	/**
-	* Convert to JSON (returns ISO 8601 string).
+	* Convert to string (same as diagnostic).
 	*
-	* @returns ISO 8601 string
+	* @returns String representation
 	*/
-	toJSON() {
-		return this.toString();
+	toString() {
+		return this.diagnostic;
 	}
-	constructor() {
-		this._seconds = Date.now() / 1e3;
+	/**
+	* Convert to JSON (returns array of values).
+	*
+	* @returns Array for JSON serialization
+	*/
+	toJSON() {
+		return this.toArray();
 	}
 };
+/**
+* Convert a value to CBOR for use in set operations.
+*
+* @internal
+*/
+function encodeCborValue(value) {
+	if (typeof value === "object" && value !== null && "isCbor" in value && value.isCbor === true) return value;
+	return cbor(value);
+}
 //#endregion
-//#region src/bignum.ts
+//#region src/cbor-tagged-encodable.ts
 /**
 * Copyright © 2023-2026 Blockchain Commons, LLC
 * Copyright © 2025-2026 Parity Technologies
 *
 *
-* CBOR bignum (tags 2 and 3) support.
+* Tagged CBOR encoding support.
 *
-* This module provides conversion between CBOR and JavaScript BigInt types,
-* implementing RFC 8949 §3.4.3 (Bignums) with dCBOR/CDE canonical encoding rules.
+* This module provides the `CborTaggedEncodable` interface, which enables types to
+* be encoded as tagged CBOR values.
 *
-* Encoding:
-* - `biguintToCbor` always encodes as tag 2 (positive bignum) with a byte
-*   string content.
-* - `bigintToCbor` encodes as tag 2 for non-negative values or tag 3
-*   (negative bignum) for negative values.
-* - No numeric reduction is performed: values are always encoded as bignums,
-*   even if they would fit in normal CBOR integers.
+* CBOR tags provide semantic information about the encoded data. For example,
+* tag 1 is used for dates, indicating that the value should be interpreted
+* as a timestamp. The dCBOR library ensures these tags are encoded
+* deterministically.
 *
-* Decoding:
-* - Accepts CBOR integers (major types 0 and 1) and converts them to bigints.
-* - Accepts tag 2 (positive bignum) and tag 3 (negative bignum) with byte
-*   string content.
-* - Enforces shortest-form canonical representation for bignum magnitudes.
-* - Rejects floating-point values.
+* This interface enables seamless encoding of TypeScript types to properly tagged CBOR
+* values.
 *
-* @module bignum
+* @module cbor-tagged-encodable
 */
-const TAG_2_POSITIVE_BIGNUM = 2;
-const TAG_3_NEGATIVE_BIGNUM = 3;
 /**
-* Validates that a bignum magnitude byte string is in shortest canonical form.
-*
-* Matches Rust's `validate_bignum_magnitude()`.
+* Helper function to create tagged CBOR from an encodable object.
 *
-* Rules:
-* - For positive bignums (tag 2): empty byte string represents zero;
-*   non-empty must not have leading zero bytes.
-* - For negative bignums (tag 3): byte string must not be empty
-*   (magnitude zero is encoded as `0x00`); must not have leading zero bytes
-*   except when the magnitude is zero (single `0x00`).
+* Uses the first tag from cborTags().
 *
-* @param bytes - The magnitude byte string to validate
-* @param isNegative - Whether this is for a negative bignum (tag 3)
-* @throws CborError with type NonCanonicalNumeric on validation failure
+* @param encodable - Object implementing CborTaggedEncodable
+* @returns Tagged CBOR value
 */
-function validateBignumMagnitude(bytes, isNegative) {
-	if (isNegative) {
-		if (bytes.length === 0) throw new CborError({ type: "NonCanonicalNumeric" });
-		if (bytes.length > 1 && bytes[0] === 0) throw new CborError({ type: "NonCanonicalNumeric" });
-	} else if (bytes.length > 0 && bytes[0] === 0) throw new CborError({ type: "NonCanonicalNumeric" });
-}
+const createTaggedCbor = (encodable) => {
+	const tags = encodable.cborTags();
+	if (tags.length === 0) throw new CborError({
+		type: "Custom",
+		message: "No tags defined for this type"
+	});
+	const tag = tags[0];
+	if (tag === void 0) throw new CborError({
+		type: "Custom",
+		message: "Tag is undefined"
+	});
+	const untagged = encodable.untaggedCbor();
+	return attachMethods({
+		isCbor: true,
+		type: MajorType.Tagged,
+		tag: tag.value,
+		value: untagged
+	});
+};
 /**
-* Strips leading zero bytes from a byte array, returning the minimal
-* representation.
-*
-* Matches Rust's `strip_leading_zeros()`.
+* Default `taggedCborData()` implementation — `taggedCbor().toData()`.
 *
-* @param bytes - The byte array to strip
-* @returns A subarray with leading zeros removed
+* Mirrors Rust's default `tagged_cbor_data()` impl on
+* `CBORTaggedEncodable`. TypeScript interfaces don't carry method bodies,
+* so this helper plays the role of the Rust trait default; concrete types
+* call it from their own `taggedCborData()` if they don't need to override.
 */
-function stripLeadingZeros(bytes) {
-	let start = 0;
-	while (start < bytes.length && bytes[start] === 0) start++;
-	return bytes.subarray(start);
-}
+const taggedCborData = (encodable) => encodable.taggedCbor().toData();
+//#endregion
+//#region src/cbor-tagged-decodable.ts
 /**
-* Convert a non-negative bigint to a big-endian byte array.
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
 *
-* Zero returns an empty Uint8Array.
 *
-* @param value - A non-negative bigint value
-* @returns Big-endian byte representation
-*/
-function bigintToBytes(value) {
-	if (value === 0n) return /* @__PURE__ */ new Uint8Array(0);
-	const hex = value.toString(16);
-	const padded = hex.length % 2 !== 0 ? `0${hex}` : hex;
-	const bytes = new Uint8Array(padded.length / 2);
-	for (let i = 0; i < bytes.length; i++) bytes[i] = parseInt(padded.substring(i * 2, i * 2 + 2), 16);
-	return bytes;
-}
-/**
-* Convert a big-endian byte array to a bigint.
+* Tagged CBOR decoding support.
 *
-* Empty array returns 0n.
+* This module provides the `CborTaggedDecodable` interface, which enables types to
+* be decoded from tagged CBOR values.
 *
-* @param bytes - Big-endian byte representation
-* @returns The bigint value
+* Tagged CBOR values include semantic information about how to interpret the
+* data. This interface allows TypeScript types to verify that incoming CBOR data has the
+* expected tag(s) and to decode the data appropriately.
+*
+* @module cbor-tagged-decodable
 */
-function bytesToBigint(bytes) {
-	if (bytes.length === 0) return 0n;
-	let result = 0n;
-	for (const byte of bytes) result = result << 8n | BigInt(byte);
-	return result;
-}
 /**
-* Encode a non-negative bigint as a CBOR tag 2 (positive bignum).
+* Helper function to validate that a CBOR value has one of the expected tags.
 *
-* Matches Rust's `From<BigUint> for CBOR`.
+* @param cbor - CBOR value to validate
+* @param expectedTags - Array of valid tags
+* @returns The matching tag
+* @throws Error if the value is not tagged or has an unexpected tag
+*/
+const validateTag = (cbor, expectedTags) => {
+	if (cbor.type !== MajorType.Tagged) throw new CborError({ type: "WrongType" });
+	const tagValue = cbor.tag;
+	const matchingTag = expectedTags.find((t) => tagValuesEqual(t.value, tagValue));
+	if (matchingTag === void 0) throw new CborError({
+		type: "WrongTag",
+		expected: expectedTags[0],
+		actual: { value: tagValue }
+	});
+	return matchingTag;
+};
+/**
+* Helper function to extract the content from a tagged CBOR value.
 *
-* The value is always encoded as a bignum regardless of size.
-* Zero is encoded as tag 2 with an empty byte string.
+* @param cbor - Tagged CBOR value
+* @returns The untagged content
+* @throws Error if the value is not tagged
+*/
+const extractTaggedContent = (cbor) => {
+	if (cbor.type !== MajorType.Tagged) throw new CborError({ type: "WrongType" });
+	return cbor.value;
+};
+/**
+* Default `fromTaggedCborData()` implementation — `decodeCbor(data)` then
+* delegate to the decodable's `fromTaggedCbor()`.
 *
-* @param value - A non-negative bigint (must be >= 0n)
-* @returns CBOR tagged value
-* @throws CborError with type OutOfRange if value is negative
+* Mirrors Rust's default `from_tagged_cbor_data` impl on
+* `CBORTaggedDecodable`.
 */
-function biguintToCbor(value) {
-	if (value < 0n) throw new CborError({ type: "OutOfRange" });
-	return toTaggedValue(TAG_2_POSITIVE_BIGNUM, stripLeadingZeros(bigintToBytes(value)));
+function fromTaggedCborData(decodable, data) {
+	return decodable.fromTaggedCbor(decodeCbor(data));
 }
 /**
-* Encode a bigint as a CBOR tag 2 or tag 3 bignum.
-*
-* Matches Rust's `From<BigInt> for CBOR`.
-*
-* - Non-negative values use tag 2 (positive bignum).
-* - Negative values use tag 3 (negative bignum), where the encoded
-*   magnitude is `|value| - 1` per RFC 8949.
+* Default `fromUntaggedCborData()` implementation — `decodeCbor(data)`
+* then delegate to the decodable's `fromUntaggedCbor()`.
 *
-* @param value - Any bigint value
-* @returns CBOR tagged value
+* Mirrors Rust's default `from_untagged_cbor_data` impl on
+* `CBORTaggedDecodable`.
 */
-function bigintToCbor(value) {
-	if (value >= 0n) return biguintToCbor(value);
-	const stripped = stripLeadingZeros(bigintToBytes(-value - 1n));
-	return toTaggedValue(TAG_3_NEGATIVE_BIGNUM, stripped.length === 0 ? new Uint8Array([0]) : stripped);
+function fromUntaggedCborData(decodable, data) {
+	return decodable.fromUntaggedCbor(decodeCbor(data));
 }
+//#endregion
+//#region src/date.ts
 /**
-* Decode a BigUint from an untagged CBOR byte string.
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
 *
-* Matches Rust's `biguint_from_untagged_cbor()`.
 *
-* This function is intended for use in tag summarizers where the tag has
-* already been stripped. It expects a CBOR byte string representing the
-* big-endian magnitude of a positive bignum (tag 2 content).
+* Date/time support for CBOR with tag(1) encoding.
 *
-* Enforces canonical encoding: no leading zero bytes (except empty for zero).
+* A CBOR-friendly representation of a date and time.
 *
-* @param cbor - A CBOR value that should be a byte string
-* @returns Non-negative bigint
-* @throws CborError with type WrongType if not a byte string
-* @throws CborError with type NonCanonicalNumeric if encoding is non-canonical
-*/
-function biguintFromUntaggedCbor(cbor) {
-	if (cbor.type !== MajorType.ByteString) throw new CborError({ type: "WrongType" });
-	const bytes = cbor.value;
-	validateBignumMagnitude(bytes, false);
-	return bytesToBigint(bytes);
-}
-/**
-* Decode a BigInt from an untagged CBOR byte string for a negative bignum.
+* The `CborDate` type provides a wrapper around JavaScript's native `Date` that
+* supports encoding and decoding to/from CBOR with tag 1, following the CBOR
+* date/time standard specified in RFC 8949.
 *
-* Matches Rust's `bigint_from_negative_untagged_cbor()`.
+* When encoded to CBOR, dates are represented as tag 1 followed by a numeric
+* value representing the number of seconds since (or before) the Unix epoch
+* (1970-01-01T00:00:00Z). The numeric value can be a positive or negative
+* integer, or a floating-point value for dates with fractional seconds.
 *
-* This function is intended for use in tag summarizers where the tag has
-* already been stripped. It expects a CBOR byte string representing `n` where
-* the actual value is `-1 - n` (tag 3 content per RFC 8949).
+* @module date
+*/
+/**
+* Normalize a timestamp (seconds since the Unix epoch) to whole seconds plus a
+* non-negative, sub-second nanosecond part, matching Rust's
+* `Date::from_timestamp` so dates round-trip byte-identically with the reference.
 *
-* Enforces canonical encoding: no leading zero bytes (except single `0x00`
-* for -1).
+* The nanosecond part is computed like Rust's `as u32` cast: truncated toward
+* zero and clamped to [0, u32::MAX]. So a negative fraction floors the value
+* (`-1.5` becomes `-1.0`) and sub-nanosecond precision is dropped
+* (`1.0000000005` becomes `1.0`).
 *
-* @param cbor - A CBOR value that should be a byte string
-* @returns Negative bigint
-* @throws CborError with type WrongType if not a byte string
-* @throws CborError with type NonCanonicalNumeric if encoding is non-canonical
+* @internal
 */
-function bigintFromNegativeUntaggedCbor(cbor) {
-	if (cbor.type !== MajorType.ByteString) throw new CborError({ type: "WrongType" });
-	const bytes = cbor.value;
-	validateBignumMagnitude(bytes, true);
-	return -(bytesToBigint(bytes) + 1n);
+function normalizeTimestampSeconds(seconds) {
+	if (!Number.isFinite(seconds)) throw new CborError({
+		type: "InvalidDate",
+		message: "non-finite timestamp"
+	});
+	const whole = Math.trunc(seconds);
+	let nsecs = Math.trunc((seconds - whole) * 1e9);
+	if (nsecs < 0) nsecs = 0;
+	else if (nsecs > 4294967295) nsecs = 4294967295;
+	return whole + nsecs / 1e9;
 }
 /**
-* Convert CBOR to a non-negative bigint.
+* A CBOR-friendly representation of a date and time.
 *
-* Matches Rust's `TryFrom<CBOR> for BigUint`.
+* The `CborDate` type provides a wrapper around JavaScript's native `Date` that
+* supports encoding and decoding to/from CBOR with tag 1, following the CBOR
+* date/time standard specified in RFC 8949.
 *
-* Accepts:
-* - Major type 0 (unsigned integer)
-* - Tag 2 (positive bignum) with canonical byte string
+* When encoded to CBOR, dates are represented as tag 1 followed by a numeric
+* value representing the number of seconds since (or before) the Unix epoch
+* (1970-01-01T00:00:00Z). The numeric value can be a positive or negative
+* integer, or a floating-point value for dates with fractional seconds.
 *
-* Rejects:
-* - Major type 1 (negative integer) -> OutOfRange
-* - Tag 3 (negative bignum) -> OutOfRange
-* - Floating-point values -> WrongType
-* - Non-canonical bignum encodings -> NonCanonicalNumeric
+* # Features
+*
+* - Supports UTC dates with optional fractional seconds
+* - Provides convenient constructors for common date creation patterns
+* - Implements the `CborTagged`, `CborTaggedEncodable`, and
+*   `CborTaggedDecodable` interfaces
+* - Supports arithmetic operations with durations and between dates
+*
+* @example
+* ```typescript
+* import { CborDate } from './date';
+*
+* // Create a date from a timestamp (seconds since Unix epoch)
+* const date = CborDate.fromTimestamp(1675854714.0);
+*
+* // Create a date from year, month, day
+* const date2 = CborDate.fromYmd(2023, 2, 8);
+*
+* // Convert to CBOR
+* const cborValue = date.taggedCbor();
+*
+* // Decode from CBOR
+* const decoded = CborDate.fromTaggedCbor(cborValue);
+* ```
+*/
+var CborDate = class CborDate {
+	/**
+	* Canonical timestamp in seconds since the Unix epoch as a JS `number`
+	* (`f64`). dCBOR encodes Date (tag 1) as a numeric value in seconds, so
+	* keeping `_seconds` as the source of truth avoids the millisecond-only
+	* round-trip precision loss that going through a JS `Date` instance
+	* introduced in earlier versions of this port.
+	*
+	* f64 still bounds the achievable precision (~16 decimal digits, so
+	* roughly microseconds for current epoch values); Rust's
+	* `chrono::DateTime<Utc>` retains nanoseconds in memory but encodes
+	* to the same f64 over the wire, so the *encode/decode round-trip* is
+	* byte-identical.
+	*/
+	_seconds;
+	/**
+	* Creates a new `CborDate` from the given JavaScript `Date`.
+	*
+	* This method creates a new `CborDate` instance by wrapping a
+	* JavaScript `Date`.
+	*
+	* @param dateTime - A `Date` instance to wrap
+	*
+	* @returns A new `CborDate` instance
+	*
+	* @example
+	* ```typescript
+	* const datetime = new Date();
+	* const date = CborDate.fromDatetime(datetime);
+	* ```
+	*/
+	static fromDatetime(dateTime) {
+		const instance = new CborDate();
+		instance._seconds = dateTime.getTime() / 1e3;
+		return instance;
+	}
+	/**
+	* Creates a new `CborDate` from year, month, and day components.
+	*
+	* This method creates a new `CborDate` with the time set to 00:00:00 UTC.
+	*
+	* @param year - The year component (e.g., 2023)
+	* @param month - The month component (1-12)
+	* @param day - The day component (1-31)
+	*
+	* @returns A new `CborDate` instance
+	*
+	* @example
+	* ```typescript
+	* // Create February 8, 2023
+	* const date = CborDate.fromYmd(2023, 2, 8);
+	* ```
+	*
+	* @throws Error if the provided components do not form a valid date.
+	*/
+	static fromYmd(year, month, day) {
+		const dt = new Date(Date.UTC(year, month - 1, day, 0, 0, 0, 0));
+		return CborDate.fromDatetime(dt);
+	}
+	/**
+	* Creates a new `CborDate` from year, month, day, hour, minute, and second
+	* components.
+	*
+	* @param year - The year component (e.g., 2023)
+	* @param month - The month component (1-12)
+	* @param day - The day component (1-31)
+	* @param hour - The hour component (0-23)
+	* @param minute - The minute component (0-59)
+	* @param second - The second component (0-59)
+	*
+	* @returns A new `CborDate` instance
+	*
+	* @example
+	* ```typescript
+	* // Create February 8, 2023, 15:30:45 UTC
+	* const date = CborDate.fromYmdHms(2023, 2, 8, 15, 30, 45);
+	* ```
+	*
+	* @throws Error if the provided components do not form a valid date and time.
+	*/
+	static fromYmdHms(year, month, day, hour, minute, second) {
+		const dt = new Date(Date.UTC(year, month - 1, day, hour, minute, second, 0));
+		return CborDate.fromDatetime(dt);
+	}
+	/**
+	* Creates a new `CborDate` from seconds since (or before) the Unix epoch.
+	*
+	* This method creates a new `CborDate` representing the specified number of
+	* seconds since the Unix epoch (1970-01-01T00:00:00Z). Negative values
+	* represent times before the epoch.
+	*
+	* @param secondsSinceUnixEpoch - Seconds from the Unix epoch (positive or
+	*   negative), which can include a fractional part for sub-second
+	*   precision
+	*
+	* @returns A new `CborDate` instance
+	*
+	* @example
+	* ```typescript
+	* // Create a date from a timestamp
+	* const date = CborDate.fromTimestamp(1675854714.0);
+	*
+	* // Create a date one second before the Unix epoch
+	* const beforeEpoch = CborDate.fromTimestamp(-1.0);
+	*
+	* // Create a date with fractional seconds
+	* const withFraction = CborDate.fromTimestamp(1675854714.5);
+	* ```
+	*/
+	static fromTimestamp(secondsSinceUnixEpoch) {
+		const instance = new CborDate();
+		instance._seconds = normalizeTimestampSeconds(secondsSinceUnixEpoch);
+		return instance;
+	}
+	/**
+	* Creates a new `CborDate` from a string containing an ISO-8601 (RFC-3339)
+	* date (with or without time).
+	*
+	* This method parses a string representation of a date or date-time in
+	* ISO-8601/RFC-3339 format and creates a new `CborDate` instance. It
+	* supports both full date-time strings (e.g., "2023-02-08T15:30:45Z")
+	* and date-only strings (e.g., "2023-02-08").
+	*
+	* @param value - A string containing a date or date-time in ISO-8601/RFC-3339
+	*   format
+	*
+	* @returns A new `CborDate` instance if parsing succeeds
+	*
+	* @throws Error if the string cannot be parsed as a valid date or date-time
+	*
+	* @example
+	* ```typescript
+	* // Parse a date-time string
+	* const date = CborDate.fromString("2023-02-08T15:30:45Z");
+	*
+	* // Parse a date-only string (time will be set to 00:00:00)
+	* const date2 = CborDate.fromString("2023-02-08");
+	* ```
+	*/
+	static fromString(value) {
+		const invalidDate = new CborError({
+			type: "InvalidDate",
+			message: "Invalid date string"
+		});
+		const rfc3339 = /^\d{4}-\d{2}-\d{2}[Tt]\d{2}:\d{2}:\d{2}(\.\d+)?([Zz]|[+-]\d{2}:\d{2})$/;
+		const dateOnly = /^\d{4}-\d{2}-\d{2}$/;
+		let parsed;
+		if (rfc3339.test(value)) parsed = new Date(value);
+		else if (dateOnly.test(value)) parsed = /* @__PURE__ */ new Date(`${value}T00:00:00Z`);
+		else throw invalidDate;
+		const [y, m, d] = value.slice(0, 10).split("-").map(Number);
+		const probe = new Date(Date.UTC(y, m - 1, d));
+		if (!(probe.getUTCFullYear() === y && probe.getUTCMonth() === m - 1 && probe.getUTCDate() === d) || isNaN(parsed.getTime())) throw invalidDate;
+		return CborDate.fromDatetime(parsed);
+	}
+	/**
+	* Creates a new `CborDate` containing the current date and time.
+	*
+	* @returns A new `CborDate` instance representing the current UTC date and time
+	*
+	* @example
+	* ```typescript
+	* const now = CborDate.now();
+	* ```
+	*/
+	static now() {
+		return CborDate.fromDatetime(/* @__PURE__ */ new Date());
+	}
+	/**
+	* Creates a new `CborDate` containing the current date and time plus the given
+	* duration.
+	*
+	* @param durationMs - The duration in milliseconds to add to the current time
+	*
+	* @returns A new `CborDate` instance representing the current UTC date and time plus
+	* the duration
+	*
+	* @example
+	* ```typescript
+	* // Get a date 1 hour from now
+	* const oneHourLater = CborDate.withDurationFromNow(3600 * 1000);
+	* ```
+	*/
+	static withDurationFromNow(durationMs) {
+		const future = new Date((/* @__PURE__ */ new Date()).getTime() + durationMs);
+		return CborDate.fromDatetime(future);
+	}
+	/**
+	* Returns the underlying JavaScript `Date` object.
+	*
+	* This method provides access to the wrapped JavaScript `Date`
+	* instance.
+	*
+	* @returns The wrapped `Date` instance
+	*
+	* @example
+	* ```typescript
+	* const date = CborDate.now();
+	* const datetime = date.datetime();
+	* const year = datetime.getFullYear();
+	* ```
+	*/
+	datetime() {
+		return /* @__PURE__ */ new Date(this._seconds * 1e3);
+	}
+	/**
+	* Returns the `CborDate` as the number of seconds since the Unix epoch.
+	*
+	* This method converts the date to a floating-point number representing
+	* the number of seconds since the Unix epoch (1970-01-01T00:00:00Z).
+	* Negative values represent times before the epoch. The fractional
+	* part represents sub-second precision.
+	*
+	* @returns Seconds since the Unix epoch as a `number`
+	*
+	* @example
+	* ```typescript
+	* const date = CborDate.fromYmd(2023, 2, 8);
+	* const timestamp = date.timestamp();
+	* ```
+	*/
+	timestamp() {
+		return this._seconds;
+	}
+	/**
+	* Add seconds to this date.
+	*
+	* @param seconds - Seconds to add (can be fractional)
+	* @returns New CborDate instance
+	*
+	* @example
+	* ```typescript
+	* const date = CborDate.fromYmd(2022, 3, 21);
+	* const tomorrow = date.add(24 * 60 * 60);
+	* ```
+	*/
+	add(seconds) {
+		return CborDate.fromTimestamp(this.timestamp() + seconds);
+	}
+	/**
+	* Subtract seconds from this date.
+	*
+	* @param seconds - Seconds to subtract (can be fractional)
+	* @returns New CborDate instance
+	*
+	* @example
+	* ```typescript
+	* const date = CborDate.fromYmd(2022, 3, 21);
+	* const yesterday = date.subtract(24 * 60 * 60);
+	* ```
+	*/
+	subtract(seconds) {
+		return CborDate.fromTimestamp(this.timestamp() - seconds);
+	}
+	/**
+	* Get the difference in seconds between this date and another.
+	*
+	* @param other - Other CborDate to compare with
+	* @returns Difference in seconds (this - other)
+	*
+	* @example
+	* ```typescript
+	* const date1 = CborDate.fromYmd(2022, 3, 22);
+	* const date2 = CborDate.fromYmd(2022, 3, 21);
+	* const diff = date1.difference(date2);
+	* // Returns 86400 (one day in seconds)
+	* ```
+	*/
+	difference(other) {
+		return this.timestamp() - other.timestamp();
+	}
+	/**
+	* Implementation of the `CborTagged` interface for `CborDate`.
+	*
+	* This implementation specifies that `CborDate` values are tagged with CBOR tag 1,
+	* which is the standard CBOR tag for date/time values represented as seconds
+	* since the Unix epoch per RFC 8949.
+	*
+	* @returns A vector containing tag 1
+	*/
+	cborTags() {
+		return [createTag(1, "date")];
+	}
+	/**
+	* Implementation of the `CborTaggedEncodable` interface for `CborDate`.
+	*
+	* Converts this `CborDate` to an untagged CBOR value.
+	*
+	* The date is converted to a numeric value representing the number of
+	* seconds since the Unix epoch. This value may be an integer or a
+	* floating-point number, depending on whether the date has fractional
+	* seconds.
+	*
+	* @returns A CBOR value representing the timestamp
+	*/
+	untaggedCbor() {
+		return cbor(this.timestamp());
+	}
+	/**
+	* Converts this `CborDate` to a tagged CBOR value with tag 1.
+	*
+	* @returns Tagged CBOR value
+	*/
+	taggedCbor() {
+		return createTaggedCbor(this);
+	}
+	/**
+	* Implementation of the `CborTaggedDecodable` interface for `CborDate`.
+	*
+	* Creates a `CborDate` from an untagged CBOR value.
+	*
+	* The CBOR value must be a numeric value (integer or floating-point)
+	* representing the number of seconds since the Unix epoch.
+	*
+	* @param cbor - The untagged CBOR value
+	*
+	* @returns This CborDate instance (mutated)
+	*
+	* @throws Error if the CBOR value is not a valid timestamp
+	*/
+	fromUntaggedCbor(cbor) {
+		let timestamp;
+		switch (cbor.type) {
+			case MajorType.Unsigned:
+				timestamp = typeof cbor.value === "number" ? cbor.value : Number(cbor.value);
+				break;
+			case MajorType.Negative:
+				if (typeof cbor.value === "bigint") timestamp = Number(-cbor.value - 1n);
+				else timestamp = -cbor.value - 1;
+				break;
+			case MajorType.Simple:
+				if (cbor.value.type === "Float") timestamp = cbor.value.value;
+				else throw new CborError({ type: "WrongType" });
+				break;
+			default: throw new CborError({ type: "WrongType" });
+		}
+		this._seconds = normalizeTimestampSeconds(timestamp);
+		return this;
+	}
+	/**
+	* Creates a `CborDate` from a tagged CBOR value with tag 1.
+	*
+	* @param cbor - Tagged CBOR value
+	*
+	* @returns This CborDate instance (mutated)
+	*
+	* @throws Error if the CBOR value has the wrong tag or cannot be decoded
+	*/
+	fromTaggedCbor(cbor) {
+		validateTag(cbor, this.cborTags());
+		const content = extractTaggedContent(cbor);
+		return this.fromUntaggedCbor(content);
+	}
+	/**
+	* Static method to create a CborDate from tagged CBOR.
+	*
+	* @param cbor - Tagged CBOR value
+	* @returns New CborDate instance
+	*/
+	static fromTaggedCbor(cbor) {
+		return new CborDate().fromTaggedCbor(cbor);
+	}
+	/**
+	* Static method to create a CborDate from untagged CBOR.
+	*
+	* @param cbor - Untagged CBOR value
+	* @returns New CborDate instance
+	*/
+	static fromUntaggedCbor(cbor) {
+		return new CborDate().fromUntaggedCbor(cbor);
+	}
+	/**
+	* Implementation of the `toString` method for `CborDate`.
+	*
+	* This implementation provides a string representation of a `CborDate` in ISO-8601
+	* format. For dates with time exactly at midnight (00:00:00), only the date
+	* part is shown. For other times, a full date-time string is shown.
+	*
+	* @returns String representation in ISO-8601 format
+	*
+	* @example
+	* ```typescript
+	* // A date at midnight will display as just the date
+	* const date = CborDate.fromYmd(2023, 2, 8);
+	* // Returns "2023-02-08"
+	* console.log(date.toString());
+	*
+	* // A date with time will display as date and time
+	* const date2 = CborDate.fromYmdHms(2023, 2, 8, 15, 30, 45);
+	* // Returns "2023-02-08T15:30:45.000Z"
+	* console.log(date2.toString());
+	* ```
+	*/
+	toString() {
+		const dt = /* @__PURE__ */ new Date(this._seconds * 1e3);
+		if (!(dt.getUTCHours() !== 0 || dt.getUTCMinutes() !== 0 || dt.getUTCSeconds() !== 0)) {
+			const datePart = dt.toISOString().split("T")[0];
+			if (datePart === void 0) throw new CborError({
+				type: "Custom",
+				message: "Invalid ISO string format"
+			});
+			return datePart;
+		} else return dt.toISOString().replace(/\.\d{3}Z$/, "Z");
+	}
+	/**
+	* Compare two dates for equality.
+	*
+	* @param other - Other CborDate to compare
+	* @returns true if dates represent the same moment in time
+	*/
+	equals(other) {
+		return this._seconds === other._seconds;
+	}
+	/**
+	* Compare two dates.
+	*
+	* @param other - Other CborDate to compare
+	* @returns -1 if this < other, 0 if equal, 1 if this > other
+	*/
+	compare(other) {
+		if (this._seconds < other._seconds) return -1;
+		if (this._seconds > other._seconds) return 1;
+		return 0;
+	}
+	/**
+	* Convert to JSON (returns ISO 8601 string).
+	*
+	* @returns ISO 8601 string
+	*/
+	toJSON() {
+		return this.toString();
+	}
+	constructor() {
+		this._seconds = Date.now() / 1e3;
+	}
+};
+//#endregion
+//#region src/bignum.ts
+/**
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
+*
+*
+* CBOR bignum (tags 2 and 3) support.
+*
+* This module provides conversion between CBOR and JavaScript BigInt types,
+* implementing RFC 8949 §3.4.3 (Bignums) with dCBOR/CDE canonical encoding rules.
+*
+* Encoding:
+* - `biguintToCbor` always encodes as tag 2 (positive bignum) with a byte
+*   string content.
+* - `bigintToCbor` encodes as tag 2 for non-negative values or tag 3
+*   (negative bignum) for negative values.
+* - No numeric reduction is performed: values are always encoded as bignums,
+*   even if they would fit in normal CBOR integers.
+*
+* Decoding:
+* - Accepts CBOR integers (major types 0 and 1) and converts them to bigints.
+* - Accepts tag 2 (positive bignum) and tag 3 (negative bignum) with byte
+*   string content.
+* - Enforces shortest-form canonical representation for bignum magnitudes.
+* - Rejects floating-point values.
+*
+* @module bignum
+*/
+const TAG_2_POSITIVE_BIGNUM = 2;
+const TAG_3_NEGATIVE_BIGNUM = 3;
+/**
+* Validates that a bignum magnitude byte string is in shortest canonical form.
+*
+* Matches Rust's `validate_bignum_magnitude()`.
+*
+* Rules:
+* - For positive bignums (tag 2): empty byte string represents zero;
+*   non-empty must not have leading zero bytes.
+* - For negative bignums (tag 3): byte string must not be empty
+*   (magnitude zero is encoded as `0x00`); must not have leading zero bytes
+*   except when the magnitude is zero (single `0x00`).
+*
+* @param bytes - The magnitude byte string to validate
+* @param isNegative - Whether this is for a negative bignum (tag 3)
+* @throws CborError with type NonCanonicalNumeric on validation failure
+*/
+function validateBignumMagnitude(bytes, isNegative) {
+	if (isNegative) {
+		if (bytes.length === 0) throw new CborError({ type: "NonCanonicalNumeric" });
+		if (bytes.length > 1 && bytes[0] === 0) throw new CborError({ type: "NonCanonicalNumeric" });
+	} else if (bytes.length > 0 && bytes[0] === 0) throw new CborError({ type: "NonCanonicalNumeric" });
+}
+/**
+* Strips leading zero bytes from a byte array, returning the minimal
+* representation.
+*
+* Matches Rust's `strip_leading_zeros()`.
+*
+* @param bytes - The byte array to strip
+* @returns A subarray with leading zeros removed
+*/
+function stripLeadingZeros(bytes) {
+	let start = 0;
+	while (start < bytes.length && bytes[start] === 0) start++;
+	return bytes.subarray(start);
+}
+/**
+* Convert a non-negative bigint to a big-endian byte array.
+*
+* Zero returns an empty Uint8Array.
+*
+* @param value - A non-negative bigint value
+* @returns Big-endian byte representation
+*/
+function bigintToBytes(value) {
+	if (value === 0n) return /* @__PURE__ */ new Uint8Array(0);
+	const hex = value.toString(16);
+	const padded = hex.length % 2 !== 0 ? `0${hex}` : hex;
+	const bytes = new Uint8Array(padded.length / 2);
+	for (let i = 0; i < bytes.length; i++) bytes[i] = parseInt(padded.substring(i * 2, i * 2 + 2), 16);
+	return bytes;
+}
+/**
+* Convert a big-endian byte array to a bigint.
+*
+* Empty array returns 0n.
+*
+* @param bytes - Big-endian byte representation
+* @returns The bigint value
+*/
+function bytesToBigint(bytes) {
+	if (bytes.length === 0) return 0n;
+	let result = 0n;
+	for (const byte of bytes) result = result << 8n | BigInt(byte);
+	return result;
+}
+/**
+* Encode a non-negative bigint as a CBOR tag 2 (positive bignum).
+*
+* Matches Rust's `From<BigUint> for CBOR`.
+*
+* The value is always encoded as a bignum regardless of size.
+* Zero is encoded as tag 2 with an empty byte string.
+*
+* @param value - A non-negative bigint (must be >= 0n)
+* @returns CBOR tagged value
+* @throws CborError with type OutOfRange if value is negative
+*/
+function biguintToCbor(value) {
+	if (value < 0n) throw new CborError({ type: "OutOfRange" });
+	return toTaggedValue(TAG_2_POSITIVE_BIGNUM, stripLeadingZeros(bigintToBytes(value)));
+}
+/**
+* Encode a bigint as a CBOR tag 2 or tag 3 bignum.
+*
+* Matches Rust's `From<BigInt> for CBOR`.
+*
+* - Non-negative values use tag 2 (positive bignum).
+* - Negative values use tag 3 (negative bignum), where the encoded
+*   magnitude is `|value| - 1` per RFC 8949.
+*
+* @param value - Any bigint value
+* @returns CBOR tagged value
+*/
+function bigintToCbor(value) {
+	if (value >= 0n) return biguintToCbor(value);
+	const stripped = stripLeadingZeros(bigintToBytes(-value - 1n));
+	return toTaggedValue(TAG_3_NEGATIVE_BIGNUM, stripped.length === 0 ? new Uint8Array([0]) : stripped);
+}
+/**
+* Decode a BigUint from an untagged CBOR byte string.
+*
+* Matches Rust's `biguint_from_untagged_cbor()`.
+*
+* This function is intended for use in tag summarizers where the tag has
+* already been stripped. It expects a CBOR byte string representing the
+* big-endian magnitude of a positive bignum (tag 2 content).
+*
+* Enforces canonical encoding: no leading zero bytes (except empty for zero).
+*
+* @param cbor - A CBOR value that should be a byte string
+* @returns Non-negative bigint
+* @throws CborError with type WrongType if not a byte string
+* @throws CborError with type NonCanonicalNumeric if encoding is non-canonical
+*/
+function biguintFromUntaggedCbor(cbor) {
+	if (cbor.type !== MajorType.ByteString) throw new CborError({ type: "WrongType" });
+	const bytes = cbor.value;
+	validateBignumMagnitude(bytes, false);
+	return bytesToBigint(bytes);
+}
+/**
+* Decode a BigInt from an untagged CBOR byte string for a negative bignum.
+*
+* Matches Rust's `bigint_from_negative_untagged_cbor()`.
+*
+* This function is intended for use in tag summarizers where the tag has
+* already been stripped. It expects a CBOR byte string representing `n` where
+* the actual value is `-1 - n` (tag 3 content per RFC 8949).
+*
+* Enforces canonical encoding: no leading zero bytes (except single `0x00`
+* for -1).
+*
+* @param cbor - A CBOR value that should be a byte string
+* @returns Negative bigint
+* @throws CborError with type WrongType if not a byte string
+* @throws CborError with type NonCanonicalNumeric if encoding is non-canonical
+*/
+function bigintFromNegativeUntaggedCbor(cbor) {
+	if (cbor.type !== MajorType.ByteString) throw new CborError({ type: "WrongType" });
+	const bytes = cbor.value;
+	validateBignumMagnitude(bytes, true);
+	return -(bytesToBigint(bytes) + 1n);
+}
+/**
+* Convert CBOR to a non-negative bigint.
+*
+* Matches Rust's `TryFrom<CBOR> for BigUint`.
+*
+* Accepts:
+* - Major type 0 (unsigned integer)
+* - Tag 2 (positive bignum) with canonical byte string
+*
+* Rejects:
+* - Major type 1 (negative integer) -> OutOfRange
+* - Tag 3 (negative bignum) -> OutOfRange
+* - Floating-point values -> WrongType
+* - Non-canonical bignum encodings -> NonCanonicalNumeric
 *
 * @param cbor - The CBOR value to convert
 * @returns Non-negative bigint
@@ -8570,553 +9179,132 @@ const TAG_MIME_MESSAGE = 36;
 /**
 * Tag 37: Binary UUID
 */
-const TAG_UUID = 37;
-/**
-* Tag 256: string reference (namespace)
-*/
-const TAG_STRING_REF_NAMESPACE = 256;
-/**
-* Tag 257: binary UUID reference
-*/
-const TAG_BINARY_UUID = 257;
-/**
-* Tag 258: Set of values (array with no duplicates)
-*/
-const TAG_SET = 258;
-/**
-* Tag 55799: Self-describe CBOR (magic number 0xd9d9f7)
-*/
-const TAG_SELF_DESCRIBE_CBOR = 55799;
-const TAG_DATE = 1;
-const TAG_NAME_DATE = "date";
-/**
-* Register standard tags in a specific tags store.
-* Matches Rust's register_tags_in() function.
-*
-* @param tagsStore - The tags store to register tags into
-*/
-const registerTagsIn = (tagsStore) => {
-	const tags = [createTag(1, TAG_NAME_DATE)];
-	tagsStore.insertAll(tags);
-	tagsStore.setSummarizer(1, (untaggedCbor, _flat) => {
-		try {
-			return {
-				ok: true,
-				value: CborDate.fromUntaggedCbor(untaggedCbor).toString()
-			};
-		} catch (e) {
-			return {
-				ok: false,
-				error: {
-					type: "Custom",
-					message: e instanceof Error ? e.message : String(e)
-				}
-			};
-		}
-	});
-	const biguintTag = createTag(2, TAG_NAME_POSITIVE_BIGNUM);
-	const bigintTag = createTag(3, TAG_NAME_NEGATIVE_BIGNUM);
-	tagsStore.insertAll([biguintTag, bigintTag]);
-	tagsStore.setSummarizer(2, (untaggedCbor, _flat) => {
-		try {
-			return {
-				ok: true,
-				value: `bignum(${biguintFromUntaggedCbor(untaggedCbor)})`
-			};
-		} catch (e) {
-			return {
-				ok: false,
-				error: {
-					type: "Custom",
-					message: e instanceof Error ? e.message : String(e)
-				}
-			};
-		}
-	});
-	tagsStore.setSummarizer(3, (untaggedCbor, _flat) => {
-		try {
-			return {
-				ok: true,
-				value: `bignum(${bigintFromNegativeUntaggedCbor(untaggedCbor)})`
-			};
-		} catch (e) {
-			return {
-				ok: false,
-				error: {
-					type: "Custom",
-					message: e instanceof Error ? e.message : String(e)
-				}
-			};
-		}
-	});
-};
-/**
-* Register standard tags in the global tags store.
-* Matches Rust's register_tags() function.
-*
-* This function is idempotent - calling it multiple times is safe.
-*/
-const registerTags = () => {
-	registerTagsIn(getGlobalTagsStore());
-};
-/**
-* Converts an array of tag values to their corresponding Tag objects.
-* Matches Rust's tags_for_values() function.
-*
-* This function looks up each tag value in the global tag registry and returns
-* an array of complete Tag objects. For any tag values that aren't
-* registered in the global registry, it creates a basic Tag with just the
-* value (no name).
-*
-* @param values - Array of numeric tag values to convert
-* @returns Array of Tag objects corresponding to the input values
-*
-* @example
-* ```typescript
-* // Register some tags first
-* registerTags();
-*
-* // Convert tag values to Tag objects
-* const tags = tagsForValues([1, 42, 999]);
-*
-* // The first tag (value 1) should be registered as "date"
-* console.log(tags[0].value); // 1
-* console.log(tags[0].name); // "date"
-*
-* // Unregistered tags will have a value but no name
-* console.log(tags[1].value); // 42
-* console.log(tags[2].value); // 999
-* ```
-*/
-const tagsForValues = (values) => {
-	const globalStore = getGlobalTagsStore();
-	return values.map((value) => {
-		const tag = globalStore.tagForValue(value);
-		if (tag !== void 0) return tag;
-		return createTag(value);
-	});
-};
-//#endregion
-//#region src/set.ts
+const TAG_UUID = 37;
 /**
-* Copyright © 2023-2026 Blockchain Commons, LLC
-* Copyright © 2025-2026 Parity Technologies
-*
-*
-* Set data structure for CBOR with tag(258) encoding.
-*
-* A Set is encoded as an array with no duplicate elements,
-* tagged with tag(258) to indicate set semantics.
-*
-* @module set
+* Tag 256: string reference (namespace)
 */
+const TAG_STRING_REF_NAMESPACE = 256;
 /**
-* CBOR Set type with tag(258) encoding.
-*
-* Internally uses a CborMap to ensure unique elements with deterministic ordering.
-* Elements are ordered by their CBOR encoding (lexicographic byte order).
-*
-* @example
-* ```typescript
-* // Create set
-* const set = CborSet.fromArray([1, 2, 3]);
-* const set2 = CborSet.fromSet(new Set([1, 2, 3]));
-*
-* // Add elements
-* set.insert(4);
-* set.insert(2); // Duplicate, no effect
-*
-* // Check membership
-* console.log(set.contains(2)); // true
-* console.log(set.contains(99)); // false
+* Tag 257: binary UUID reference
+*/
+const TAG_BINARY_UUID = 257;
+/**
+* Tag 258: Set of values (array with no duplicates)
+*/
+const TAG_SET = 258;
+/**
+* Tag 55799: Self-describe CBOR (magic number 0xd9d9f7)
+*/
+const TAG_SELF_DESCRIBE_CBOR = 55799;
+const TAG_DATE = 1;
+const TAG_NAME_DATE = "date";
+/**
+* Register standard tags in a specific tags store.
+* Matches Rust's register_tags_in() function.
 *
-* // Encode to CBOR
-* const tagged = set.taggedCbor();
-* ```
+* @param tagsStore - The tags store to register tags into
 */
-var CborSet = class CborSet {
-	_map;
-	constructor() {
-		this._map = new CborMap();
-	}
-	/**
-	* Create CborSet from array.
-	*
-	* Duplicates are automatically removed.
-	*
-	* @param items - Array of items to add to the set
-	* @returns New CborSet instance
-	*
-	* @example
-	* ```typescript
-	* const set = CborSet.fromArray([1, 2, 3, 2, 1]);
-	* console.log(set.size); // 3
-	* ```
-	*/
-	static fromArray(items) {
-		const set = new CborSet();
-		for (const item of items) set.insert(item);
-		return set;
-	}
-	/**
-	* Create CborSet from JavaScript Set.
-	*
-	* @param items - JavaScript Set of items
-	* @returns New CborSet instance
-	*
-	* @example
-	* ```typescript
-	* const jsSet = new Set([1, 2, 3]);
-	* const cborSet = CborSet.fromSet(jsSet);
-	* ```
-	*/
-	static fromSet(items) {
-		return CborSet.fromArray(Array.from(items));
-	}
-	/**
-	* Create CborSet from iterable.
-	*
-	* @param items - Iterable of items
-	* @returns New CborSet instance
-	*/
-	static fromIterable(items) {
-		return CborSet.fromArray(Array.from(items));
-	}
-	/**
-	* Insert an element into the set.
-	*
-	* If the element already exists, has no effect.
-	*
-	* @param value - Value to insert
-	*
-	* @example
-	* ```typescript
-	* const set = new CborSet();
-	* set.insert(1);
-	* set.insert(2);
-	* set.insert(1); // No effect, already exists
-	* ```
-	*/
-	insert(value) {
-		const cborValue = encodeCborValue(value);
-		this._map.set(cborValue, cborValue);
-	}
-	/**
-	* Insert an element into the set, requiring it to be strictly greater
-	* (in canonical CBOR-encoded byte order) than every previously-inserted
-	* element. Used by the decoder to reject misordered or duplicate
-	* elements in tag-258 set encodings.
-	*
-	* Mirrors Rust `Set::insert_next` (`pub(crate)`); exposed here because
-	* TypeScript doesn't have a crate-private visibility level.
-	*
-	* @throws CborError of type `MisorderedMap` if `value` would not preserve
-	*   strict ascending CBOR-byte order, or `DuplicateMapKey` for an exact
-	*   repeat.
-	*/
-	insertNext(value) {
-		const cborValue = encodeCborValue(value);
-		this._map.setNext(cborValue, cborValue);
-	}
-	/**
-	* Check if set contains an element.
-	*
-	* @param value - Value to check
-	* @returns true if element is in the set
-	*
-	* @example
-	* ```typescript
-	* const set = CborSet.fromArray([1, 2, 3]);
-	* console.log(set.contains(2)); // true
-	* console.log(set.contains(99)); // false
-	* ```
-	*/
-	contains(value) {
-		const cborValue = encodeCborValue(value);
-		return this._map.has(cborValue);
-	}
-	/**
-	* Remove an element from the set.
-	*
-	* @param value - Value to remove
-	* @returns true if element was removed, false if not found
-	*
-	* @example
-	* ```typescript
-	* const set = CborSet.fromArray([1, 2, 3]);
-	* set.delete(2); // Returns true
-	* set.delete(99); // Returns false
-	* ```
-	*/
-	delete(value) {
-		const cborValue = encodeCborValue(value);
-		return this._map.delete(cborValue);
-	}
-	/**
-	* Remove all elements from the set.
-	*/
-	clear() {
-		this._map.clear();
-	}
-	/**
-	* Get the number of elements in the set.
-	*
-	* @returns Number of elements
-	*/
-	get size() {
-		return this._map.size;
-	}
-	/**
-	* Check if the set is empty.
-	*
-	* @returns true if set has no elements
-	*/
-	isEmpty() {
-		return this._map.size === 0;
-	}
-	/**
-	* Create a new set containing elements in this set or the other set.
-	*
-	* @param other - Other set
-	* @returns New set with union of elements
-	*
-	* @example
-	* ```typescript
-	* const set1 = CborSet.fromArray([1, 2, 3]);
-	* const set2 = CborSet.fromArray([3, 4, 5]);
-	* const union = set1.union(set2);
-	* // union contains [1, 2, 3, 4, 5]
-	* ```
-	*/
-	union(other) {
-		const result = new CborSet();
-		for (const value of this) result.insert(extractCbor(value));
-		for (const value of other) result.insert(extractCbor(value));
-		return result;
-	}
-	/**
-	* Create a new set containing elements in both this set and the other set.
-	*
-	* @param other - Other set
-	* @returns New set with intersection of elements
-	*
-	* @example
-	* ```typescript
-	* const set1 = CborSet.fromArray([1, 2, 3]);
-	* const set2 = CborSet.fromArray([2, 3, 4]);
-	* const intersection = set1.intersection(set2);
-	* // intersection contains [2, 3]
-	* ```
-	*/
-	intersection(other) {
-		const result = new CborSet();
-		for (const value of this) {
-			const extracted = extractCbor(value);
-			if (other.contains(extracted)) result.insert(extracted);
+const registerTagsIn = (tagsStore) => {
+	const tags = [createTag(1, TAG_NAME_DATE)];
+	tagsStore.insertAll(tags);
+	tagsStore.setSummarizer(1, (untaggedCbor, _flat) => {
+		try {
+			return {
+				ok: true,
+				value: CborDate.fromUntaggedCbor(untaggedCbor).toString()
+			};
+		} catch (e) {
+			return {
+				ok: false,
+				error: {
+					type: "Custom",
+					message: e instanceof Error ? e.message : String(e)
+				}
+			};
+		}
+	});
+	const biguintTag = createTag(2, TAG_NAME_POSITIVE_BIGNUM);
+	const bigintTag = createTag(3, TAG_NAME_NEGATIVE_BIGNUM);
+	tagsStore.insertAll([biguintTag, bigintTag]);
+	tagsStore.setSummarizer(2, (untaggedCbor, _flat) => {
+		try {
+			return {
+				ok: true,
+				value: `bignum(${biguintFromUntaggedCbor(untaggedCbor)})`
+			};
+		} catch (e) {
+			return {
+				ok: false,
+				error: {
+					type: "Custom",
+					message: e instanceof Error ? e.message : String(e)
+				}
+			};
 		}
-		return result;
-	}
-	/**
-	* Create a new set containing elements in this set but not in the other set.
-	*
-	* @param other - Other set
-	* @returns New set with difference of elements
-	*
-	* @example
-	* ```typescript
-	* const set1 = CborSet.fromArray([1, 2, 3]);
-	* const set2 = CborSet.fromArray([2, 3, 4]);
-	* const diff = set1.difference(set2);
-	* // diff contains [1]
-	* ```
-	*/
-	difference(other) {
-		const result = new CborSet();
-		for (const value of this) {
-			const extracted = extractCbor(value);
-			if (!other.contains(extracted)) result.insert(extracted);
+	});
+	tagsStore.setSummarizer(3, (untaggedCbor, _flat) => {
+		try {
+			return {
+				ok: true,
+				value: `bignum(${bigintFromNegativeUntaggedCbor(untaggedCbor)})`
+			};
+		} catch (e) {
+			return {
+				ok: false,
+				error: {
+					type: "Custom",
+					message: e instanceof Error ? e.message : String(e)
+				}
+			};
 		}
-		return result;
-	}
-	/**
-	* Check if this set is a subset of another set.
-	*
-	* @param other - Other set
-	* @returns true if all elements of this set are in the other set
-	*/
-	isSubsetOf(other) {
-		for (const value of this) if (!other.contains(extractCbor(value))) return false;
-		return true;
-	}
-	/**
-	* Check if this set is a superset of another set.
-	*
-	* @param other - Other set
-	* @returns true if all elements of the other set are in this set
-	*/
-	isSupersetOf(other) {
-		return other.isSubsetOf(this);
-	}
-	/**
-	* Iterate over elements in the set.
-	*
-	* Elements are returned in deterministic order (by CBOR encoding).
-	*
-	* @example
-	* ```typescript
-	* const set = CborSet.fromArray([3, 1, 2]);
-	* for (const value of set) {
-	*   console.log(extractCbor(value));
-	* }
-	* ```
-	*/
-	*[Symbol.iterator]() {
-		for (const [_, value] of this._map) yield value;
-	}
-	/**
-	* Get all values as an array.
-	*
-	* @returns Array of CBOR values in deterministic order
-	*
-	* @example
-	* ```typescript
-	* const set = CborSet.fromArray([3, 1, 2]);
-	* const values = set.values();
-	* // Values in deterministic order
-	* ```
-	*/
-	values() {
-		return Array.from(this);
-	}
-	/**
-	* Execute a function for each element.
-	*
-	* @param callback - Function to call for each element
-	*
-	* @example
-	* ```typescript
-	* set.forEach(value => {
-	*   console.log(extractCbor(value));
-	* });
-	* ```
-	*/
-	forEach(callback) {
-		for (const value of this) callback(value);
-	}
-	cborTags() {
-		return [createTag(258, "set")];
-	}
-	untaggedCbor() {
-		return cbor(this.values());
-	}
-	taggedCbor() {
-		return createTaggedCbor(this);
-	}
-	fromUntaggedCbor(c) {
-		if (c.type !== MajorType.Array) throw new CborError({ type: "WrongType" });
-		this.clear();
-		for (const value of c.value) this.insertNext(extractCbor(value));
-		return this;
-	}
-	fromTaggedCbor(c) {
-		validateTag(c, this.cborTags());
-		const content = extractTaggedContent(c);
-		return this.fromUntaggedCbor(content);
-	}
-	/**
-	* Decode a CborSet from tagged CBOR (static method).
-	*
-	* @param cbor - Tagged CBOR value with tag(258)
-	* @returns Decoded CborSet instance
-	*/
-	static fromTaggedCborStatic(cbor) {
-		return new CborSet().fromTaggedCbor(cbor);
-	}
-	/**
-	* Convert to CBOR array (untagged).
-	*
-	* @returns CBOR array
-	*/
-	toCbor() {
-		return this.untaggedCbor();
-	}
-	/**
-	* Convert to CBOR bytes (tagged).
-	*
-	* @returns Encoded CBOR bytes
-	*/
-	toBytes() {
-		return cborData(this.taggedCbor());
-	}
-	/**
-	* Convert to JavaScript Set.
-	*
-	* @returns JavaScript Set with extracted values
-	*
-	* @example
-	* ```typescript
-	* const cborSet = CborSet.fromArray([1, 2, 3]);
-	* const jsSet = cborSet.toSet();
-	* console.log(jsSet.has(1)); // true
-	* ```
-	*/
-	toSet() {
-		const result = /* @__PURE__ */ new Set();
-		for (const value of this) result.add(extractCbor(value));
-		return result;
-	}
-	/**
-	* Convert to JavaScript Array.
-	*
-	* @returns Array with extracted values
-	*/
-	toArray() {
-		return Array.from(this.toSet());
-	}
-	/**
-	* Get diagnostic notation for the set.
-	*
-	* @returns String representation
-	*
-	* @example
-	* ```typescript
-	* const set = CborSet.fromArray([1, 2, 3]);
-	* console.log(set.diagnostic); // "[1, 2, 3]"
-	* ```
-	*/
-	get diagnostic() {
-		return `[${this.values().map((v) => {
-			const extracted = extractCbor(v);
-			if (typeof extracted === "string") return `"${extracted}"`;
-			return String(extracted);
-		}).join(", ")}]`;
-	}
-	/**
-	* Convert to string (same as diagnostic).
-	*
-	* @returns String representation
-	*/
-	toString() {
-		return this.diagnostic;
-	}
-	/**
-	* Convert to JSON (returns array of values).
-	*
-	* @returns Array for JSON serialization
-	*/
-	toJSON() {
-		return this.toArray();
-	}
+	});
 };
 /**
-* Convert a value to CBOR for use in set operations.
+* Register standard tags in the global tags store.
+* Matches Rust's register_tags() function.
 *
-* @internal
+* This function is idempotent - calling it multiple times is safe.
 */
-function encodeCborValue(value) {
-	if (typeof value === "object" && value !== null && "isCbor" in value && value.isCbor === true) return value;
-	return cbor(value);
-}
+const registerTags = () => {
+	registerTagsIn(getGlobalTagsStore());
+};
+/**
+* Converts an array of tag values to their corresponding Tag objects.
+* Matches Rust's tags_for_values() function.
+*
+* This function looks up each tag value in the global tag registry and returns
+* an array of complete Tag objects. For any tag values that aren't
+* registered in the global registry, it creates a basic Tag with just the
+* value (no name).
+*
+* @param values - Array of numeric tag values to convert
+* @returns Array of Tag objects corresponding to the input values
+*
+* @example
+* ```typescript
+* // Register some tags first
+* registerTags();
+*
+* // Convert tag values to Tag objects
+* const tags = tagsForValues([1, 42, 999]);
+*
+* // The first tag (value 1) should be registered as "date"
+* console.log(tags[0].value); // 1
+* console.log(tags[0].name); // "date"
+*
+* // Unregistered tags will have a value but no name
+* console.log(tags[1].value); // 42
+* console.log(tags[2].value); // 999
+* ```
+*/
+const tagsForValues = (values) => {
+	const globalStore = getGlobalTagsStore();
+	return values.map((value) => {
+		const tag = globalStore.tagForValue(value);
+		if (tag !== void 0) return tag;
+		return createTag(value);
+	});
+};
 //#endregion
 //#region src/sortable.ts
 /**
@@ -9446,6 +9634,6 @@ var ByteString = class ByteString {
 	}
 };
 //#endregion
-export { ByteString, Cbor, CborDate, CborError, CborMap, CborSet, Err, MajorType, Ok, TAG_BASE16, TAG_BASE64, TAG_BASE64URL, TAG_BASE64URL_TEXT, TAG_BASE64_TEXT, TAG_BIGFLOAT, TAG_BINARY_UUID, TAG_DATE, TAG_DATE_TIME_STRING, TAG_DECIMAL_FRACTION, TAG_ENCODED_CBOR, TAG_EPOCH_DATE, TAG_EPOCH_DATE_TIME, TAG_MIME_MESSAGE, TAG_NAME_DATE, TAG_NAME_NEGATIVE_BIGNUM, TAG_NAME_POSITIVE_BIGNUM, TAG_NEGATIVE_BIGNUM, TAG_POSITIVE_BIGNUM, TAG_REGEXP, TAG_SELF_DESCRIBE_CBOR, TAG_SET, TAG_STRING_REF_NAMESPACE, TAG_URI, TAG_UUID, TagsStore, arrayIsEmpty, arrayItem, arrayLength, arraySortable, asArray, asBoolean, asByteString, asBytes, asCborArray, asCborMap, asFloat, asInteger, asKeyValue, asMap, asNegative, asNumber, asSingle, asTaggedValue, asText, asUnsigned, bigintFromNegativeUntaggedCbor, bigintToCbor, biguintFromUntaggedCbor, biguintToCbor, bytesToHex, cbor, cborData, cborEquals, cborFalse, cborNaN, cborNull, cborToBigint, cborToBiguint, cborTrue, createTag, createTaggedCbor, decodeCbor, decodeVarInt, decodeVarIntData, diagnostic, diagnosticAnnotated, diagnosticFlat, diagnosticOpt, edgeLabel, encodeVarInt, errorMsg, errorToString, expectArray, expectBoolean, expectBoolean as tryIntoBool, expectBytes, expectBytes as tryIntoByteString, expectFloat, expectInteger, expectMap, expectNegative, expectNumber, expectTaggedContent, expectTaggedContent as tryExpectedTaggedValue, expectText, expectText as tryIntoText, expectUnsigned, extractCbor, extractTaggedContent, fromTaggedCborData, fromUntaggedCborData, getGlobalTagsStore, getTaggedContent, hasFractionalPart, hasTag, hex, hexAnnotated, hexOpt, hexToBytes, isArray, isBoolean, isBytes, isFloat, isInteger, isMap, isNaN$1 as isNaN, isNegative, isNull, isNumber, isSimple, isTagged, isText, isUnsigned, mapHas, mapIsEmpty, mapKeys, mapSize, mapValue, mapValues, registerTags, registerTagsIn, setSortable, simpleName, sortArrayByCborEncoding, summary, tagContent, tagValue, tagWithStaticName, tagWithValue, taggedCborData, tagsEqual, tagsForValues, toByteString, toByteStringFromHex, toTaggedValue, validateTag, walk };
+export { ByteString, Cbor, CborDate, CborError, CborMap, CborSet, Err, MajorType, Ok, TAG_BASE16, TAG_BASE64, TAG_BASE64URL, TAG_BASE64URL_TEXT, TAG_BASE64_TEXT, TAG_BIGFLOAT, TAG_BINARY_UUID, TAG_DATE, TAG_DATE_TIME_STRING, TAG_DECIMAL_FRACTION, TAG_ENCODED_CBOR, TAG_EPOCH_DATE, TAG_EPOCH_DATE_TIME, TAG_MIME_MESSAGE, TAG_NAME_DATE, TAG_NAME_NEGATIVE_BIGNUM, TAG_NAME_POSITIVE_BIGNUM, TAG_NEGATIVE_BIGNUM, TAG_POSITIVE_BIGNUM, TAG_REGEXP, TAG_SELF_DESCRIBE_CBOR, TAG_SET, TAG_STRING_REF_NAMESPACE, TAG_URI, TAG_UUID, TagsStore, arrayIsEmpty, arrayItem, arrayLength, arraySortable, asArray, asBoolean, asByteString, asBytes, asCborArray, asCborMap, asFloat, asInteger, asKeyValue, asMap, asNegative, asNumber, asSingle, asTaggedValue, asText, asUnsigned, bigintFromNegativeUntaggedCbor, bigintToCbor, biguintFromUntaggedCbor, biguintToCbor, bytesToHex, cbor, cborData, cborEquals, cborFalse, cborNaN, cborNull, cborToBigint, cborToBiguint, cborTrue, createTag, createTaggedCbor, decodeCbor, decodeVarInt, decodeVarIntData, diagnostic, diagnosticAnnotated, diagnosticFlat, diagnosticOpt, edgeLabel, encodeVarInt, errorMsg, errorToString, expectArray, expectBoolean, expectBoolean as tryIntoBool, expectBytes, expectBytes as tryIntoByteString, expectFloat, expectInteger, expectMap, expectNegative, expectNumber, expectTaggedContent, expectTaggedContent as tryExpectedTaggedValue, expectText, expectText as tryIntoText, expectUnsigned, extractCbor, extractTaggedContent, fromTaggedCborData, fromUntaggedCborData, getGlobalTagsStore, getTaggedContent, hasFractionalPart, hasTag, hex, hexAnnotated, hexOpt, hexToBytes, isArray, isBoolean, isBytes, isFloat, isInteger, isMap, isNaN$1 as isNaN, isNegative, isNull, isNumber, isSimple, isTagged, isText, isUnsigned, mapHas, mapIsEmpty, mapKeys, mapSize, mapValue, mapValues, registerTags, registerTagsIn, setSortable, simpleName, sortArrayByCborEncoding, summary, tagContent, tagValue, tagValuesEqual, tagWithStaticName, tagWithValue, taggedCborData, tagsEqual, tagsForValues, toByteString, toByteStringFromHex, toTaggedValue, validateTag, walk, withTags, withTagsMut };
 
 //# sourceMappingURL=index.mjs.map