fix: compute DID from signed operation (include sig in hash)

The PLC spec requires the DID to be derived from the hash of the
complete signed operation, not just the unsigned operation.

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

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

package-lock.json

···
+{
+  "name": "cloudflare-pds",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "cloudflare-pds",
+      "version": "0.1.0"
+    }
+  }
+}

scripts/setup.js

···
   return result
 }
 
-// === CBOR ENCODING (minimal for PLC operations) ===
+// === CBOR ENCODING (dag-cbor compliant for PLC operations) ===
+
+function cborEncodeKey(key) {
+  // Encode a string key to CBOR bytes (for sorting)
+  const bytes = new TextEncoder().encode(key)
+  const parts = []
+  const mt = 3 << 5 // major type 3 = text string
+  if (bytes.length < 24) {
+    parts.push(mt | bytes.length)
+  } else if (bytes.length < 256) {
+    parts.push(mt | 24, bytes.length)
+  } else if (bytes.length < 65536) {
+    parts.push(mt | 25, bytes.length >> 8, bytes.length & 0xff)
+  }
+  parts.push(...bytes)
+  return new Uint8Array(parts)
+}
+
+function compareBytes(a, b) {
+  // dag-cbor: bytewise lexicographic order of encoded keys
+  const minLen = Math.min(a.length, b.length)
+  for (let i = 0; i < minLen; i++) {
+    if (a[i] !== b[i]) return a[i] - b[i]
+  }
+  return a.length - b.length
+}
 
 function cborEncode(value) {
   const parts = []
···
       encodeHead(4, val.length)
       for (const item of val) encode(item)
     } else if (typeof val === 'object') {
-      const keys = Object.keys(val).sort()
-      encodeHead(5, keys.length)
-      for (const key of keys) {
+      // dag-cbor: sort keys by their CBOR-encoded bytes (length first, then lexicographic)
+      const keys = Object.keys(val)
+      const keysSorted = keys.sort((a, b) => compareBytes(cborEncodeKey(a), cborEncodeKey(b)))
+      encodeHead(5, keysSorted.length)
+      for (const key of keysSorted) {
         encode(key)
         encode(val[key])
       }
···
 }
 
 async function deriveDidFromOperation(operation) {
-  const { sig, ...opWithoutSig } = operation
-  const encoded = cborEncode(opWithoutSig)
+  // DID is computed from the FULL operation INCLUDING the signature
+  const encoded = cborEncode(operation)
   const hash = await sha256(encoded)
-  // DID is base32 of first 24 bytes of hash
-  return 'did:plc:' + base32Encode(hash.slice(0, 24))
+  // DID is base32 of first 15 bytes of hash (= 24 base32 chars)
+  return 'did:plc:' + base32Encode(hash.slice(0, 15))
 }
 
 function base32Encode(bytes) {