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

package/dist/index.iife.js

@@ -4188,13 +4188,19 @@ var bctsDcbor = (function(exports) {
 		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.
@@ -4613,6 +4619,33 @@ var bctsDcbor = (function(exports) {
 	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).
 	*/
@@ -4776,6 +4809,55 @@ var bctsDcbor = (function(exports) {
 			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
 	/**
@@ -4830,7 +4912,7 @@ var bctsDcbor = (function(exports) {
 	* Convert number to 32-bit float binary (big-endian).
 	*/
 	const numberToBinary32 = (n) => {
-		const data = new Uint8Array(4);
+		const data = /* @__PURE__ */ new Uint8Array(4);
 		import_byte_data.packTo(n, {
 			bits: 32,
 			fp: true,
@@ -4852,7 +4934,7 @@ var bctsDcbor = (function(exports) {
 	* Convert number to 16-bit float binary (big-endian).
 	*/
 	const numberToBinary16 = (n) => {
-		const data = new Uint8Array(2);
+		const data = /* @__PURE__ */ new Uint8Array(2);
 		import_byte_data.packTo(n, {
 			bits: 16,
 			fp: true,
@@ -4884,11 +4966,11 @@ var bctsDcbor = (function(exports) {
 			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);
@@ -4906,8 +4988,8 @@ var bctsDcbor = (function(exports) {
 		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);
@@ -4925,7 +5007,7 @@ var bctsDcbor = (function(exports) {
 		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);
@@ -4933,6 +5015,31 @@ var bctsDcbor = (function(exports) {
 		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
 	/**
@@ -5197,6 +5304,34 @@ var bctsDcbor = (function(exports) {
 		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
 	/**
@@ -5400,7 +5535,7 @@ var bctsDcbor = (function(exports) {
 				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;
@@ -5627,7 +5762,7 @@ var bctsDcbor = (function(exports) {
 			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;
@@ -5650,7 +5785,7 @@ var bctsDcbor = (function(exports) {
 		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) {
@@ -5661,20 +5796,11 @@ var bctsDcbor = (function(exports) {
 		}
 	}
 	/**
-	* 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;
@@ -5764,7 +5890,7 @@ var bctsDcbor = (function(exports) {
 		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);
@@ -5868,7 +5994,15 @@ var bctsDcbor = (function(exports) {
 				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({
@@ -6247,9 +6381,12 @@ var bctsDcbor = (function(exports) {
 	* @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).
@@ -6370,9 +6507,13 @@ var bctsDcbor = (function(exports) {
 	* @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.
@@ -6510,7 +6651,7 @@ var bctsDcbor = (function(exports) {
 	*/
 	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.
@@ -6520,7 +6661,7 @@ var bctsDcbor = (function(exports) {
 	* @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.
@@ -6535,7 +6676,7 @@ var bctsDcbor = (function(exports) {
 	*/
 	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 }
@@ -6775,15 +6916,13 @@ var bctsDcbor = (function(exports) {
 		* 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)
@@ -7137,15 +7276,27 @@ var bctsDcbor = (function(exports) {
 				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,
@@ -7496,7 +7647,7 @@ var bctsDcbor = (function(exports) {
 			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 }
@@ -7509,7 +7660,7 @@ var bctsDcbor = (function(exports) {
 			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],
@@ -7591,809 +7742,1267 @@ var bctsDcbor = (function(exports) {
 		}
 	};
 	//#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 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
 	*
-	* @param cbor - The CBOR value to convert
+	* - 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
 	* @throws CborError
 	*/
@@ -8572,553 +9181,132 @@ var bctsDcbor = (function(exports) {
 	/**
 	* 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
 	/**
@@ -9533,6 +9721,7 @@ var bctsDcbor = (function(exports) {
 	exports.summary = summary;
 	exports.tagContent = tagContent;
 	exports.tagValue = tagValue;
+	exports.tagValuesEqual = tagValuesEqual;
 	exports.tagWithStaticName = tagWithStaticName;
 	exports.tagWithValue = tagWithValue;
 	exports.taggedCborData = taggedCborData;
@@ -9547,6 +9736,8 @@ var bctsDcbor = (function(exports) {
 	exports.tryIntoText = expectText;
 	exports.validateTag = validateTag;
 	exports.walk = walk;
+	exports.withTags = withTags;
+	exports.withTagsMut = withTagsMut;
 	return exports;
 })({});