update

config.yaml

···
   scan_interval: "5s"
   bundle_dir: "./plc_bundles"
   use_cache: true
+  index_dids: true
 
 pds:
   scan_interval: "15m"

internal/api/handlers.go

···
 	didRecord, err := s.db.GetDIDRecord(r.Context(), did)
 	if err != nil {
 		if err == sql.ErrNoRows {
-			resp.error("DID not found", http.StatusNotFound)
+			// NEW: Provide helpful message if indexing is disabled
+			resp.error("DID not found. Note: DID indexing may be disabled in configuration.", http.StatusNotFound)
 		} else {
 			resp.error(err.Error(), http.StatusInternalServerError)
 		}

internal/api/server.go

···
 }
 
 func NewServer(db storage.Database, apiCfg config.APIConfig, plcCfg config.PLCConfig) *Server {
-	bundleManager, _ := plc.NewBundleManager(plcCfg.BundleDir, plcCfg.UseCache, db)
+	bundleManager, _ := plc.NewBundleManager(plcCfg.BundleDir, plcCfg.UseCache, db, plcCfg.IndexDIDs)
 
 	s := &Server{
 		router:        mux.NewRouter(),

internal/config/config.go

···
 	DirectoryURL string        `yaml:"directory_url"`
 	ScanInterval time.Duration `yaml:"scan_interval"`
 	BatchSize    int           `yaml:"batch_size"`
-	BundleDir    string        `yaml:"bundles_dir"` // NEW: Cache directory
-	UseCache     bool          `yaml:"use_cache"`   // NEW: Enable/disable cache
+	BundleDir    string        `yaml:"bundles_dir"`
+	UseCache     bool          `yaml:"use_cache"`
+	IndexDIDs    bool          `yaml:"index_dids"`
 }
 
 type PDSConfig struct {

internal/plc/bundle.go

···
 const BUNDLE_SIZE = 10000
 
 type BundleManager struct {
-	dir     string
-	enabled bool
-	encoder *zstd.Encoder
-	decoder *zstd.Decoder
-	db      storage.Database
+	dir       string
+	enabled   bool
+	encoder   *zstd.Encoder
+	decoder   *zstd.Decoder
+	db        storage.Database
+	indexDIDs bool
 }
 
 // ===== INITIALIZATION =====
 
-func NewBundleManager(dir string, enabled bool, db storage.Database) (*BundleManager, error) {
+func NewBundleManager(dir string, enabled bool, db storage.Database, indexDIDs bool) (*BundleManager, error) {
 	if !enabled {
 		return &BundleManager{enabled: false}, nil
 	}
···
 	}
 
 	return &BundleManager{
-		dir:     dir,
-		enabled: enabled,
-		encoder: encoder,
-		decoder: decoder,
-		db:      db,
+		dir:       dir,
+		enabled:   enabled,
+		encoder:   encoder,
+		decoder:   decoder,
+		db:        db,
+		indexDIDs: indexDIDs, // NEW
 	}, nil
 }
 
···
 		return err
 	}
 
-	start := time.Now()
-	// Index DIDs synchronously (will use bulk inserts for speed)
-	if err := bm.db.AddBundleDIDs(ctx, bundleNum, dids); err != nil {
-		log.Error("Failed to index DIDs for bundle %06d: %v", bundleNum, err)
-		// Don't return error - bundle is already created
-		// DID indexing can be retried later
+	// NEW: Only index DIDs if enabled
+	if bm.indexDIDs {
+		start := time.Now()
+		if err := bm.db.AddBundleDIDs(ctx, bundleNum, dids); err != nil {
+			log.Error("Failed to index DIDs for bundle %06d: %v", bundleNum, err)
+			// Don't return error - bundle is already created
+		} else {
+			elapsed := time.Since(start)
+			log.Verbose("✓ Indexed %d unique DIDs for bundle %06d in %v", len(dids), bundleNum, elapsed)
+		}
 	} else {
-		elapsed := time.Since(start)
-		log.Verbose("✓ Indexed %d unique DIDs for bundle %06d in %v", len(dids), bundleNum, elapsed)
+		log.Verbose("⊘ Skipped DID indexing for bundle %06d (disabled in config)", bundleNum)
 	}
 
 	return nil

internal/plc/scanner.go

···
 }
 
 func NewScanner(db storage.Database, cfg config.PLCConfig) *Scanner {
-	bundleManager, err := NewBundleManager(cfg.BundleDir, cfg.UseCache, db)
+	bundleManager, err := NewBundleManager(cfg.BundleDir, cfg.UseCache, db, cfg.IndexDIDs) // NEW: pass IndexDIDs
 	if err != nil {
 		log.Error("Warning: failed to initialize bundle manager: %v", err)
 		bundleManager = &BundleManager{enabled: false}