docs: add JSDoc to exported functions

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[e-mail]>

src/pds.js

···
   }
 }
 
+/**
+ * Encode a value as CBOR bytes (RFC 8949 deterministic encoding)
+ * @param {*} value - Value to encode (null, boolean, number, string, Uint8Array, array, or object)
+ * @returns {Uint8Array} CBOR-encoded bytes
+ */
 export function cborEncode(value) {
   const parts = []
 
···
   return new Uint8Array(parts)
 }
 
+/**
+ * Decode CBOR bytes to a JavaScript value
+ * @param {Uint8Array} bytes - CBOR-encoded bytes
+ * @returns {*} Decoded value
+ */
 export function cborDecode(bytes) {
   let offset = 0
 
···
 // === CID GENERATION ===
 // dag-cbor (0x71) + sha-256 (0x12) + 32 bytes
 
+/**
+ * Create a CIDv1 (dag-cbor + sha-256) from raw bytes
+ * @param {Uint8Array} bytes - Content to hash
+ * @returns {Promise<Uint8Array>} CID bytes (36 bytes: version + codec + multihash)
+ */
 export async function createCid(bytes) {
   const hash = await crypto.subtle.digest('SHA-256', bytes)
   const hashBytes = new Uint8Array(hash)
···
   return cid
 }
 
+/**
+ * Convert CID bytes to base32lower string representation
+ * @param {Uint8Array} cid - CID bytes
+ * @returns {string} Base32lower-encoded CID with 'b' prefix
+ */
 export function cidToString(cid) {
   // base32lower encoding for CIDv1
   return 'b' + base32Encode(cid)
 }
 
+/**
+ * Encode bytes as base32lower string
+ * @param {Uint8Array} bytes - Bytes to encode
+ * @returns {string} Base32lower-encoded string
+ */
 export function base32Encode(bytes) {
   const alphabet = 'abcdefghijklmnopqrstuvwxyz234567'
   let result = ''
···
 let lastTimestamp = 0
 let clockId = Math.floor(Math.random() * 1024)
 
+/**
+ * Generate a timestamp-based ID (TID) for record keys
+ * Monotonic within a process, sortable by time
+ * @returns {string} 13-character base32-sort encoded TID
+ */
 export function createTid() {
   let timestamp = Date.now() * 1000 // microseconds
 
···
 // === P-256 SIGNING ===
 // Web Crypto ECDSA with P-256 curve
 
+/**
+ * Import a raw P-256 private key for signing
+ * @param {Uint8Array} privateKeyBytes - 32-byte raw private key
+ * @returns {Promise<CryptoKey>} Web Crypto key handle
+ */
 export async function importPrivateKey(privateKeyBytes) {
   // Validate private key length (P-256 requires exactly 32 bytes)
   if (!(privateKeyBytes instanceof Uint8Array) || privateKeyBytes.length !== 32) {
···
   return bytes
 }
 
+/**
+ * Sign data with ECDSA P-256, returning low-S normalized signature
+ * @param {CryptoKey} privateKey - Web Crypto key from importPrivateKey
+ * @param {Uint8Array} data - Data to sign
+ * @returns {Promise<Uint8Array>} 64-byte signature (r || s)
+ */
 export async function sign(privateKey, data) {
   const signature = await crypto.subtle.sign(
     { name: 'ECDSA', hash: 'SHA-256' },
···
   return sig
 }
 
+/**
+ * Generate a new P-256 key pair
+ * @returns {Promise<{privateKey: Uint8Array, publicKey: Uint8Array}>} 32-byte private key, 33-byte compressed public key
+ */
 export async function generateKeyPair() {
   const keyPair = await crypto.subtle.generateKey(
     { name: 'ECDSA', namedCurve: 'P-256' },
···
   return bytes
 }
 
+/**
+ * Convert bytes to hexadecimal string
+ * @param {Uint8Array} bytes - Bytes to convert
+ * @returns {string} Hex string
+ */
 export function bytesToHex(bytes) {
   return Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('')
 }
 
+/**
+ * Convert hexadecimal string to bytes
+ * @param {string} hex - Hex string
+ * @returns {Uint8Array} Decoded bytes
+ */
 export function hexToBytes(hex) {
   const bytes = new Uint8Array(hex.length / 2)
   for (let i = 0; i < hex.length; i += 2) {
···
 // Cache for key depths (SHA-256 is expensive)
 const keyDepthCache = new Map()
 
+/**
+ * Get MST tree depth for a key based on leading zeros in SHA-256 hash
+ * @param {string} key - Record key (collection/rkey)
+ * @returns {Promise<number>} Tree depth (leading zeros / 2)
+ */
 export async function getKeyDepth(key) {
   // Count leading zeros in SHA-256 hash, divide by 2
   if (keyDepthCache.has(key)) return keyDepthCache.get(key)
···
 
 // === CAR FILE BUILDER ===
 
+/**
+ * Encode integer as unsigned varint
+ * @param {number} n - Non-negative integer
+ * @returns {Uint8Array} Varint-encoded bytes
+ */
 export function varint(n) {
   const bytes = []
   while (n >= 0x80) {
···
   return new Uint8Array(bytes)
 }
 
+/**
+ * Convert base32lower CID string to raw bytes
+ * @param {string} cidStr - CID string with 'b' prefix
+ * @returns {Uint8Array} CID bytes
+ */
 export function cidToBytes(cidStr) {
   // Decode base32lower CID string to bytes
   if (!cidStr.startsWith('b')) throw new Error('expected base32lower CID')
   return base32Decode(cidStr.slice(1))
 }
 
+/**
+ * Decode base32lower string to bytes
+ * @param {string} str - Base32lower-encoded string
+ * @returns {Uint8Array} Decoded bytes
+ */
 export function base32Decode(str) {
   const alphabet = 'abcdefghijklmnopqrstuvwxyz234567'
   let bits = 0
···
   return new Uint8Array(parts)
 }
 
+/**
+ * Build a CAR (Content Addressable aRchive) file
+ * @param {string} rootCid - Root CID string
+ * @param {Array<{cid: string, data: Uint8Array}>} blocks - Blocks to include
+ * @returns {Uint8Array} CAR file bytes
+ */
 export function buildCarFile(rootCid, blocks) {
   const parts = []