update

internal/api/handlers.go

···
 	"github.com/klauspost/compress/zstd"
 )
 
-func (s *Server) handleGetPDSList(w http.ResponseWriter, r *http.Request) {
+// ====================
+// Endpoint Handlers (new)
+// ====================
+
+func (s *Server) handleGetEndpoints(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
 
-	filter := &storage.PDSFilter{}
+	filter := &storage.EndpointFilter{}
+
+	if typ := r.URL.Query().Get("type"); typ != "" {
+		filter.Type = typ
+	}
 
 	if status := r.URL.Query().Get("status"); status != "" {
 		filter.Status = status
 	}
 
+	if minUserCount := r.URL.Query().Get("min_user_count"); minUserCount != "" {
+		if count, err := strconv.ParseInt(minUserCount, 10, 64); err == nil {
+			filter.MinUserCount = count
+		}
+	}
+
 	if limit := r.URL.Query().Get("limit"); limit != "" {
 		if l, err := strconv.Atoi(limit); err == nil {
 			filter.Limit = l
···
 		}
 	}
 
-	servers, err := s.db.GetPDSServers(ctx, filter)
+	endpoints, err := s.db.GetEndpoints(ctx, filter)
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
 
 	// Convert status codes to strings for API
-	response := make([]map[string]interface{}, len(servers))
-	for i, srv := range servers {
+	response := make([]map[string]interface{}, len(endpoints))
+	for i, ep := range endpoints {
 		response[i] = map[string]interface{}{
-			"id":            srv.ID,
-			"endpoint":      srv.Endpoint,
-			"discovered_at": srv.DiscoveredAt,
-			"last_checked":  srv.LastChecked,
-			"status":        statusToString(srv.Status),
-			"user_count":    srv.UserCount,
+			"id":            ep.ID,
+			"endpoint_type": ep.EndpointType,
+			"endpoint":      ep.Endpoint,
+			"discovered_at": ep.DiscoveredAt,
+			"last_checked":  ep.LastChecked,
+			"status":        statusToString(ep.Status),
+			"user_count":    ep.UserCount,
 		}
 	}
 
 	respondJSON(w, response)
 }
 
-func (s *Server) handleGetPDS(w http.ResponseWriter, r *http.Request) {
+func (s *Server) handleGetEndpoint(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
 	vars := mux.Vars(r)
 	endpoint := vars["endpoint"]
 
-	pds, err := s.db.GetPDS(ctx, endpoint)
+	// Get type from query param, default to "pds" for backward compatibility
+	endpointType := r.URL.Query().Get("type")
+	if endpointType == "" {
+		endpointType = "pds"
+	}
+
+	ep, err := s.db.GetEndpoint(ctx, endpoint, endpointType)
 	if err != nil {
-		http.Error(w, "PDS not found", http.StatusNotFound)
+		http.Error(w, "Endpoint not found", http.StatusNotFound)
 		return
 	}
 
 	// Get recent scans
-	scans, _ := s.db.GetPDSScans(ctx, pds.ID, 10)
+	scans, _ := s.db.GetEndpointScans(ctx, ep.ID, 10)
 
 	response := map[string]interface{}{
-		"id":            pds.ID,
-		"endpoint":      pds.Endpoint,
-		"discovered_at": pds.DiscoveredAt,
-		"last_checked":  pds.LastChecked,
-		"status":        statusToString(pds.Status),
-		"user_count":    pds.UserCount,
+		"id":            ep.ID,
+		"endpoint_type": ep.EndpointType,
+		"endpoint":      ep.Endpoint,
+		"discovered_at": ep.DiscoveredAt,
+		"last_checked":  ep.LastChecked,
+		"status":        statusToString(ep.Status),
+		"user_count":    ep.UserCount,
 		"recent_scans":  scans,
 	}
 
 	respondJSON(w, response)
 }
 
-func (s *Server) handleGetPDSStats(w http.ResponseWriter, r *http.Request) {
+func (s *Server) handleGetEndpointStats(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
 
-	stats, err := s.db.GetPDSStats(ctx)
+	stats, err := s.db.GetEndpointStats(ctx)
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
···
 
 	respondJSON(w, stats)
 }
+
+// ====================
+// DID Handlers
+// ====================
 
 func (s *Server) handleGetDID(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
···
 	respondJSON(w, history)
 }
 
+// ====================
+// PLC Bundle Handlers
+// ====================
+
 func (s *Server) handleGetPLCBundle(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
 	vars := mux.Vars(r)
···
 		"end_time":          bundle.EndTime,
 		"operation_count":   plc.BUNDLE_SIZE,
 		"did_count":         len(bundle.DIDs),
-		"hash":              bundle.Hash,           // Uncompressed (verifiable)
-		"compressed_hash":   bundle.CompressedHash, // File integrity
+		"hash":              bundle.Hash,
+		"compressed_hash":   bundle.CompressedHash,
 		"compressed_size":   bundle.CompressedSize,
 		"prev_bundle_hash":  bundle.PrevBundleHash,
 		"created_at":        bundle.CreatedAt,
···
 	}
 }
 
+func (s *Server) handleGetPLCBundles(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+
+	limit := 50
+	if l := r.URL.Query().Get("limit"); l != "" {
+		if parsed, err := strconv.Atoi(l); err == nil {
+			limit = parsed
+		}
+	}
+
+	bundles, err := s.db.GetBundles(ctx, limit)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	response := make([]map[string]interface{}, len(bundles))
+	for i, bundle := range bundles {
+		response[i] = map[string]interface{}{
+			"plc_bundle_number": bundle.BundleNumber,
+			"start_time":        bundle.StartTime,
+			"end_time":          bundle.EndTime,
+			"operation_count":   plc.BUNDLE_SIZE,
+			"did_count":         len(bundle.DIDs),
+			"hash":              bundle.Hash,
+			"compressed_hash":   bundle.CompressedHash,
+			"compressed_size":   bundle.CompressedSize,
+			"prev_bundle_hash":  bundle.PrevBundleHash,
+		}
+	}
+
+	respondJSON(w, response)
+}
+
+func (s *Server) handleGetPLCBundleStats(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+
+	count, size, err := s.db.GetBundleStats(ctx)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	respondJSON(w, map[string]interface{}{
+		"plc_bundle_count": count,
+		"total_size":       size,
+		"total_size_mb":    float64(size) / 1024 / 1024,
+	})
+}
+
+// ====================
+// Mempool Handlers
+// ====================
+
 func (s *Server) handleGetMempoolStats(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
 
···
 	respondJSON(w, response)
 }
 
-// Helper to load bundle operations - UPDATED FOR JSONL FORMAT
-func (s *Server) loadBundleOperations(path string) ([]plc.PLCOperation, error) {
-	decoder, err := zstd.NewReader(nil)
-	if err != nil {
-		return nil, err
-	}
-	defer decoder.Close()
-
-	compressedData, err := os.ReadFile(path)
-	if err != nil {
-		return nil, err
-	}
-
-	decompressed, err := decoder.DecodeAll(compressedData, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	// Parse JSONL (newline-delimited JSON)
-	var operations []plc.PLCOperation
-	scanner := bufio.NewScanner(bytes.NewReader(decompressed))
-
-	lineNum := 0
-	for scanner.Scan() {
-		lineNum++
-		line := scanner.Bytes()
-
-		// Skip empty lines
-		if len(line) == 0 {
-			continue
-		}
-
-		var op plc.PLCOperation
-		if err := json.Unmarshal(line, &op); err != nil {
-			return nil, fmt.Errorf("failed to parse operation on line %d: %w", lineNum, err)
-		}
-
-		// CRITICAL: Store the original raw JSON bytes
-		op.RawJSON = make([]byte, len(line))
-		copy(op.RawJSON, line)
-
-		operations = append(operations, op)
-	}
-
-	if err := scanner.Err(); err != nil {
-		return nil, fmt.Errorf("error reading JSONL: %w", err)
-	}
-
-	return operations, nil
-}
+// ====================
+// PLC Metrics Handlers
+// ====================
 
 func (s *Server) handleGetPLCMetrics(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
···
 	respondJSON(w, metrics)
 }
 
-func (s *Server) handleGetPLCBundles(w http.ResponseWriter, r *http.Request) {
-	ctx := r.Context()
-
-	limit := 50
-	if l := r.URL.Query().Get("limit"); l != "" {
-		if parsed, err := strconv.Atoi(l); err == nil {
-			limit = parsed
-		}
-	}
-
-	bundles, err := s.db.GetBundles(ctx, limit)
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-
-	response := make([]map[string]interface{}, len(bundles))
-	for i, bundle := range bundles {
-		response[i] = map[string]interface{}{
-			"plc_bundle_number": bundle.BundleNumber,
-			"start_time":        bundle.StartTime,
-			"end_time":          bundle.EndTime,
-			"operation_count":   10000,
-			"did_count":         len(bundle.DIDs),
-			"hash":              bundle.Hash,
-			"compressed_hash":   bundle.CompressedHash,
-			"compressed_size":   bundle.CompressedSize,
-			"prev_bundle_hash":  bundle.PrevBundleHash,
-		}
-	}
-
-	respondJSON(w, response)
-}
-
-func (s *Server) handleGetPLCBundleStats(w http.ResponseWriter, r *http.Request) {
-	ctx := r.Context()
-
-	count, size, err := s.db.GetBundleStats(ctx)
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-
-	respondJSON(w, map[string]interface{}{
-		"plc_bundle_count": count,
-		"total_size":       size,
-		"total_size_mb":    float64(size) / 1024 / 1024,
-	})
-}
-
-func (s *Server) handleHealth(w http.ResponseWriter, r *http.Request) {
-	respondJSON(w, map[string]string{"status": "ok"})
-}
+// ====================
+// Verification Handlers
+// ====================
 
 func (s *Server) handleVerifyPLCBundle(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
···
 		"verified":           verified,
 		"local_hash":         bundle.Hash,
 		"remote_hash":        remoteHash,
-		"local_op_count":     bundle.OperationCount,
+		"local_op_count":     plc.BUNDLE_SIZE,
 		"remote_op_count":    len(allRemoteOps),
 		"boundary_cids_used": len(prevBoundaryCIDs),
 	})
···
 		"chain_start_time": firstBundle.StartTime,
 		"chain_end_time":   lastBundleData.EndTime,
 		"chain_head_hash":  lastBundleData.Hash,
-		"first_prev_hash":  firstBundle.PrevBundleHash, // Should be empty
+		"first_prev_hash":  firstBundle.PrevBundleHash,
 		"last_prev_hash":   lastBundleData.PrevBundleHash,
 	})
 }
 
