update

config.yaml

···
 
 plc:
   directory_url: "https://plc.directory"
-  scan_interval: "10s"
+  scan_interval: "5s"
   bundle_dir: "./plc_bundles"
   use_cache: true
 

internal/api/handlers.go

···
 	})
 }
 
+func (s *Server) handleDownloadPLCBundle(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	vars := mux.Vars(r)
+
+	bundleNumber, err := strconv.Atoi(vars["number"])
+	if err != nil {
+		http.Error(w, "invalid bundle number", http.StatusBadRequest)
+		return
+	}
+
+	// Verify bundle exists in database
+	bundle, err := s.db.GetBundleByNumber(ctx, bundleNumber)
+	if err != nil {
+		http.Error(w, "bundle not found", http.StatusNotFound)
+		return
+	}
+
+	// Build file path
+	filePath := filepath.Join(s.plcBundleDir, fmt.Sprintf("%06d.jsonl.zst", bundleNumber))
+
+	// Check if file exists
+	fileInfo, err := os.Stat(filePath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			http.Error(w, "bundle file not found on disk", http.StatusNotFound)
+			return
+		}
+		http.Error(w, fmt.Sprintf("error accessing bundle file: %v", err), http.StatusInternalServerError)
+		return
+	}
+
+	// Open file
+	file, err := os.Open(filePath)
+	if err != nil {
+		http.Error(w, fmt.Sprintf("error opening bundle file: %v", err), http.StatusInternalServerError)
+		return
+	}
+	defer file.Close()
+
+	// Set headers
+	w.Header().Set("Content-Type", "application/zstd")
+	w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=%06d.jsonl.zst", bundleNumber))
+	w.Header().Set("Content-Length", fmt.Sprintf("%d", fileInfo.Size()))
+	w.Header().Set("X-Bundle-Number", fmt.Sprintf("%d", bundleNumber))
+	w.Header().Set("X-Bundle-Hash", bundle.Hash)
+	w.Header().Set("X-Bundle-Compressed-Hash", bundle.CompressedHash)
+	w.Header().Set("X-Bundle-Start-Time", bundle.StartTime.Format(time.RFC3339Nano))
+	w.Header().Set("X-Bundle-End-Time", bundle.EndTime.Format(time.RFC3339Nano))
+	w.Header().Set("X-Bundle-Operation-Count", fmt.Sprintf("%d", plc.BUNDLE_SIZE))
+	w.Header().Set("X-Bundle-DID-Count", fmt.Sprintf("%d", len(bundle.DIDs)))
+
+	// Stream the file
+	http.ServeContent(w, r, filepath.Base(filePath), bundle.CreatedAt, file)
+}
+
 func (s *Server) handleGetMempoolStats(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
 
···
 		return
 	}
 
-	respondJSON(w, map[string]interface{}{
+	response := map[string]interface{}{
 		"operation_count":   count,
-		"can_create_bundle": count >= 1000,
-	})
+		"can_create_bundle": count >= plc.BUNDLE_SIZE,
+	}
+
+	// Get mempool start time (first item)
+	if count > 0 {
+		firstOp, err := s.db.GetFirstMempoolOperation(ctx)
+		if err == nil && firstOp != nil {
+			response["mempool_start_time"] = firstOp.CreatedAt
+
+			// Calculate estimated next bundle time
+			if count < plc.BUNDLE_SIZE {
+				lastOp, err := s.db.GetLastMempoolOperation(ctx)
+				if err == nil && lastOp != nil {
+					// Calculate rate of operations per second
+					timeSpan := lastOp.CreatedAt.Sub(firstOp.CreatedAt).Seconds()
+
+					if timeSpan > 0 {
+						opsPerSecond := float64(count) / timeSpan
+
+						if opsPerSecond > 0 {
+							remainingOps := plc.BUNDLE_SIZE - count
+							secondsNeeded := float64(remainingOps) / opsPerSecond
+							estimatedTime := time.Now().Add(time.Duration(secondsNeeded) * time.Second)
+
+							response["estimated_next_bundle_time"] = estimatedTime
+							response["operations_needed"] = remainingOps
+							response["current_rate_per_second"] = opsPerSecond
+						}
+					}
+				}
+			} else {
+				// Bundle can be created now
+				response["estimated_next_bundle_time"] = time.Now()
+				response["operations_needed"] = 0
+			}
+		}
+	} else {
+		response["mempool_start_time"] = nil
+		response["estimated_next_bundle_time"] = nil
+	}
+
+	respondJSON(w, response)
 }
 
 // Helper to load bundle operations - UPDATED FOR JSONL FORMAT

internal/api/server.go

···
 	api.HandleFunc("/plc/bundles/chain", s.handleGetChainInfo).Methods("GET")
 	api.HandleFunc("/plc/bundles/verify-chain", s.handleVerifyChain).Methods("POST")
 	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")
 	api.HandleFunc("/plc/export", s.handlePLCExport).Methods("GET")

internal/storage/db.go

···
 	GetMempoolCount(ctx context.Context) (int, error)
 	GetMempoolOperations(ctx context.Context, limit int) ([]MempoolOperation, error)
 	DeleteFromMempool(ctx context.Context, ids []int64) error
+	GetFirstMempoolOperation(ctx context.Context) (*MempoolOperation, error)
 	GetLastMempoolOperation(ctx context.Context) (*MempoolOperation, error)
 
 	// Metrics

internal/storage/sqlite.go

···
 	return err
 }
 
+// GetFirstMempoolOperation retrieves the oldest operation from mempool
+func (s *SQLiteDB) GetFirstMempoolOperation(ctx context.Context) (*MempoolOperation, error) {
+	query := `
+        SELECT id, did, operation, cid, created_at, added_at
+        FROM plc_mempool
+        ORDER BY created_at ASC, id ASC
+        LIMIT 1
+    `
+
+	var op MempoolOperation
+	err := s.db.QueryRowContext(ctx, query).Scan(
+		&op.ID, &op.DID, &op.Operation, &op.CID, &op.CreatedAt, &op.AddedAt,
+	)
+	if err == sql.ErrNoRows {
+		return nil, nil // No operations in mempool
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	return &op, nil
+}
+
 // GetLastMempoolOperation retrieves the most recent operation from mempool
 func (s *SQLiteDB) GetLastMempoolOperation(ctx context.Context) (*MempoolOperation, error) {
 	query := `

utils/check-order.sh

···
-pv plc_cache/*.jsonl.zst | zstdcat | \
+pv plc_bundles/*.jsonl.zst | zstdcat | \
   jq -r '.createdAt' | \
   awk '
     NR > 1 && $0 < prev {