update

internal/api/handlers.go

···
 			"scanned_at": scan.ScannedAt,
 		}
 
+		if scan.Status != storage.EndpointStatusOnline && scan.ScanData != nil && scan.ScanData.Metadata != nil {
+			if errorMsg, ok := scan.ScanData.Metadata["error"].(string); ok && errorMsg != "" {
+				scanMap["error"] = errorMsg
+			}
+		}
+
 		if scan.ResponseTime > 0 {
 			scanMap["response_time"] = scan.ResponseTime
 		}
···
 	}
 
 	resp.json(result)
+}
+
+// ===== DEBUG HANDLERS =====
+
+func (s *Server) handleGetDBSizes(w http.ResponseWriter, r *http.Request) {
+	resp := newResponse(w)
+	ctx := r.Context()
+	schema := "public" // Or make configurable if needed
+
+	tableSizes, err := s.db.GetTableSizes(ctx, schema)
+	if err != nil {
+		log.Error("Failed to get table sizes: %v", err)
+		resp.error("Failed to retrieve table sizes", http.StatusInternalServerError)
+		return
+	}
+
+	indexSizes, err := s.db.GetIndexSizes(ctx, schema)
+	if err != nil {
+		log.Error("Failed to get index sizes: %v", err)
+		resp.error("Failed to retrieve index sizes", http.StatusInternalServerError)
+		return
+	}
+
+	resp.json(map[string]interface{}{
+		"schema":      schema,
+		"tables":      tableSizes,
+		"indexes":     indexSizes,
+		"retrievedAt": time.Now().UTC(),
+	})
 }
 
 // ===== UTILITY FUNCTIONS =====

internal/api/server.go

···
 	// Metrics routes
 	api.HandleFunc("/metrics/plc", s.handleGetPLCMetrics).Methods("GET")
 
-	// Job status endpoint
+	// Debug Endpoints
+	api.HandleFunc("/debug/db/sizes", s.handleGetDBSizes).Methods("GET")
 	api.HandleFunc("/jobs", s.handleGetJobStatus).Methods("GET")
 
 	// Health check

internal/storage/db.go

···
 	GetPDSRepos(ctx context.Context, endpointID int64, activeOnly bool, limit int, offset int) ([]*PDSRepo, error) // Updated
 	GetReposByDID(ctx context.Context, did string) ([]*PDSRepo, error)
 	GetPDSRepoStats(ctx context.Context, endpointID int64) (map[string]interface{}, error)
+
+	// Internal
+	GetTableSizes(ctx context.Context, schema string) ([]TableSizeInfo, error)
+	GetIndexSizes(ctx context.Context, schema string) ([]IndexSizeInfo, error)
 }

internal/storage/postgres.go

···
 		"recent_changes":    recentChanges,
 	}, nil
 }
