cors and cleanup

bundle/manager.go

···
 			m.logger.Printf("Warning: failed to save mempool: %v", err)
 		}
 	}
-	if m.didIndex != nil { // ← ADD THIS
+	if m.didIndex != nil {
 		m.didIndex.Close()
 	}
 }

bundle/mempool.go

···
 			didSet[op.DID] = true
 		}
 		stats["size_bytes"] = totalSize
-		stats["did_count"] = len(didSet) // ← ADDED
+		stats["did_count"] = len(didSet)
 	}
 
 	return stats

cmd/plcbundle/detector.go

···
 	bundleNum := fs.Int("bundle", 0, "bundle number to test")
 	confidence := fs.Float64("confidence", 0.90, "minimum confidence threshold")
 	verbose := fs.Bool("v", false, "verbose output")
-	fs.Parse(os.Args[4:]) // ← Changed from os.Args[3:]
+	fs.Parse(os.Args[4:])
 
 	if *bundleNum == 0 {
 		fmt.Fprintf(os.Stderr, "Error: --bundle required\n")
···
 	var maxConfidence float64
 
 	for _, det := range detectors {
-		match, err := det.Detect(ctx, op) // ← op now has ParsedOperation set
+		match, err := det.Detect(ctx, op)
 		if err != nil || match == nil || match.Confidence < minConfidence {
 			continue
 		}

cmd/plcbundle/main.go

···
 	}
 
 	config := bundle.DefaultConfig(dir)
-	config.AutoRebuild = false // ← Disable auto-rebuild
+	config.AutoRebuild = false
 	config.RebuildWorkers = *workers
 
 	mgr, err := bundle.NewManager(config, nil)
···
 	enableWebSocket := fs.Bool("websocket", false, "enable WebSocket endpoint for streaming records")
 	workers := fs.Int("workers", 4, "number of workers for auto-rebuild (0 = CPU count)")
 	verbose := fs.Bool("verbose", false, "verbose sync logging")
-	enableResolver := fs.Bool("resolver", false, "enable DID resolution endpoints (/<did>)") // ← NEW
+	enableResolver := fs.Bool("resolver", false, "enable DID resolution endpoints (/<did>)")
 	fs.Parse(os.Args[2:])
 
 	serverStartTime = time.Now()
 	syncInterval = *syncIntervalFlag
 	verboseMode = *verbose
-	resolverEnabled = *enableResolver // ← NEW global
+	resolverEnabled = *enableResolver
 
 	// Auto-detect CPU count
 	if *workers == 0 {
···
 	}
 	defer mgr.Close()
 
-	// ═══════════════════════════════════════════════════════════
-	// DID INDEX AUTO-BUILD LOGIC
-	// ═══════════════════════════════════════════════════════════
 	if *enableResolver {
 		index := mgr.GetIndex()
 		bundleCount := index.Count()
···
 				// Check version
 				didIndex := mgr.GetDIDIndex()
 				if didIndex != nil {
-					config := didIndex.GetConfig() // ← Need to expose this
+					config := didIndex.GetConfig()
 					if config.Version != bundle.DIDINDEX_VERSION {
 						needsBuild = true
 						reason = fmt.Sprintf("index version outdated (v%d, need v%d)",
···
 	defer cancel()
 
 	if *sync {
-		go runSync(ctx, mgr, syncInterval, *verbose, *enableResolver) // ← Pass resolver flag
+		go runSync(ctx, mgr, syncInterval, *verbose, *enableResolver)
 	}
 
 	server := &http.Server{
 		Addr:         addr,
-		Handler:      newServerHandler(mgr, *sync, *enableWebSocket, *enableResolver), // ← Pass resolver flag
+		Handler:      newServerHandler(mgr, *sync, *enableWebSocket, *enableResolver),
 		ReadTimeout:  30 * time.Second,
 		WriteTimeout: 30 * time.Second,
 	}

cmd/plcbundle/progress.go

···
 	pb.current = pb.total
 	pb.currentBytes = pb.totalBytes
 	pb.print()
-	fmt.Fprintf(os.Stderr, "\n") // ← FIXED: Use stderr
+	fmt.Fprintf(os.Stderr, "\n")
 }
 
 // print renders the progress bar (must be called with lock held)

cmd/plcbundle/server.go

···
 	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		path := r.URL.Path
 
-		// DID Resolution - delegate to specific handler
-		if strings.HasPrefix(path, "/did:plc:") {
+		// DID Resolution - only if resolver is enabled
+		if resolverEnabled && strings.HasPrefix(path, "/did:plc:") {
 			handleDIDEndpoint(w, r, mgr)
 			return
 		}
···
 		http.NotFound(w, r)
 	})
 
-	// Index JSON (reload from disk each time for fresh data during rebuild)
+	// Index JSON
 	mux.HandleFunc("/index.json", func(w http.ResponseWriter, r *http.Request) {
-		// Reload index to get latest data
-		mgr.GetIndex() // This will refresh if needed
+		mgr.GetIndex()
 		handleIndexJSON(w, mgr)
 	})
 
···
 		fmt.Fprintf(w, "\nDID Index:\n")
 		fmt.Fprintf(w, "  Cached shards: %d/%d\n", didStats["cached_shards"], didStats["cache_limit"])
 
-		// Force GC and show again
 		runtime.GC()
 		runtime.ReadMemStats(&m)
 		fmt.Fprintf(w, "\nAfter GC:\n")
···
 		})
 	}
 
