appview: remove use of all fields under `ResolvedRepo`

Now `ResolvedRepo` is basically same to `models.Repo` so we can safely
remove it. (not included in this commit to make change reviewable size.)

Signed-off-by: Seongmin Lee <[e-mail]>

appview/issues/issues.go

···
 
 	rp.pages.RepoSingleIssue(w, pages.RepoSingleIssueParams{
 		LoggedInUser:         user,
-		RepoInfo:             f.RepoInfo(user),
+		RepoInfo:             rp.repoResolver.GetRepoInfo(r, user),
 		Issue:                issue,
 		CommentList:          issue.CommentList(),
 		OrderedReactionKinds: models.OrderedReactionKinds,
···
 func (rp *Issues) EditIssue(w http.ResponseWriter, r *http.Request) {
 	l := rp.logger.With("handler", "EditIssue")
 	user := rp.oauth.GetUser(r)
-	f, err := rp.repoResolver.Resolve(r)
-	if err != nil {
-		l.Error("failed to get repo and knot", "err", err)
-		return
-	}
 
 	issue, ok := r.Context().Value("issue").(*models.Issue)
 	if !ok {
···
 	case http.MethodGet:
 		rp.pages.EditIssueFragment(w, pages.EditIssueParams{
 			LoggedInUser: user,
-			RepoInfo:     f.RepoInfo(user),
+			RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),
 			Issue:        issue,
 		})
 	case http.MethodPost:
···
 func (rp *Issues) IssueComment(w http.ResponseWriter, r *http.Request) {
 	l := rp.logger.With("handler", "IssueComment")
 	user := rp.oauth.GetUser(r)
-	f, err := rp.repoResolver.Resolve(r)
-	if err != nil {
-		l.Error("failed to get repo and knot", "err", err)
-		return
-	}
 
 	issue, ok := r.Context().Value("issue").(*models.Issue)
 	if !ok {
···
 
 	rp.pages.IssueCommentBodyFragment(w, pages.IssueCommentBodyParams{
 		LoggedInUser: user,
-		RepoInfo:     f.RepoInfo(user),
+		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),
 		Issue:        issue,
 		Comment:      &comment,
 	})
···
 func (rp *Issues) EditIssueComment(w http.ResponseWriter, r *http.Request) {
 	l := rp.logger.With("handler", "EditIssueComment")
 	user := rp.oauth.GetUser(r)
-	f, err := rp.repoResolver.Resolve(r)
-	if err != nil {
-		l.Error("failed to get repo and knot", "err", err)
-		return
-	}
 
 	issue, ok := r.Context().Value("issue").(*models.Issue)
 	if !ok {
···
 	case http.MethodGet:
 		rp.pages.EditIssueCommentFragment(w, pages.EditIssueCommentParams{
 			LoggedInUser: user,
-			RepoInfo:     f.RepoInfo(user),
+			RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),
 			Issue:        issue,
 			Comment:      &comment,
 		})
···
 		// return new comment body with htmx
 		rp.pages.IssueCommentBodyFragment(w, pages.IssueCommentBodyParams{
 			LoggedInUser: user,
-			RepoInfo:     f.RepoInfo(user),
+			RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),
 			Issue:        issue,
 			Comment:      &newComment,
 		})
···
 func (rp *Issues) ReplyIssueCommentPlaceholder(w http.ResponseWriter, r *http.Request) {
 	l := rp.logger.With("handler", "ReplyIssueCommentPlaceholder")
 	user := rp.oauth.GetUser(r)
-	f, err := rp.repoResolver.Resolve(r)
-	if err != nil {
-		l.Error("failed to get repo and knot", "err", err)
-		return
-	}
 
 	issue, ok := r.Context().Value("issue").(*models.Issue)
 	if !ok {
···
 
 	rp.pages.ReplyIssueCommentPlaceholderFragment(w, pages.ReplyIssueCommentPlaceholderParams{
 		LoggedInUser: user,
-		RepoInfo:     f.RepoInfo(user),
+		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),
 		Issue:        issue,
 		Comment:      &comment,
 	})
···
 func (rp *Issues) ReplyIssueComment(w http.ResponseWriter, r *http.Request) {
 	l := rp.logger.With("handler", "ReplyIssueComment")
 	user := rp.oauth.GetUser(r)
-	f, err := rp.repoResolver.Resolve(r)
-	if err != nil {
-		l.Error("failed to get repo and knot", "err", err)
-		return
-	}
 
 	issue, ok := r.Context().Value("issue").(*models.Issue)
 	if !ok {
···
 
 	rp.pages.ReplyIssueCommentFragment(w, pages.ReplyIssueCommentParams{
 		LoggedInUser: user,
-		RepoInfo:     f.RepoInfo(user),
+		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),
 		Issue:        issue,
 		Comment:      &comment,
 	})
···
 func (rp *Issues) DeleteIssueComment(w http.ResponseWriter, r *http.Request) {
 	l := rp.logger.With("handler", "DeleteIssueComment")
 	user := rp.oauth.GetUser(r)
-	f, err := rp.repoResolver.Resolve(r)
-	if err != nil {
-		l.Error("failed to get repo and knot", "err", err)
-		return
-	}
 
 	issue, ok := r.Context().Value("issue").(*models.Issue)
 	if !ok {
···
 	// htmx fragment of comment after deletion
 	rp.pages.IssueCommentBodyFragment(w, pages.IssueCommentBodyParams{
 		LoggedInUser: user,
-		RepoInfo:     f.RepoInfo(user),
+		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),
 		Issue:        issue,
 		Comment:      &comment,
 	})
···
 
 	rp.pages.RepoIssues(w, pages.RepoIssuesParams{
 		LoggedInUser:    rp.oauth.GetUser(r),
-		RepoInfo:        f.RepoInfo(user),
+		RepoInfo:        rp.repoResolver.GetRepoInfo(r, user),
 		Issues:          issues,
 		IssueCount:      totalIssues,
 		LabelDefs:       defs,
···
 	case http.MethodGet:
 		rp.pages.RepoNewIssue(w, pages.RepoNewIssueParams{
 			LoggedInUser: user,
-			RepoInfo:     f.RepoInfo(user),
+			RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),
 		})
 	case http.MethodPost:
 		issue := &models.Issue{

appview/pipelines/pipelines.go

···
 
 	p.pages.Pipelines(w, pages.PipelinesParams{
 		LoggedInUser: user,
-		RepoInfo:     f.RepoInfo(user),
+		RepoInfo:     p.repoResolver.GetRepoInfo(r, user),
 		Pipelines:    ps,
 	})
 }
···
 
 	p.pages.Workflow(w, pages.WorkflowParams{
 		LoggedInUser: user,
-		RepoInfo:     f.RepoInfo(user),
+		RepoInfo:     p.repoResolver.GetRepoInfo(r, user),
 		Pipeline:     singlePipeline,
 		Workflow:     workflow,
 	})

appview/pulls/pulls.go

···
 
 		s.pages.PullActionsFragment(w, pages.PullActionsParams{
 			LoggedInUser:       user,
-			RepoInfo:           f.RepoInfo(user),
+			RepoInfo:           s.repoResolver.GetRepoInfo(r, user),
 			Pull:               pull,
 			RoundNumber:        roundNumber,
 			MergeCheck:         mergeCheckResponse,
···
 
 	s.pages.RepoSinglePull(w, pages.RepoSinglePullParams{
 		LoggedInUser:       user,
-		RepoInfo:           f.RepoInfo(user),
+		RepoInfo:           s.repoResolver.GetRepoInfo(r, user),
 		Pull:               pull,
 		Stack:              stack,
 		AbandonedPulls:     abandonedPulls,
···
 
 func (s *Pulls) RepoPullPatch(w http.ResponseWriter, r *http.Request) {
 	user := s.oauth.GetUser(r)
-	f, err := s.repoResolver.Resolve(r)
-	if err != nil {
-		log.Println("failed to get repo and knot", err)
-		return
-	}
 
 	var diffOpts types.DiffOpts
 	if d := r.URL.Query().Get("diff"); d == "split" {
···
 
 	s.pages.RepoPullPatchPage(w, pages.RepoPullPatchParams{
 		LoggedInUser: user,
-		RepoInfo:     f.RepoInfo(user),
+		RepoInfo:     s.repoResolver.GetRepoInfo(r, user),
 		Pull:         pull,
 		Stack:        stack,
 		Round:        roundIdInt,
···
 func (s *Pulls) RepoPullInterdiff(w http.ResponseWriter, r *http.Request) {
 	user := s.oauth.GetUser(r)
 
-	f, err := s.repoResolver.Resolve(r)
-	if err != nil {
-		log.Println("failed to get repo and knot", err)
-		return
-	}
-
 	var diffOpts types.DiffOpts
 	if d := r.URL.Query().Get("diff"); d == "split" {
 		diffOpts.Split = true
···
 
 	s.pages.RepoPullInterdiffPage(w, pages.RepoPullInterdiffParams{
 		LoggedInUser: s.oauth.GetUser(r),
-		RepoInfo:     f.RepoInfo(user),
+		RepoInfo:     s.repoResolver.GetRepoInfo(r, user),
 		Pull:         pull,
 		Round:        roundIdInt,
 		Interdiff:    interdiff,
···
 
 	s.pages.RepoPulls(w, pages.RepoPullsParams{
 		LoggedInUser: s.oauth.GetUser(r),
-		RepoInfo:     f.RepoInfo(user),
+		RepoInfo:     s.repoResolver.GetRepoInfo(r, user),
 		Pulls:        pulls,
 		LabelDefs:    defs,
 		FilteringBy:  state,
···
 	case http.MethodGet:
 		s.pages.PullNewCommentFragment(w, pages.PullNewCommentParams{
 			LoggedInUser: user,
-			RepoInfo:     f.RepoInfo(user),
+			RepoInfo:     s.repoResolver.GetRepoInfo(r, user),
 			Pull:         pull,
 			RoundNumber:  roundNumber,
 		})
···
 
 		s.pages.RepoNewPull(w, pages.RepoNewPullParams{
 			LoggedInUser: user,
-			RepoInfo:     f.RepoInfo(user),
+			RepoInfo:     s.repoResolver.GetRepoInfo(r, user),
 			Branches:     result.Branches,
 			Strategy:     strategy,
 			SourceBranch: sourceBranch,
···
 
 func (s *Pulls) PatchUploadFragment(w http.ResponseWriter, r *http.Request) {
 	user := s.oauth.GetUser(r)
-	f, err := s.repoResolver.Resolve(r)
-	if err != nil {
-		log.Println("failed to get repo and knot", err)
-		return
-	}
 
 	s.pages.PullPatchUploadFragment(w, pages.PullPatchUploadParams{
-		RepoInfo: f.RepoInfo(user),
+		RepoInfo: s.repoResolver.GetRepoInfo(r, user),
 	})
 }
 
···
 	}
 
 	s.pages.PullCompareBranchesFragment(w, pages.PullCompareBranchesParams{
-		RepoInfo: f.RepoInfo(user),
+		RepoInfo: s.repoResolver.GetRepoInfo(r, user),
 		Branches: withoutDefault,
 	})
 }
 
 func (s *Pulls) CompareForksFragment(w http.ResponseWriter, r *http.Request) {
 	user := s.oauth.GetUser(r)
-	f, err := s.repoResolver.Resolve(r)
-	if err != nil {
-		log.Println("failed to get repo and knot", err)
-		return
-	}
 
 	forks, err := db.GetForksByDid(s.db, user.Did)
 	if err != nil {
···
 	}
 
 	s.pages.PullCompareForkFragment(w, pages.PullCompareForkParams{
-		RepoInfo: f.RepoInfo(user),
+		RepoInfo: s.repoResolver.GetRepoInfo(r, user),
 		Forks:    forks,
 		Selected: r.URL.Query().Get("fork"),
 	})
···
 	})
 
 	s.pages.PullCompareForkBranchesFragment(w, pages.PullCompareForkBranchesParams{
-		RepoInfo:       f.RepoInfo(user),
+		RepoInfo:       s.repoResolver.GetRepoInfo(r, user),
 		SourceBranches: sourceBranches.Branches,
 		TargetBranches: targetBranches.Branches,
 	})
···
 
 func (s *Pulls) ResubmitPull(w http.ResponseWriter, r *http.Request) {
 	user := s.oauth.GetUser(r)
-	f, err := s.repoResolver.Resolve(r)
-	if err != nil {
-		log.Println("failed to get repo and knot", err)
-		return
-	}
 
 	pull, ok := r.Context().Value("pull").(*models.Pull)
 	if !ok {
···
 	switch r.Method {
 	case http.MethodGet:
 		s.pages.PullResubmitFragment(w, pages.PullResubmitParams{
-			RepoInfo: f.RepoInfo(user),
+			RepoInfo: s.repoResolver.GetRepoInfo(r, user),
 			Pull:     pull,
 		})
 		return

appview/repo/artifact.go

···
 
 	rp.pages.RepoArtifactFragment(w, pages.RepoArtifactParams{
 		LoggedInUser: user,
-		RepoInfo:     f.RepoInfo(user),
+		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),
 		Artifact:     artifact,
 	})
 }

appview/repo/blob.go

···
 
 	rp.pages.RepoBlob(w, pages.RepoBlobParams{
 		LoggedInUser:    user,
-		RepoInfo:        f.RepoInfo(user),
+		RepoInfo:        rp.repoResolver.GetRepoInfo(r, user),
 		BreadCrumbs:     breadcrumbs,
 		BlobView:        blobView,
 		RepoBlob_Output: resp,

appview/repo/branches.go

···
 	user := rp.oauth.GetUser(r)
 	rp.pages.RepoBranches(w, pages.RepoBranchesParams{
 		LoggedInUser:         user,
-		RepoInfo:             f.RepoInfo(user),
+		RepoInfo:             rp.repoResolver.GetRepoInfo(r, user),
 		RepoBranchesResponse: result,
 	})
 }

appview/repo/compare.go

···
 
 	rp.pages.RepoCompareNew(w, pages.RepoCompareNewParams{
 		LoggedInUser: user,
-		RepoInfo:     f.RepoInfo(user),
+		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),
 		Branches:     branches,
 		Tags:         tags.Tags,
 		Base:         base,
···
 
 	rp.pages.RepoCompare(w, pages.RepoCompareParams{
 		LoggedInUser: user,
-		RepoInfo:     f.RepoInfo(user),
+		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),
 		Branches:     branches.Branches,
 		Tags:         tags.Tags,
 		Base:         base,

appview/repo/index.go

···
 			rp.pages.RepoIndexPage(w, pages.RepoIndexParams{
 				LoggedInUser:     user,
 				NeedsKnotUpgrade: true,
-				RepoInfo:         f.RepoInfo(user),
+				RepoInfo:         rp.repoResolver.GetRepoInfo(r, user),
 			})
 			return
 		}
···
 
 	rp.pages.RepoIndexPage(w, pages.RepoIndexParams{
 		LoggedInUser:      user,
-		RepoInfo:          f.RepoInfo(user),
+		RepoInfo:          rp.repoResolver.GetRepoInfo(r, user),
 		TagMap:            tagMap,
 		RepoIndexResponse: *result,
 		CommitsTrunc:      commitsTrunc,

appview/repo/log.go

···
 	rp.pages.RepoLog(w, pages.RepoLogParams{
 		LoggedInUser:    user,
 		TagMap:          tagMap,
-		RepoInfo:        f.RepoInfo(user),
+		RepoInfo:        rp.repoResolver.GetRepoInfo(r, user),
 		RepoLogResponse: xrpcResp,
 		EmailToDid:      emailToDidMap,
 		VerifiedCommits: vc,
···
 
 	rp.pages.RepoCommit(w, pages.RepoCommitParams{
 		LoggedInUser:       user,
-		RepoInfo:           f.RepoInfo(user),
+		RepoInfo:           rp.repoResolver.GetRepoInfo(r, user),
 		RepoCommitResponse: result,
 		EmailToDid:         emailToDidMap,
 		VerifiedCommit:     vc,

appview/repo/repo.go

···
 	user := rp.oauth.GetUser(r)
 	rp.pages.LabelPanel(w, pages.LabelPanelParams{
 		LoggedInUser: user,
-		RepoInfo:     f.RepoInfo(user),
+		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),
 		Defs:         defs,
 		Subject:      subject.String(),
 		State:        state,
···
 	user := rp.oauth.GetUser(r)
 	rp.pages.EditLabelPanel(w, pages.EditLabelPanelParams{
 		LoggedInUser: user,
-		RepoInfo:     f.RepoInfo(user),
+		RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),
 		Defs:         defs,
 		Subject:      subject.String(),
 		State:        state,
···
 		rp.pages.ForkRepo(w, pages.ForkRepoParams{
 			LoggedInUser: user,
 			Knots:        knots,
-			RepoInfo:     f.RepoInfo(user),
+			RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),
 		})
 
 	case http.MethodPost:

appview/repo/settings.go

···
 
 	rp.pages.RepoGeneralSettings(w, pages.RepoGeneralSettingsParams{
 		LoggedInUser:       user,
-		RepoInfo:           f.RepoInfo(user),
+		RepoInfo:           rp.repoResolver.GetRepoInfo(r, user),
 		Branches:           result.Branches,
 		Labels:             labels,
 		DefaultLabels:      defaultLabels,
···
 
 	rp.pages.RepoAccessSettings(w, pages.RepoAccessSettingsParams{
 		LoggedInUser:  user,
-		RepoInfo:      f.RepoInfo(user),
+		RepoInfo:      rp.repoResolver.GetRepoInfo(r, user),
 		Tabs:          settingsTabs,
 		Tab:           "access",
 		Collaborators: collaborators,
···
 
 	rp.pages.RepoPipelineSettings(w, pages.RepoPipelineSettingsParams{
 		LoggedInUser:   user,
-		RepoInfo:       f.RepoInfo(user),
+		RepoInfo:       rp.repoResolver.GetRepoInfo(r, user),
 		Tabs:           settingsTabs,
 		Tab:            "pipelines",
 		Spindles:       spindles,

appview/repo/tags.go

···
 	user := rp.oauth.GetUser(r)
 	rp.pages.RepoTags(w, pages.RepoTagsParams{
 		LoggedInUser:      user,
-		RepoInfo:          f.RepoInfo(user),
+		RepoInfo:          rp.repoResolver.GetRepoInfo(r, user),
 		RepoTagsResponse:  result,
 		ArtifactMap:       artifactMap,
 		DanglingArtifacts: danglingArtifacts,

appview/repo/tree.go

···
 		LoggedInUser:     user,
 		BreadCrumbs:      breadcrumbs,
 		TreePath:         treePath,
-		RepoInfo:         f.RepoInfo(user),
+		RepoInfo:         rp.repoResolver.GetRepoInfo(r, user),
 		RepoTreeResponse: result,
 	})
 }

appview/reporesolver/resolver.go

···
 
 type ResolvedRepo struct {
 	models.Repo
-	OwnerId    identity.Identity
-	CurrentDir string
-	Ref        string
-
-	rr *RepoResolver
 }
 
 type RepoResolver struct {
···
 	return path.Join(user, name)
 }
 
+// TODO: move this out of `RepoResolver` struct
 func (rr *RepoResolver) Resolve(r *http.Request) (*ResolvedRepo, error) {
 	repo, ok := r.Context().Value("repo").(*models.Repo)
 	if !ok {
 		log.Println("malformed middleware: `repo` not exist in context")
 		return nil, fmt.Errorf("malformed middleware")
 	}
-	id, ok := r.Context().Value("resolvedId").(identity.Identity)
-	if !ok {
-		log.Println("malformed middleware")
-		return nil, fmt.Errorf("malformed middleware")
+
+	return &ResolvedRepo{
+		Repo: *repo,
+	}, nil
+}
+
+// 1. [x] replace `RepoInfo` to `reporesolver.GetRepoInfo(r *http.Request, repo, user)`
+// 2. [x] remove `rr`, `CurrentDir`, `Ref` fields from `ResolvedRepo`
+// 3. [ ] remove `ResolvedRepo`
+// 4. [ ] replace reporesolver to reposervice
+func (rr *RepoResolver) GetRepoInfo(r *http.Request, user *oauth.User) repoinfo.RepoInfo {
+	ownerId, ook := r.Context().Value("resolvedId").(identity.Identity)
+	repo, rok := r.Context().Value("repo").(*models.Repo)
+	if !ook || !rok {
+		log.Println("malformed request, failed to get repo from context")
 	}
 
+	// get dir/ref
 	currentDir := path.Dir(extractPathAfterRef(r.URL.EscapedPath()))
 	ref := chi.URLParam(r, "ref")
 
-	return &ResolvedRepo{
-		Repo:       *repo,
-		OwnerId:    id,
-		CurrentDir: currentDir,
-		Ref:        ref,
-
-		rr: rr,
-	}, nil
-}
-
-// this function is a bit weird since it now returns RepoInfo from an entirely different
-// package. we should refactor this or get rid of RepoInfo entirely.
-func (f *ResolvedRepo) RepoInfo(user *oauth.User) repoinfo.RepoInfo {
-	repoAt := f.RepoAt()
+	repoAt := repo.RepoAt()
 	isStarred := false
 	roles := repoinfo.RolesInRepo{}
 	if user != nil {
-		isStarred = db.GetStarStatus(f.rr.execer, user.Did, repoAt)
-		roles.Roles = f.rr.enforcer.GetPermissionsInRepo(user.Did, f.Knot, f.DidSlashRepo())
+		isStarred = db.GetStarStatus(rr.execer, user.Did, repoAt)
+		roles.Roles = rr.enforcer.GetPermissionsInRepo(user.Did, repo.Knot, repo.DidSlashRepo())
 	}
 
-	stats := f.RepoStats
+	stats := repo.RepoStats
 	if stats == nil {
-		starCount, err := db.GetStarCount(f.rr.execer, repoAt)
+		starCount, err := db.GetStarCount(rr.execer, repoAt)
 		if err != nil {
 			log.Println("failed to get star count for ", repoAt)
 		}
-		issueCount, err := db.GetIssueCount(f.rr.execer, repoAt)
+		issueCount, err := db.GetIssueCount(rr.execer, repoAt)
 		if err != nil {
 			log.Println("failed to get issue count for ", repoAt)
 		}
-		pullCount, err := db.GetPullCount(f.rr.execer, repoAt)
+		pullCount, err := db.GetPullCount(rr.execer, repoAt)
 		if err != nil {
 			log.Println("failed to get pull count for ", repoAt)
 		}
···
 		}
 	}
 
-	sourceRepo, err := db.GetRepoSourceRepo(f.rr.execer, repoAt)
-	if err != nil {
-		log.Println("failed to get repo by at uri", err)
+	var sourceRepo *models.Repo
+	var err error
+	if repo.Source != "" {
+		sourceRepo, err = db.GetRepoByAtUri(rr.execer, repo.Source)
+		if err != nil {
+			log.Println("failed to get repo by at uri", err)
+		}
 	}
 
 	repoInfo := repoinfo.RepoInfo{
 		// this is basically a models.Repo
-		OwnerDid:    f.OwnerId.DID.String(),
-		OwnerHandle: f.OwnerId.Handle.String(),
-		Name:        f.Name,
-		Rkey:        f.Rkey,
-		Description: f.Description,
-		Website:     f.Website,
-		Topics:      f.Topics,
-		Knot:        f.Knot,
-		Spindle:     f.Spindle,
+		OwnerDid:    ownerId.DID.String(),
+		OwnerHandle: ownerId.Handle.String(),
+		Name:        repo.Name,
+		Rkey:        repo.Rkey,
+		Description: repo.Description,
+		Website:     repo.Website,
+		Topics:      repo.Topics,
+		Knot:        repo.Knot,
+		Spindle:     repo.Spindle,
 		Stats:       *stats,
 
 		// fork repo upstream
 		Source: sourceRepo,
 
-		CurrentDir: f.CurrentDir,
-		Ref:        f.Ref,
+		// page context
+		CurrentDir: currentDir,
+		Ref:        ref,
 
 		// info related to the session
 		IsStarred: isStarred,