@marcuspuchalla/nachos 0.1.1 → 0.1.4

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/__tests__/cbor-string-encoder.test.ts

@@ -329,6 +329,20 @@ describe('CBOR String Encoder', () => {
       expect(() => encodeByteStringIndefinite([new Uint8Array([1])]))
         .toThrow('Indefinite-length encoding not allowed in canonical mode')
     })
+
+    it('should reject allowIndefinite=false for text strings', () => {
+      const { encodeTextStringIndefinite } = useCborStringEncoder({ allowIndefinite: false })
+
+      expect(() => encodeTextStringIndefinite(['a', 'b']))
+        .toThrow('Indefinite-length encoding is not allowed')
+    })
+
+    it('should reject allowIndefinite=false for byte strings', () => {
+      const { encodeByteStringIndefinite } = useCborStringEncoder({ allowIndefinite: false })
+
+      expect(() => encodeByteStringIndefinite([new Uint8Array([1])]))
+        .toThrow('Indefinite-length encoding is not allowed')
+    })
   })
 
   describe('Byte string array handling', () => {

package/src/encoder/composables/useCborCollectionEncoder.ts

@@ -9,6 +9,7 @@ import { DEFAULT_ENCODE_OPTIONS, INDEFINITE_SYMBOL, ALL_ENTRIES_SYMBOL } from '.
 import { bytesToHex, concatenateUint8Arrays, compareBytes } 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)) {
@@ -105,6 +116,9 @@ export function useCborCollectionEncoder(globalOptions?: Partial<EncodeOptions>)
       const newCtx = { ...ctx, depth: ctx.depth + 1 }
 
       if (isIndefinite) {
+        if (ctx.options.allowIndefinite === false) {
+          throw new Error('Indefinite-length encoding is not allowed')
+        }
         // Use indefinite encoding - but need to recursively encode items
         const parts: Uint8Array[] = [new Uint8Array([0x9f])]  // Start marker
         for (const item of value) {
@@ -130,6 +144,9 @@ export function useCborCollectionEncoder(globalOptions?: Partial<EncodeOptions>)
       const newCtx = { ...ctx, depth: ctx.depth + 1 }
 
       if (isIndefinite) {
+        if (ctx.options.allowIndefinite === false) {
+          throw new Error('Indefinite-length encoding is not allowed')
+        }
         // Use indefinite encoding
         const entries: Array<[EncodableValue, EncodableValue]> =
           value instanceof Map
@@ -205,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)
@@ -233,6 +244,9 @@ export function useCborCollectionEncoder(globalOptions?: Partial<EncodeOptions>)
 
     // Handle indefinite-length encoding
     if (encodeOptions?.indefinite || isIndefinite) {
+      if (options.allowIndefinite === false) {
+        throw new Error('Indefinite-length encoding is not allowed')
+      }
       if (options.canonical) {
         throw new Error('Indefinite-length encoding not allowed in canonical mode')
       }
@@ -242,7 +256,6 @@ export function useCborCollectionEncoder(globalOptions?: Partial<EncodeOptions>)
     // Definite-length encoding
     const ctx: EncodeContext = {
       depth: 0,
-      bytesWritten: 0,
       options
     }
 
@@ -256,6 +269,9 @@ export function useCborCollectionEncoder(globalOptions?: Partial<EncodeOptions>)
    * @returns Encoded CBOR bytes and hex string
    */
   const encodeArrayIndefinite = (array: EncodableValue[]): EncodeResult => {
+    if (options.allowIndefinite === false) {
+      throw new Error('Indefinite-length encoding is not allowed')
+    }
     if (options.canonical) {
       throw new Error('Indefinite-length encoding not allowed in canonical mode')
     }
@@ -264,7 +280,6 @@ export function useCborCollectionEncoder(globalOptions?: Partial<EncodeOptions>)
 
     const ctx: EncodeContext = {
       depth: 0,
-      bytesWritten: 0,
       options
     }
 
@@ -304,13 +319,33 @@ 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
+      }))
+      withEncodedKeys.sort((a, b) => compareBytes(a.encodedKey, b.encodedKey))
+      entries = withEncodedKeys.map(t => t.entry)
+      preEncodedKeys = withEncodedKeys.map(t => t.encodedKey)
+    }
+
+    if (ctx.options.rejectDuplicateKeys) {
+      const seen = new Set<string>()
+      // 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')
+        }
+        seen.add(keyHex)
+      }
     }
 
     const header = encodeLengthHeader(5, entries.length)