-	return mux
+	return corsMiddleware(mux)
 }
 
 // handleWebSocket streams all records via WebSocket starting from cursor
···
 
 	json.NewEncoder(w).Encode(auditLog)
 }
+
+// corsMiddleware adds CORS headers to all responses
+func corsMiddleware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// Set CORS headers
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.Header().Set("Access-Control-Allow-Methods", "GET, OPTIONS")
+		w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")
+		w.Header().Set("Access-Control-Max-Age", "86400") // 24 hours
+
+		// Handle preflight OPTIONS request
+		if r.Method == "OPTIONS" {
+			w.WriteHeader(http.StatusNoContent)
+			return
+		}
+
+		// Call the next handler
+		next.ServeHTTP(w, r)
+	})
+}

detector/detector.go

···
 	BundleNumber int
 	Position     int
 	DID          string
-	CID          string // ← Add this field
+	CID          string
 	Match        *Match // nil if no match
 	Error        error
 	DetectorName string

detector/runner.go

···
 		BundleNumber: bundleNum,
 		Position:     pos,
 		DID:          op.DID,
-		CID:          op.CID, // ← Add this
+		CID:          op.CID,
 		DetectorName: detector.Name(),
 		DetectedAt:   time.Now(),
 	}

plc/resolver.go

···
 	// Convert services
 	for id, svc := range state.Services {
 		doc.Service = append(doc.Service, Service{
-			ID:              "#" + id, // ← Just fragment (matching plc.directory)
+			ID:              "#" + id,
 			Type:            svc.Type,
 			ServiceEndpoint: svc.Endpoint,
 		})
···
 	// Keep verification methods with full DID (they're correct):
 	for id, didKey := range state.VerificationMethods {
 		doc.VerificationMethod = append(doc.VerificationMethod, VerificationMethod{
-			ID:                 state.DID + "#" + id, // ← Keep this as-is
+			ID:                 state.DID + "#" + id,
 			Type:               "Multikey",
 			Controller:         state.DID,
 			PublicKeyMultibase: ExtractMultibaseFromDIDKey(didKey),
···
 	// The 'z' is the base58btc multibase prefix
 	// Actual key starts at position 1
 	switch {
-	case multibase[1] == 'Q' && multibase[2] == '3': // ← Fixed: was [0] and [1]
+	case multibase[1] == 'Q' && multibase[2] == '3':
 		return "secp256k1" // Starts with zQ3s
-	case multibase[1] == 'D' && multibase[2] == 'n': // ← Fixed
+	case multibase[1] == 'D' && multibase[2] == 'n':
 		return "p256" // Starts with zDn
-	case multibase[1] == '6' && multibase[2] == 'M': // ← Fixed
+	case multibase[1] == '6' && multibase[2] == 'M':
 		return "ed25519" // Starts with z6Mk
 	default:
 		return "unknown"