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

package/src/float.ts

@@ -28,7 +28,6 @@ import * as byteData from "byte-data";
 import { encodeVarInt } from "./varint";
 import { MajorType } from "./cbor";
 import { ExactU64, ExactU32, ExactU16, ExactI128 } from "./exact";
-import { CborError } from "./error";
 
 /**
  * Canonical NaN representation in CBOR: 0xf97e00
@@ -102,9 +101,10 @@ export const f64CborData = (value: number): Uint8Array => {
     if (i128 !== undefined) {
       const i = ExactU64.exactFromI128(-1n - i128);
       if (i !== undefined) {
-        // Encode as a negative integer
-        const num = typeof i === "bigint" ? Number(i) : i;
-        return encodeVarInt(num, MajorType.Negative);
+        // Encode as a negative integer. Pass the bigint straight through:
+        // encodeVarInt handles u64 losslessly via setBigUint64, whereas
+        // narrowing through Number() would round magnitudes above 2^53.
+        return encodeVarInt(i, MajorType.Negative);
       }
     }
   }
@@ -112,8 +112,7 @@ export const f64CborData = (value: number): Uint8Array => {
   // Try numeric reduction to unsigned integer
   const u = ExactU64.exactFromF64(n);
   if (u !== undefined) {
-    const num = typeof u === "bigint" ? Number(u) : u;
-    return encodeVarInt(num, MajorType.Unsigned);
+    return encodeVarInt(u, MajorType.Unsigned);
   }
 
   // Canonical NaN
@@ -130,32 +129,6 @@ export const f64CborData = (value: number): Uint8Array => {
   return new Uint8Array([majorByte, ...bytes]);
 };
 
-/**
- * Validate canonical encoding for f64.
- *
- * Counterpart to Rust's `validate_canonical_f64`. **NOT used by the
- * decoder.** JavaScript's `Number` type does not preserve NaN payload
- * bits — every NaN collapses to a single value — which means the
- * Rust-style `n.to_bits() != 0x7e00` distinction can't be made on a
- * post-decoded `number`. The TS decoder uses
- * {@link checkCanonicalEncoding} (re-encode-and-compare) instead, which
- * handles every same-failure case including non-canonical NaNs because
- * the canonicalising encoder always re-emits the canonical bit pattern.
- *
- * Kept for API parity with Rust's `pub(crate)` helper, plus as a
- * documentation anchor; not recommended for callers.
- *
- * @internal
- */
-export const validateCanonicalF64 = (n: number): void => {
-  const f32Bytes = numberToBinary32(n);
-  const f32 = binary32ToNumber(f32Bytes);
-
-  if (n === f32 || n === Math.trunc(n) || Number.isNaN(n)) {
-    throw new CborError({ type: "NonCanonicalNumeric" });
-  }
-};
-
 /**
  * Encode f32 value to CBOR data bytes.
  * Implements numeric reduction and canonical encoding rules.
@@ -172,12 +145,12 @@ export const f32CborData = (value: number): Uint8Array => {
     return f16CborData(f);
   }
 
-  // Try numeric reduction to negative integer
+  // Try numeric reduction to negative integer. Math.fround keeps `-1 - n` in
+  // f32 precision to match Rust's `-1f32 - n`.
   if (n < 0.0) {
-    const u = ExactU64.exactFromF32(-1.0 - n);
+    const u = ExactU64.exactFromF32(Math.fround(-1.0 - n));
     if (u !== undefined) {
-      const num = typeof u === "bigint" ? Number(u) : u;
-      return encodeVarInt(num, MajorType.Negative);
+      return encodeVarInt(u, MajorType.Negative);
     }
   }
 
@@ -197,23 +170,6 @@ export const f32CborData = (value: number): Uint8Array => {
   return new Uint8Array([0xfa, ...bytes]);
 };
 
-/**
- * Validate canonical encoding for f32.
- *
- * @see {@link validateCanonicalF64} — same caveat about JS NaN bit
- *   preservation. The decoder relies on {@link checkCanonicalEncoding}.
- *
- * @internal
- */
-export const validateCanonicalF32 = (n: number): void => {
-  const f16Bytes = numberToBinary16(n);
-  const f16 = binary16ToNumber(f16Bytes);
-
-  if (n === f16 || n === Math.trunc(n) || Number.isNaN(n)) {
-    throw new CborError({ type: "NonCanonicalNumeric" });
-  }
-};
-
 /**
  * Encode f16 value to CBOR data bytes.
  * Implements numeric reduction and canonical encoding rules.
@@ -227,8 +183,7 @@ export const f16CborData = (value: number): Uint8Array => {
   if (n < 0.0) {
     const u = ExactU64.exactFromF64(-1.0 - n);
     if (u !== undefined) {
-      const num = typeof u === "bigint" ? Number(u) : u;
-      return encodeVarInt(num, MajorType.Negative);
+      return encodeVarInt(u, MajorType.Negative);
     }
   }
 
@@ -249,23 +204,37 @@ export const f16CborData = (value: number): Uint8Array => {
 };
 
 /**
- * Validate canonical encoding for f16.
+ * Render a float to its diagnostic string, matching Rust's `Simple` Display.
  *
- * @see {@link validateCanonicalF64} — same caveat about JS NaN bit
- *   preservation. The decoder relies on {@link checkCanonicalEncoding}.
+ * 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`.
  *
- * @internal
+ * 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
  */
