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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bcts/dcbor",
-  "version": "1.0.0-beta.2",
+  "version": "1.0.0-beta.4",
   "type": "module",
   "description": "Blockchain Commons Deterministic CBOR (dCBOR) for TypeScript",
   "license": "BSD-2-Clause-Patent",
@@ -40,7 +40,7 @@
     "typecheck": "tsc --noEmit",
     "clean": "rm -rf dist",
     "docs": "typedoc",
-    "prepublishOnly": "npm run clean && npm run build && npm test"
+    "prepublishOnly": "npm run build"
   },
   "keywords": [
     "cbor",
@@ -60,10 +60,10 @@
     "@bcts/tsconfig": "^0.1.0",
     "@eslint/js": "^10.0.1",
     "@types/collections": "^5.1.5",
-    "@types/node": "^25.9.3",
-    "@typescript-eslint/eslint-plugin": "^8.61.1",
-    "@typescript-eslint/parser": "^8.61.1",
-    "eslint": "^10.5.0",
+    "@types/node": "^26.0.1",
+    "@typescript-eslint/eslint-plugin": "^8.62.0",
+    "@typescript-eslint/parser": "^8.62.0",
+    "eslint": "^10.6.0",
     "ts-node": "^10.9.2",
     "tsdown": "^0.22.3",
     "typedoc": "^0.28.19",

package/src/cbor-tagged-decodable.ts

@@ -17,7 +17,7 @@
 
 import { type Cbor, MajorType } from "./cbor";
 import type { CborTagged } from "./cbor-tagged";
-import type { Tag } from "./tag";
+import { tagValuesEqual, type Tag } from "./tag";
 import { CborError } from "./error";
 import { decodeCbor } from "./decode";
 
@@ -160,7 +160,7 @@ export const validateTag = (cbor: Cbor, expectedTags: Tag[]): Tag => {
   }
 
   const tagValue = cbor.tag;
-  const matchingTag = expectedTags.find((t) => t.value === tagValue);
+  const matchingTag = expectedTags.find((t) => tagValuesEqual(t.value, tagValue));
   if (matchingTag === undefined) {
     // Mirror Rust's `Error::WrongTag(expected, actual)` — produce the
     // structured WrongTag variant rather than a stringly-typed Custom

package/src/cbor.ts

@@ -12,7 +12,7 @@ import { encodeVarInt } from "./varint";
 import { concatBytes } from "./stdlib";
 import { bytesToHex, hexOpt } from "./dump";
 import { hexToBytes } from "./dump";
-import type { Tag } from "./tag";
+import { tagValuesEqual, type Tag } from "./tag";
 import type { ByteString } from "./byte-string";
 import type { CborDate } from "./date";
 import { diagnosticOpt } from "./diag";
@@ -104,6 +104,10 @@ export type CborInput =
   | CborInput[]
   | Map<unknown, unknown>
   | Set<unknown>
+  // Values that convert themselves to CBOR (e.g. untagged CborSet or a
+  // tagged-encodable type); `cbor()` dispatches to these at runtime.
+  | ToCbor
+  | TaggedCborEncodable
   | Record<string, unknown>;
 
 export const isCborNumber = (value: unknown): value is CborNumber => {
@@ -377,12 +381,19 @@ export const cbor = (value: CborInput): Cbor => {
     } else if (value == -Infinity) {
       result = { isCbor: true, type: MajorType.Simple, value: { type: "Float", value: -Infinity } };
     } else if (typeof value === "number" && !Number.isSafeInteger(value)) {
-      // Mirrors Rust `f64::exact_from_f64`: any finite, integer-valued
-      // float that exceeds the safe-integer range (so adjacent integers
-      // can't be distinguished, e.g. `1e21`) cannot be encoded as a
-      // canonical integer. Route to Float instead — Rust's `From<f64>
-      // for CBOR` does the same fallback.
-      result = { isCbor: true, type: MajorType.Simple, value: { type: "Float", value: value } };
+      // A finite, whole-valued `number` beyond the safe-integer range (NaN,
+      // ±Infinity, and fractional values are handled above). Like Rust's
+      // `From<f64> for CBOR`, reduce any whole value in `[-(2^64), 2^64)` to a
+      // CBOR integer; values outside that range (e.g. `1e21`) stay floats.
+      // Go through BigInt so we don't lose precision above 2^53.
+      const big = BigInt(value);
+      if (big >= 0n && big <= 0xffffffffffffffffn) {
+        result = { isCbor: true, type: MajorType.Unsigned, value: big };
+      } else if (big < 0n && big >= -0x10000000000000000n) {
+        result = { isCbor: true, type: MajorType.Negative, value: -big - 1n };
+      } else {
+        result = { isCbor: true, type: MajorType.Simple, value: { type: "Float", value: value } };
+      }
     } else if (
       typeof value === "bigint" &&
       (value > 0xffffffffffffffffn || value < -0x10000000000000000n)
@@ -817,7 +828,7 @@ export const attachMethods = <T extends Omit<Cbor, keyof CborMethods>>(obj: T):
         typeof expectedTag === "object" && "value" in expectedTag
           ? expectedTag
           : { value: expectedTag };
-      if (this.tag !== expected.value) {
+      if (!tagValuesEqual(this.tag, expected.value)) {
         // Mirror Rust `Error::WrongTag(expected, actual)`.
         throw new CborError({
           type: "WrongTag",
@@ -837,7 +848,7 @@ export const attachMethods = <T extends Omit<Cbor, keyof CborMethods>>(obj: T):
         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 === undefined) {
         // Mirror Rust `Error::WrongTag(expected, actual)`.
         throw new CborError({

package/src/conveniences.ts

@@ -29,6 +29,7 @@ import {
 import type { CborMap } from "./map";
 import { isFloat as isSimpleFloat } from "./simple";
 import { decodeCbor } from "./decode";
+import { ExactF64 } from "./exact";
 import { CborError } from "./error";
 
 // ============================================================================
@@ -358,12 +359,20 @@ export const asBoolean = (cbor: Cbor): boolean | undefined => {
  * @returns Float or undefined
  */
 export const asFloat = (cbor: Cbor): number | undefined => {
-  if (cbor.type !== MajorType.Simple) {
-    return undefined;
+  // Integers coerce to float too, matching Rust's `TryFrom<CBOR> for f64`.
+  // dCBOR reduces whole-valued floats to integers (42.0 encodes as 42), so a
+  // float-only accessor would wrongly reject them. Returns undefined for
+  // non-numeric types and for integers not exactly representable as f64.
+  if (cbor.type === MajorType.Unsigned) {
+    return ExactF64.exactFromU64(cbor.value);
   }
-  const simple = cbor.value;
-  if (isSimpleFloat(simple)) {
-    return simple.value;
+  if (cbor.type === MajorType.Negative) {
+    // cbor.value holds the raw magnitude n; the actual value is -1 - n.
+    const f = ExactF64.exactFromU64(cbor.value);
+    return f === undefined ? undefined : -1 - f;
+  }
+  if (cbor.type === MajorType.Simple) {
+    return isSimpleFloat(cbor.value) ? cbor.value.value : undefined;
   }
   return undefined;
 };
@@ -527,11 +536,20 @@ export const expectBoolean = (cbor: Cbor): boolean => {
  * @throws {CborError} With type 'WrongType' if cbor is not a float
  */
 export const expectFloat = (cbor: Cbor): number => {
-  const value = asFloat(cbor);
-  if (value === undefined) {
-    throw new CborError({ type: "WrongType" });
+  // Numeric types coerce to float (OutOfRange if an integer isn't exactly
+  // representable as f64); anything else is WrongType. Matches Rust's
+  // `TryFrom<CBOR> for f64`.
+  if (cbor.type === MajorType.Unsigned || cbor.type === MajorType.Negative) {
+    const value = asFloat(cbor);
+    if (value === undefined) {
+      throw new CborError({ type: "OutOfRange" });
+    }
+    return value;
   }
-  return value;
+  if (cbor.type === MajorType.Simple && isSimpleFloat(cbor.value)) {
+    return cbor.value.value;
+  }
+  throw new CborError({ type: "WrongType" });
 };
 
 /**
@@ -722,7 +740,7 @@ export const hasTag = (cbor: Cbor, tag: number | bigint): boolean => {
   if (cbor.type !== MajorType.Tagged) {
     return false;
   }
-  return cbor.tag === tag;
+  return tagValuesEqual(cbor.tag, tag);
 };
 
 /**
@@ -733,7 +751,7 @@ export const hasTag = (cbor: Cbor, tag: number | bigint): boolean => {
  * @returns Tagged content or undefined
  */
 export const getTaggedContent = (cbor: Cbor, tag: number | bigint): Cbor | undefined => {
-  if (cbor.type === MajorType.Tagged && cbor.tag === tag) {
+  if (cbor.type === MajorType.Tagged && tagValuesEqual(cbor.tag, tag)) {
     return cbor.value;
   }
   return undefined;
@@ -754,7 +772,7 @@ export const expectTaggedContent = (cbor: Cbor, tag: number | bigint): Cbor => {
   if (cbor.type !== MajorType.Tagged) {
     throw new CborError({ type: "WrongType" });
   }
-  if (cbor.tag !== tag) {
+  if (!tagValuesEqual(cbor.tag, tag)) {
     throw new CborError({
       type: "WrongTag",
       expected: { value: tag },
@@ -769,7 +787,7 @@ export const expectTaggedContent = (cbor: Cbor, tag: number | bigint): Cbor => {
 // These functions provide the API expected by the envelope package
 // ============================================================================
 
-import type { Tag } from "./tag";
+import { tagValuesEqual, type Tag } from "./tag";
 import { getGlobalTagsStore } from "./tags-store";
 
 /**

package/src/date.ts

@@ -33,6 +33,34 @@ import {
 } from "./cbor-tagged";
 import { CborError } from "./error";
 
+/**
+ * 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.
+ *
+ * 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`).
+ *
+ * @internal
+ */
+function normalizeTimestampSeconds(seconds: number): number {
+  if (!Number.isFinite(seconds)) {
+    // chrono has no representation for a non-finite instant; reject with a
+    // typed error.
+    throw new CborError({ type: "InvalidDate", message: "non-finite timestamp" });
+  }
+  const whole = Math.trunc(seconds);
+  let nsecs = Math.trunc((seconds - whole) * 1_000_000_000);
+  if (nsecs < 0) {
+    nsecs = 0;
+  } else if (nsecs > 0xffffffff) {
+    nsecs = 0xffffffff;
+  }
+  return whole + nsecs / 1_000_000_000;
+}
+
 /**
  * A CBOR-friendly representation of a date and time.
  *
@@ -192,7 +220,9 @@ export class CborDate implements CborTagged, CborTaggedEncodable, CborTaggedDeco
    */
   static fromTimestamp(secondsSinceUnixEpoch: number): CborDate {
     const instance = new CborDate();
-    instance._seconds = secondsSinceUnixEpoch;
+    // Normalize on construction so the stored value (and thus its encoding,
+    // equality, and ordering) matches the reference.
+    instance._seconds = normalizeTimestampSeconds(secondsSinceUnixEpoch);
     return instance;
   }
 
@@ -222,12 +252,40 @@ export class CborDate implements CborTagged, CborTaggedEncodable, CborTaggedDeco
    * ```
    */
   static fromString(value: string): CborDate {
-    // Try parsing as ISO 8601 date string
-    const dt = new Date(value);
-    if (isNaN(dt.getTime())) {
-      throw new CborError({ type: "InvalidDate", message: "Invalid date string" });
+    // Accept only strict RFC-3339 date-times (with seconds and an explicit
+    // `Z`/±HH:MM offset) or bare `YYYY-MM-DD` dates (read as UTC midnight),
+    // matching Rust's `Date::from_string`. The plain `new Date()` parser is far
+    // more lenient (and engine-dependent), so we gate it behind explicit regexes.
+    const invalidDate = new CborError({ type: "InvalidDate", message: "Invalid date string" });
+
+    // RFC-3339 date-time: `YYYY-MM-DDThh:mm:ss[.frac](Z|±hh:mm)`.
+    const rfc3339 = /^\d{4}-\d{2}-\d{2}[Tt]\d{2}:\d{2}:\d{2}(\.\d+)?([Zz]|[+-]\d{2}:\d{2})$/;
+    // Date-only: `YYYY-MM-DD`.
+    const dateOnly = /^\d{4}-\d{2}-\d{2}$/;
+
+    let parsed: Date;
+    if (rfc3339.test(value)) {
+      parsed = new Date(value);
+    } else if (dateOnly.test(value)) {
+      // Treat a bare date as UTC midnight (chrono uses 00:00:00 UTC).
+      parsed = new Date(`${value}T00:00:00Z`);
+    } else {
+      throw invalidDate;
     }
-    return CborDate.fromDatetime(dt);
+
+    // `new Date` rolls impossible dates over (`2023-02-30` becomes Mar 2)
+    // rather than failing, so check the `YYYY-MM-DD` portion is a real calendar
+    // date. The first 10 chars are always `YYYY-MM-DD` given the regexes above.
+    const [y, m, d] = value.slice(0, 10).split("-").map(Number);
+    const probe = new Date(Date.UTC(y, m - 1, d));
+    const calendarValid =
+      probe.getUTCFullYear() === y && probe.getUTCMonth() === m - 1 && probe.getUTCDate() === d;
+
+    // ...and reject any residual unparseable input (e.g. an out-of-range time).
+    if (!calendarValid || isNaN(parsed.getTime())) {
+      throw invalidDate;
+    }
+    return CborDate.fromDatetime(parsed);
   }
 
   /**
@@ -439,7 +497,9 @@ export class CborDate implements CborTagged, CborTaggedEncodable, CborTaggedDeco
         throw new CborError({ type: "WrongType" });
     }
 
-    this._seconds = timestamp;
+    // Normalize the decoded value so it re-encodes to the same bytes as the
+    // reference (e.g. a tag-1 float of -1.5 decodes and re-encodes as integer -1).
+    this._seconds = normalizeTimestampSeconds(timestamp);
     return this;
   }
 

package/src/decode.ts

@@ -40,7 +40,12 @@ function at(data: DataView, index: number): number {
 }
 
 function from(data: DataView, index: number): DataView {
-  return new DataView(data.buffer, data.byteOffset + index);
+  // Bound the sub-view to the remaining logical bytes; without a length it
+  // would span the whole backing ArrayBuffer, letting a nested decode read
+  // past the input's end when the input is itself a slice of a larger buffer.
+  // This matches Rust's `&data[index..]`, so an over-long inner item fails as
+  // an Underrun at its source instead of only at the top-level length check.
+  return new DataView(data.buffer, data.byteOffset + index, data.byteLength - index);
 }
 
 function range(data: DataView, start: number, end: number): DataView {
@@ -165,7 +170,18 @@ function decodeCborInternal(data: DataView): { cbor: Cbor; len: number } {
         throw new CborError({ type: "OutOfRange" });
       }
       const textBuf = parseBytes(from(data, varIntLen), textLen);
-      const text = new TextDecoder().decode(textBuf);
+      // dCBOR text strings must be valid UTF-8 (RFC 8949). Use a fatal decoder
+      // so invalid bytes throw rather than getting replaced with U+FFFD and
+      // silently accepted, matching the Rust reference's InvalidUtf8 rejection.
+      let text: string;
+      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),
+        });
+      }
       // dCBOR requires all text strings to be in Unicode Normalization Form C (NFC)
       // Reject any strings that are not already in NFC form
       if (text.normalize("NFC") !== text) {

package/src/diag.ts

@@ -16,8 +16,10 @@
 
 import { type Cbor, MajorType, type Simple } from "./cbor";
 import { bytesToHex } from "./dump";
+import { errorToString } from "./error";
+import { floatDisplayString } from "./float";
 import type { CborMap } from "./map";
-import { getGlobalTagsStore, type TagsStore } from "./tags-store";
+import { getGlobalTagsStore, type TagsStore, type TagsStoreOpt } from "./tags-store";
 import type { Tag } from "./tag";
 import type { WalkElement } from "./walk";
 import { flanked } from "./string-util";
@@ -63,7 +65,7 @@ export interface DiagFormatOpts {
    *
    * @default 'global'
    */
-  tags?: TagsStore | "global" | "none";
+  tags?: TagsStoreOpt;
 
   /**
    * Current indentation level (internal use for recursion).
@@ -412,13 +414,9 @@ function item_tagged(tag: number | bigint, content: Cbor, opts: DiagFormatOpts):
       if (result.ok) {
         return item(result.value);
       }
-      const errorMsg =
-        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: ${errorMsg}>`);
+      // Use the shared error formatter so every variant gets its full message,
+      // including name-aware tag rendering for WrongTag (matches Rust).
+      return item(`<error: ${errorToString(result.error)}>`);
     }
   }
 
@@ -450,12 +448,9 @@ function formatBytes(value: Uint8Array): string {
 }
 
 function formatText(value: string): string {
-  const escaped = value
-    .replace(/\\/g, "\\\\")
-    .replace(/"/g, '\\"')
-    .replace(/\n/g, "\\n")
-    .replace(/\r/g, "\\r")
-    .replace(/\t/g, "\\t");
+  // Match Rust `format_string` (cbor.rs): only the double-quote is escaped;
+  // backslash, tab, newline, and carriage return are emitted verbatim.
+  const escaped = value.replace(/"/g, '\\"');
   return `"${escaped}"`;
 }
 
@@ -473,26 +468,14 @@ function formatSimple(value: Simple): string {
 }
 
 /**
- * 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: number): string {
-  if (Number.isNaN(value)) return "NaN";
-  if (!Number.isFinite(value)) return value > 0 ? "Infinity" : "-Infinity";
-  let str = String(value);
-  // Strip the JS-only `+` in scientific exponents to match Rust Debug format.
-  str = str.replace(/e\+/, "e");
-  if (!str.includes(".") && !str.includes("e")) {
-    str = `${str}.0`;
-  }
-  return str;
+  return floatDisplayString(value);
 }
 
-function resolveTagsStore(tags?: TagsStore | "global" | "none"): TagsStore | undefined {
+function resolveTagsStore(tags?: TagsStoreOpt): TagsStore | undefined {
   if (tags === "none") return undefined;
   if (tags === "global" || tags === undefined) return getGlobalTagsStore();
   return tags;

package/src/dump.ts

@@ -14,6 +14,7 @@
 
 import { type Cbor, MajorType, cborData } from "./cbor";
 import { encodeVarInt } from "./varint";
+import { floatDisplayString } from "./float";
 import { flanked, sanitized } from "./string-util";
 import type { TagsStore } from "./tags-store";
 import { getGlobalTagsStore } from "./tags-store";
@@ -274,7 +275,8 @@ function dumpItems(cbor: Cbor, level: number, opts: HexFormatOpts): DumpItem[] {
       } else if (simple.type === "Null") {
         note = "null";
       } else if (simple.type === "Float") {
-        note = `${simple.value}`;
+        // Use the same float formatting as diagnostic output, not raw JS coercion.
+        note = floatDisplayString(simple.value);
       } else {
         note = "simple";
       }

package/src/exact.ts

@@ -25,6 +25,37 @@ const hasFract = (n: number): boolean => {
   return n % 1 !== 0;
 };
 
+const U64_MAX_BIG = 0xffffffffffffffffn;
+const I64_MAX_BIG = 0x7fffffffffffffffn;
+const I64_MIN_BIG = -0x8000000000000000n;
+
+/**
+ * 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: number): bigint => {
+  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: number): bigint => {
+  if (Number.isNaN(f)) return 0n;
+  const t = Math.trunc(f);
+  const big = BigInt(t);
+  if (big > I64_MAX_BIG) return I64_MAX_BIG;
+  if (big < I64_MIN_BIG) return I64_MIN_BIG;
+  return big;
+};
+
 /**
  * Exact conversions for i16 (-32768 to 32767).
  */
@@ -529,19 +560,18 @@ export class ExactF32 {
   }
 
   static exactFromU64(source: number | bigint): number | undefined {
-    const n = typeof source === "bigint" ? Number(source) : source;
-    const f32Bytes = numberToBinary32(n);
-    const f = binary32ToNumber(f32Bytes);
-    const roundTrip = typeof source === "bigint" ? BigInt(Math.trunc(f)) : Math.trunc(f);
-    return roundTrip === source ? f : undefined;
+    const srcBig = typeof source === "bigint" ? source : BigInt(source);
+    const f = binary32ToNumber(numberToBinary32(Number(srcBig)));
+    if (!Number.isFinite(f)) return undefined;
+    // Saturating round-trip so u64::MAX (which rounds up to 2^64 here) still matches.
+    return saturateFloatToU64(f) === srcBig ? f : undefined;
   }
 
   static exactFromI64(source: number | bigint): number | undefined {
-    const n = typeof source === "bigint" ? Number(source) : source;
-    const f32Bytes = numberToBinary32(n);
-    const f = binary32ToNumber(f32Bytes);
-    const roundTrip = typeof source === "bigint" ? BigInt(Math.trunc(f)) : Math.trunc(f);
-    return roundTrip === source ? f : undefined;
+    const srcBig = typeof source === "bigint" ? source : BigInt(source);
+    const f = binary32ToNumber(numberToBinary32(Number(srcBig)));
+    if (!Number.isFinite(f)) return undefined;
+    return saturateFloatToI64(f) === srcBig ? f : undefined;
   }
 
   static exactFromU128(source: bigint): number | undefined {
@@ -594,15 +624,18 @@ export class ExactF64 {
   }
 
   static exactFromU64(source: number | bigint): number | undefined {
-    const n = typeof source === "bigint" ? Number(source) : source;
-    const roundTrip = typeof source === "bigint" ? BigInt(Math.trunc(n)) : Math.trunc(n);
-    return roundTrip === source ? n : undefined;
+    const srcBig = typeof source === "bigint" ? source : BigInt(source);
+    const n = Number(srcBig);
+    if (!Number.isFinite(n)) return undefined;
+    // Saturating round-trip so u64::MAX (which rounds up to 2^64 here) still matches.
+    return saturateFloatToU64(n) === srcBig ? n : undefined;
   }
 
   static exactFromI64(source: number | bigint): number | undefined {
-    const n = typeof source === "bigint" ? Number(source) : source;
-    const roundTrip = typeof source === "bigint" ? BigInt(Math.trunc(n)) : Math.trunc(n);
-    return roundTrip === source ? n : undefined;
+    const srcBig = typeof source === "bigint" ? source : BigInt(source);
+    const n = Number(srcBig);
+    if (!Number.isFinite(n)) return undefined;
+    return saturateFloatToI64(n) === srcBig ? n : undefined;
   }
 
   static exactFromU128(source: bigint): number | undefined {