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

package/dist/index.cjs

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