@@ -326,12 +361,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)
@@ -354,6 +383,9 @@ export function useCborCollectionEncoder(globalOptions?: Partial<EncodeOptions>)
 
     // Handle indefinite-length encoding
     if (encodeOptions?.indefinite || isIndefinite) {
+      if (options.allowIndefinite === false) {
+        throw new Error('Indefinite-length encoding is not allowed')
+      }
       if (options.canonical) {
         throw new Error('Indefinite-length encoding not allowed in canonical mode')
       }
@@ -363,7 +395,6 @@ export function useCborCollectionEncoder(globalOptions?: Partial<EncodeOptions>)
     // Definite-length encoding
     const ctx: EncodeContext = {
       depth: 0,
-      bytesWritten: 0,
       options
     }
 
@@ -379,6 +410,9 @@ export function useCborCollectionEncoder(globalOptions?: Partial<EncodeOptions>)
   const encodeMapIndefinite = (
     map: Map<EncodableValue, EncodableValue> | { [key: string]: EncodableValue }
   ): EncodeResult => {
+    if (options.allowIndefinite === false) {
+      throw new Error('Indefinite-length encoding is not allowed')
+    }
     if (options.canonical) {
       throw new Error('Indefinite-length encoding not allowed in canonical mode')
     }
@@ -392,7 +426,6 @@ export function useCborCollectionEncoder(globalOptions?: Partial<EncodeOptions>)
 
     const ctx: EncodeContext = {
       depth: 0,
-      bytesWritten: 0,
       options
     }
 

package/src/encoder/composables/useCborEncoder.ts

@@ -42,6 +42,11 @@ import { useCborByteString, useCborTextString } from '../../parser/composables/u
 export function useCborEncoder(globalOptions?: Partial<EncodeOptions>) {
   const options = { ...DEFAULT_ENCODE_OPTIONS, ...globalOptions }
 
+  // Canonical mode overrides: indefinite-length is forbidden per RFC 8949 Section 4.2
+  if (options.canonical && options.allowIndefinite) {
+    options.allowIndefinite = false
+  }
+
   // Get all specialized encoders
   const { encodeInteger } = useCborIntegerEncoder()
   const { encodeTextString, encodeByteString } = useCborStringEncoder(options)
@@ -70,6 +75,24 @@ 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
+  }
+
+  /**
+   * Encode any JavaScript value to CBOR (internal, no size check)
+   */
+  const encodeValue = (value: EncodableValue): EncodeResult => {
     // Handle null/undefined/boolean
     if (value === null || value === undefined || typeof value === 'boolean') {
       return encodeSimple(value)
@@ -77,8 +100,11 @@ 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.isInteger(value) && Number.isSafeInteger(value)) {
+      if (Number.isSafeInteger(value)) {
         return encodeInteger(value)
       }
       // It's a float

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,22 +88,54 @@ 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
 
-    if (exp64 < -14) {
-      // Subnormal or zero
+    if (exp64 < -24) {
+      // Too small even for subnormal float16
       exp16 = 0
       mant16 = 0
+    } else if (exp64 < -14) {
+      // Subnormal float16: shift the implicit 1.mantissa into the fraction bits
+      exp16 = 0
+      const shift = -14 - exp64
+      // 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
@@ -150,7 +182,7 @@ 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
     }
 
@@ -190,7 +222,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/composables/useCborStringEncoder.ts

@@ -106,6 +106,9 @@ export function useCborStringEncoder(globalOptions?: Partial<EncodeOptions>) {
 
     // Handle indefinite-length encoding
     if (encodeOptions?.indefinite || Array.isArray(data) || isIndefinite) {
+      if (options.allowIndefinite === false) {
+        throw new Error('Indefinite-length encoding is not allowed')
+      }
       if (options.canonical) {
         throw new Error('Indefinite-length encoding not allowed in canonical mode')
       }
@@ -122,14 +125,15 @@ export function useCborStringEncoder(globalOptions?: Partial<EncodeOptions>) {
 
     // Definite-length encoding - extract bytes from CborByteString if needed
     const bytes = isCborByteString(data) ? data.bytes : (data as Uint8Array)
-    const header = encodeLengthHeader(2, bytes.length)
-    const result = concatenateUint8Arrays([header, bytes])
 
-    // Check output size limit
-    if (result.length > options.maxOutputSize) {
-      throw new Error('Encoded output exceeds maximum size')
+    // Check size limit before allocating (header is at most 9 bytes)
+    if (bytes.length + 9 > options.maxOutputSize) {
+      throw new Error(`Encoded output exceeds maximum size`)
     }
 
+    const header = encodeLengthHeader(2, bytes.length)
+    const result = concatenateUint8Arrays([header, bytes])
+
     return {
       bytes: result,
       hex: bytesToHex(result)
@@ -146,6 +150,9 @@ export function useCborStringEncoder(globalOptions?: Partial<EncodeOptions>) {
    * @returns Encoded CBOR bytes and hex string
    */
   const encodeByteStringIndefinite = (chunks: Uint8Array[]): EncodeResult => {
+    if (options.allowIndefinite === false) {
+      throw new Error('Indefinite-length encoding is not allowed')
+    }
     if (options.canonical) {
       throw new Error('Indefinite-length encoding not allowed in canonical mode')
     }
@@ -187,6 +194,9 @@ export function useCborStringEncoder(globalOptions?: Partial<EncodeOptions>) {
 
     // Handle indefinite-length encoding
     if (encodeOptions?.indefinite || isIndefinite) {
+      if (options.allowIndefinite === false) {
+        throw new Error('Indefinite-length encoding is not allowed')
+      }
       if (options.canonical) {
         throw new Error('Indefinite-length encoding not allowed in canonical mode')
       }
@@ -208,14 +218,14 @@ export function useCborStringEncoder(globalOptions?: Partial<EncodeOptions>) {
     const encoder = new TextEncoder()
     const utf8Bytes = encoder.encode(textStr)
 
+    // Check size limit before allocating (header is at most 9 bytes)
+    if (utf8Bytes.length + 9 > options.maxOutputSize) {
+      throw new Error(`Encoded output exceeds maximum size`)
+    }
+
     const header = encodeLengthHeader(3, utf8Bytes.length)
     const result = concatenateUint8Arrays([header, utf8Bytes])
 
-    // Check output size limit
-    if (result.length > options.maxOutputSize) {
-      throw new Error('Encoded output exceeds maximum size')
-    }
-
     return {
       bytes: result,
       hex: bytesToHex(result)
@@ -232,6 +242,9 @@ export function useCborStringEncoder(globalOptions?: Partial<EncodeOptions>) {
    * @returns Encoded CBOR bytes and hex string
    */
   const encodeTextStringIndefinite = (chunks: string[]): EncodeResult => {
+    if (options.allowIndefinite === false) {
+      throw new Error('Indefinite-length encoding is not allowed')
+    }
     if (options.canonical) {
       throw new Error('Indefinite-length encoding not allowed in canonical mode')
     }

package/src/encoder/types.ts

@@ -81,8 +81,6 @@ export interface TaggedValue {
 export interface EncodeContext {
   /** Current nesting depth */
   depth: number
-  /** Bytes written so far */
-  bytesWritten: number
   /** Encoder options */
   options: Required<EncodeOptions>
 }

package/src/index.ts

@@ -96,9 +96,14 @@ import type { ParseResult, ParseResultWithMap, ParseOptions } from './parser/typ
 import type { EncodeResult, EncodeOptions, EncodableValue } from './encoder/types'
 
 /**
- * Decode CBOR hex string to JavaScript value
+ * Decode CBOR data to JavaScript value
  *
- * @param hexString - CBOR data as hex string (e.g., "1864" for integer 100)
+ * Accepts either a hex string or a Uint8Array of raw CBOR bytes.
+ * When passing a Uint8Array, the bytes are used directly without
+ * hex conversion, which is more efficient for binary sources
+ * (WebSocket, fetch, file I/O, etc.).
+ *
+ * @param input - CBOR data as hex string (e.g., "1864") or Uint8Array
  * @param options - Optional parser configuration
  * @returns Decoded value and number of bytes consumed
  *
@@ -106,9 +111,12 @@ import type { EncodeResult, EncodeOptions, EncodableValue } from './encoder/type
  *
  * @example
  * ```typescript
- * // Decode integer
+ * // Decode from hex string
  * decode('1864')  // { value: 100, bytesRead: 2 }
  *
+ * // Decode from Uint8Array (zero-copy, no hex conversion)
+ * decode(new Uint8Array([0x18, 0x64]))  // { value: 100, bytesRead: 2 }
+ *
  * // Decode string
  * decode('6449455446')  // { value: "IETF", bytesRead: 5 }
  *
@@ -124,18 +132,20 @@ import type { EncodeResult, EncodeOptions, EncodableValue } from './encoder/type
  *
  * @see {@link https://datatracker.ietf.org/doc/html/rfc8949 | RFC 8949}
  */
-export function decode(hexString: string, options?: ParseOptions): ParseResult {
+export function decode(input: string | Uint8Array, options?: ParseOptions): ParseResult {
   const { parse } = useCborParser()
-  return parse(hexString, options)
+  return parse(input, options)
 }
 
 /**
- * Decode CBOR hex string with source map generation
+ * Decode CBOR data with source map generation
  *
  * Source maps provide bidirectional linking between hex bytes and decoded values,
  * enabling interactive debugging visualizations.
  *
- * @param hexString - CBOR data as hex string
+ * Accepts either a hex string or a Uint8Array of raw CBOR bytes.
+ *
+ * @param input - CBOR data as hex string or Uint8Array
  * @param options - Optional parser configuration
  * @returns Decoded value, byte count, and source map
  *
@@ -148,14 +158,13 @@ export function decode(hexString: string, options?: ParseOptions): ParseResult {
  * //   { path: '.value', start: 2, end: 3, majorType: 4, type: 'Array', parent: '' }
  * // ]
  *
- * // Use source map for hex-to-JSON linking
- * const entry = sourceMap.find(e => e.path === '.value')
- * console.log(`Value is at bytes ${entry.start}-${entry.end}`)
+ * // From Uint8Array
+ * const { value, sourceMap } = decodeWithSourceMap(new Uint8Array([0xd8, 0x79, 0x80]))
  * ```
  */
-export function decodeWithSourceMap(hexString: string, options?: ParseOptions): ParseResultWithMap {
+export function decodeWithSourceMap(input: string | Uint8Array, options?: ParseOptions): ParseResultWithMap {
   const { parseWithSourceMap } = useCborParser()
-  return parseWithSourceMap(hexString, options)
+  return parseWithSourceMap(input, options)
 }
 
 /**
@@ -287,23 +296,23 @@ export class CborDecoder {
   }
 
   /**
-   * Decode CBOR hex string
+   * Decode CBOR data
    *
-   * @param hexString - CBOR data as hex string
+   * @param input - CBOR data as hex string or Uint8Array
    * @returns Decoded value and byte count
    */
-  decode(hexString: string): ParseResult {
-    return decode(hexString, this.options)
+  decode(input: string | Uint8Array): ParseResult {
+    return decode(input, this.options)
   }
 
   /**
-   * Decode CBOR hex string with source map
+   * Decode CBOR data with source map
    *
-   * @param hexString - CBOR data as hex string
+   * @param input - CBOR data as hex string or Uint8Array
    * @returns Decoded value, byte count, and source map
    */
-  decodeWithSourceMap(hexString: string): ParseResultWithMap {
-    return decodeWithSourceMap(hexString, this.options)
+  decodeWithSourceMap(input: string | Uint8Array): ParseResultWithMap {
+    return decodeWithSourceMap(input, this.options)
   }
 }