-export const validateCanonicalF16 = (value: number): void => {
-  const n = value;
-  const f = n;
-
-  const f16Bytes = numberToBinary16(value);
-  const bits = new DataView(f16Bytes.buffer).getUint16(0, false);
-
-  if (f === Math.trunc(f) || (Number.isNaN(value) && bits !== 0x7e00)) {
-    throw new CborError({ type: "NonCanonicalNumeric" });
+export const floatDisplayString = (value: number): string => {
+  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 < 1e16) {
+    // In this range String() never switches to exponential. Ensure at least
+    // one fractional digit.
+    let str = String(value);
+    if (!str.includes(".")) {
+      str = `${str}.0`;
+    }
+    return str;
   }
+
+  // Drop the `+` in the exponent to match Rust (`1.5e+20` → `1.5e20`);
+  // negative exponents keep their sign.
+  return value.toExponential().replace("e+", "e");
 };
 
 /**

package/src/index.ts

@@ -25,6 +25,9 @@ export {
   type CborMapType,
   type CborTaggedType,
   type CborSimpleType,
+  // Conversion interfaces accepted by `cbor()` / referenced by `CborInput`.
+  type ToCbor,
+  type TaggedCborEncodable,
 } from "./cbor";
 
 // Simple value types
@@ -59,6 +62,7 @@ export {
   tagWithValue,
   tagWithStaticName,
   tagsEqual,
+  tagValuesEqual,
 } from "./tag";
 export {
   type CborTagged,
@@ -77,7 +81,10 @@ export {
   type TagsStoreTrait,
   type CborSummarizer,
   type SummarizerResult,
+  type TagsStoreOpt,
   getGlobalTagsStore,
+  withTags,
+  withTagsMut,
 } from "./tags-store";
 export * from "./tags";
 export { registerTags, registerTagsIn, tagsForValues } from "./tags";

package/src/map.ts

@@ -217,19 +217,19 @@ export class CborMap {
    * Matches Rust's Map::insert_next().
    */
   setNext<K extends CborInput, V extends CborInput>(key: K, value: V): void {
-    const lastEntry = this._dict.max();
-    if (lastEntry === undefined) {
-      this.set(key, value);
-      return;
-    }
     const keyCbor = cbor(key);
     const newKey = cborData(keyCbor);
     if (this._dict.has(newKey)) {
       throw new CborError({ type: "DuplicateMapKey" });
     }
-    const lastEntryKey = this._makeKey(lastEntry.key);
-    if (lexicographicallyCompareBytes(newKey, lastEntryKey) <= 0) {
-      throw new CborError({ type: "MisorderedMapKey" });
+    // Enforce strict ascending order by comparing the new key against the
+    // greatest existing encoded key, read from the sorted store's last item.
+    // Mirrors Rust's insert_next/last_key_value.
+    const greatest = this._dict.store.max();
+    if (greatest !== undefined) {
+      if (lexicographicallyCompareBytes(newKey, greatest.key) <= 0) {
+        throw new CborError({ type: "MisorderedMapKey" });
+      }
     }
     this._dict.set(newKey, { key: keyCbor, value: cbor(value) });
   }

package/src/prelude.ts

@@ -56,9 +56,9 @@ export { CborDate } from "./date";
 
 // Tag handling
 export type { Tag, TagValue } from "./tag";
-export { createTag, tagWithValue, tagWithStaticName, tagsEqual } from "./tag";
+export { createTag, tagWithValue, tagWithStaticName, tagsEqual, tagValuesEqual } from "./tag";
 export { TagsStore, getGlobalTagsStore, withTags, withTagsMut } from "./tags-store";
-export type { TagsStoreTrait } from "./tags-store";
+export type { TagsStoreTrait, CborSummarizer, SummarizerResult, TagsStoreOpt } from "./tags-store";
 export { tagsForValues } from "./tags";
 
 // Format options

package/src/set.ts

@@ -3,10 +3,11 @@
  * Copyright © 2025-2026 Parity Technologies
  *
  *
- * Set data structure for CBOR with tag(258) encoding.
+ * Set data structure for CBOR.
  *
- * A Set is encoded as an array with no duplicate elements,
- * tagged with tag(258) to indicate set semantics.
+ * 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 set
  */
@@ -14,20 +15,11 @@
 import { type Cbor, MajorType, type CborInput } from "./cbor";
 import { cbor, cborData } from "./cbor";
 import { CborMap } from "./map";
-import { createTag, type Tag } from "./tag";
-import { TAG_SET } from "./tags";
-import {
-  type CborTaggedEncodable,
-  type CborTaggedDecodable,
-  createTaggedCbor,
-  validateTag,
-  extractTaggedContent,
-} from "./cbor-tagged";
 import { extractCbor } from "./conveniences";
 import { CborError } from "./error";
 
 /**
- * CBOR Set type with tag(258) encoding.
+ * CBOR Set type, encoded as a plain (untagged) array.
  *
  * Internally uses a CborMap to ensure unique elements with deterministic ordering.
  * Elements are ordered by their CBOR encoding (lexicographic byte order).
@@ -46,11 +38,11 @@ import { CborError } from "./error";
  * console.log(set.contains(2)); // true
  * console.log(set.contains(99)); // false
  *
- * // Encode to CBOR
- * const tagged = set.taggedCbor();
+ * // Encode to CBOR (untagged array)
+ * const c = set.toCbor();
  * ```
  */
-export class CborSet implements CborTaggedEncodable, CborTaggedDecodable<CborSet> {
+export class CborSet {
   private readonly _map: CborMap;
 
   constructor() {
@@ -135,13 +127,12 @@ export class CborSet implements CborTaggedEncodable, CborTaggedDecodable<CborSet
   }
 
   /**
-   * 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.
+   * 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.
    *
    * Mirrors Rust `Set::insert_next` (`pub(crate)`); exposed here because
-   * TypeScript doesn't have a crate-private visibility level.
+   * TypeScript has no crate-private visibility.
    *
    * @throws CborError of type `MisorderedMap` if `value` would not preserve
    *   strict ascending CBOR-byte order, or `DuplicateMapKey` for an exact
@@ -377,32 +368,38 @@ export class CborSet implements CborTaggedEncodable, CborTaggedDecodable<CborSet
   }
 
   // =========================================================================
-  // CborTagged Implementation
+  // CBOR Encoding / Decoding (untagged array — Rust parity)
   // =========================================================================
 
-  cborTags(): Tag[] {
-    return [createTag(TAG_SET, "set")];
-  }
-
+  /**
+   * Encode the set as an (untagged) CBOR array of its elements, in canonical
+   * ascending CBOR-byte order. Matches Rust `From<Set> for CBOR`.
+   *
+   * @returns CBOR array
+   */
   untaggedCbor(): Cbor {
     // Encode as an array of values
     const values = this.values();
     return cbor(values);
   }
 
-  taggedCbor(): Cbor {
-    return createTaggedCbor(this);
-  }
-
+  /**
+   * Decode a CborSet from a CBOR array into this instance.
+   *
+   * 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`).
+   *
+   * @param c - CBOR array value
+   * @returns this
+   * @throws CborError of type `WrongType` if `c` is not an array.
+   */
   fromUntaggedCbor(c: Cbor): CborSet {
     if (c.type !== MajorType.Array) {
       throw new CborError({ type: "WrongType" });
     }
 
     this.clear();
-    // Mirrors Rust `Set::try_from_vec` which calls `insert_next` per item:
-    // a tag-258 wire encoding must already be in strict ascending CBOR-byte
-    // order with no duplicates.
     for (const value of c.value) {
       this.insertNext(extractCbor(value) as CborInput);
     }
@@ -410,21 +407,14 @@ export class CborSet implements CborTaggedEncodable, CborTaggedDecodable<CborSet
     return this;
   }
 
-  fromTaggedCbor(c: Cbor): CborSet {
-    const expectedTags = this.cborTags();
-    validateTag(c, expectedTags);
-    const content = extractTaggedContent(c);
-    return this.fromUntaggedCbor(content);
-  }
-
   /**
-   * Decode a CborSet from tagged CBOR (static method).
+   * Decode a CborSet from a CBOR array.
    *
-   * @param cbor - Tagged CBOR value with tag(258)
+   * @param c - CBOR array value
    * @returns Decoded CborSet instance
    */
-  static fromTaggedCborStatic(cbor: Cbor): CborSet {
-    return new CborSet().fromTaggedCbor(cbor);
+  static fromCbor(c: Cbor): CborSet {
+    return new CborSet().fromUntaggedCbor(c);
   }
 
   // =========================================================================
@@ -441,12 +431,12 @@ export class CborSet implements CborTaggedEncodable, CborTaggedDecodable<CborSet
   }
 
   /**
-   * Convert to CBOR bytes (tagged).
+   * Convert to encoded CBOR bytes.
    *
    * @returns Encoded CBOR bytes
    */
   toBytes(): Uint8Array {
-    return cborData(this.taggedCbor());
+    return cborData(this.untaggedCbor());
   }
 
   /**

package/src/tag.ts

@@ -80,16 +80,23 @@ export const tagWithValue = (value: TagValue): Tag => ({ value });
 export const tagWithStaticName = (value: TagValue, name: string): Tag => ({ value, name });
 
 /**
- * Compare two tags for equality. Mirrors Rust's `PartialEq for Tag`, which
- * compares by `value` only and ignores the optional `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`.
  */
-export const tagsEqual = (a: Tag, b: Tag): boolean => {
-  if (typeof a.value === "bigint" || typeof b.value === "bigint") {
-    return BigInt(a.value) === BigInt(b.value);
+export const tagValuesEqual = (a: TagValue, b: TagValue): boolean => {
+  if (typeof a === "bigint" || typeof b === "bigint") {
+    return BigInt(a) === BigInt(b);
   }
-  return a.value === b.value;
+  return a === b;
 };
 
+/**
+ * Compare two tags for equality. Mirrors Rust's `PartialEq for Tag`, which
+ * compares by `value` only and ignores the optional `name`.
+ */
+export const tagsEqual = (a: Tag, b: Tag): boolean => tagValuesEqual(a.value, b.value);
+
 /**
  * Get the string representation of a tag.
  * Internal function used for error messages.

package/src/tags-store.ts

@@ -34,6 +34,16 @@ export type SummarizerResult =
  */
 export type CborSummarizer = (cbor: Cbor, flat: boolean) => SummarizerResult;
 
+/**
+ * Selects which tag store the diagnostic/hex formatters consult when resolving
+ * tag names and summarizers (mirrors Rust's `TagsStoreOpt`):
+ *
+ * - a concrete {@link TagsStore} to use
+ * - `"global"` for the process-wide store
+ * - `"none"` to skip name/summary resolution
+ */
+export type TagsStoreOpt = TagsStore | "global" | "none";
+
 /**
  * Interface for tag store operations.
  */

package/src/walk.ts

@@ -89,8 +89,7 @@ export const edgeLabel = (edge: EdgeTypeVariant): string | undefined => {
  * Can be either a single CBOR value or a key-value pair from a map.
  */
 export type WalkElement =
-  | { type: "single"; cbor: Cbor }
-  | { type: "keyvalue"; key: Cbor; value: Cbor };
+  { type: "single"; cbor: Cbor } | { type: "keyvalue"; key: Cbor; value: Cbor };
 
 /**
  * Helper functions for WalkElement