+
+// GetTableSizes fetches size information (in bytes) for all tables in the specified schema.
+func (p *PostgresDB) GetTableSizes(ctx context.Context, schema string) ([]TableSizeInfo, error) {
+	// Query now selects raw byte values directly
+	query := `
+		SELECT
+			c.relname AS table_name,
+			pg_total_relation_size(c.oid) AS total_bytes,
+			pg_relation_size(c.oid) AS table_heap_bytes,
+			pg_indexes_size(c.oid) AS indexes_bytes
+		FROM
+			pg_class c
+		LEFT JOIN
+			pg_namespace n ON n.oid = c.relnamespace
+		WHERE
+			c.relkind = 'r' -- 'r' = ordinary table
+			AND n.nspname = $1
+		ORDER BY
+			total_bytes DESC;
+	`
+	rows, err := p.db.QueryContext(ctx, query, schema)
+	if err != nil {
+		return nil, fmt.Errorf("failed to query table sizes: %w", err)
+	}
+	defer rows.Close()
+
+	var results []TableSizeInfo
+	for rows.Next() {
+		var info TableSizeInfo
+		// Scan directly into int64 fields
+		if err := rows.Scan(
+			&info.TableName,
+			&info.TotalBytes,
+			&info.TableHeapBytes,
+			&info.IndexesBytes,
+		); err != nil {
+			return nil, fmt.Errorf("failed to scan table size row: %w", err)
+		}
+		results = append(results, info)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("error iterating table size rows: %w", err)
+	}
+
+	return results, nil
+}
+
+// GetIndexSizes fetches size information (in bytes) for all indexes in the specified schema.
+func (p *PostgresDB) GetIndexSizes(ctx context.Context, schema string) ([]IndexSizeInfo, error) {
+	// Query now selects raw byte values directly
+	query := `
+		SELECT
+			c.relname AS index_name,
+			COALESCE(i.indrelid::regclass::text, 'N/A') AS table_name,
+			pg_relation_size(c.oid) AS index_bytes
+		FROM
+			pg_class c
+		LEFT JOIN
+			pg_index i ON i.indexrelid = c.oid
+		LEFT JOIN
+			pg_namespace n ON n.oid = c.relnamespace
+		WHERE
+			c.relkind = 'i' -- 'i' = index
+			AND n.nspname = $1
+		ORDER BY
+			index_bytes DESC;
+	`
+	rows, err := p.db.QueryContext(ctx, query, schema)
+	if err != nil {
+		return nil, fmt.Errorf("failed to query index sizes: %w", err)
+	}
+	defer rows.Close()
+
+	var results []IndexSizeInfo
+	for rows.Next() {
+		var info IndexSizeInfo
+		var tableName sql.NullString
+		// Scan directly into int64 field
+		if err := rows.Scan(
+			&info.IndexName,
+			&tableName,
+			&info.IndexBytes,
+		); err != nil {
+			return nil, fmt.Errorf("failed to scan index size row: %w", err)
+		}
+		if tableName.Valid {
+			info.TableName = tableName.String
+		} else {
+			info.TableName = "N/A"
+		}
+		results = append(results, info)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("error iterating index size rows: %w", err)
+	}
+
+	return results, nil
+}

internal/storage/types.go

···
 package storage
 
 import (
+	"database/sql"
 	"fmt"
 	"path/filepath"
 	"time"
···
 // DIDRecord represents a DID entry in the database
 type DIDRecord struct {
 	DID           string    `json:"did"`
+	Handle        string    `json:"handle,omitempty"`
+	CurrentPDS    string    `json:"current_pds,omitempty"`
+	LastOpAt      time.Time `json:"last_op_at,omitempty"`
 	BundleNumbers []int     `json:"bundle_numbers"`
 	CreatedAt     time.Time `json:"created_at"`
+}
+
+// GlobalDIDInfo consolidates DID data from PLC and PDS tables
+type GlobalDIDInfo struct {
+	DIDRecord            // Embeds all fields: DID, Handle, CurrentPDS, etc.
+	HostingOn []*PDSRepo `json:"hosting_on"`
 }
 
 // IPInfo represents IP information (stored with IP as primary key)
···
 	Status string
 }
 
-type GlobalDIDInfo struct {
-	DIDRecord
-	HostingOn []*PDSRepo `json:"hosting_on"`
+type DIDBackfillInfo struct {
+	DID           string
+	LastBundleNum int
+}
+
+type DIDStateUpdateData struct {
+	DID    string
+	Handle sql.NullString // Use sql.NullString for potential NULLs
+	PDS    sql.NullString
+	OpTime time.Time
+}
+
+// TableSizeInfo holds size information for a database table.
+type TableSizeInfo struct {
+	TableName      string `json:"table_name"`
+	TotalBytes     int64  `json:"total_bytes"`      // Raw bytes
+	TableHeapBytes int64  `json:"table_heap_bytes"` // Raw bytes
+	IndexesBytes   int64  `json:"indexes_bytes"`    // Raw bytes
+}
+
+// IndexSizeInfo holds size information for a database index.
+type IndexSizeInfo struct {
+	IndexName  string `json:"index_name"`
+	TableName  string `json:"table_name"`
+	IndexBytes int64  `json:"index_bytes"` // Raw bytes
 }