-// handlePLCExport simulates PLC directory /export endpoint using cached bundles
+// ====================
+// PLC Export Handler
+// ====================
+
 func (s *Server) handlePLCExport(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
 
···
 	if afterStr != "" {
 		// Try multiple timestamp formats (from most specific to least)
 		formats := []string{
-			time.RFC3339Nano,           // 2023-11-09T03:55:00.123456789Z
-			time.RFC3339,               // 2023-11-09T03:55:00Z
-			"2006-01-02T15:04:05.000Z", // 2023-11-09T03:55:00.000Z
-			"2006-01-02T15:04:05",      // 2023-11-09T03:55:00
-			"2006-01-02T15:04",         // 2023-11-09T03:55
-			"2006-01-02",               // 2023-11-09
+			time.RFC3339Nano,
+			time.RFC3339,
+			"2006-01-02T15:04:05.000Z",
+			"2006-01-02T15:04:05",
+			"2006-01-02T15:04",
+			"2006-01-02",
 		}
 
 		var parsed time.Time
 		var parseErr error
-		parsed = time.Time{} // zero value
+		parsed = time.Time{}
 
 		for _, format := range formats {
 			parsed, parseErr = time.Parse(format, afterStr)
···
 	}
 }
 
-// computeRemoteOperationsHash - matching format
+// ====================
+// Health Handler
+// ====================
+
+func (s *Server) handleHealth(w http.ResponseWriter, r *http.Request) {
+	respondJSON(w, map[string]string{"status": "ok"})
+}
+
+// ====================
+// Helper Functions
+// ====================
+
+// loadBundleOperations loads operations from a bundle file
+func (s *Server) loadBundleOperations(path string) ([]plc.PLCOperation, error) {
+	decoder, err := zstd.NewReader(nil)
+	if err != nil {
+		return nil, err
+	}
+	defer decoder.Close()
+
+	compressedData, err := os.ReadFile(path)
+	if err != nil {
+		return nil, err
+	}
+
+	decompressed, err := decoder.DecodeAll(compressedData, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	// Parse JSONL (newline-delimited JSON)
+	var operations []plc.PLCOperation
+	scanner := bufio.NewScanner(bytes.NewReader(decompressed))
+
+	lineNum := 0
+	for scanner.Scan() {
+		lineNum++
+		line := scanner.Bytes()
+
+		// Skip empty lines
+		if len(line) == 0 {
+			continue
+		}
+
+		var op plc.PLCOperation
+		if err := json.Unmarshal(line, &op); err != nil {
+			return nil, fmt.Errorf("failed to parse operation on line %d: %w", lineNum, err)
+		}
+
+		// CRITICAL: Store the original raw JSON bytes
+		op.RawJSON = make([]byte, len(line))
+		copy(op.RawJSON, line)
+
+		operations = append(operations, op)
+	}
+
+	if err := scanner.Err(); err != nil {
+		return nil, fmt.Errorf("error reading JSONL: %w", err)
+	}
+
+	return operations, nil
+}
+
+// computeRemoteOperationsHash computes hash for remote operations
 func computeRemoteOperationsHash(ops []plc.PLCOperation) (string, error) {
 	var jsonlData []byte
 	for i, op := range ops {
···
 	return hex.EncodeToString(hash[:]), nil
 }
 
-func respondJSON(w http.ResponseWriter, data interface{}) {
-	w.Header().Set("Content-Type", "application/json")
-	json.NewEncoder(w).Encode(data)
-}
-
-// Helper function
+// statusToString converts status int to string
 func statusToString(status int) string {
 	switch status {
-	case storage.PDSStatusOnline:
+	case storage.PDSStatusOnline: // Use PDSStatusOnline (alias)
 		return "online"
-	case storage.PDSStatusOffline:
+	case storage.PDSStatusOffline: // Use PDSStatusOffline (alias)
 		return "offline"
 	default:
 		return "unknown"
 	}
 }
+
+// respondJSON writes JSON response
+func respondJSON(w http.ResponseWriter, data interface{}) {
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(data)
+}

internal/api/server.go

···
 func (s *Server) setupRoutes() {
 	api := s.router.PathPrefix("/api/v1").Subrouter()
 
-	// PDS endpoints
-	api.HandleFunc("/pds", s.handleGetPDSList).Methods("GET")
-	api.HandleFunc("/pds/stats", s.handleGetPDSStats).Methods("GET")
-	api.HandleFunc("/pds/{endpoint}", s.handleGetPDS).Methods("GET")
+	// Endpoint routes (replaces PDS routes)
+	api.HandleFunc("/endpoints", s.handleGetEndpoints).Methods("GET")
+	api.HandleFunc("/endpoints/stats", s.handleGetEndpointStats).Methods("GET")
+	api.HandleFunc("/endpoints/{endpoint}", s.handleGetEndpoint).Methods("GET")
 
-	// Metrics endpoints
-	api.HandleFunc("/metrics/plc", s.handleGetPLCMetrics).Methods("GET")
-
-	// PLC Bundle endpoints
+	// PLC Bundle routes
 	api.HandleFunc("/plc/bundles", s.handleGetPLCBundles).Methods("GET")
 	api.HandleFunc("/plc/bundles/stats", s.handleGetPLCBundleStats).Methods("GET")
 	api.HandleFunc("/plc/bundles/chain", s.handleGetChainInfo).Methods("GET")
 	api.HandleFunc("/plc/bundles/verify-chain", s.handleVerifyChain).Methods("POST")
+	api.HandleFunc("/plc/bundles/{number}", s.handleGetPLCBundle).Methods("GET")
 	api.HandleFunc("/plc/bundles/{number}/dids", s.handleGetPLCBundleDIDs).Methods("GET")
 	api.HandleFunc("/plc/bundles/{number}/download", s.handleDownloadPLCBundle).Methods("GET")
 	api.HandleFunc("/plc/bundles/{bundleNumber}/verify", s.handleVerifyPLCBundle).Methods("POST")
-	api.HandleFunc("/plc/bundles/{number}", s.handleGetPLCBundle).Methods("GET")
+
+	// PLC Export endpoint (simulates PLC directory)
 	api.HandleFunc("/plc/export", s.handlePLCExport).Methods("GET")
 
-	// PLC/DID endpoints
+	// DID routes
 	api.HandleFunc("/plc/did/{did}", s.handleGetDID).Methods("GET")
 	api.HandleFunc("/plc/did/{did}/history", s.handleGetDIDHistory).Methods("GET")
 
-	// Mempool endpoint - NEW
+	// Mempool routes
 	api.HandleFunc("/mempool/stats", s.handleGetMempoolStats).Methods("GET")
 
-	// Chain verification - NEW
+	// Metrics routes
+	api.HandleFunc("/metrics/plc", s.handleGetPLCMetrics).Methods("GET")
 
 	// Health check
 	s.router.HandleFunc("/health", s.handleHealth).Methods("GET")
 }
+
 func (s *Server) Start() error {
 	log.Info("API server listening on %s", s.server.Addr)
 	return s.server.ListenAndServe()

internal/pds/scanner.go

···
 	startTime := time.Now()
 	log.Info("Starting PDS availability scan...")
 
-	servers, err := s.db.GetPDSServers(ctx, nil)
+	// Get only PDS endpoints
+	servers, err := s.db.GetEndpoints(ctx, &storage.EndpointFilter{
+		Type: "pds",
+	})
 	if err != nil {
 		return err
 	}
···
 	log.Info("Scanning %d PDS servers...", len(servers))
 
 	// Worker pool
-	jobs := make(chan *storage.PDS, len(servers))
+	jobs := make(chan *storage.Endpoint, len(servers))
 	results := make(chan *PDSStatus, len(servers))
 
 	var wg sync.WaitGroup
···
 		}
 
 		// Build scan data
-		scanData := &storage.PDSScanData{
+		scanData := &storage.EndpointScanData{
 			ServerInfo: status.Description,
 			DIDs:       status.DIDs,
 			DIDCount:   len(status.DIDs),
 		}
 
-		// Update using PDS ID
-		if err := s.db.UpdatePDSStatus(ctx, status.PDSID, &storage.PDSUpdate{
+		// Update using Endpoint ID
+		if err := s.db.UpdateEndpointStatus(ctx, status.EndpointID, &storage.EndpointUpdate{
 			Status:       statusCode,
 			LastChecked:  status.LastChecked,
 			ResponseTime: status.ResponseTime.Seconds() * 1000, // Convert to ms
 			ScanData:     scanData,
 		}); err != nil {
-			log.Error("Error updating PDS ID %d: %v", status.PDSID, err)
+			log.Error("Error updating endpoint ID %d: %v", status.EndpointID, err)
 		}
 
 		if status.Available {
···
 	return nil
 }
 
-func (s *Scanner) worker(ctx context.Context, jobs <-chan *storage.PDS, results chan<- *PDSStatus) {
+func (s *Scanner) worker(ctx context.Context, jobs <-chan *storage.Endpoint, results chan<- *PDSStatus) {
 	for server := range jobs {
 		select {
 		case <-ctx.Done():
···
 	}
 }
 
-func (s *Scanner) scanPDS(ctx context.Context, pdsID int64, endpoint string) *PDSStatus {
+func (s *Scanner) scanPDS(ctx context.Context, endpointID int64, endpoint string) *PDSStatus {
 	status := &PDSStatus{
-		PDSID:       pdsID, // Store ID
+		EndpointID:  endpointID, // Store Endpoint ID
 		Endpoint:    endpoint,
 		LastChecked: time.Now(),
 	}
···
 		status.Description = desc
 	}
 
-	// List repos (DIDs)
+	// Optionally list repos (DIDs) - commented out by default for performance
 	/*dids, err := s.client.ListRepos(ctx, endpoint)
 	if err != nil {
 		log.Verbose("Warning: failed to list repos for %s: %v", endpoint, err)

internal/pds/types.go

···
 }
 
 type PDSStatus struct {
-	PDSID        int64 // NEW: PDS ID
+	EndpointID   int64 // Changed from PDSID to EndpointID
 	Endpoint     string
 	Available    bool
 	ResponseTime time.Duration

internal/plc/scanner.go

···
 	"context"
 	"encoding/json"
 	"fmt"
+	"strings"
 	"time"
 
-	"github.com/acarl005/stripansi"
 	"github.com/atscan/atscanner/internal/config"
 	"github.com/atscan/atscanner/internal/log"
 	"github.com/atscan/atscanner/internal/storage"
···
 
 // processBatch processes operations for PDS discovery
 func (s *Scanner) processBatch(ctx context.Context, operations []PLCOperation) (int64, error) {
-	newPDSCount := int64(0)
-	seenInBatch := make(map[string]*PLCOperation)
+	newEndpointCount := int64(0)
+	seenInBatch := make(map[string]*PLCOperation) // key: "type:endpoint"
 
 	for _, op := range operations {
 		if op.IsNullified() {
 			continue
 		}
 
-		pdsEndpoint := s.extractPDSFromOperation(op)
-		if pdsEndpoint == "" {
-			continue
+		endpoints := s.extractEndpointsFromOperation(op)
+		for _, ep := range endpoints {
+			key := fmt.Sprintf("%s:%s", ep.Type, ep.Endpoint)
+			if _, seen := seenInBatch[key]; !seen {
+				seenInBatch[key] = &op
+			}
 		}
+	}
 
-		if _, seen := seenInBatch[pdsEndpoint]; !seen {
-			seenInBatch[pdsEndpoint] = &op
-		}
-	}
+	for key, firstOp := range seenInBatch {
+		parts := strings.SplitN(key, ":", 2)
+		endpointType := parts[0]
+		endpoint := parts[1]
 
-	for pdsEndpoint, firstOp := range seenInBatch {
-		exists, err := s.db.PDSExists(ctx, pdsEndpoint)
+		exists, err := s.db.EndpointExists(ctx, endpoint, endpointType)
 		if err != nil || exists {
 			continue
 		}
 
-		if err := s.db.UpsertPDS(ctx, &storage.PDS{
-			Endpoint:     pdsEndpoint,
+		if err := s.db.UpsertEndpoint(ctx, &storage.Endpoint{
+			EndpointType: endpointType,
+			Endpoint:     endpoint,
 			DiscoveredAt: firstOp.CreatedAt,
 			LastChecked:  time.Time{},
-			Status:       storage.PDSStatusUnknown,
+			Status:       storage.EndpointStatusUnknown,
 		}); err != nil {
-			log.Error("Error storing PDS %s: %v", stripansi.Strip(pdsEndpoint), err)
+			log.Error("Error storing %s endpoint %s: %v", endpointType, endpoint, err)
 			continue
 		}
 
-		log.Info("✓ Discovered new PDS: %s", stripansi.Strip(pdsEndpoint))
-		newPDSCount++
+		log.Info("✓ Discovered new %s endpoint: %s", endpointType, endpoint)
+		newEndpointCount++
 	}
 
-	return newPDSCount, nil
+	return newEndpointCount, nil
 }
 
-func (s *Scanner) extractPDSFromOperation(op PLCOperation) string {
+// extractEndpointsFromOperation extracts ALL service endpoints
+func (s *Scanner) extractEndpointsFromOperation(op PLCOperation) []EndpointInfo {
+	var endpoints []EndpointInfo
+
 	if services, ok := op.Operation["services"].(map[string]interface{}); ok {
+		// Extract PDS
 		if atprotoPDS, ok := services["atproto_pds"].(map[string]interface{}); ok {
 			if endpoint, ok := atprotoPDS["endpoint"].(string); ok {
 				if svcType, ok := atprotoPDS["type"].(string); ok {
 					if svcType == "AtprotoPersonalDataServer" {
-						return endpoint
+						endpoints = append(endpoints, EndpointInfo{
+							Type:     "pds",
+							Endpoint: endpoint,
+						})
+					}
+				}
+			}
+		}
+
+		// Extract Labeler
+		if atprotoLabeler, ok := services["atproto_labeler"].(map[string]interface{}); ok {
+			if endpoint, ok := atprotoLabeler["endpoint"].(string); ok {
+				if svcType, ok := atprotoLabeler["type"].(string); ok {
+					if svcType == "AtprotoLabeler" {
+						endpoints = append(endpoints, EndpointInfo{
+							Type:     "labeler",
+							Endpoint: endpoint,
+						})
 					}
 				}
 			}
 		}
+
+		// Add more service types as needed...
 	}
-	return ""
+
+	return endpoints
 }
 
 func contains(s, substr string) bool {

internal/plc/types.go

···
 	Current    *PLCOperation     `json:"current"`
 	Operations []DIDHistoryEntry `json:"operations"`
 }
+
+type EndpointInfo struct {
+	Type     string
+	Endpoint string
+}

internal/storage/db.go

···
 	Close() error
 	Migrate() error
 
-	// PDS operations
-	UpsertPDS(ctx context.Context, pds *PDS) error
-	GetPDS(ctx context.Context, endpoint string) (*PDS, error)
-	GetPDSByID(ctx context.Context, id int64) (*PDS, error)
-	GetPDSServers(ctx context.Context, filter *PDSFilter) ([]*PDS, error)
-	UpdatePDSStatus(ctx context.Context, pdsID int64, update *PDSUpdate) error
-	PDSExists(ctx context.Context, endpoint string) (bool, error)
-	GetPDSIDByEndpoint(ctx context.Context, endpoint string) (int64, error)
-	GetPDSScans(ctx context.Context, pdsID int64, limit int) ([]*PDSScan, error)
+	// Endpoint operations (renamed from PDS)
+	UpsertEndpoint(ctx context.Context, endpoint *Endpoint) error
+	GetEndpoint(ctx context.Context, endpoint string, endpointType string) (*Endpoint, error)
+	GetEndpointByID(ctx context.Context, id int64) (*Endpoint, error)
+	GetEndpoints(ctx context.Context, filter *EndpointFilter) ([]*Endpoint, error)
+	UpdateEndpointStatus(ctx context.Context, endpointID int64, update *EndpointUpdate) error
+	EndpointExists(ctx context.Context, endpoint string, endpointType string) (bool, error)
+	GetEndpointIDByEndpoint(ctx context.Context, endpoint string, endpointType string) (int64, error)
+	GetEndpointScans(ctx context.Context, endpointID int64, limit int) ([]*EndpointScan, error)
 
 	// Cursor operations
 	GetScanCursor(ctx context.Context, source string) (*ScanCursor, error)
···
 	// Bundle operations
 	CreateBundle(ctx context.Context, bundle *PLCBundle) error
 	GetBundleByNumber(ctx context.Context, bundleNumber int) (*PLCBundle, error)
-	// GetBundleByID removed - bundle_number IS the ID
 	GetBundles(ctx context.Context, limit int) ([]*PLCBundle, error)
 	GetBundlesForDID(ctx context.Context, did string) ([]*PLCBundle, error)
 	GetBundleStats(ctx context.Context) (int64, int64, error)
···
 	// Metrics
 	StorePLCMetrics(ctx context.Context, metrics *PLCMetrics) error
 	GetPLCMetrics(ctx context.Context, limit int) ([]*PLCMetrics, error)
-	GetPDSStats(ctx context.Context) (*PDSStats, error)
+	GetEndpointStats(ctx context.Context) (*EndpointStats, error)
 }

internal/storage/sqlite.go

···
 
 func (s *SQLiteDB) Migrate() error {
 	schema := `
-    -- PDS tables (same as before)
-    CREATE TABLE IF NOT EXISTS pds_servers (
+    -- Endpoints table (replaces pds_servers)
+    CREATE TABLE IF NOT EXISTS endpoints (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
-        endpoint TEXT UNIQUE NOT NULL,
+        endpoint_type TEXT NOT NULL DEFAULT 'pds',
+        endpoint TEXT NOT NULL,
         discovered_at TIMESTAMP NOT NULL,
         last_checked TIMESTAMP,
         status INTEGER DEFAULT 0,
         user_count INTEGER DEFAULT 0,
-        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        UNIQUE(endpoint_type, endpoint)
     );
 
-    CREATE INDEX IF NOT EXISTS idx_pds_endpoint ON pds_servers(endpoint);
-    CREATE INDEX IF NOT EXISTS idx_pds_status ON pds_servers(status);
-    CREATE INDEX IF NOT EXISTS idx_pds_user_count ON pds_servers(user_count);
+    CREATE INDEX IF NOT EXISTS idx_endpoints_type_endpoint ON endpoints(endpoint_type, endpoint);
+    CREATE INDEX IF NOT EXISTS idx_endpoints_status ON endpoints(status);
+    CREATE INDEX IF NOT EXISTS idx_endpoints_type ON endpoints(endpoint_type);
+    CREATE INDEX IF NOT EXISTS idx_endpoints_user_count ON endpoints(user_count);
 
+    -- Keep pds_scans table (or rename to endpoint_scans later)
     CREATE TABLE IF NOT EXISTS pds_scans (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         pds_id INTEGER NOT NULL,
···
         response_time REAL,
         scan_data TEXT,
         scanned_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        FOREIGN KEY (pds_id) REFERENCES pds_servers(id) ON DELETE CASCADE
+        FOREIGN KEY (pds_id) REFERENCES endpoints(id) ON DELETE CASCADE
     );
 
     CREATE INDEX IF NOT EXISTS idx_pds_scans_pds_id ON pds_scans(pds_id);
···
 	return count, totalSize, err
 }
 
-// UpsertPDS inserts or updates a PDS server
-func (s *SQLiteDB) UpsertPDS(ctx context.Context, pds *PDS) error {
+// UpsertEndpoint inserts or updates an endpoint
+func (s *SQLiteDB) UpsertEndpoint(ctx context.Context, endpoint *Endpoint) error {
 	query := `
-        INSERT INTO pds_servers (endpoint, discovered_at, last_checked, status)
-        VALUES (?, ?, ?, ?)
-        ON CONFLICT(endpoint) DO UPDATE SET
+        INSERT INTO endpoints (endpoint_type, endpoint, discovered_at, last_checked, status)
+        VALUES (?, ?, ?, ?, ?)
+        ON CONFLICT(endpoint_type, endpoint) DO UPDATE SET
             last_checked = excluded.last_checked
         RETURNING id
     `
-	err := s.db.QueryRowContext(ctx, query, pds.Endpoint, pds.DiscoveredAt, pds.LastChecked, pds.Status).Scan(&pds.ID)
+	err := s.db.QueryRowContext(ctx, query,
+		endpoint.EndpointType, endpoint.Endpoint, endpoint.DiscoveredAt,
+		endpoint.LastChecked, endpoint.Status).Scan(&endpoint.ID)
 	return err
 }
 
-// PDSExists checks if a PDS endpoint already exists
-func (s *SQLiteDB) PDSExists(ctx context.Context, endpoint string) (bool, error) {
-	query := "SELECT EXISTS(SELECT 1 FROM pds_servers WHERE endpoint = ?)"
+// EndpointExists checks if an endpoint already exists
+func (s *SQLiteDB) EndpointExists(ctx context.Context, endpoint string, endpointType string) (bool, error) {
+	query := "SELECT EXISTS(SELECT 1 FROM endpoints WHERE endpoint = ? AND endpoint_type = ?)"
 	var exists bool
-	err := s.db.QueryRowContext(ctx, query, endpoint).Scan(&exists)
+	err := s.db.QueryRowContext(ctx, query, endpoint, endpointType).Scan(&exists)
 	return exists, err
 }
 
-// GetPDSIDByEndpoint gets the ID for an endpoint
-func (s *SQLiteDB) GetPDSIDByEndpoint(ctx context.Context, endpoint string) (int64, error) {
-	query := "SELECT id FROM pds_servers WHERE endpoint = ?"
+// GetEndpointIDByEndpoint gets the ID for an endpoint
+func (s *SQLiteDB) GetEndpointIDByEndpoint(ctx context.Context, endpoint string, endpointType string) (int64, error) {
+	query := "SELECT id FROM endpoints WHERE endpoint = ? AND endpoint_type = ?"
 	var id int64
-	err := s.db.QueryRowContext(ctx, query, endpoint).Scan(&id)
+	err := s.db.QueryRowContext(ctx, query, endpoint, endpointType).Scan(&id)
 	return id, err
 }
 
-// GetPDS retrieves a PDS by endpoint
-func (s *SQLiteDB) GetPDS(ctx context.Context, endpoint string) (*PDS, error) {
+// GetEndpoint retrieves an endpoint by endpoint string and type
+func (s *SQLiteDB) GetEndpoint(ctx context.Context, endpoint string, endpointType string) (*Endpoint, error) {
 	query := `
-        SELECT id, endpoint, discovered_at, last_checked, status, user_count, updated_at
-        FROM pds_servers 
-        WHERE endpoint = ?
+        SELECT id, endpoint_type, endpoint, discovered_at, last_checked, status, user_count, updated_at
+        FROM endpoints 
+        WHERE endpoint = ? AND endpoint_type = ?
     `
 
-	var pds PDS
+	var ep Endpoint
 	var lastChecked sql.NullTime
 
-	err := s.db.QueryRowContext(ctx, query, endpoint).Scan(
-		&pds.ID, &pds.Endpoint, &pds.DiscoveredAt, &lastChecked,
-		&pds.Status, &pds.UserCount, &pds.UpdatedAt,
+	err := s.db.QueryRowContext(ctx, query, endpoint, endpointType).Scan(
+		&ep.ID, &ep.EndpointType, &ep.Endpoint, &ep.DiscoveredAt, &lastChecked,
+		&ep.Status, &ep.UserCount, &ep.UpdatedAt,
 	)
 	if err != nil {
 		return nil, err
 	}
 
 	if lastChecked.Valid {
-		pds.LastChecked = lastChecked.Time
+		ep.LastChecked = lastChecked.Time
 	}
 
-	return &pds, nil
+	return &ep, nil
 }
 
-// GetPDSByID retrieves a PDS by ID
-func (s *SQLiteDB) GetPDSByID(ctx context.Context, id int64) (*PDS, error) {
+// GetEndpointByID retrieves an endpoint by ID
+func (s *SQLiteDB) GetEndpointByID(ctx context.Context, id int64) (*Endpoint, error) {
 	query := `
-        SELECT id, endpoint, discovered_at, last_checked, status, user_count, updated_at
-        FROM pds_servers 
+        SELECT id, endpoint_type, endpoint, discovered_at, last_checked, status, user_count, updated_at
+        FROM endpoints 
         WHERE id = ?
     `
 
-	var pds PDS
+	var ep Endpoint
 	var lastChecked sql.NullTime
 
 	err := s.db.QueryRowContext(ctx, query, id).Scan(
-		&pds.ID, &pds.Endpoint, &pds.DiscoveredAt, &lastChecked,
-		&pds.Status, &pds.UserCount, &pds.UpdatedAt,
+		&ep.ID, &ep.EndpointType, &ep.Endpoint, &ep.DiscoveredAt, &lastChecked,
+		&ep.Status, &ep.UserCount, &ep.UpdatedAt,
 	)
 	if err != nil {
 		return nil, err
 	}
 
 	if lastChecked.Valid {
-		pds.LastChecked = lastChecked.Time
+		ep.LastChecked = lastChecked.Time
 	}
 
-	return &pds, nil
+	return &ep, nil
 }
 
-// GetPDSServers retrieves multiple PDS servers
-func (s *SQLiteDB) GetPDSServers(ctx context.Context, filter *PDSFilter) ([]*PDS, error) {
+// GetEndpoints retrieves multiple endpoints
+func (s *SQLiteDB) GetEndpoints(ctx context.Context, filter *EndpointFilter) ([]*Endpoint, error) {
 	query := `
-        SELECT id, endpoint, discovered_at, last_checked, status, user_count, updated_at
-        FROM pds_servers
+        SELECT id, endpoint_type, endpoint, discovered_at, last_checked, status, user_count, updated_at
+        FROM endpoints
+        WHERE 1=1
     `
 	args := []interface{}{}
 
-	if filter != nil && filter.Status != "" {
-		// Map string status to int
-		statusInt := PDSStatusUnknown
-		switch filter.Status {
-		case "online":
-			statusInt = PDSStatusOnline
-		case "offline":
-			statusInt = PDSStatusOffline
+	if filter != nil {
+		if filter.Type != "" {
+			query += " AND endpoint_type = ?"
+			args = append(args, filter.Type)
 		}
-		query += " WHERE status = ?"
-		args = append(args, statusInt)
+		if filter.Status != "" {
+			statusInt := EndpointStatusUnknown
+			switch filter.Status {
+			case "online":
+				statusInt = EndpointStatusOnline
+			case "offline":
+				statusInt = EndpointStatusOffline
+			}
+			query += " AND status = ?"
+			args = append(args, statusInt)
+		}
+		if filter.MinUserCount > 0 {
+			query += " AND user_count >= ?"
+			args = append(args, filter.MinUserCount)
+		}
 	}
 
 	query += " ORDER BY user_count DESC"
···
 	}
 	defer rows.Close()
 
-	var servers []*PDS
+	var endpoints []*Endpoint
 	for rows.Next() {
-		var pds PDS
+		var ep Endpoint
 		var lastChecked sql.NullTime
 
 		err := rows.Scan(
-			&pds.ID, &pds.Endpoint, &pds.DiscoveredAt, &lastChecked,
-			&pds.Status, &pds.UserCount, &pds.UpdatedAt,
+			&ep.ID, &ep.EndpointType, &ep.Endpoint, &ep.DiscoveredAt, &lastChecked,
+			&ep.Status, &ep.UserCount, &ep.UpdatedAt,
 		)
 		if err != nil {
 			return nil, err
 		}
 
 		if lastChecked.Valid {
-			pds.LastChecked = lastChecked.Time
+			ep.LastChecked = lastChecked.Time
 		}
 
-		servers = append(servers, &pds)
+		endpoints = append(endpoints, &ep)
 	}
 
-	return servers, rows.Err()
+	return endpoints, rows.Err()
 }
 
-// UpdatePDSStatus updates the status and creates a scan record
-func (s *SQLiteDB) UpdatePDSStatus(ctx context.Context, pdsID int64, update *PDSUpdate) error {
+// UpdateEndpointStatus updates the status and creates a scan record
+func (s *SQLiteDB) UpdateEndpointStatus(ctx context.Context, endpointID int64, update *EndpointUpdate) error {
 	tx, err := s.db.BeginTx(ctx, nil)
 	if err != nil {
 		return err
···
 		userCount = update.ScanData.DIDCount
 	}
 
-	// Update main pds_servers record
+	// Update main endpoints record
 	query := `
-        UPDATE pds_servers 
+        UPDATE endpoints 
         SET status = ?, last_checked = ?, user_count = ?, updated_at = ?
         WHERE id = ?
     `
-	_, err = tx.ExecContext(ctx, query, update.Status, update.LastChecked, userCount, time.Now(), pdsID)
+	_, err = tx.ExecContext(ctx, query, update.Status, update.LastChecked, userCount, time.Now(), endpointID)
 	if err != nil {
 		return err
 	}
···
 		scanDataJSON, _ = json.Marshal(update.ScanData)
 	}
 
-	// Insert scan history
+	// Insert scan history (reuse pds_scans table or rename it to endpoint_scans)
 	scanQuery := `
         INSERT INTO pds_scans (pds_id, status, response_time, scan_data)
         VALUES (?, ?, ?, ?)
     `
-	_, err = tx.ExecContext(ctx, scanQuery, pdsID, update.Status, update.ResponseTime, string(scanDataJSON))
+	_, err = tx.ExecContext(ctx, scanQuery, endpointID, update.Status, update.ResponseTime, string(scanDataJSON))
 	if err != nil {
 		return err
 	}
···
 	return tx.Commit()
 }
 
-// GetPDSScans retrieves scan history for a PDS
-func (s *SQLiteDB) GetPDSScans(ctx context.Context, pdsID int64, limit int) ([]*PDSScan, error) {
+// GetEndpointScans retrieves scan history for an endpoint
+func (s *SQLiteDB) GetEndpointScans(ctx context.Context, endpointID int64, limit int) ([]*EndpointScan, error) {
 	query := `
         SELECT id, pds_id, status, response_time, scan_data, scanned_at
         FROM pds_scans
···
         LIMIT ?
     `
 
-	rows, err := s.db.QueryContext(ctx, query, pdsID, limit)
+	rows, err := s.db.QueryContext(ctx, query, endpointID, limit)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
 
-	var scans []*PDSScan
+	var scans []*EndpointScan
 	for rows.Next() {
-		var scan PDSScan
+		var scan EndpointScan
 		var responseTime sql.NullFloat64
 		var scanDataJSON sql.NullString
 
-		err := rows.Scan(&scan.ID, &scan.PDSID, &scan.Status, &responseTime, &scanDataJSON, &scan.ScannedAt)
+		err := rows.Scan(&scan.ID, &scan.EndpointID, &scan.Status, &responseTime, &scanDataJSON, &scan.ScannedAt)
 		if err != nil {
 			return nil, err
 		}
···
 		}
 
 		if scanDataJSON.Valid && scanDataJSON.String != "" {
-			var scanData PDSScanData
+			var scanData EndpointScanData
 			if err := json.Unmarshal([]byte(scanDataJSON.String), &scanData); err == nil {
 				scan.ScanData = &scanData
 			}
···
 	return scans, rows.Err()
 }
 
-// GetPDSStats returns aggregate statistics
-func (s *SQLiteDB) GetPDSStats(ctx context.Context) (*PDSStats, error) {
+// GetEndpointStats returns aggregate statistics about all endpoints
+func (s *SQLiteDB) GetEndpointStats(ctx context.Context) (*EndpointStats, error) {
 	query := `
         SELECT 
-            COUNT(*) as total_pds,
-            SUM(CASE WHEN status = 1 THEN 1 ELSE 0 END) as online_pds,
-            SUM(CASE WHEN status = 2 THEN 1 ELSE 0 END) as offline_pds,
+            COUNT(*) as total_endpoints,
+            SUM(CASE WHEN status = 1 THEN 1 ELSE 0 END) as online_endpoints,
+            SUM(CASE WHEN status = 2 THEN 1 ELSE 0 END) as offline_endpoints,
             (SELECT AVG(response_time) FROM pds_scans WHERE response_time > 0 
              AND scanned_at > datetime('now', '-1 hour')) as avg_response_time,
             SUM(user_count) as total_dids
-        FROM pds_servers
+        FROM endpoints
     `
 
-	var stats PDSStats
+	var stats EndpointStats
 	var avgResponseTime sql.NullFloat64
 
 	err := s.db.QueryRowContext(ctx, query).Scan(
-		&stats.TotalPDS, &stats.OnlinePDS, &stats.OfflinePDS, &avgResponseTime, &stats.TotalDIDs,
+		&stats.TotalEndpoints, &stats.OnlineEndpoints, &stats.OfflineEndpoints,
+		&avgResponseTime, &stats.TotalDIDs,
 	)
 
 	if avgResponseTime.Valid {
 		stats.AvgResponseTime = avgResponseTime.Float64
+	}
+
+	// Get counts by type
+	typeQuery := `
+        SELECT endpoint_type, COUNT(*) 
+        FROM endpoints 
+        GROUP BY endpoint_type
+    `
+	rows, err := s.db.QueryContext(ctx, typeQuery)
+	if err == nil {
+		defer rows.Close()
+		stats.ByType = make(map[string]int64)
+		for rows.Next() {
+			var typ string
+			var count int64
+			if err := rows.Scan(&typ, &count); err == nil {
+				stats.ByType[typ] = count
+			}
+		}
 	}
 
 	return &stats, err

internal/storage/types.go

···
 	UpdatedAt   time.Time
 }
 
-// PDS represents a Personal Data Server
-type PDS struct {
-	ID           int64  // NEW: Primary key
-	Endpoint     string // UNIQUE but not primary key
+// Endpoint represents any AT Protocol service endpoint
+type Endpoint struct {
+	ID           int64
+	EndpointType string // "pds", "labeler", etc.
+	Endpoint     string
 	DiscoveredAt time.Time
 	LastChecked  time.Time
-	Status       int // 0=unknown, 1=online, 2=offline
+	Status       int
 	UserCount    int64
 	UpdatedAt    time.Time
 }
 
-// PDSUpdate contains fields to update for a PDS
-type PDSUpdate struct {
+// EndpointUpdate contains fields to update for an Endpoint
+type EndpointUpdate struct {
 	Status       int
 	LastChecked  time.Time
-	ResponseTime float64 // milliseconds as float
-	ScanData     *PDSScanData
+	ResponseTime float64
+	ScanData     *EndpointScanData
 }
 
-// PDSScanData contains data from a PDS scan
-type PDSScanData struct {
+// EndpointScanData contains data from an endpoint scan
+type EndpointScanData struct {
 	ServerInfo interface{} `json:"server_info,omitempty"`
 	DIDs       []string    `json:"dids,omitempty"`
 	DIDCount   int         `json:"did_count"`
+	Metadata   interface{} `json:"metadata,omitempty"` // Type-specific metadata
 }
 
-// PDSScan represents a historical PDS scan
-type PDSScan struct {
+// EndpointScan represents a historical endpoint scan
+type EndpointScan struct {
 	ID           int64
-	PDSID        int64
+	EndpointID   int64
 	Status       int
 	ResponseTime float64
-	ScanData     *PDSScanData
+	ScanData     *EndpointScanData
 	ScannedAt    time.Time
 }
 
···
 	PDSStatusOffline = 2
 )
 
-// PDSFilter for querying PDS servers
-type PDSFilter struct {
+// Endpoint status constants (aliases for compatibility)
+const (
+	EndpointStatusUnknown = PDSStatusUnknown
+	EndpointStatusOnline  = PDSStatusOnline
+	EndpointStatusOffline = PDSStatusOffline
+)
+
+// EndpointFilter for querying endpoints
+type EndpointFilter struct {
+	Type         string // "pds", "labeler", etc.
 	Status       string
 	MinUserCount int64
 	Limit        int
 	Offset       int
 }
 
-// PDSStats contains aggregate statistics about PDS servers
-type PDSStats struct {
-	TotalPDS        int64   `json:"total_pds"`
-	UniquePDS       int64   `json:"unique_pds"`
-	OnlinePDS       int64   `json:"online_pds"`
-	OfflinePDS      int64   `json:"offline_pds"`
-	AvgResponseTime float64 `json:"avg_response_time"`
-	TotalDIDs       int64   `json:"total_dids"`
+// EndpointStats contains aggregate statistics about endpoints
+type EndpointStats struct {
+	TotalEndpoints   int64            `json:"total_endpoints"`
+	ByType           map[string]int64 `json:"by_type"`
+	OnlineEndpoints  int64            `json:"online_endpoints"`
+	OfflineEndpoints int64            `json:"offline_endpoints"`
+	AvgResponseTime  float64          `json:"avg_response_time"`
+	TotalDIDs        int64            `json:"total_dids"` // Only for PDS
 }
 
+// Legacy type aliases for backward compatibility in code
+type PDS = Endpoint
+type PDSUpdate = EndpointUpdate
+type PDSScanData = EndpointScanData
+type PDSScan = EndpointScan
+type PDSFilter = EndpointFilter
+type PDSStats = EndpointStats
+
 // PLCMetrics contains metrics from PLC directory scans
 type PLCMetrics struct {
 	TotalDIDs    int64     `json:"total_dids"`
···
 
 // PLCBundle represents a cached bundle of PLC operations
 type PLCBundle struct {
-	BundleNumber   int // PRIMARY KEY
+	BundleNumber   int
 	StartTime      time.Time
 	EndTime        time.Time
 	BoundaryCIDs   []string
 	DIDs           []string
-	Hash           string // SHA256 of uncompressed JSONL (verifiable against PLC)
-	CompressedHash string // SHA256 of compressed file on disk
-	CompressedSize int64  // Size of compressed file in bytes
-	PrevBundleHash string // Hash of previous bundle (for chain)
+	Hash           string
+	CompressedHash string
+	CompressedSize int64
+	PrevBundleHash string
 	Compressed     bool
 	CreatedAt      time.Time
 }
···
 	return filepath.Join(bundleDir, fmt.Sprintf("%06d.jsonl.zst", b.BundleNumber))
 }
 
-// OperationCount() returns 1000 (all bundles have exactly 1000 operations)
+// OperationCount returns the number of operations in a bundle (always 10000)
 func (b *PLCBundle) OperationCount() int {
-	return 1000
+	return 10000
 }
 
 // MempoolOperation represents an operation waiting to be bundled
 type MempoolOperation struct {
 	ID        int64
 	DID       string
-	Operation string // JSON of the full operation
+	Operation string
 	CID       string
 	CreatedAt time.Time
 	AddedAt   time.Time
 }
 
-// ScanCursor now stores bundle number
+// ScanCursor stores scanning progress
 type ScanCursor struct {
 	Source           string
-	LastBundleNumber int // NEW: Last processed bundle number
+	LastBundleNumber int
 	LastScanTime     time.Time
 	RecordsProcessed int64
 }