@marcuspuchalla/nachos 0.1.3 → 0.2.0

package/src/encoder/__tests__/cbor-collection-encoder.test.ts

@@ -285,6 +285,100 @@ describe('CBOR Collection Encoder', () => {
           .toThrow('Duplicate map key detected')
       })
     })
+
+    describe('Canonical sort pre-encoding optimization', () => {
+      it('should produce identical output for canonical sort with many keys', () => {
+        const { encodeMap } = useCborCollectionEncoder({ canonical: true })
+
+        // Use many keys to exercise sorting — result must be deterministic
+        const map = new Map<EncodableValue, EncodableValue>([
+          ['zebra', 1],
+          ['apple', 2],
+          ['mango', 3],
+          ['banana', 4],
+          ['kiwi', 5],
+          ['cherry', 6],
+          ['date', 7],
+          ['fig', 8],
+          ['grape', 9],
+          ['lemon', 10],
+        ])
+        const result1 = encodeMap(map)
+        const result2 = encodeMap(map)
+
+        // Must be deterministic
+        expect(result1.hex).toBe(result2.hex)
+
+        // Verify canonical order: sorted by encoded key length first, then bytewise
+        // 3-char keys: fig, 4-char keys: date, kiwi, 5-char keys: apple, grape, lemon, mango
+        // 6-char keys: banana, cherry, zebra
+        const hex = result1.hex
+        const figPos = hex.indexOf('6366696703')   // "fig" + integer 8 (but let's just check key order)
+        const datePos = hex.indexOf('6464617465')   // "date"
+        const bananaPos = hex.indexOf('6662616e616e61') // "banana"
+
+        // fig (3 chars) should come before date (4 chars) should come before banana (6 chars)
+        expect(figPos).toBeLessThan(datePos)
+        expect(datePos).toBeLessThan(bananaPos)
+      })
+
+      it('should produce correct canonical order with mixed-type Map keys', () => {
+        const { encodeMap } = useCborCollectionEncoder({ canonical: true })
+
+        // Integer keys encode shorter than string keys
+        const map = new Map<EncodableValue, EncodableValue>([
+          ['z', 3],
+          [1, 1],
+          ['a', 2],
+        ])
+        const result = encodeMap(map)
+
+        // Integer 1 encodes as 0x01 (1 byte), "a" as 0x6161 (2 bytes), "z" as 0x617a (2 bytes)
+        // Canonical order: 1 (shortest), then "a" < "z" (same length, bytewise)
+        const hex = result.hex
+        // After map header (0xa3), first key should be integer 1 (0x01)
+        expect(hex.startsWith('a3')).toBe(true)
+        expect(hex.substring(2, 4)).toBe('01')  // integer key 1
+      })
+
+      it('should reject duplicates when both canonical and rejectDuplicateKeys are on', () => {
+        const { encodeMap } = useCborCollectionEncoder({
+          canonical: true,
+          rejectDuplicateKeys: true
+        })
+
+        const map = new Map<EncodableValue, EncodableValue>([['x', 1]])
+        ;(map as any)[ALL_ENTRIES_SYMBOL] = [['x', 1], ['x', 2]]
+
+        expect(() => encodeMap(map))
+          .toThrow('Duplicate map key detected')
+      })
+
+      it('should not reject unique keys when both canonical and rejectDuplicateKeys are on', () => {
+        const { encodeMap } = useCborCollectionEncoder({
+          canonical: true,
+          rejectDuplicateKeys: true
+        })
+
+        const map = new Map<EncodableValue, EncodableValue>([
+          ['b', 2],
+          ['a', 1],
+          ['c', 3],
+        ])
+        const result = encodeMap(map)
+
+        // Should succeed and produce canonical order
+        expect(result.bytes[0]).toBe(0xa3)  // 3 entries
+
+        // Keys in canonical order: a, b, c
+        const hex = result.hex
+        const aPos = hex.indexOf('6161')  // "a"
+        const bPos = hex.indexOf('6162')  // "b"
+        const cPos = hex.indexOf('6163')  // "c"
+        expect(aPos).toBeLessThan(bPos)
+        expect(bPos).toBeLessThan(cPos)
+      })
+    })
   })
 
   describe('Depth limits', () => {
@@ -320,18 +414,22 @@ describe('CBOR Collection Encoder', () => {
   })
 
   describe('Output size limits', () => {
-    it('should respect maxOutputSize option', () => {
+    it('should not enforce maxOutputSize at the collection level (enforced at root encoder)', () => {
+      // maxOutputSize is now checked at the root level in useCborEncoder,
+      // not inside the collection encoder. The collection encoder should
+      // encode without throwing, and the root encoder applies the check.
       const { encodeArray } = useCborCollectionEncoder({ maxOutputSize: 10 })
-      const largeArray = Array(100).fill(1)
+      const smallArray = Array(20).fill(1)
 
-      expect(() => encodeArray(largeArray))
-        .toThrow('Encoded output exceeds maximum size')
+      // Collection encoder no longer throws on size - it just encodes
+      const result = encodeArray(smallArray)
+      expect(result.bytes.length).toBeGreaterThan(10)
     })
   })
 
   describe('Real-world Cardano examples', () => {
     it('should encode Cardano transaction structure', () => {
-      const { encodeMap, encodeArray } = useCborCollectionEncoder()
+      const { encodeMap } = useCborCollectionEncoder()
 
       // Simplified Cardano transaction
       const tx = {

package/src/encoder/__tests__/cbor-encoder-errors.test.ts

@@ -185,7 +185,7 @@ describe('CBOR Encoder Error Handling', () => {
 
       const largeArray = Array(100).fill(1)
 
-      expect(() => encode(largeArray)).toThrow('Encoded output exceeds maximum size')
+      expect(() => encode(largeArray)).toThrow(/[Ee]ncoded output.*exceeds/)
     })
 
     it('should succeed when output is within maxOutputSize', () => {
@@ -205,6 +205,40 @@ describe('CBOR Encoder Error Handling', () => {
 
       expect(() => encode(largeMap)).toThrow('Encoded output exceeds maximum size')
     })
+
+    it('should enforce maxOutputSize on deeply nested structures whose total exceeds limit', () => {
+      // Total encoded size is 25 bytes, limit is 20.
+      const { encode } = useCborEncoder({ maxOutputSize: 20 })
+
+      const nested = [
+        [1, 2, 3, 4, 5],
+        [6, 7, 8, 9, 10],
+        [11, 12, 13, 14, 15],
+        [16, 17, 18, 19, 20],
+      ]
+
+      expect(() => encode(nested)).toThrow(/[Ee]ncoded output.*exceeds/)
+    })
+
+    it('should enforce maxOutputSize on nested maps whose total exceeds limit', () => {
+      // Total encoded size is 19 bytes, limit is 15.
+      const { encode } = useCborEncoder({ maxOutputSize: 15 })
+
+      const bigger = {
+        a: { x: 1, y: 2 },
+        b: { x: 3, y: 4 },
+      }
+
+      expect(() => encode(bigger)).toThrow(/[Ee]ncoded output.*exceeds/)
+    })
+
+    it('should include byte counts in the maxOutputSize error message', () => {
+      // After the fix, the root-level check should report actual size and limit.
+      // [1,2,3,4,5] encodes to 6 bytes; limit is 5.
+      const { encode } = useCborEncoder({ maxOutputSize: 5 })
+
+      expect(() => encode([1, 2, 3, 4, 5])).toThrow(/6 bytes exceeds limit of 5 bytes/)
+    })
   })
 
   describe('maxDepth as circular reference protection', () => {
@@ -540,13 +574,14 @@ describe('CBOR Canonical Encoding Validation', () => {
       expect(result.bytes.length).toBe(3)
     })
 
-    it('should encode 1.5 as float32 (not float16)', () => {
+    it('should encode 1.5 as float16 (exact float16 representation)', () => {
       const { encode } = useCborEncoder()
       const result = encode(1.5)
 
-      // 1.5 encodes as float32 due to float16 round-trip precision: 0xfa + 4 bytes
-      expect(result.bytes[0]).toBe(0xfa)
-      expect(result.bytes.length).toBe(5)
+      // 1.5 is exactly representable in float16: 0xf9 + 2 bytes
+      // float16 = 0 01111 1000000000 = 0x3e00
+      expect(result.bytes[0]).toBe(0xf9)
+      expect(result.bytes.length).toBe(3)
     })
 
     it('should encode 1.1 as float64 (no exact float16/32 representation)', () => {

package/src/encoder/__tests__/cbor-simple-encoder.test.ts

@@ -96,6 +96,132 @@ describe('CBOR Simple Values and Floats Encoder', () => {
         expect(result.bytes).toEqual(new Uint8Array([0xf9, 0x7e, 0x00]))
         expect(result.hex).toBe('f97e00')
       })
+
+      it('should encode 1.5 as float16', () => {
+        const { encodeFloat } = useCborSimpleEncoder()
+        const result = encodeFloat(1.5, 16)
+
+        // 1.5 = 0 01111 1000000000 = 0x3e00
+        expect(result.bytes).toEqual(new Uint8Array([0xf9, 0x3e, 0x00]))
+        expect(result.hex).toBe('f93e00')
+      })
+
+      it('should encode -2.0 as float16', () => {
+        const { encodeFloat } = useCborSimpleEncoder()
+        const result = encodeFloat(-2.0, 16)
+
+        // -2.0 = 1 10000 0000000000 = 0xc000
+        expect(result.bytes).toEqual(new Uint8Array([0xf9, 0xc0, 0x00]))
+        expect(result.hex).toBe('f9c000')
+      })
+
+      it('should encode 0.5 as float16', () => {
+        const { encodeFloat } = useCborSimpleEncoder()
+        const result = encodeFloat(0.5, 16)
+
+        // 0.5 = 0 01110 0000000000 = 0x3800
+        expect(result.bytes).toEqual(new Uint8Array([0xf9, 0x38, 0x00]))
+        expect(result.hex).toBe('f93800')
+      })
+
+      it('should encode 65504 (max finite float16) as float16', () => {
+        const { encodeFloat } = useCborSimpleEncoder()
+        const result = encodeFloat(65504, 16)
+
+        // 65504 = 0 11110 1111111111 = 0x7bff
+        expect(result.bytes).toEqual(new Uint8Array([0xf9, 0x7b, 0xff]))
+        expect(result.hex).toBe('f97bff')
+      })
+    })
+
+    describe('Float16 IEEE 754 round-half-to-even', () => {
+      // Helper to construct a float64 value from raw mantissa bits
+      // exp64=0 means biased exponent=1023, so the value is 1.mantissa
+      function makeFloat64(exp64: number, mant64: number, sign = 0): number {
+        const biasedExp = BigInt(exp64 + 1023)
+        const bits = (BigInt(sign) << 63n) | (biasedExp << 52n) | BigInt(mant64)
+        const buf = new ArrayBuffer(8)
+        const view = new DataView(buf)
+        view.setBigUint64(0, bits, false)
+        return view.getFloat64(0, false)
+      }
+
+      it('should round down at midpoint when truncated mantissa is even (round-half-to-even)', () => {
+        const { encodeFloat } = useCborSimpleEncoder()
+        // Construct: mant16_truncated=256 (even), guard=1, round=0, sticky=0
+        // mant64 = (256 << 42) | (1 << 41)
+        const mant64 = 256 * Math.pow(2, 42) + Math.pow(2, 41)
+        const value = makeFloat64(0, mant64)
+        const result = encodeFloat(value, 16)
+
+        // Should round DOWN to mant16=256 (even), exp16=15
+        // float16 = 0 01111 0100000000 = 0x3d00
+        expect(result.bytes).toEqual(new Uint8Array([0xf9, 0x3d, 0x00]))
+      })
+
+      it('should round up at midpoint when truncated mantissa is odd (round-half-to-even)', () => {
+        const { encodeFloat } = useCborSimpleEncoder()
+        // Construct: mant16_truncated=257 (odd), guard=1, round=0, sticky=0
+        const mant64 = 257 * Math.pow(2, 42) + Math.pow(2, 41)
+        const value = makeFloat64(0, mant64)
+        const result = encodeFloat(value, 16)
+
+        // Should round UP to mant16=258 (even), exp16=15
+        // float16 = 0 01111 0100000010 = 0x3d02
+        expect(result.bytes).toEqual(new Uint8Array([0xf9, 0x3d, 0x02]))
+      })
+
+      it('should round up when above midpoint (guard=1, sticky bits set)', () => {
+        const { encodeFloat } = useCborSimpleEncoder()
+        // Construct: mant16_truncated=256 (even), guard=1, sticky=1 -> above midpoint
+        const mant64 = 256 * Math.pow(2, 42) + Math.pow(2, 41) + 1
+        const value = makeFloat64(0, mant64)
+        const result = encodeFloat(value, 16)
+
+        // Should round UP to mant16=257, exp16=15
+        // float16 = 0 01111 0100000001 = 0x3d01
+        expect(result.bytes).toEqual(new Uint8Array([0xf9, 0x3d, 0x01]))
+      })
+
+      it('should truncate when below midpoint (guard=0)', () => {
+        const { encodeFloat } = useCborSimpleEncoder()
+        // Construct: mant16_truncated=256, guard=0, some lower bits set
+        // mant64 = (256 << 42) | (1 << 40) -- only round bit, no guard
+        const mant64 = 256 * Math.pow(2, 42) + Math.pow(2, 40)
+        const value = makeFloat64(0, mant64)
+        const result = encodeFloat(value, 16)
+
+        // Should truncate to mant16=256, exp16=15
+        // float16 = 0 01111 0100000000 = 0x3d00
+        expect(result.bytes).toEqual(new Uint8Array([0xf9, 0x3d, 0x00]))
+      })
+
+      it('should handle mantissa overflow from rounding (bump exponent)', () => {
+        const { encodeFloat } = useCborSimpleEncoder()
+        // Construct: mant16_truncated=0x3FF (1023, odd), guard=1, sticky=1
+        // Rounding up gives 0x400, which overflows 10-bit mantissa
+        // Should become mant16=0, exp16+1
+        const mant64 = 0x3FF * Math.pow(2, 42) + Math.pow(2, 41) + 1
+        const value = makeFloat64(0, mant64)
+        const result = encodeFloat(value, 16)
+
+        // Mantissa overflows: exp16 bumps from 15 to 16, mant16=0
+        // float16 = 0 10000 0000000000 = 0x4000 = 2.0
+        expect(result.bytes).toEqual(new Uint8Array([0xf9, 0x40, 0x00]))
+      })
+
+      it('should handle mantissa overflow to infinity at max exponent', () => {
+        const { encodeFloat } = useCborSimpleEncoder()
+        // Construct: exp64=15 (exp16=30, max normal), mant16_truncated=0x3FF, guard=1, sticky=1
+        // Rounding overflows mantissa, bumps exp16 to 31 = infinity
+        const mant64 = 0x3FF * Math.pow(2, 42) + Math.pow(2, 41) + 1
+        const value = makeFloat64(15, mant64)
+        const result = encodeFloat(value, 16)
+
+        // exp16=30 + overflow = 31 (infinity), mant16=0
+        // float16 = 0 11111 0000000000 = 0x7c00 = +Infinity
+        expect(result.bytes).toEqual(new Uint8Array([0xf9, 0x7c, 0x00]))
+      })
     })
 
     describe('Float32 (single precision)', () => {

package/src/encoder/composables/useCborCollectionEncoder.ts

@@ -6,9 +6,10 @@
 
 import type { EncodeResult, EncodeOptions, EncodeContext, EncodableValue } from '../types'
 import { DEFAULT_ENCODE_OPTIONS, INDEFINITE_SYMBOL, ALL_ENTRIES_SYMBOL } from '../types'
-import { bytesToHex, concatenateUint8Arrays, compareBytes } from '../utils'
+import { bytesToHex, concatenateUint8Arrays, compareMapKeys } from '../utils'
 import { useCborIntegerEncoder } from './useCborIntegerEncoder'
 import { useCborStringEncoder } from './useCborStringEncoder'
+import { useCborSimpleEncoder } from './useCborSimpleEncoder'
 import { useCborByteString, useCborTextString } from '../../parser/composables/useCborStringTypes'
 
 interface CollectionEncodeOptions {
@@ -49,6 +50,7 @@ export function useCborCollectionEncoder(globalOptions?: Partial<EncodeOptions>)
   // Get other encoders
   const { encodeInteger } = useCborIntegerEncoder()
   const { encodeTextString, encodeByteString } = useCborStringEncoder(globalOptions)
+  const { encodeFloat } = useCborSimpleEncoder(options)
   const { isCborByteString } = useCborByteString()
   const { isCborTextString } = useCborTextString()
 
@@ -90,7 +92,16 @@ export function useCborCollectionEncoder(globalOptions?: Partial<EncodeOptions>)
       // true: 0xf5, false: 0xf4
       return new Uint8Array([value ? 0xf5 : 0xf4])
     }
-    else if (typeof value === 'number' || typeof value === 'bigint') {
+    else if (typeof value === 'number') {
+      if (Object.is(value, -0)) {
+        return encodeFloat(value, 16).bytes
+      }
+      if (Number.isInteger(value) && Number.isSafeInteger(value)) {
+        return encodeInteger(value).bytes
+      }
+      return encodeFloat(value).bytes
+    }
+    else if (typeof value === 'bigint') {
       return encodeInteger(value).bytes
     }
     else if (typeof value === 'string' || isCborTextString(value)) {
@@ -211,12 +222,6 @@ export function useCborCollectionEncoder(globalOptions?: Partial<EncodeOptions>)
 
     const result = concatenateUint8Arrays(parts)
 
-    // Check output size
-    ctx.bytesWritten += result.length
-    if (ctx.bytesWritten > ctx.options.maxOutputSize) {
-      throw new Error('Encoded output exceeds maximum size')
-    }
-
     return {
       bytes: result,
       hex: bytesToHex(result)
@@ -251,7 +256,6 @@ export function useCborCollectionEncoder(globalOptions?: Partial<EncodeOptions>)
     // Definite-length encoding
     const ctx: EncodeContext = {
       depth: 0,
-      bytesWritten: 0,
       options
     }
 
@@ -276,7 +280,6 @@ export function useCborCollectionEncoder(globalOptions?: Partial<EncodeOptions>)
 
     const ctx: EncodeContext = {
       depth: 0,
-      bytesWritten: 0,
       options
     }
 
@@ -316,19 +319,28 @@ export function useCborCollectionEncoder(globalOptions?: Partial<EncodeOptions>)
         : Object.entries(map)
     }
 
-    // In canonical mode, sort entries by encoded key (unless using allEntries for byte-perfect)
+    // Pre-encode keys once for canonical sorting and/or duplicate detection
+    // This avoids re-encoding keys O(N log N) times inside the sort comparator
+    let preEncodedKeys: Uint8Array[] | null = null
+
     if (ctx.options.canonical && !(map as any)[ALL_ENTRIES_SYMBOL]) {
-      entries.sort((a, b) => {
-        const keyA = encodeValue(a[0], { ...ctx, depth: ctx.depth + 1 })
-        const keyB = encodeValue(b[0], { ...ctx, depth: ctx.depth + 1 })
-        return compareBytes(keyA, keyB)
-      })
+      const childCtx = { ...ctx, depth: ctx.depth + 1 }
+      const withEncodedKeys = entries.map(entry => ({
+        encodedKey: encodeValue(entry[0], childCtx),
+        entry
+      }))
+      const keyOrder = ctx.options.mapKeyOrder ?? 'length-first'
+      withEncodedKeys.sort((a, b) => compareMapKeys(a.encodedKey, b.encodedKey, keyOrder))
+      entries = withEncodedKeys.map(t => t.entry)
+      preEncodedKeys = withEncodedKeys.map(t => t.encodedKey)
     }
 
     if (ctx.options.rejectDuplicateKeys) {
       const seen = new Set<string>()
-      for (const [key] of entries) {
-        const keyBytes = encodeValue(key, { ...ctx, depth: ctx.depth + 1, bytesWritten: 0 })
+      // Reuse pre-encoded keys if available (from canonical sort above)
+      const keysForDupCheck = preEncodedKeys
+        ?? entries.map(e => encodeValue(e[0], { ...ctx, depth: ctx.depth + 1 }))
+      for (const keyBytes of keysForDupCheck) {
         const keyHex = bytesToHex(keyBytes)
         if (seen.has(keyHex)) {
           throw new Error('Duplicate map key detected')
@@ -350,12 +362,6 @@ export function useCborCollectionEncoder(globalOptions?: Partial<EncodeOptions>)
 
     const result = concatenateUint8Arrays(parts)
 
-    // Check output size
-    ctx.bytesWritten += result.length
-    if (ctx.bytesWritten > ctx.options.maxOutputSize) {
-      throw new Error('Encoded output exceeds maximum size')
-    }
-
     return {
       bytes: result,
       hex: bytesToHex(result)
@@ -390,7 +396,6 @@ export function useCborCollectionEncoder(globalOptions?: Partial<EncodeOptions>)
     // Definite-length encoding
     const ctx: EncodeContext = {
       depth: 0,
-      bytesWritten: 0,
       options
     }
 
@@ -422,7 +427,6 @@ export function useCborCollectionEncoder(globalOptions?: Partial<EncodeOptions>)
 
     const ctx: EncodeContext = {
       depth: 0,
-      bytesWritten: 0,
       options
     }
 

package/src/encoder/composables/useCborEncoder.ts

@@ -75,6 +75,43 @@ export function useCborEncoder(globalOptions?: Partial<EncodeOptions>) {
    * @throws Error if value type is unsupported
    */
   const encode = (value: EncodableValue): EncodeResult => {
+    const result = encodeValue(value)
+
+    // Enforce maxOutputSize at the root level.
+    // This is the single authoritative check — collection/string encoders no longer
+    // track bytesWritten individually, which was broken for nested structures.
+    if (options.maxOutputSize && result.bytes.length > options.maxOutputSize) {
+      throw new Error(
+        `Encoded output size ${result.bytes.length} bytes exceeds limit of ${options.maxOutputSize} bytes`
+      )
+    }
+
+    return result
+  }
+
+  // Recursion depth tracked across ALL value types — including the tag boundary.
+  // Tagged values re-enter through this same encode()/encodeValue() pair, so
+  // counting here (rather than only inside the collection encoder) prevents a
+  // deeply nested {tag,value} chain from silently bypassing maxDepth and
+  // overflowing the call stack.
+  let currentDepth = 0
+
+  /**
+   * Encode any JavaScript value to CBOR (internal, no size check)
+   */
+  const encodeValue = (value: EncodableValue): EncodeResult => {
+    if (currentDepth > options.maxDepth) {
+      throw new Error(`Maximum nesting depth ${options.maxDepth} exceeded`)
+    }
+    currentDepth++
+    try {
+      return encodeValueInner(value)
+    } finally {
+      currentDepth--
+    }
+  }
+
+  const encodeValueInner = (value: EncodableValue): EncodeResult => {
     // Handle null/undefined/boolean
     if (value === null || value === undefined || typeof value === 'boolean') {
       return encodeSimple(value)
@@ -82,6 +119,9 @@ export function useCborEncoder(globalOptions?: Partial<EncodeOptions>) {
 
     // Handle numbers
     if (typeof value === 'number') {
+      if (Object.is(value, -0)) {
+        return encodeFloat(value, 16)
+      }
       // Check if it's an integer
       if (Number.isSafeInteger(value)) {
         return encodeInteger(value)

package/src/encoder/composables/useCborSimpleEncoder.ts

@@ -68,8 +68,8 @@ export function useCborSimpleEncoder(_globalOptions?: Partial<EncodeOptions>) {
    */
   const encodeFloat16Bytes = (value: number): Uint8Array => {
     // Handle special cases
+    if (Object.is(value, -0)) return new Uint8Array([0x80, 0x00])
     if (value === 0) return new Uint8Array([0x00, 0x00])
-    if (value === -0) return new Uint8Array([0x80, 0x00])
     if (Number.isNaN(value)) return new Uint8Array([0x7e, 0x00])
     if (value === Infinity) return new Uint8Array([0x7c, 0x00])
     if (value === -Infinity) return new Uint8Array([0xfc, 0x00])
@@ -88,6 +88,9 @@ export function useCborSimpleEncoder(_globalOptions?: Partial<EncodeOptions>) {
     const mant64 = Number(bits & 0xfffffffffffffn)
 
     // Convert to float16 range
+    // Use BigInt for bit manipulation since mant64 can exceed 32 bits,
+    // which would cause JavaScript's bitwise operators to truncate silently.
+    const mant64n = BigInt(mant64)
     let exp16: number
     let mant16: number
 
@@ -99,16 +102,40 @@ export function useCborSimpleEncoder(_globalOptions?: Partial<EncodeOptions>) {
       // Subnormal float16: shift the implicit 1.mantissa into the fraction bits
       exp16 = 0
       const shift = -14 - exp64
-      mant16 = (((1 << 10) | (mant64 >> 42)) + ((1 << (shift - 1)) - 1)) >> shift
+      // Build the full subnormal mantissa: implicit 1 bit + top 10 mantissa bits,
+      // then apply IEEE 754 round-half-to-even before shifting into subnormal position.
+      // The 11-bit value (1.mant10) needs to be right-shifted by 'shift' to get the
+      // subnormal mantissa. We apply rounding at the shift boundary.
+      const fullMant = (1n << 10n) | (mant64n >> 42n)
+      // Bits lost from the float64 mantissa during the >> 42 extraction
+      const lostFromExtract = mant64n & ((1n << 42n) - 1n)
+      // The 'shift' additional bits lost when converting to subnormal
+      const shiftN = BigInt(shift)
+      const guardBit = Number((fullMant >> (shiftN - 1n)) & 1n)
+      // Sticky includes bits below guard in fullMant plus any bits lost from extraction
+      const stickyBitsBelow = shiftN > 1n ? (fullMant & ((1n << (shiftN - 1n)) - 1n)) : 0n
+      const sticky = (stickyBitsBelow !== 0n || lostFromExtract !== 0n) ? 1 : 0
+      const truncated = Number(fullMant >> shiftN)
+      const lsb = truncated & 1
+      mant16 = truncated + (guardBit & (sticky | lsb))
     } else if (exp64 > 15) {
       // Overflow to infinity
       exp16 = 31
       mant16 = 0
     } else {
-      // Normal number
+      // Normal number: IEEE 754 round-half-to-even (guard/round/sticky)
       exp16 = exp64 + 15
-      // Take top 10 bits of mantissa
-      mant16 = mant64 >> 42
+      const truncated = Number(mant64n >> 42n)
+      const guardBit = Number((mant64n >> 41n) & 1n)
+      const stickyBits = (mant64n & ((1n << 41n) - 1n)) !== 0n ? 1 : 0
+      const lsb = truncated & 1  // least significant bit of truncated result
+      mant16 = truncated + (guardBit & (stickyBits | lsb))
+      // Handle mantissa overflow from rounding (0x3FF + 1 = 0x400 bumps exponent)
+      if (mant16 > 0x3ff) {
+        mant16 = 0
+        exp16 += 1
+        // If exp16 overflows to 31 (0x1f), it becomes infinity -- correct IEEE 754 behavior
+      }
     }
 
     const float16 = (sign << 15) | (exp16 << 10) | mant16
@@ -155,13 +182,17 @@ export function useCborSimpleEncoder(_globalOptions?: Partial<EncodeOptions>) {
    */
   const canBeFloat16 = (value: number): boolean => {
     // Special values
-    if (!Number.isFinite(value) || value === 0 || value === -0) {
+    if (!Number.isFinite(value) || Object.is(value, 0) || Object.is(value, -0)) {
       return true
     }
 
-    // Check range
+    // Check range. The lower bound is the smallest positive float16 SUBNORMAL
+    // (2^-24 ≈ 5.96e-8), NOT the smallest normal (2^-14). Using 2^-14 here
+    // previously made the encoder emit float32 for representable subnormals,
+    // producing output its own canonical decoder (fitsInFloat16) then rejected.
+    // The round-trip equality check below is the real precision gate.
     const absValue = Math.abs(value)
-    if (absValue < 0.00006103515625 || absValue > 65504) {
+    if (absValue < 5.960464477539063e-8 || absValue > 65504) {
       return false
     }
 
@@ -195,7 +226,7 @@ export function useCborSimpleEncoder(_globalOptions?: Partial<EncodeOptions>) {
    */
   const canBeFloat32 = (value: number): boolean => {
     // Special values
-    if (!Number.isFinite(value) || value === 0 || value === -0) {
+    if (!Number.isFinite(value) || Object.is(value, 0) || Object.is(value, -0)) {
       return true
     }
 

package/src/encoder/types.ts

@@ -3,12 +3,12 @@
  * Following RFC 8949 specification
  */
 
-import type { PlutusConstr, CborByteString, CborTextString } from '../parser/types'
+import type { PlutusConstr, CborByteString, CborTextString, MapKeyOrder } from '../parser/types'
 import { INDEFINITE_SYMBOL, ALL_ENTRIES_SYMBOL } from '../parser/types'
 
 // Re-export symbols and types for use in encoder
 export { INDEFINITE_SYMBOL, ALL_ENTRIES_SYMBOL }
-export type { CborByteString, CborTextString }
+export type { CborByteString, CborTextString, MapKeyOrder }
 
 /**
  * Encoder options for controlling behavior
@@ -20,6 +20,12 @@ export interface EncodeOptions {
   allowIndefinite?: boolean
   /** Reject duplicate map keys */
   rejectDuplicateKeys?: boolean
+  /**
+   * Map key ordering used in canonical mode.
+   * Defaults to 'length-first' (Cardano CIP-21 / RFC 7049 §3.9).
+   * Use 'bytewise' for RFC 8949 §4.2.1 core deterministic order.
+   */
+  mapKeyOrder?: MapKeyOrder
   /** Maximum nesting depth */
   maxDepth?: number
   /** Maximum output size in bytes */
@@ -33,6 +39,7 @@ export const DEFAULT_ENCODE_OPTIONS: Required<EncodeOptions> = {
   canonical: false,
   allowIndefinite: true,
   rejectDuplicateKeys: false,
+  mapKeyOrder: 'length-first',
   maxDepth: 64,
   maxOutputSize: 100 * 1024 * 1024  // 100 MB
 }
@@ -81,8 +88,6 @@ export interface TaggedValue {
 export interface EncodeContext {
   /** Current nesting depth */
   depth: number
-  /** Bytes written so far */
-  bytesWritten: number
   /** Encoder options */
   options: Required<EncodeOptions>
 }