Timeline improvements (#41)

Tidying up.
Parent/child statuses now display correctly in status/id/context.

38 files changed, 737 insertions, 600 deletions

diff --git a/internal/db/db.go b/internal/db/db.go
index 51685f024..4e21358c3 100644
--- a/internal/db/db.go
+++ b/internal/db/db.go
@@ -199,21 +199,6 @@ type DB interface {
 	// GetRelationship retrieves the relationship of the targetAccount to the requestingAccount.
 	GetRelationship(requestingAccount string, targetAccount string) (*gtsmodel.Relationship, error)
 
-	// StatusVisible returns true if targetStatus is visible to requestingAccount, based on the
-	// privacy settings of the status, and any blocks/mutes that might exist between the two accounts
-	// or account domains.
-	//
-	// StatusVisible will also check through the given slice of 'otherRelevantAccounts', which should include:
-	//
-	// 1. Accounts mentioned in the targetStatus
-	//
-	// 2. Accounts replied to by the target status
-	//
-	// 3. Accounts boosted by the target status
-	//
-	// Will return an error if something goes wrong while pulling stuff out of the database.
-	StatusVisible(targetStatus *gtsmodel.Status, requestingAccount *gtsmodel.Account, relevantAccounts *gtsmodel.RelevantAccounts) (bool, error)
-
 	// Follows returns true if sourceAccount follows target account, or an error if something goes wrong while finding out.
 	Follows(sourceAccount *gtsmodel.Account, targetAccount *gtsmodel.Account) (bool, error)
 
@@ -223,9 +208,6 @@ type DB interface {
 	// Mutuals returns true if account1 and account2 both follow each other, or an error if something goes wrong while finding out.
 	Mutuals(account1 *gtsmodel.Account, account2 *gtsmodel.Account) (bool, error)
 
-	// PullRelevantAccountsFromStatus returns all accounts mentioned in a status, replied to by a status, or boosted by a status
-	PullRelevantAccountsFromStatus(status *gtsmodel.Status) (*gtsmodel.RelevantAccounts, error)
-
 	// GetReplyCountForStatus returns the amount of replies recorded for a status, or an error if something goes wrong
 	GetReplyCountForStatus(status *gtsmodel.Status) (int, error)
 
@@ -235,6 +217,12 @@ type DB interface {
 	// GetFaveCountForStatus returns the amount of faves/likes recorded for a status, or an error if something goes wrong
 	GetFaveCountForStatus(status *gtsmodel.Status) (int, error)
 
+	// StatusParents get the parent statuses of a given status.
+	StatusParents(status *gtsmodel.Status) ([]*gtsmodel.Status, error)
+
+	// StatusChildren gets the child statuses of a given status.
+	StatusChildren(status *gtsmodel.Status) ([]*gtsmodel.Status, error)
+
 	// StatusFavedBy checks if a given status has been faved by a given account ID
 	StatusFavedBy(status *gtsmodel.Status, accountID string) (bool, error)
 
diff --git a/internal/db/pg/pg.go b/internal/db/pg/pg.go
index 2866a1157..851501334 100644
--- a/internal/db/pg/pg.go
+++ b/internal/db/pg/pg.go
@@ -806,196 +806,27 @@ func (ps *postgresService) GetRelationship(requestingAccount string, targetAccou
 	return r, nil
 }
 
-func (ps *postgresService) StatusVisible(targetStatus *gtsmodel.Status, requestingAccount *gtsmodel.Account, relevantAccounts *gtsmodel.RelevantAccounts) (bool, error) {
-	l := ps.log.WithField("func", "StatusVisible")
-
-	targetAccount := relevantAccounts.StatusAuthor
-
-	// if target account is suspended then don't show the status
-	if !targetAccount.SuspendedAt.IsZero() {
-		l.Trace("target account suspended at is not zero")
-		return false, nil
-	}
-
-	// if the target user doesn't exist (anymore) then the status also shouldn't be visible
-	// note: we only do this for local users
-	if targetAccount.Domain == "" {
-		targetUser := &gtsmodel.User{}
-		if err := ps.conn.Model(targetUser).Where("account_id = ?", targetAccount.ID).Select(); err != nil {
-			l.Debug("target user could not be selected")
-			if err == pg.ErrNoRows {
-				return false, db.ErrNoEntries{}
-			}
-			return false, err
-		}
-
-		// if target user is disabled, not yet approved, or not confirmed then don't show the status
-		// (although in the latter two cases it's unlikely they posted a status yet anyway, but you never know!)
-		if targetUser.Disabled || !targetUser.Approved || targetUser.ConfirmedAt.IsZero() {
-			l.Trace("target user is disabled, not approved, or not confirmed")
-			return false, nil
-		}
-	}
-
-	// If requesting account is nil, that means whoever requested the status didn't auth, or their auth failed.
-	// In this case, we can still serve the status if it's public, otherwise we definitely shouldn't.
-	if requestingAccount == nil {
-		if targetStatus.Visibility == gtsmodel.VisibilityPublic {
-			return true, nil
-		}
-		l.Trace("requesting account is nil but the target status isn't public")
-		return false, nil
-	}
-
-	// if requesting account is suspended then don't show the status -- although they probably shouldn't have gotten
-	// this far (ie., been authed) in the first place: this is just for safety.
-	if !requestingAccount.SuspendedAt.IsZero() {
-		l.Trace("requesting account is suspended")
-		return false, nil
-	}
-
-	// check if we have a local account -- if so we can check the user for that account in the DB
-	if requestingAccount.Domain == "" {
-		requestingUser := &gtsmodel.User{}
-		if err := ps.conn.Model(requestingUser).Where("account_id = ?", requestingAccount.ID).Select(); err != nil {
-			// if the requesting account is local but doesn't have a corresponding user in the db this is a problem
-			if err == pg.ErrNoRows {
-				l.Debug("requesting account is local but there's no corresponding user")
-				return false, nil
-			}
-			l.Debugf("requesting account is local but there was an error getting the corresponding user: %s", err)
-			return false, err
-		}
-		// okay, user exists, so make sure it has full privileges/is confirmed/approved
-		if requestingUser.Disabled || !requestingUser.Approved || requestingUser.ConfirmedAt.IsZero() {
-			l.Trace("requesting account is local but corresponding user is either disabled, not approved, or not confirmed")
-			return false, nil
-		}
-	}
-
-	// if the target status belongs to the requesting account, they should always be able to view it at this point
-	if targetStatus.AccountID == requestingAccount.ID {
-		return true, nil
-	}
-
-	// At this point we have a populated targetAccount, targetStatus, and requestingAccount, so we can check for blocks and whathaveyou
-	// First check if a block exists directly between the target account (which authored the status) and the requesting account.
-	if blocked, err := ps.Blocked(targetAccount.ID, requestingAccount.ID); err != nil {
-		l.Debugf("something went wrong figuring out if the accounts have a block: %s", err)
-		return false, err
-	} else if blocked {
-		// don't allow the status to be viewed if a block exists in *either* direction between these two accounts, no creepy stalking please
-		l.Trace("a block exists between requesting account and target account")
+func (ps *postgresService) Follows(sourceAccount *gtsmodel.Account, targetAccount *gtsmodel.Account) (bool, error) {
+	if sourceAccount == nil || targetAccount == nil {
 		return false, nil
 	}
-
-	// check other accounts mentioned/boosted by/replied to by the status, if they exist
-	if relevantAccounts != nil {
-		// status replies to account id
-		if relevantAccounts.ReplyToAccount != nil && relevantAccounts.ReplyToAccount.ID != requestingAccount.ID {
-			if blocked, err := ps.Blocked(relevantAccounts.ReplyToAccount.ID, requestingAccount.ID); err != nil {
-				return false, err
-			} else if blocked {
-				l.Trace("a block exists between requesting account and reply to account")
-				return false, nil
-			}
-
-			// check reply to ID
-			if targetStatus.InReplyToID != "" {
-				followsRepliedAccount, err := ps.Follows(requestingAccount, relevantAccounts.ReplyToAccount)
-				if err != nil {
-					return false, err
-				}
-				if !followsRepliedAccount {
-					l.Trace("target status is a followers-only reply to an account that is not followed by the requesting account")
-					return false, nil
-				}
-			}
-		}
-
-		// status boosts accounts id
-		if relevantAccounts.BoostedAccount != nil {
-			if blocked, err := ps.Blocked(relevantAccounts.BoostedAccount.ID, requestingAccount.ID); err != nil {
-				return false, err
-			} else if blocked {
-				l.Trace("a block exists between requesting account and boosted account")
-				return false, nil
-			}
-		}
-
-		// status boosts a reply to account id
-		if relevantAccounts.BoostedReplyToAccount != nil {
-			if blocked, err := ps.Blocked(relevantAccounts.BoostedReplyToAccount.ID, requestingAccount.ID); err != nil {
-				return false, err
-			} else if blocked {
-				l.Trace("a block exists between requesting account and boosted reply to account")
-				return false, nil
-			}
-		}
-
-		// status mentions accounts
-		for _, a := range relevantAccounts.MentionedAccounts {
-			if blocked, err := ps.Blocked(a.ID, requestingAccount.ID); err != nil {
-				return false, err
-			} else if blocked {
-				l.Trace("a block exists between requesting account and a mentioned account")
-				return false, nil
-			}
-		}
-
-		// if the requesting account is mentioned in the status it should always be visible
-		for _, acct := range relevantAccounts.MentionedAccounts {
-			if acct.ID == requestingAccount.ID {
-				return true, nil // yep it's mentioned!
-			}
-		}
-	}
-
-	// at this point we know neither account blocks the other, or another account mentioned or otherwise referred to in the status
-	// that means it's now just a matter of checking the visibility settings of the status itself
-	switch targetStatus.Visibility {
-	case gtsmodel.VisibilityPublic, gtsmodel.VisibilityUnlocked:
-		// no problem here, just return OK
-		return true, nil
-	case gtsmodel.VisibilityFollowersOnly:
-		// check one-way follow
-		follows, err := ps.Follows(requestingAccount, targetAccount)
-		if err != nil {
-			return false, err
-		}
-		if !follows {
-			l.Trace("requested status is followers only but requesting account is not a follower")
-			return false, nil
-		}
-		return true, nil
-	case gtsmodel.VisibilityMutualsOnly:
-		// check mutual follow
-		mutuals, err := ps.Mutuals(requestingAccount, targetAccount)
-		if err != nil {
-			return false, err
-		}
-		if !mutuals {
-			l.Trace("requested status is mutuals only but accounts aren't mufos")
-			return false, nil
-		}
-		return true, nil
-	case gtsmodel.VisibilityDirect:
-		l.Trace("requesting account requests a status it's not mentioned in")
-		return false, nil // it's not mentioned -_-
-	}
-
-	return false, errors.New("reached the end of StatusVisible with no result")
-}
-
-func (ps *postgresService) Follows(sourceAccount *gtsmodel.Account, targetAccount *gtsmodel.Account) (bool, error) {
+	
 	return ps.conn.Model(&gtsmodel.Follow{}).Where("account_id = ?", sourceAccount.ID).Where("target_account_id = ?", targetAccount.ID).Exists()
 }
 
 func (ps *postgresService) FollowRequested(sourceAccount *gtsmodel.Account, targetAccount *gtsmodel.Account) (bool, error) {
+	if sourceAccount == nil || targetAccount == nil {
+		return false, nil
+	}
+	
 	return ps.conn.Model(&gtsmodel.FollowRequest{}).Where("account_id = ?", sourceAccount.ID).Where("target_account_id = ?", targetAccount.ID).Exists()
 }
 
 func (ps *postgresService) Mutuals(account1 *gtsmodel.Account, account2 *gtsmodel.Account) (bool, error) {
+	if account1 == nil || account2 == nil {
+		return false, nil
+	}
+	
 	// make sure account 1 follows account 2
 	f1, err := ps.conn.Model(&gtsmodel.Follow{}).Where("account_id = ?", account1.ID).Where("target_account_id = ?", account2.ID).Exists()
 	if err != nil {
@@ -1017,71 +848,6 @@ func (ps *postgresService) Mutuals(account1 *gtsmodel.Account, account2 *gtsmode
 	return f1 && f2, nil
 }
 
-func (ps *postgresService) PullRelevantAccountsFromStatus(targetStatus *gtsmodel.Status) (*gtsmodel.RelevantAccounts, error) {
-	accounts := &gtsmodel.RelevantAccounts{
-		MentionedAccounts: []*gtsmodel.Account{},
-	}
-
-	// get the author account
-	if targetStatus.GTSAuthorAccount == nil {
-		statusAuthor := &gtsmodel.Account{}
-		if err := ps.conn.Model(statusAuthor).Where("id = ?", targetStatus.AccountID).Select(); err != nil {
-			return accounts, fmt.Errorf("PullRelevantAccountsFromStatus: error getting statusAuthor with id %s: %s", targetStatus.AccountID, err)
-		}
-		targetStatus.GTSAuthorAccount = statusAuthor
-	}
-	accounts.StatusAuthor = targetStatus.GTSAuthorAccount
-
-	// get the replied to account from the status and add it to the pile
-	if targetStatus.InReplyToAccountID != "" {
-		repliedToAccount := &gtsmodel.Account{}
-		if err := ps.conn.Model(repliedToAccount).Where("id = ?", targetStatus.InReplyToAccountID).Select(); err != nil {
-			return accounts, fmt.Errorf("PullRelevantAccountsFromStatus: error getting repliedToAcount with id %s: %s", targetStatus.InReplyToAccountID, err)
-		}
-		accounts.ReplyToAccount = repliedToAccount
-	}
-
-	// get the boosted account from the status and add it to the pile
-	if targetStatus.BoostOfID != "" {
-		// retrieve the boosted status first
-		boostedStatus := &gtsmodel.Status{}
-		if err := ps.conn.Model(boostedStatus).Where("id = ?", targetStatus.BoostOfID).Select(); err != nil {
-			return accounts, fmt.Errorf("PullRelevantAccountsFromStatus: error getting boostedStatus with id %s: %s", targetStatus.BoostOfID, err)
-		}
-		boostedAccount := &gtsmodel.Account{}
-		if err := ps.conn.Model(boostedAccount).Where("id = ?", boostedStatus.AccountID).Select(); err != nil {
-			return accounts, fmt.Errorf("PullRelevantAccountsFromStatus: error getting boostedAccount with id %s: %s", boostedStatus.AccountID, err)
-		}
-		accounts.BoostedAccount = boostedAccount
-
-		// the boosted status might be a reply to another account so we should get that too
-		if boostedStatus.InReplyToAccountID != "" {
-			boostedStatusRepliedToAccount := &gtsmodel.Account{}
-			if err := ps.conn.Model(boostedStatusRepliedToAccount).Where("id = ?", boostedStatus.InReplyToAccountID).Select(); err != nil {
-				return accounts, fmt.Errorf("PullRelevantAccountsFromStatus: error getting boostedStatusRepliedToAccount with id %s: %s", boostedStatus.InReplyToAccountID, err)
-			}
-			accounts.BoostedReplyToAccount = boostedStatusRepliedToAccount
-		}
-	}
-
-	// now get all accounts with IDs that are mentioned in the status
-	for _, mentionID := range targetStatus.Mentions {
-
-		mention := &gtsmodel.Mention{}
-		if err := ps.conn.Model(mention).Where("id = ?", mentionID).Select(); err != nil {
-			return accounts, fmt.Errorf("PullRelevantAccountsFromStatus: error getting mention with id %s: %s", mentionID, err)
-		}
-
-		mentionedAccount := &gtsmodel.Account{}
-		if err := ps.conn.Model(mentionedAccount).Where("id = ?", mention.TargetAccountID).Select(); err != nil {
-			return accounts, fmt.Errorf("PullRelevantAccountsFromStatus: error getting mentioned account: %s", err)
-		}
-		accounts.MentionedAccounts = append(accounts.MentionedAccounts, mentionedAccount)
-	}
-
-	return accounts, nil
-}
-
 func (ps *postgresService) GetReplyCountForStatus(status *gtsmodel.Status) (int, error) {
 	return ps.conn.Model(&gtsmodel.Status{}).Where("in_reply_to_id = ?", status.ID).Count()
 }
diff --git a/internal/db/pg/statuscontext.go b/internal/db/pg/statuscontext.go
new file mode 100644
index 000000000..e907a2d6f
--- /dev/null
+++ b/internal/db/pg/statuscontext.go
@@ -0,0 +1,75 @@
+package pg
+
+import (
+	"container/list"
+	"errors"
+
+	"github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
+)
+
+func (ps *postgresService) StatusParents(status *gtsmodel.Status) ([]*gtsmodel.Status, error) {
+	parents := []*gtsmodel.Status{}
+	ps.statusParent(status, &parents)
+
+	return parents, nil
+}
+
+func (ps *postgresService) statusParent(status *gtsmodel.Status, foundStatuses *[]*gtsmodel.Status) {
+	if status.InReplyToID == "" {
+		return
+	}
+
+	parentStatus := &gtsmodel.Status{}
+	if err := ps.conn.Model(parentStatus).Where("id = ?", status.InReplyToID).Select(); err == nil {
+		*foundStatuses = append(*foundStatuses, parentStatus)
+	}
+
+	ps.statusParent(parentStatus, foundStatuses)
+}
+
+func (ps *postgresService) StatusChildren(status *gtsmodel.Status) ([]*gtsmodel.Status, error) {
+	foundStatuses := &list.List{}
+	foundStatuses.PushFront(status)
+	ps.statusChildren(status, foundStatuses)
+
+	children := []*gtsmodel.Status{}
+	for e := foundStatuses.Front(); e != nil; e = e.Next() {
+		entry, ok := e.Value.(*gtsmodel.Status)
+		if !ok {
+			panic(errors.New("entry in foundStatuses was not a *gtsmodel.Status"))
+		}
+
+		// only append children, not the overall parent status
+		if entry.ID != status.ID {
+			children = append(children, entry)
+		}
+	}
+
+	return children, nil
+}
+
+func (ps *postgresService) statusChildren(status *gtsmodel.Status, foundStatuses *list.List) {
+	immediateChildren := []*gtsmodel.Status{}
+
+	err := ps.conn.Model(&immediateChildren).Where("in_reply_to_id = ?", status.ID).Select()
+	if err != nil {
+		return
+	}
+
+	for _, child := range immediateChildren {
+	insertLoop:
+		for e := foundStatuses.Front(); e != nil; e = e.Next() {
+			entry, ok := e.Value.(*gtsmodel.Status)
+			if !ok {
+				panic(errors.New("entry in foundStatuses was not a *gtsmodel.Status"))
+			}
+
+			if child.InReplyToAccountID != "" && entry.ID == child.InReplyToID {
+				foundStatuses.InsertAfter(child, e)
+				break insertLoop
+			}
+		}
+
+		ps.statusChildren(child, foundStatuses)
+	}
+}
diff --git a/internal/federation/federatingdb/create.go b/internal/federation/federatingdb/create.go
index 3ab6e2eca..02a5dfd72 100644
--- a/internal/federation/federatingdb/create.go
+++ b/internal/federation/federatingdb/create.go
@@ -87,6 +87,7 @@ func (f *federatingDB) Create(ctx context.Context, asType vocab.Type) error {
 
 	switch asType.GetTypeName() {
 	case gtsmodel.ActivityStreamsCreate:
+		// CREATE SOMETHING
 		create, ok := asType.(vocab.ActivityStreamsCreate)
 		if !ok {
 			return errors.New("could not convert type to create")
@@ -95,6 +96,7 @@ func (f *federatingDB) Create(ctx context.Context, asType vocab.Type) error {
 		for objectIter := object.Begin(); objectIter != object.End(); objectIter = objectIter.Next() {
 			switch objectIter.GetType().GetTypeName() {
 			case gtsmodel.ActivityStreamsNote:
+				// CREATE A NOTE
 				note := objectIter.GetActivityStreamsNote()
 				status, err := f.typeConverter.ASStatusToStatus(note)
 				if err != nil {
diff --git a/internal/gtsmodel/status.go b/internal/gtsmodel/status.go
index f5e332978..caa5a2a25 100644
--- a/internal/gtsmodel/status.go
+++ b/internal/gtsmodel/status.go
@@ -46,8 +46,12 @@ type Status struct {
 	Local bool
 	// which account posted this status?
 	AccountID string `pg:"type:CHAR(26),notnull"`
+	// AP uri of the owner of this status
+	AccountURI string
 	// id of the status this status is a reply to
 	InReplyToID string `pg:"type:CHAR(26)"`
+	// AP uri of the status this status is a reply to
+	InReplyToURI string
 	// id of the account that this status replies to
 	InReplyToAccountID string `pg:"type:CHAR(26)"`
 	// id of the status this status is a boost of
@@ -97,20 +101,6 @@ type Status struct {
 	GTSBoostedStatus *Status `pg:"-"`
 	// Account of the boosted status
 	GTSBoostedAccount *Account `pg:"-"`
-
-	/*
-		AP NON-DATABASE FIELDS
-
-		These are for convenience while passing the status around internally,
-		but these fields should *never* be put in the db.
-	*/
-
-	// AP URI of the status being replied to.
-	// Useful when that status doesn't exist in the database yet and we still need to dereference it.
-	APReplyToStatusURI string `pg:"-"`
-	// The AP URI of the owner/creator of the status.
-	// Useful when that account doesn't exist in the database yet and we still need to dereference it.
-	APStatusOwnerURI string `pg:"-"`
 }
 
 // Visibility represents the visibility granularity of a status.
@@ -150,12 +140,3 @@ type VisibilityAdvanced struct {
 	// This status can be liked/faved
 	Likeable bool `pg:"default:true"`
 }
-
-// RelevantAccounts denotes accounts that are replied to, boosted by, or mentioned in a status.
-type RelevantAccounts struct {
-	StatusAuthor          *Account
-	ReplyToAccount        *Account
-	BoostedAccount        *Account
-	BoostedReplyToAccount *Account
-	MentionedAccounts     []*Account
-}
diff --git a/internal/processing/account.go b/internal/processing/account.go
index 870734184..0e7dbbad3 100644
--- a/internal/processing/account.go
+++ b/internal/processing/account.go
@@ -222,12 +222,7 @@ func (p *processor) AccountStatusesGet(authed *oauth.Auth, targetAccountID strin
 	}
 
 	for _, s := range statuses {
-		relevantAccounts, err := p.db.PullRelevantAccountsFromStatus(&s)
-		if err != nil {
-			return nil, gtserror.NewErrorInternalError(fmt.Errorf("error getting relevant statuses: %s", err))
-		}
-
-		visible, err := p.db.StatusVisible(&s, authed.Account, relevantAccounts)
+		visible, err := p.filter.StatusVisible(&s, authed.Account)
 		if err != nil {
 			return nil, gtserror.NewErrorInternalError(fmt.Errorf("error checking status visibility: %s", err))
 		}
@@ -235,28 +230,7 @@ func (p *processor) AccountStatusesGet(authed *oauth.Auth, targetAccountID strin
 			continue
 		}
 
-		var boostedStatus *gtsmodel.Status
-		if s.BoostOfID != "" {
-			bs := &gtsmodel.Status{}
-			if err := p.db.GetByID(s.BoostOfID, bs); err != nil {
-				return nil, gtserror.NewErrorInternalError(fmt.Errorf("error getting boosted status: %s", err))
-			}
-			boostedRelevantAccounts, err := p.db.PullRelevantAccountsFromStatus(bs)
-			if err != nil {
-				return nil, gtserror.NewErrorInternalError(fmt.Errorf("error getting relevant accounts from boosted status: %s", err))
-			}
-
-			boostedVisible, err := p.db.StatusVisible(bs, authed.Account, boostedRelevantAccounts)
-			if err != nil {
-				return nil, gtserror.NewErrorInternalError(fmt.Errorf("error checking boosted status visibility: %s", err))
-			}
-
-			if boostedVisible {
-				boostedStatus = bs
-			}
-		}
-
-		apiStatus, err := p.tc.StatusToMasto(&s, targetAccount, authed.Account, relevantAccounts.BoostedAccount, relevantAccounts.ReplyToAccount, boostedStatus)
+		apiStatus, err := p.tc.StatusToMasto(&s, authed.Account)
 		if err != nil {
 			return nil, gtserror.NewErrorInternalError(fmt.Errorf("error converting status to masto: %s", err))
 		}
diff --git a/internal/processing/federation.go b/internal/processing/federation.go
index 1c0d67fc8..5693caf90 100644
--- a/internal/processing/federation.go
+++ b/internal/processing/federation.go
@@ -223,6 +223,8 @@ func (p *processor) GetFediStatus(requestedUsername string, requestedStatusID st
 		return nil, gtserror.NewErrorNotAuthorized(err)
 	}
 
+	// authorize the request:
+	// 1. check if a block exists between the requester and the requestee
 	blocked, err := p.db.Blocked(requestedAccount.ID, requestingAccount.ID)
 	if err != nil {
 		return nil, gtserror.NewErrorInternalError(err)
@@ -232,6 +234,7 @@ func (p *processor) GetFediStatus(requestedUsername string, requestedStatusID st
 		return nil, gtserror.NewErrorNotAuthorized(fmt.Errorf("block exists between accounts %s and %s", requestedAccount.ID, requestingAccount.ID))
 	}
 
+	// get the status out of the database here
 	s := &gtsmodel.Status{}
 	if err := p.db.GetWhere([]db.Where{
 		{Key: "id", Value: requestedStatusID},
@@ -240,6 +243,15 @@ func (p *processor) GetFediStatus(requestedUsername string, requestedStatusID st
 		return nil, gtserror.NewErrorNotFound(fmt.Errorf("database error getting status with id %s and account id %s: %s", requestedStatusID, requestedAccount.ID, err))
 	}
 
+	visible, err := p.filter.StatusVisible(s, requestingAccount)
+	if err != nil {
+		return nil, gtserror.NewErrorInternalError(err)
+	}
+	if !visible {
+		return nil, gtserror.NewErrorNotFound(fmt.Errorf("status with id %s not visible to user with id %s", s.ID, requestingAccount.ID))
+	}
+
+	// requester is authorized to view the status, so convert it to AP representation and serialize it
 	asStatus, err := p.tc.StatusToAS(s)
 	if err != nil {
 		return nil, gtserror.NewErrorInternalError(err)
diff --git a/internal/processing/fromclientapi.go b/internal/processing/fromclientapi.go
index d171e593a..8c4a1692e 100644
--- a/internal/processing/fromclientapi.go
+++ b/internal/processing/fromclientapi.go
@@ -83,6 +83,10 @@ func (p *processor) processFromClientAPI(clientMsg gtsmodel.FromClientAPI) error
 				return errors.New("boost was not parseable as *gtsmodel.Status")
 			}
 
+			if err := p.timelineStatus(boostWrapperStatus); err != nil {
+				return err
+			}
+
 			if err := p.notifyAnnounce(boostWrapperStatus); err != nil {
 				return err
 			}
diff --git a/internal/processing/fromcommon.go b/internal/processing/fromcommon.go
index 85531d20b..65ccef45d 100644
--- a/internal/processing/fromcommon.go
+++ b/internal/processing/fromcommon.go
@@ -255,12 +255,6 @@ func (p *processor) timelineStatus(status *gtsmodel.Status) error {
 		status.GTSAuthorAccount = a
 	}
 
-	// get all relevant accounts here once
-	relevantAccounts, err := p.db.PullRelevantAccountsFromStatus(status)
-	if err != nil {
-		return fmt.Errorf("timelineStatus: error getting relevant accounts from status: %s", err)
-	}
-
 	// get local followers of the account that posted the status
 	followers := []gtsmodel.Follow{}
 	if err := p.db.GetFollowersByAccountID(status.AccountID, &followers, true); err != nil {
@@ -279,7 +273,7 @@ func (p *processor) timelineStatus(status *gtsmodel.Status) error {
 	errors := make(chan error, len(followers))
 
 	for _, f := range followers {
-		go p.timelineStatusForAccount(status, f.AccountID, relevantAccounts, errors, &wg)
+		go p.timelineStatusForAccount(status, f.AccountID, errors, &wg)
 	}
 
 	// read any errors that come in from the async functions
@@ -306,29 +300,29 @@ func (p *processor) timelineStatus(status *gtsmodel.Status) error {
 	return nil
 }
 
-func (p *processor) timelineStatusForAccount(status *gtsmodel.Status, accountID string, relevantAccounts *gtsmodel.RelevantAccounts, errors chan error, wg *sync.WaitGroup) {
+func (p *processor) timelineStatusForAccount(status *gtsmodel.Status, accountID string, errors chan error, wg *sync.WaitGroup) {
 	defer wg.Done()
 
-	// get the targetAccount
+	// get the timeline owner account
 	timelineAccount := &gtsmodel.Account{}
 	if err := p.db.GetByID(accountID, timelineAccount); err != nil {
-		errors <- fmt.Errorf("timelineStatus: error getting account for timeline with id %s: %s", accountID, err)
+		errors <- fmt.Errorf("timelineStatusForAccount: error getting account for timeline with id %s: %s", accountID, err)
 		return
 	}
 
-	// make sure the status is visible
-	visible, err := p.db.StatusVisible(status, timelineAccount, relevantAccounts)
+	// make sure the status is timelineable
+	timelineable, err := p.filter.StatusHometimelineable(status, timelineAccount)
 	if err != nil {
-		errors <- fmt.Errorf("timelineStatus: error getting visibility for status for timeline with id %s: %s", accountID, err)
+		errors <- fmt.Errorf("timelineStatusForAccount: error getting timelineability for status for timeline with id %s: %s", accountID, err)
 		return
 	}
 
-	if !visible {
+	if !timelineable {
 		return
 	}
 
 	if err := p.timelineManager.IngestAndPrepare(status, timelineAccount.ID); err != nil {
-		errors <- fmt.Errorf("initTimelineFor: error ingesting status %s: %s", status.ID, err)
+		errors <- fmt.Errorf("timelineStatusForAccount: error ingesting status %s: %s", status.ID, err)
 	}
 }
 
diff --git a/internal/processing/fromfederator.go b/internal/processing/fromfederator.go
index f010a7aa1..cc3ffa153 100644
--- a/internal/processing/fromfederator.go
+++ b/internal/processing/fromfederator.go
@@ -121,6 +121,10 @@ func (p *processor) processFromFederator(federatorMsg gtsmodel.FromFederator) er
 				}
 			}
 
+			if err := p.timelineStatus(incomingAnnounce); err != nil {
+				return err
+			}
+
 			if err := p.notifyAnnounce(incomingAnnounce); err != nil {
 				return err
 			}
diff --git a/internal/processing/processor.go b/internal/processing/processor.go
index 1ccf71e34..301cb5707 100644
--- a/internal/processing/processor.go
+++ b/internal/processing/processor.go
@@ -35,6 +35,7 @@ import (
 	"github.com/superseriousbusiness/gotosocial/internal/processing/synchronous/status"
 	"github.com/superseriousbusiness/gotosocial/internal/timeline"
 	"github.com/superseriousbusiness/gotosocial/internal/typeutils"
+	"github.com/superseriousbusiness/gotosocial/internal/visibility"
 )
 
 // Processor should be passed to api modules (see internal/apimodule/...). It is used for
@@ -185,6 +186,7 @@ type processor struct {
 	storage         blob.Storage
 	timelineManager timeline.Manager
 	db              db.DB
+	filter          visibility.Filter
 
 	/*
 		SUB-PROCESSORS
@@ -214,6 +216,7 @@ func NewProcessor(config *config.Config, tc typeutils.TypeConverter, federator f
 		storage:         storage,
 		timelineManager: timelineManager,
 		db:              db,
+		filter:          visibility.NewFilter(db, log),
 
 		statusProcessor: statusProcessor,
 	}
diff --git a/internal/processing/search.go b/internal/processing/search.go
index d518a0310..a0a48145b 100644
--- a/internal/processing/search.go
+++ b/internal/processing/search.go
@@ -106,15 +106,11 @@ func (p *processor) SearchGet(authed *oauth.Auth, searchQuery *apimodel.SearchQu
 			continue
 		}
 
-		relevantAccounts, err := p.db.PullRelevantAccountsFromStatus(foundStatus)
-		if err != nil {
-			continue
-		}
-		if visible, err := p.db.StatusVisible(foundStatus, authed.Account, relevantAccounts); !visible || err != nil {
+		if visible, err := p.filter.StatusVisible(foundStatus, authed.Account); !visible || err != nil {
 			continue
 		}
 
-		statusMasto, err := p.tc.StatusToMasto(foundStatus, statusOwner, authed.Account, relevantAccounts.BoostedAccount, relevantAccounts.ReplyToAccount, nil)
+		statusMasto, err := p.tc.StatusToMasto(foundStatus, authed.Account)
 		if err != nil {
 			continue
 		}
diff --git a/internal/processing/synchronous/status/boost.go b/internal/processing/synchronous/status/boost.go
index a746e9fd8..93d0f19de 100644
--- a/internal/processing/synchronous/status/boost.go
+++ b/internal/processing/synchronous/status/boost.go
@@ -24,14 +24,8 @@ func (p *processor) Boost(account *gtsmodel.Account, application *gtsmodel.Appli
 		return nil, gtserror.NewErrorNotFound(fmt.Errorf("error fetching target account %s: %s", targetStatus.AccountID, err))
 	}
 
-	l.Trace("going to get relevant accounts")
-	relevantAccounts, err := p.db.PullRelevantAccountsFromStatus(targetStatus)
-	if err != nil {
-		return nil, gtserror.NewErrorNotFound(fmt.Errorf("error fetching related accounts for status %s: %s", targetStatusID, err))
-	}
-
 	l.Trace("going to see if status is visible")
-	visible, err := p.db.StatusVisible(targetStatus, account, relevantAccounts)
+	visible, err := p.filter.StatusVisible(targetStatus, account)
 	if err != nil {
 		return nil, gtserror.NewErrorNotFound(fmt.Errorf("error seeing if status %s is visible: %s", targetStatus.ID, err))
 	}
@@ -70,7 +64,7 @@ func (p *processor) Boost(account *gtsmodel.Account, application *gtsmodel.Appli
 	}
 
 	// return the frontend representation of the new status to the submitter
-	mastoStatus, err := p.tc.StatusToMasto(boostWrapperStatus, account, account, targetAccount, nil, targetStatus)
+	mastoStatus, err := p.tc.StatusToMasto(boostWrapperStatus, account)
 	if err != nil {
 		return nil, gtserror.NewErrorInternalError(fmt.Errorf("error converting status %s to frontend representation: %s", targetStatus.ID, err))
 	}
diff --git a/internal/processing/synchronous/status/boostedby.go b/internal/processing/synchronous/status/boostedby.go
index 8ebfcebc0..b352178e3 100644
--- a/internal/processing/synchronous/status/boostedby.go
+++ b/internal/processing/synchronous/status/boostedby.go
@@ -24,14 +24,8 @@ func (p *processor) BoostedBy(account *gtsmodel.Account, targetStatusID string)
 		return nil, gtserror.NewErrorNotFound(fmt.Errorf("StatusBoostedBy: error fetching target account %s: %s", targetStatus.AccountID, err))
 	}
 
-	l.Trace("going to get relevant accounts")
-	relevantAccounts, err := p.db.PullRelevantAccountsFromStatus(targetStatus)
-	if err != nil {
-		return nil, gtserror.NewErrorNotFound(fmt.Errorf("StatusBoostedBy: error fetching related accounts for status %s: %s", targetStatusID, err))
-	}
-
 	l.Trace("going to see if status is visible")
-	visible, err := p.db.StatusVisible(targetStatus, account, relevantAccounts)
+	visible, err := p.filter.StatusVisible(targetStatus, account)
 	if err != nil {
 		return nil, gtserror.NewErrorNotFound(fmt.Errorf("StatusBoostedBy: error seeing if status %s is visible: %s", targetStatus.ID, err))
 	}
diff --git a/internal/processing/synchronous/status/context.go b/internal/processing/synchronous/status/context.go
index cac86815e..72b9b5623 100644
--- a/internal/processing/synchronous/status/context.go
+++ b/internal/processing/synchronous/status/context.go
@@ -1,14 +1,69 @@
 package status
 
 import (
+	"fmt"
+	"sort"
+
 	apimodel "github.com/superseriousbusiness/gotosocial/internal/api/model"
+	"github.com/superseriousbusiness/gotosocial/internal/db"
 	"github.com/superseriousbusiness/gotosocial/internal/gtserror"
 	"github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
 )
 
 func (p *processor) Context(account *gtsmodel.Account, targetStatusID string) (*apimodel.Context, gtserror.WithCode) {
-	return &apimodel.Context{
+
+	context := &apimodel.Context{
 		Ancestors:   []apimodel.Status{},
 		Descendants: []apimodel.Status{},
-	}, nil
+	}
+
+	targetStatus := &gtsmodel.Status{}
+	if err := p.db.GetByID(targetStatusID, targetStatus); err != nil {
+		if _, ok := err.(db.ErrNoEntries); ok {
+			return nil, gtserror.NewErrorNotFound(err)
+		}
+		return nil, gtserror.NewErrorInternalError(err)
+	}
+
+	visible, err := p.filter.StatusVisible(targetStatus, account)
+	if err != nil {
+		return nil, gtserror.NewErrorNotFound(err)
+	}
+	if !visible {
+		return nil, gtserror.NewErrorForbidden(fmt.Errorf("account with id %s does not have permission to view status %s", account.ID, targetStatusID))
+	}
+
+	parents, err := p.db.StatusParents(targetStatus)
+	if err != nil {
+		return nil, gtserror.NewErrorInternalError(err)
+	}
+
+	for _, status := range parents {
+		if v, err := p.filter.StatusVisible(status, account); err == nil && v {
+			mastoStatus, err := p.tc.StatusToMasto(status, account)
+			if err == nil {
+				context.Ancestors = append(context.Ancestors, *mastoStatus)
+			}
+		}
+	}
+
+	sort.Slice(context.Ancestors, func(i int, j int) bool {
+		return context.Ancestors[i].ID < context.Ancestors[j].ID
+	})
+
+	children, err := p.db.StatusChildren(targetStatus)
+	if err != nil {
+		return nil, gtserror.NewErrorInternalError(err)
+	}
+
+	for _, status := range children {
+		if v, err := p.filter.StatusVisible(status, account); err == nil && v {
+			mastoStatus, err := p.tc.StatusToMasto(status, account)
+			if err == nil {
+				context.Descendants = append(context.Descendants, *mastoStatus)
+			}
+		}
+	}
+
+	return context, nil
 }
diff --git a/internal/processing/synchronous/status/create.go b/internal/processing/synchronous/status/create.go
index 07f670d1a..aa7468ae5 100644
--- a/internal/processing/synchronous/status/create.go
+++ b/internal/processing/synchronous/status/create.go
@@ -28,6 +28,7 @@ func (p *processor) Create(account *gtsmodel.Account, application *gtsmodel.Appl
 		UpdatedAt:                time.Now(),
 		Local:                    true,
 		AccountID:                account.ID,
+		AccountURI:               account.URI,
 		ContentWarning:           form.SpoilerText,
 		ActivityStreamsType:      gtsmodel.ActivityStreamsNote,
 		Sensitive:                form.Sensitive,
@@ -96,7 +97,7 @@ func (p *processor) Create(account *gtsmodel.Account, application *gtsmodel.Appl
 	}
 
 	// return the frontend representation of the new status to the submitter
-	mastoStatus, err := p.tc.StatusToMasto(newStatus, account, account, nil, newStatus.GTSReplyToAccount, nil)
+	mastoStatus, err := p.tc.StatusToMasto(newStatus, account)
 	if err != nil {
 		return nil, gtserror.NewErrorInternalError(fmt.Errorf("error converting status %s to frontend representation: %s", newStatus.ID, err))
 	}
diff --git a/internal/processing/synchronous/status/delete.go b/internal/processing/synchronous/status/delete.go
index 7e251080a..5da196a9f 100644
--- a/internal/processing/synchronous/status/delete.go
+++ b/internal/processing/synchronous/status/delete.go
@@ -26,12 +26,6 @@ func (p *processor) Delete(account *gtsmodel.Account, targetStatusID string) (*a
 		return nil, gtserror.NewErrorForbidden(errors.New("status doesn't belong to requesting account"))
 	}
 
-	l.Trace("going to get relevant accounts")
-	relevantAccounts, err := p.db.PullRelevantAccountsFromStatus(targetStatus)
-	if err != nil {
-		return nil, gtserror.NewErrorNotFound(fmt.Errorf("error fetching related accounts for status %s: %s", targetStatusID, err))
-	}
-
 	var boostOfStatus *gtsmodel.Status
 	if targetStatus.BoostOfID != "" {
 		boostOfStatus = &gtsmodel.Status{}
@@ -40,7 +34,7 @@ func (p *processor) Delete(account *gtsmodel.Account, targetStatusID string) (*a
 		}
 	}
 
-	mastoStatus, err := p.tc.StatusToMasto(targetStatus, account, account, relevantAccounts.BoostedAccount, relevantAccounts.ReplyToAccount, boostOfStatus)
+	mastoStatus, err := p.tc.StatusToMasto(targetStatus, account)
 	if err != nil {
 		return nil, gtserror.NewErrorInternalError(fmt.Errorf("error converting status %s to frontend representation: %s", targetStatus.ID, err))
 	}
diff --git a/internal/processing/synchronous/status/fave.go b/internal/processing/synchronous/status/fave.go
index b4622abbc..23f0d2944 100644
--- a/internal/processing/synchronous/status/fave.go
+++ b/internal/processing/synchronous/status/fave.go
@@ -26,12 +26,6 @@ func (p *processor) Fave(account *gtsmodel.Account, targetStatusID string) (*api
 		return nil, gtserror.NewErrorNotFound(fmt.Errorf("error fetching target account %s: %s", targetStatus.AccountID, err))
 	}
 
-	l.Trace("going to get relevant accounts")
-	relevantAccounts, err := p.db.PullRelevantAccountsFromStatus(targetStatus)
-	if err != nil {
-		return nil, gtserror.NewErrorNotFound(fmt.Errorf("error fetching related accounts for status %s: %s", targetStatusID, err))
-	}
-
 	var boostOfStatus *gtsmodel.Status
 	if targetStatus.BoostOfID != "" {
 		boostOfStatus = &gtsmodel.Status{}
@@ -41,7 +35,7 @@ func (p *processor) Fave(account *gtsmodel.Account, targetStatusID string) (*api
 	}
 
 	l.Trace("going to see if status is visible")
-	visible, err := p.db.StatusVisible(targetStatus, account, relevantAccounts) // requestingAccount might well be nil here, but StatusVisible knows how to take care of that
+	visible, err := p.filter.StatusVisible(targetStatus, account) // requestingAccount might well be nil here, but StatusVisible knows how to take care of that
 	if err != nil {
 		return nil, gtserror.NewErrorNotFound(fmt.Errorf("error seeing if status %s is visible: %s", targetStatus.ID, err))
 	}
@@ -98,7 +92,7 @@ func (p *processor) Fave(account *gtsmodel.Account, targetStatusID string) (*api
 	}
 
 	// return the mastodon representation of the target status
-	mastoStatus, err := p.tc.StatusToMasto(targetStatus, targetAccount, account, relevantAccounts.BoostedAccount, relevantAccounts.ReplyToAccount, boostOfStatus)
+	mastoStatus, err := p.tc.StatusToMasto(targetStatus, account)
 	if err != nil {
 		return nil, gtserror.NewErrorInternalError(fmt.Errorf("error converting status %s to frontend representation: %s", targetStatus.ID, err))
 	}
diff --git a/internal/processing/synchronous/status/favedby.go b/internal/processing/synchronous/status/favedby.go
index bda47d581..5194cc258 100644
--- a/internal/processing/synchronous/status/favedby.go
+++ b/internal/processing/synchronous/status/favedby.go
@@ -24,14 +24,8 @@ func (p *processor) FavedBy(account *gtsmodel.Account, targetStatusID string) ([
 		return nil, gtserror.NewErrorNotFound(fmt.Errorf("error fetching target account %s: %s", targetStatus.AccountID, err))
 	}
 
-	l.Trace("going to get relevant accounts")
-	relevantAccounts, err := p.db.PullRelevantAccountsFromStatus(targetStatus)
-	if err != nil {
-		return nil, gtserror.NewErrorNotFound(fmt.Errorf("error fetching related accounts for status %s: %s", targetStatusID, err))
-	}
-
 	l.Trace("going to see if status is visible")
-	visible, err := p.db.StatusVisible(targetStatus, account, relevantAccounts) // requestingAccount might well be nil here, but StatusVisible knows how to take care of that
+	visible, err := p.filter.StatusVisible(targetStatus, account)
 	if err != nil {
 		return nil, gtserror.NewErrorNotFound(fmt.Errorf("error seeing if status %s is visible: %s", targetStatus.ID, err))
 	}
diff --git a/internal/processing/synchronous/status/get.go b/internal/processing/synchronous/status/get.go
index 7dbbb4e7d..9a70185b0 100644
--- a/internal/processing/synchronous/status/get.go
+++ b/internal/processing/synchronous/status/get.go
@@ -24,14 +24,8 @@ func (p *processor) Get(account *gtsmodel.Account, targetStatusID string) (*apim
 		return nil, gtserror.NewErrorNotFound(fmt.Errorf("error fetching target account %s: %s", targetStatus.AccountID, err))
 	}
 
-	l.Trace("going to get relevant accounts")
-	relevantAccounts, err := p.db.PullRelevantAccountsFromStatus(targetStatus)
-	if err != nil {
-		return nil, gtserror.NewErrorNotFound(fmt.Errorf("error fetching related accounts for status %s: %s", targetStatusID, err))
-	}
-
 	l.Trace("going to see if status is visible")
-	visible, err := p.db.StatusVisible(targetStatus, account, relevantAccounts) // requestingAccount might well be nil here, but StatusVisible knows how to take care of that
+	visible, err := p.filter.StatusVisible(targetStatus, account) // requestingAccount might well be nil here, but StatusVisible knows how to take care of that
 	if err != nil {
 		return nil, gtserror.NewErrorNotFound(fmt.Errorf("error seeing if status %s is visible: %s", targetStatus.ID, err))
 	}
@@ -48,7 +42,7 @@ func (p *processor) Get(account *gtsmodel.Account, targetStatusID string) (*apim
 		}
 	}
 
-	mastoStatus, err := p.tc.StatusToMasto(targetStatus, targetAccount, account, relevantAccounts.BoostedAccount, relevantAccounts.ReplyToAccount, boostOfStatus)
+	mastoStatus, err := p.tc.StatusToMasto(targetStatus, account)
 	if err != nil {
 		return nil, gtserror.NewErrorInternalError(fmt.Errorf("error converting status %s to frontend representation: %s", targetStatus.ID, err))
 	}
diff --git a/internal/processing/synchronous/status/status.go b/internal/processing/synchronous/status/status.go
index 5dd26a2f0..cfc48ff30 100644
--- a/internal/processing/synchronous/status/status.go
+++ b/internal/processing/synchronous/status/status.go
@@ -8,6 +8,7 @@ import (
 	"github.com/superseriousbusiness/gotosocial/internal/gtserror"
 	"github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
 	"github.com/superseriousbusiness/gotosocial/internal/typeutils"
+	"github.com/superseriousbusiness/gotosocial/internal/visibility"
 )
 
 // Processor wraps a bunch of functions for processing statuses.
@@ -36,6 +37,7 @@ type processor struct {
 	tc            typeutils.TypeConverter
 	config        *config.Config
 	db            db.DB
+	filter        visibility.Filter
 	fromClientAPI chan gtsmodel.FromClientAPI
 	log           *logrus.Logger
 }
@@ -46,6 +48,7 @@ func New(db db.DB, tc typeutils.TypeConverter, config *config.Config, fromClient
 		tc:            tc,
 		config:        config,
 		db:            db,
+		filter:        visibility.NewFilter(db, log),
 		fromClientAPI: fromClientAPI,
 		log:           log,
 	}
diff --git a/internal/processing/synchronous/status/unfave.go b/internal/processing/synchronous/status/unfave.go
index 54cbbf509..b51daacb9 100644
--- a/internal/processing/synchronous/status/unfave.go
+++ b/internal/processing/synchronous/status/unfave.go
@@ -24,14 +24,8 @@ func (p *processor) Unfave(account *gtsmodel.Account, targetStatusID string) (*a
 		return nil, gtserror.NewErrorNotFound(fmt.Errorf("error fetching target account %s: %s", targetStatus.AccountID, err))
 	}
 
-	l.Trace("going to get relevant accounts")
-	relevantAccounts, err := p.db.PullRelevantAccountsFromStatus(targetStatus)
-	if err != nil {
-		return nil, gtserror.NewErrorNotFound(fmt.Errorf("error fetching related accounts for status %s: %s", targetStatusID, err))
-	}
-
 	l.Trace("going to see if status is visible")
-	visible, err := p.db.StatusVisible(targetStatus, account, relevantAccounts) // requestingAccount might well be nil here, but StatusVisible knows how to take care of that
+	visible, err := p.filter.StatusVisible(targetStatus, account)
 	if err != nil {
 		return nil, gtserror.NewErrorNotFound(fmt.Errorf("error seeing if status %s is visible: %s", targetStatus.ID, err))
 	}
@@ -74,16 +68,7 @@ func (p *processor) Unfave(account *gtsmodel.Account, targetStatusID string) (*a
 		}
 	}
 
-	// return the status (whatever its state) back to the caller
-	var boostOfStatus *gtsmodel.Status
-	if targetStatus.BoostOfID != "" {
-		boostOfStatus = &gtsmodel.Status{}
-		if err := p.db.GetByID(targetStatus.BoostOfID, boostOfStatus); err != nil {
-			return nil, gtserror.NewErrorInternalError(fmt.Errorf("error fetching boosted status %s: %s", targetStatus.BoostOfID, err))
-		}
-	}
-
-	mastoStatus, err := p.tc.StatusToMasto(targetStatus, targetAccount, account, relevantAccounts.BoostedAccount, relevantAccounts.ReplyToAccount, boostOfStatus)
+	mastoStatus, err := p.tc.StatusToMasto(targetStatus, account)
 	if err != nil {
 		return nil, gtserror.NewErrorInternalError(fmt.Errorf("error converting status %s to frontend representation: %s", targetStatus.ID, err))
 	}
diff --git a/internal/processing/timeline.go b/internal/processing/timeline.go
index 80e63317f..a8f42d64c 100644
--- a/internal/processing/timeline.go
+++ b/internal/processing/timeline.go
@@ -94,47 +94,15 @@ func (p *processor) filterStatuses(authed *oauth.Auth, statuses []*gtsmodel.Stat
 			return nil, gtserror.NewErrorInternalError(fmt.Errorf("HomeTimelineGet: error getting status author: %s", err))
 		}
 
-		relevantAccounts, err := p.db.PullRelevantAccountsFromStatus(s)
-		if err != nil {
-			l.Debugf("skipping status %s because we couldn't pull relevant accounts from the db", s.ID)
-			continue
-		}
-
-		visible, err := p.db.StatusVisible(s, authed.Account, relevantAccounts)
+		timelineable, err := p.filter.StatusHometimelineable(s, authed.Account)
 		if err != nil {
 			return nil, gtserror.NewErrorInternalError(fmt.Errorf("HomeTimelineGet: error checking status visibility: %s", err))
 		}
-		if !visible {
+		if !timelineable {
 			continue
 		}
 
-		var boostedStatus *gtsmodel.Status
-		if s.BoostOfID != "" {
-			bs := &gtsmodel.Status{}
-			if err := p.db.GetByID(s.BoostOfID, bs); err != nil {
-				if _, ok := err.(db.ErrNoEntries); ok {
-					l.Debugf("skipping status %s because status %s can't be found in the db", s.ID, s.BoostOfID)
-					continue
-				}
-				return nil, gtserror.NewErrorInternalError(fmt.Errorf("HomeTimelineGet: error getting boosted status: %s", err))
-			}
-			boostedRelevantAccounts, err := p.db.PullRelevantAccountsFromStatus(bs)
-			if err != nil {
-				l.Debugf("skipping status %s because we couldn't pull relevant accounts from the db", s.ID)
-				continue
-			}
-
-			boostedVisible, err := p.db.StatusVisible(bs, authed.Account, boostedRelevantAccounts)
-			if err != nil {
-				return nil, gtserror.NewErrorInternalError(fmt.Errorf("HomeTimelineGet: error checking boosted status visibility: %s", err))
-			}
-
-			if boostedVisible {
-				boostedStatus = bs
-			}
-		}
-
-		apiStatus, err := p.tc.StatusToMasto(s, targetAccount, authed.Account, relevantAccounts.BoostedAccount, relevantAccounts.ReplyToAccount, boostedStatus)
+		apiStatus, err := p.tc.StatusToMasto(s, authed.Account)
 		if err != nil {
 			l.Debugf("skipping status %s because it couldn't be converted to its mastodon representation: %s", s.ID, err)
 			continue
@@ -227,17 +195,12 @@ func (p *processor) indexAndIngest(statuses []*gtsmodel.Status, timelineAccount
 	})
 
 	for _, s := range statuses {
-		relevantAccounts, err := p.db.PullRelevantAccountsFromStatus(s)
-		if err != nil {
-			l.Error(fmt.Errorf("initTimelineFor: error getting relevant accounts from status %s: %s", s.ID, err))
-			continue
-		}
-		visible, err := p.db.StatusVisible(s, timelineAccount, relevantAccounts)
+		timelineable, err := p.filter.StatusHometimelineable(s, timelineAccount)
 		if err != nil {
-			l.Error(fmt.Errorf("initTimelineFor: error checking visibility of status %s: %s", s.ID, err))
+			l.Error(fmt.Errorf("initTimelineFor: error checking home timelineability of status %s: %s", s.ID, err))
 			continue
 		}
-		if visible {
+		if timelineable {
 			if err := p.timelineManager.Ingest(s, timelineAccount.ID); err != nil {
 				l.Error(fmt.Errorf("initTimelineFor: error ingesting status %s: %s", s.ID, err))
 				continue
diff --git a/internal/timeline/index.go b/internal/timeline/index.go
index 56f5c14df..bc1bf996b 100644
--- a/internal/timeline/index.go
+++ b/internal/timeline/index.go
@@ -10,41 +10,6 @@ import (
 )
 
 func (t *timeline) IndexBefore(statusID string, include bool, amount int) error {
-	// 	filtered := []*gtsmodel.Status{}
-	// 	offsetStatus := statusID
-
-	// grabloop:
-	// 	for len(filtered) < amount {
-	// 		statuses, err := t.db.GetStatusesWhereFollowing(t.accountID, amount, offsetStatus, include, true)
-	// 		if err != nil {
-	// 			if _, ok := err.(db.ErrNoEntries); !ok {
-	// 				return fmt.Errorf("IndexBeforeAndIncluding: error getting statuses from db: %s", err)
-	// 			}
-	// 			break grabloop // we just don't have enough statuses left in the db so index what we've got and then bail
-	// 		}
-
-	// 		for _, s := range statuses {
-	// 			relevantAccounts, err := t.db.PullRelevantAccountsFromStatus(s)
-	// 			if err != nil {
-	// 				continue
-	// 			}
-	// 			visible, err := t.db.StatusVisible(s, t.account, relevantAccounts)
-	// 			if err != nil {
-	// 				continue
-	// 			}
-	// 			if visible {
-	// 				filtered = append(filtered, s)
-	// 			}
-	// 			offsetStatus = s.ID
-	// 		}
-	// 	}
-
-	// 	for _, s := range filtered {
-	// 		if err := t.IndexOne(s.CreatedAt, s.ID); err != nil {
-	// 			return fmt.Errorf("IndexBeforeAndIncluding: error indexing status with id %s: %s", s.ID, err)
-	// 		}
-	// 	}
-
 	return nil
 }
 
@@ -63,15 +28,11 @@ grabloop:
 		}
 
 		for _, s := range statuses {
-			relevantAccounts, err := t.db.PullRelevantAccountsFromStatus(s)
+			timelineable, err := t.filter.StatusHometimelineable(s, t.account)
 			if err != nil {
 				continue
 			}
-			visible, err := t.db.StatusVisible(s, t.account, relevantAccounts)
-			if err != nil {
-				continue
-			}
-			if visible {
+			if timelineable {
 				filtered = append(filtered, s)
 			}
 			offsetStatus = s.ID
@@ -79,7 +40,7 @@ grabloop:
 	}
 
 	for _, s := range filtered {
-		if err := t.IndexOne(s.CreatedAt, s.ID); err != nil {
+		if err := t.IndexOne(s.CreatedAt, s.ID, s.BoostOfID); err != nil {
 			return fmt.Errorf("IndexBehindAndIncluding: error indexing status with id %s: %s", s.ID, err)
 		}
 	}
@@ -91,12 +52,13 @@ func (t *timeline) IndexOneByID(statusID string) error {
 	return nil
 }
 
-func (t *timeline) IndexOne(statusCreatedAt time.Time, statusID string) error {
+func (t *timeline) IndexOne(statusCreatedAt time.Time, statusID string, boostOfID string) error {
 	t.Lock()
 	defer t.Unlock()
 
 	postIndexEntry := &postIndexEntry{
-		statusID: statusID,
+		statusID:  statusID,
+		boostOfID: boostOfID,
 	}
 
 	return t.postIndex.insertIndexed(postIndexEntry)
diff --git a/internal/timeline/manager.go b/internal/timeline/manager.go
index 9d28b5060..c389a6b8a 100644
--- a/internal/timeline/manager.go
+++ b/internal/timeline/manager.go
@@ -105,7 +105,7 @@ func (m *manager) Ingest(status *gtsmodel.Status, timelineAccountID string) erro
 	t := m.getOrCreateTimeline(timelineAccountID)
 
 	l.Trace("ingesting status")
-	return t.IndexOne(status.CreatedAt, status.ID)
+	return t.IndexOne(status.CreatedAt, status.ID, status.BoostOfID)
 }
 
 func (m *manager) IngestAndPrepare(status *gtsmodel.Status, timelineAccountID string) error {
diff --git a/internal/timeline/postindex.go b/internal/timeline/postindex.go
index 2ab65e087..7142035a7 100644
--- a/internal/timeline/postindex.go
+++ b/internal/timeline/postindex.go
@@ -10,7 +10,8 @@ type postIndex struct {
 }
 
 type postIndexEntry struct {
-	statusID string
+	statusID  string
+	boostOfID string
 }
 
 func (p *postIndex) insertIndexed(i *postIndexEntry) error {
@@ -25,14 +26,26 @@ func (p *postIndex) insertIndexed(i *postIndexEntry) error {
 	}
 
 	var insertMark *list.Element
+	var position int
 	// We need to iterate through the index to make sure we put this post in the appropriate place according to when it was created.
 	// We also need to make sure we're not inserting a duplicate post -- this can happen sometimes and it's not nice UX (*shudder*).
 	for e := p.data.Front(); e != nil; e = e.Next() {
+		position = position + 1
+
 		entry, ok := e.Value.(*postIndexEntry)
 		if !ok {
 			return errors.New("index: could not parse e as a postIndexEntry")
 		}
 
+		// don't insert this if it's a boost of a status we've seen recently
+		if i.boostOfID != "" {
+			if i.boostOfID == entry.boostOfID || i.boostOfID == entry.statusID {
+				if position < boostReinsertionDepth {
+					return nil
+				}
+			}
+		}
+
 		// if the post to index is newer than e, insert it before e in the list
 		if insertMark == nil {
 			if i.statusID > entry.statusID {
diff --git a/internal/timeline/prepare.go b/internal/timeline/prepare.go
index 1fb1cd714..cd740993c 100644
--- a/internal/timeline/prepare.go
+++ b/internal/timeline/prepare.go
@@ -163,24 +163,8 @@ func (t *timeline) prepare(statusID string) error {
 		t.account = timelineOwnerAccount
 	}
 
-	// to convert the status we need relevant accounts from it, so pull them out here
-	relevantAccounts, err := t.db.PullRelevantAccountsFromStatus(gtsStatus)
-	if err != nil {
-		return err
-	}
-
-	// check if this is a boost...
-	var reblogOfStatus *gtsmodel.Status
-	if gtsStatus.BoostOfID != "" {
-		s := &gtsmodel.Status{}
-		if err := t.db.GetByID(gtsStatus.BoostOfID, s); err != nil {
-			return err
-		}
-		reblogOfStatus = s
-	}
-
 	// serialize the status (or, at least, convert it to a form that's ready to be serialized)
-	apiModelStatus, err := t.tc.StatusToMasto(gtsStatus, relevantAccounts.StatusAuthor, t.account, relevantAccounts.BoostedAccount, relevantAccounts.ReplyToAccount, reblogOfStatus)
+	apiModelStatus, err := t.tc.StatusToMasto(gtsStatus, t.account)
 	if err != nil {
 		return err
 	}
diff --git a/internal/timeline/preparedposts.go b/internal/timeline/preparedposts.go
index 429ce5415..1976189c8 100644
--- a/internal/timeline/preparedposts.go
+++ b/internal/timeline/preparedposts.go
@@ -28,14 +28,32 @@ func (p *preparedPosts) insertPrepared(i *preparedPostsEntry) error {
 	}
 
 	var insertMark *list.Element
+	var position int
 	// We need to iterate through the index to make sure we put this post in the appropriate place according to when it was created.
 	// We also need to make sure we're not inserting a duplicate post -- this can happen sometimes and it's not nice UX (*shudder*).
 	for e := p.data.Front(); e != nil; e = e.Next() {
+		position = position + 1
+
 		entry, ok := e.Value.(*preparedPostsEntry)
 		if !ok {
 			return errors.New("index: could not parse e as a preparedPostsEntry")
 		}
 
+		// don't insert this if it's a boost of a status we've seen recently
+		if i.prepared.Reblog != nil {
+			if entry.prepared.Reblog != nil && i.prepared.Reblog.ID == entry.prepared.Reblog.ID {
+				if position < boostReinsertionDepth {
+					return nil
+				}
+			}
+
+			if i.prepared.Reblog.ID == entry.statusID {
+				if position < boostReinsertionDepth {
+					return nil
+				}
+			}
+		}
+
 		// if the post to index is newer than e, insert it before e in the list
 		if insertMark == nil {
 			if i.statusID > entry.statusID {
diff --git a/internal/timeline/timeline.go b/internal/timeline/timeline.go
index 7408436dc..363c0999c 100644
--- a/internal/timeline/timeline.go
+++ b/internal/timeline/timeline.go
@@ -27,8 +27,11 @@ import (
 	"github.com/superseriousbusiness/gotosocial/internal/db"
 	"github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
 	"github.com/superseriousbusiness/gotosocial/internal/typeutils"
+	"github.com/superseriousbusiness/gotosocial/internal/visibility"
 )
 
+const boostReinsertionDepth = 50
+
 // Timeline represents a timeline for one account, and contains indexed and prepared posts.
 type Timeline interface {
 	/*
@@ -59,7 +62,7 @@ type Timeline interface {
 	*/
 
 	// IndexOne puts a status into the timeline at the appropriate place according to its 'createdAt' property.
-	IndexOne(statusCreatedAt time.Time, statusID string) error
+	IndexOne(statusCreatedAt time.Time, statusID string, boostOfID string) error
 
 	// OldestIndexedPostID returns the id of the rearmost (ie., the oldest) indexed post, or an error if something goes wrong.
 	// If nothing goes wrong but there's no oldest post, an empty string will be returned so make sure to check for this.
@@ -109,6 +112,7 @@ type timeline struct {
 	accountID     string
 	account       *gtsmodel.Account
 	db            db.DB
+	filter        visibility.Filter
 	tc            typeutils.TypeConverter
 	log           *logrus.Logger
 	sync.Mutex
@@ -121,6 +125,7 @@ func NewTimeline(accountID string, db db.DB, typeConverter typeutils.TypeConvert
 		preparedPosts: &preparedPosts{},
 		accountID:     accountID,
 		db:            db,
+		filter:        visibility.NewFilter(db, log),
 		tc:            typeConverter,
 		log:           log,
 	}
diff --git a/internal/typeutils/astointernal.go b/internal/typeutils/astointernal.go
index 5990e750f..dc58346fb 100644
--- a/internal/typeutils/astointernal.go
+++ b/internal/typeutils/astointernal.go
@@ -222,13 +222,14 @@ func (c *converter) ASStatusToStatus(statusable Statusable) (*gtsmodel.Status, e
 	if err != nil {
 		return nil, errors.New("attributedTo was empty")
 	}
-	status.APStatusOwnerURI = attributedTo.String()
+	status.AccountURI = attributedTo.String()
 
 	statusOwner := &gtsmodel.Account{}
 	if err := c.db.GetWhere([]db.Where{{Key: "uri", Value: attributedTo.String(), CaseInsensitive: true}}, statusOwner); err != nil {
 		return nil, fmt.Errorf("couldn't get status owner from db: %s", err)
 	}
 	status.AccountID = statusOwner.ID
+	status.AccountURI = statusOwner.URI
 	status.GTSAuthorAccount = statusOwner
 
 	// check if there's a post that this is a reply to
@@ -236,7 +237,7 @@ func (c *converter) ASStatusToStatus(statusable Statusable) (*gtsmodel.Status, e
 	if err == nil {
 		// something is set so we can at least set this field on the
 		// status and dereference using this later if we need to
-		status.APReplyToStatusURI = inReplyToURI.String()
+		status.InReplyToURI = inReplyToURI.String()
 
 		// now we can check if we have the replied-to status in our db already
 		inReplyToStatus := &gtsmodel.Status{}
@@ -475,6 +476,7 @@ func (c *converter) ASAnnounceToStatus(announceable Announceable) (*gtsmodel.Sta
 		return nil, isNew, fmt.Errorf("ASAnnounceToStatus: error in db fetching account with uri %s: %s", actor.String(), err)
 	}
 	status.AccountID = boostingAccount.ID
+	status.AccountURI = boostingAccount.URI
 
 	// these will all be wrapped in the boosted status so set them empty here
 	status.Attachments = []string{}
diff --git a/internal/typeutils/converter.go b/internal/typeutils/converter.go
index ab680fbdd..806090f66 100644
--- a/internal/typeutils/converter.go
+++ b/internal/typeutils/converter.go
@@ -65,7 +65,9 @@ type TypeConverter interface {
 	// TagToMasto converts a gts model tag into its mastodon (frontend) representation for serialization on the API.
 	TagToMasto(t *gtsmodel.Tag) (model.Tag, error)
 	// StatusToMasto converts a gts model status into its mastodon (frontend) representation for serialization on the API.
-	StatusToMasto(s *gtsmodel.Status, statusAuthor *gtsmodel.Account, requestingAccount *gtsmodel.Account, boostOfAccount *gtsmodel.Account, replyToAccount *gtsmodel.Account, reblogOfStatus *gtsmodel.Status) (*model.Status, error)
+	//
+	// Requesting account can be nil.
+	StatusToMasto(s *gtsmodel.Status, requestingAccount *gtsmodel.Account) (*model.Status, error)
 	// VisToMasto converts a gts visibility into its mastodon equivalent
 	VisToMasto(m gtsmodel.Visibility) model.Visibility
 	// InstanceToMasto converts a gts instance into its mastodon equivalent for serving at /api/v1/instance
diff --git a/internal/typeutils/internal.go b/internal/typeutils/internal.go
index 3b3c8bd1b..b081708a2 100644
--- a/internal/typeutils/internal.go
+++ b/internal/typeutils/internal.go
@@ -43,10 +43,11 @@ func (c *converter) StatusToBoost(s *gtsmodel.Status, boostingAccount *gtsmodel.
 		URL: boostWrapperStatusURL,
 
 		// the boosted status is not created now, but the boost certainly is
-		CreatedAt: time.Now(),
-		UpdatedAt: time.Now(),
-		Local:     local,
-		AccountID: boostingAccount.ID,
+		CreatedAt:  time.Now(),
+		UpdatedAt:  time.Now(),
+		Local:      local,
+		AccountID:  boostingAccount.ID,
+		AccountURI: boostingAccount.URI,
 
 		// replies can be boosted, but boosts are never replies
 		InReplyToID:        "",
diff --git a/internal/typeutils/internaltofrontend.go b/internal/typeutils/internaltofrontend.go
index 1c283e9b8..90460ecdd 100644
--- a/internal/typeutils/internaltofrontend.go
+++ b/internal/typeutils/internaltofrontend.go
@@ -268,14 +268,7 @@ func (c *converter) TagToMasto(t *gtsmodel.Tag) (model.Tag, error) {
 	}, nil
 }
 
-func (c *converter) StatusToMasto(
-	s *gtsmodel.Status,
-	statusAuthor *gtsmodel.Account,
-	requestingAccount *gtsmodel.Account,
-	boostOfAccount *gtsmodel.Account,
-	replyToAccount *gtsmodel.Account,
-	reblogOfStatus *gtsmodel.Status) (*model.Status, error) {
-
+func (c *converter) StatusToMasto(s *gtsmodel.Status, requestingAccount *gtsmodel.Account) (*model.Status, error) {
 	repliesCount, err := c.db.GetReplyCountForStatus(s)
 	if err != nil {
 		return nil, fmt.Errorf("error counting replies: %s", err)
@@ -291,82 +284,32 @@ func (c *converter) StatusToMasto(
 		return nil, fmt.Errorf("error counting faves: %s", err)
 	}
 
-	var faved bool
-	var reblogged bool
-	var bookmarked bool
-	var muted bool
-
-	// requestingAccount will be nil for public requests without auth
-	// But if it's not nil, we can also get information about the requestingAccount's interaction with this status
-	if requestingAccount != nil {
-		faved, err = c.db.StatusFavedBy(s, requestingAccount.ID)
-		if err != nil {
-			return nil, fmt.Errorf("error checking if requesting account has faved status: %s", err)
-		}
-
-		reblogged, err = c.db.StatusRebloggedBy(s, requestingAccount.ID)
-		if err != nil {
-			return nil, fmt.Errorf("error checking if requesting account has reblogged status: %s", err)
-		}
-
-		muted, err = c.db.StatusMutedBy(s, requestingAccount.ID)
-		if err != nil {
-			return nil, fmt.Errorf("error checking if requesting account has muted status: %s", err)
-		}
-
-		bookmarked, err = c.db.StatusBookmarkedBy(s, requestingAccount.ID)
-		if err != nil {
-			return nil, fmt.Errorf("error checking if requesting account has bookmarked status: %s", err)
-		}
-	}
-
 	var mastoRebloggedStatus *model.Status
 	if s.BoostOfID != "" {
 		// the boosted status might have been set on this struct already so check first before doing db calls
-		var gtsBoostedStatus *gtsmodel.Status
-		if s.GTSBoostedStatus != nil {
-			// it's set, great!
-			gtsBoostedStatus = s.GTSBoostedStatus
-		} else {
+		if s.GTSBoostedStatus == nil {
 			// it's not set so fetch it from the db
-			gtsBoostedStatus = &gtsmodel.Status{}
-			if err := c.db.GetByID(s.BoostOfID, gtsBoostedStatus); err != nil {
+			bs := &gtsmodel.Status{}
+			if err := c.db.GetByID(s.BoostOfID, bs); err != nil {
 				return nil, fmt.Errorf("error getting boosted status with id %s: %s", s.BoostOfID, err)
 			}
+			s.GTSBoostedStatus = bs
 		}
 
 		// the boosted account might have been set on this struct already or passed as a param so check first before doing db calls
-		var gtsBoostedAccount *gtsmodel.Account
-		if s.GTSBoostedAccount != nil {
-			// it's set, great!
-			gtsBoostedAccount = s.GTSBoostedAccount
-		} else if boostOfAccount != nil {
-			// it's been given as a param, great!
-			gtsBoostedAccount = boostOfAccount
-		} else if boostOfAccount == nil && s.GTSBoostedAccount == nil {
+		if s.GTSBoostedAccount == nil {
 			// it's not set so fetch it from the db
-			gtsBoostedAccount = &gtsmodel.Account{}
-			if err := c.db.GetByID(gtsBoostedStatus.AccountID, gtsBoostedAccount); err != nil {
-				return nil, fmt.Errorf("error getting boosted account %s from status with id %s: %s", gtsBoostedStatus.AccountID, s.BoostOfID, err)
+			ba := &gtsmodel.Account{}
+			if err := c.db.GetByID(s.GTSBoostedStatus.AccountID, ba); err != nil {
+				return nil, fmt.Errorf("error getting boosted account %s from status with id %s: %s", s.GTSBoostedStatus.AccountID, s.BoostOfID, err)
 			}
+			s.GTSBoostedAccount = ba
+			s.GTSBoostedStatus.GTSAuthorAccount = ba
 		}
 
-		// the boosted status might be a reply so check this
-		var gtsBoostedReplyToAccount *gtsmodel.Account
-		if gtsBoostedStatus.InReplyToAccountID != "" {
-			gtsBoostedReplyToAccount = &gtsmodel.Account{}
-			if err := c.db.GetByID(gtsBoostedStatus.InReplyToAccountID, gtsBoostedReplyToAccount); err != nil {
-				return nil, fmt.Errorf("error getting account that boosted status was a reply to: %s", err)
-			}
-		}
-
-		if gtsBoostedStatus != nil || gtsBoostedAccount != nil {
-			mastoRebloggedStatus, err = c.StatusToMasto(gtsBoostedStatus, gtsBoostedAccount, requestingAccount, nil, gtsBoostedReplyToAccount, nil)
-			if err != nil {
-				return nil, fmt.Errorf("error converting boosted status to mastotype: %s", err)
-			}
-		} else {
-			return nil, fmt.Errorf("boost of id was set to %s but that status or account was nil", s.BoostOfID)
+		mastoRebloggedStatus, err = c.StatusToMasto(s.GTSBoostedStatus, requestingAccount)
+		if err != nil {
+			return nil, fmt.Errorf("error converting boosted status to mastotype: %s", err)
 		}
 	}
 
@@ -382,7 +325,15 @@ func (c *converter) StatusToMasto(
 		}
 	}
 
-	mastoAuthorAccount, err := c.AccountToMastoPublic(statusAuthor)
+	if s.GTSAuthorAccount == nil {
+		a := &gtsmodel.Account{}
+		if err := c.db.GetByID(s.AccountID, a); err != nil {
+			return nil, fmt.Errorf("error getting status author: %s", err)
+		}
+		s.GTSAuthorAccount = a
+	}
+
+	mastoAuthorAccount, err := c.AccountToMastoPublic(s.GTSAuthorAccount)
 	if err != nil {
 		return nil, fmt.Errorf("error parsing account of status author: %s", err)
 	}
@@ -498,6 +449,12 @@ func (c *converter) StatusToMasto(
 	var mastoCard *model.Card
 	var mastoPoll *model.Poll
 
+	statusInteractions := &statusInteractions{}
+	si, err := c.interactionsWithStatusForAccount(s, requestingAccount)
+	if err == nil {
+		statusInteractions = si
+	}
+
 	return &model.Status{
 		ID:                 s.ID,
 		CreatedAt:          s.CreatedAt.Format(time.RFC3339),
@@ -512,10 +469,10 @@ func (c *converter) StatusToMasto(
 		RepliesCount:       repliesCount,
 		ReblogsCount:       reblogsCount,
 		FavouritesCount:    favesCount,
-		Favourited:         faved,
-		Reblogged:          reblogged,
-		Muted:              muted,
-		Bookmarked:         bookmarked,
+		Favourited:         statusInteractions.Faved,
+		Bookmarked:         statusInteractions.Bookmarked,
+		Muted:              statusInteractions.Muted,
+		Reblogged:          statusInteractions.Reblogged,
 		Pinned:             s.Pinned,
 		Content:            s.Content,
 		Reblog:             mastoRebloggedStatus,
@@ -630,15 +587,6 @@ func (c *converter) NotificationToMasto(n *gtsmodel.Notification) (*model.Notifi
 			n.GTSStatus = status
 		}
 
-		var replyToAccount *gtsmodel.Account
-		if n.GTSStatus.InReplyToAccountID != "" {
-			r := &gtsmodel.Account{}
-			if err := c.db.GetByID(n.GTSStatus.InReplyToAccountID, r); err != nil {
-				return nil, fmt.Errorf("NotificationToMasto: error getting replied to account with id %s from the db: %s", n.GTSStatus.InReplyToAccountID, err)
-			}
-			replyToAccount = r
-		}
-
 		if n.GTSStatus.GTSAuthorAccount == nil {
 			if n.GTSStatus.AccountID == n.GTSTargetAccount.ID {
 				n.GTSStatus.GTSAuthorAccount = n.GTSTargetAccount
@@ -648,7 +596,7 @@ func (c *converter) NotificationToMasto(n *gtsmodel.Notification) (*model.Notifi
 		}
 
 		var err error
-		mastoStatus, err = c.StatusToMasto(n.GTSStatus, n.GTSStatus.GTSAuthorAccount, n.GTSTargetAccount, nil, replyToAccount, nil)
+		mastoStatus, err = c.StatusToMasto(n.GTSStatus, nil)
 		if err != nil {
 			return nil, fmt.Errorf("NotificationToMasto: error converting status to masto: %s", err)
 		}
diff --git a/internal/typeutils/util.go b/internal/typeutils/util.go
new file mode 100644
index 000000000..1e13f0713
--- /dev/null
+++ b/internal/typeutils/util.go
@@ -0,0 +1,46 @@
+package typeutils
+
+import (
+	"fmt"
+
+	"github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
+)
+
+func (c *converter) interactionsWithStatusForAccount(s *gtsmodel.Status, requestingAccount *gtsmodel.Account) (*statusInteractions, error) {
+	si := &statusInteractions{}
+
+	if requestingAccount != nil {
+		faved, err := c.db.StatusFavedBy(s, requestingAccount.ID)
+		if err != nil {
+			return nil, fmt.Errorf("error checking if requesting account has faved status: %s", err)
+		}
+		si.Faved = faved
+
+		reblogged, err := c.db.StatusRebloggedBy(s, requestingAccount.ID)
+		if err != nil {
+			return nil, fmt.Errorf("error checking if requesting account has reblogged status: %s", err)
+		}
+		si.Reblogged = reblogged
+
+		muted, err := c.db.StatusMutedBy(s, requestingAccount.ID)
+		if err != nil {
+			return nil, fmt.Errorf("error checking if requesting account has muted status: %s", err)
+		}
+		si.Muted = muted
+
+		bookmarked, err := c.db.StatusBookmarkedBy(s, requestingAccount.ID)
+		if err != nil {
+			return nil, fmt.Errorf("error checking if requesting account has bookmarked status: %s", err)
+		}
+		si.Bookmarked = bookmarked
+	}
+	return si, nil
+}
+
+// StatusInteractions denotes interactions with a status on behalf of an account.
+type statusInteractions struct {
+	Faved      bool
+	Muted      bool
+	Bookmarked bool
+	Reblogged  bool
+}
diff --git a/internal/visibility/filter.go b/internal/visibility/filter.go
new file mode 100644
index 000000000..d12ad0ff6
--- /dev/null
+++ b/internal/visibility/filter.go
@@ -0,0 +1,33 @@
+package visibility
+
+import (
+	"github.com/sirupsen/logrus"
+	"github.com/superseriousbusiness/gotosocial/internal/db"
+	"github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
+)
+
+// Filter packages up a bunch of logic for checking whether given statuses or accounts are visible to a requester.
+type Filter interface {
+	// StatusVisible returns true if targetStatus is visible to requestingAccount, based on the
+	// privacy settings of the status, and any blocks/mutes that might exist between the two accounts
+	// or account domains, and other relevant accounts mentioned in or replied to by the status.
+	StatusVisible(targetStatus *gtsmodel.Status, requestingAccount *gtsmodel.Account) (bool, error)
+
+	// StatusHometimelineable returns true if targetStatus should be in the home timeline of the requesting account.
+	//
+	// This function will call StatusVisible internally, so it's not necessary to call it beforehand.
+	StatusHometimelineable(targetStatus *gtsmodel.Status, requestingAccount *gtsmodel.Account) (bool, error)
+}
+
+type filter struct {
+	db  db.DB
+	log *logrus.Logger
+}
+
+// NewFilter returns a new Filter interface that will use the provided database and logger.
+func NewFilter(db db.DB, log *logrus.Logger) Filter {
+	return &filter{
+		db:  db,
+		log: log,
+	}
+}
diff --git a/internal/visibility/statushometimelineable.go b/internal/visibility/statushometimelineable.go
new file mode 100644
index 000000000..bc5f7bcb8
--- /dev/null
+++ b/internal/visibility/statushometimelineable.go
@@ -0,0 +1,75 @@
+package visibility
+
+import (
+	"fmt"
+
+	"github.com/sirupsen/logrus"
+	"github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
+)
+
+func (f *filter) StatusHometimelineable(targetStatus *gtsmodel.Status, timelineOwnerAccount *gtsmodel.Account) (bool, error) {
+	l := f.log.WithFields(logrus.Fields{
+		"func":     "StatusHometimelineable",
+		"statusID": targetStatus.ID,
+	})
+
+	// status owner should always be able to see their own status in their timeline so we can return early if this is the case
+	if timelineOwnerAccount != nil && targetStatus.AccountID == timelineOwnerAccount.ID {
+		return true, nil
+	}
+
+	v, err := f.StatusVisible(targetStatus, timelineOwnerAccount)
+	if err != nil {
+		return false, fmt.Errorf("StatusHometimelineable: error checking visibility of status with id %s: %s", targetStatus.ID, err)
+	}
+
+	if !v {
+		l.Debug("status is not hometimelineable because it's not visible to the requester")
+		return false, nil
+	}
+
+	// Don't timeline a status whose parent hasn't been dereferenced yet or can't be dereferenced.
+	// If we have the reply to URI but don't have an ID for the replied-to account or the replied-to status in our database, we haven't dereferenced it yet.
+	if targetStatus.InReplyToURI != "" && (targetStatus.InReplyToID == "" || targetStatus.InReplyToAccountID == "") {
+		return false, nil
+	}
+
+	// if a status replies to an ID we know in the database, we need to make sure we also follow the replied-to status owner account
+	if targetStatus.InReplyToID != "" {
+		// pin the reply to status on to this status if it hasn't been done already
+		if targetStatus.GTSReplyToStatus == nil {
+			rs := &gtsmodel.Status{}
+			if err := f.db.GetByID(targetStatus.InReplyToID, rs); err != nil {
+				return false, fmt.Errorf("StatusHometimelineable: error getting replied to status with id %s: %s", targetStatus.InReplyToID, err)
+			}
+			targetStatus.GTSReplyToStatus = rs
+		}
+
+		// pin the reply to account on to this status if it hasn't been done already
+		if targetStatus.GTSReplyToAccount == nil {
+			ra := &gtsmodel.Account{}
+			if err := f.db.GetByID(targetStatus.InReplyToAccountID, ra); err != nil {
+				return false, fmt.Errorf("StatusHometimelineable: error getting replied to account with id %s: %s", targetStatus.InReplyToAccountID, err)
+			}
+			targetStatus.GTSReplyToAccount = ra
+		}
+
+		// if it's a reply to the timelineOwnerAccount, we don't need to check if the timelineOwnerAccount follows itself, just return true, they can see it
+		if targetStatus.AccountID == timelineOwnerAccount.ID {
+			return true, nil
+		}
+
+		// the replied-to account != timelineOwnerAccount, so make sure the timelineOwnerAccount follows the replied-to account
+		follows, err := f.db.Follows(timelineOwnerAccount, targetStatus.GTSReplyToAccount)
+		if err != nil {
+			return false, fmt.Errorf("StatusHometimelineable: error checking follow from account %s to account %s: %s", timelineOwnerAccount.ID, targetStatus.InReplyToAccountID, err)
+		}
+
+		// we don't want to timeline a reply to a status whose owner isn't followed by the requesting account
+		if !follows {
+			return false, nil
+		}
+	}
+
+	return true, nil
+}
diff --git a/internal/visibility/statusvisible.go b/internal/visibility/statusvisible.go
new file mode 100644
index 000000000..caf5cfcfd
--- /dev/null
+++ b/internal/visibility/statusvisible.go
@@ -0,0 +1,197 @@
+package visibility
+
+import (
+	"errors"
+
+	"fmt"
+
+	"github.com/sirupsen/logrus"
+	"github.com/superseriousbusiness/gotosocial/internal/db"
+	"github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
+)
+
+func (f *filter) StatusVisible(targetStatus *gtsmodel.Status, requestingAccount *gtsmodel.Account) (bool, error) {
+	l := f.log.WithFields(logrus.Fields{
+		"func":                "StatusVisible",
+		"statusID":            targetStatus.ID,
+		"requestingAccountID": requestingAccount.ID,
+	})
+
+	relevantAccounts, err := f.pullRelevantAccountsFromStatus(targetStatus)
+	if err != nil {
+		l.Debugf("error pulling relevant accounts for status %s: %s", targetStatus.ID, err)
+	}
+	targetAccount := relevantAccounts.StatusAuthor
+
+	// if target account is suspended then don't show the status
+	if !targetAccount.SuspendedAt.IsZero() {
+		l.Trace("target account suspended at is not zero")
+		return false, nil
+	}
+
+	// if the target user doesn't exist (anymore) then the status also shouldn't be visible
+	// note: we only do this for local users
+	if targetAccount.Domain == "" {
+		targetUser := &gtsmodel.User{}
+		if err := f.db.GetWhere([]db.Where{{Key: "account_id", Value: targetAccount.ID}}, targetUser); err != nil {
+			l.Debug("target user could not be selected")
+			if _, ok := err.(db.ErrNoEntries); ok {
+				return false, nil
+			}
+			return false, fmt.Errorf("StatusVisible: db error selecting user for local target account %s: %s", targetAccount.ID, err)
+		}
+
+		// if target user is disabled, not yet approved, or not confirmed then don't show the status
+		// (although in the latter two cases it's unlikely they posted a status yet anyway, but you never know!)
+		if targetUser.Disabled || !targetUser.Approved || targetUser.ConfirmedAt.IsZero() {
+			l.Trace("target user is disabled, not approved, or not confirmed")
+			return false, nil
+		}
+	}
+
+	// if the requesting user doesn't exist (anymore) then the status also shouldn't be visible
+	// note: we only do this for local users
+	if requestingAccount.Domain == "" {
+		requestingUser := &gtsmodel.User{}
+		if err := f.db.GetWhere([]db.Where{{Key: "account_id", Value: requestingAccount.ID}}, requestingUser); err != nil {
+			// if the requesting account is local but doesn't have a corresponding user in the db this is a problem
+			l.Debug("requesting user could not be selected")
+			if _, ok := err.(db.ErrNoEntries); ok {
+				return false, nil
+			}
+			return false, fmt.Errorf("StatusVisible: db error selecting user for local requesting account %s: %s", requestingAccount.ID, err)
+		}
+		// okay, user exists, so make sure it has full privileges/is confirmed/approved
+		if requestingUser.Disabled || !requestingUser.Approved || requestingUser.ConfirmedAt.IsZero() {
+			l.Trace("requesting account is local but corresponding user is either disabled, not approved, or not confirmed")
+			return false, nil
+		}
+	}
+
+	// If requesting account is nil, that means whoever requested the status didn't auth, or their auth failed.
+	// In this case, we can still serve the status if it's public, otherwise we definitely shouldn't.
+	if requestingAccount == nil {
+		if targetStatus.Visibility == gtsmodel.VisibilityPublic {
+			return true, nil
+		}
+		l.Trace("requesting account is nil but the target status isn't public")
+		return false, nil
+	}
+
+	// if requesting account is suspended then don't show the status -- although they probably shouldn't have gotten
+	// this far (ie., been authed) in the first place: this is just for safety.
+	if !requestingAccount.SuspendedAt.IsZero() {
+		l.Trace("requesting account is suspended")
+		return false, nil
+	}
+
+	// if the target status belongs to the requesting account, they should always be able to view it at this point
+	if targetStatus.AccountID == requestingAccount.ID {
+		return true, nil
+	}
+
+	// At this point we have a populated targetAccount, targetStatus, and requestingAccount, so we can check for blocks and whathaveyou
+	// First check if a block exists directly between the target account (which authored the status) and the requesting account.
+	if blocked, err := f.db.Blocked(targetAccount.ID, requestingAccount.ID); err != nil {
+		l.Debugf("something went wrong figuring out if the accounts have a block: %s", err)
+		return false, err
+	} else if blocked {
+		// don't allow the status to be viewed if a block exists in *either* direction between these two accounts, no creepy stalking please
+		l.Trace("a block exists between requesting account and target account")
+		return false, nil
+	}
+
+	// status replies to account id
+	if relevantAccounts.ReplyToAccount != nil && relevantAccounts.ReplyToAccount.ID != requestingAccount.ID {
+		if blocked, err := f.db.Blocked(relevantAccounts.ReplyToAccount.ID, requestingAccount.ID); err != nil {
+			return false, err
+		} else if blocked {
+			l.Trace("a block exists between requesting account and reply to account")
+			return false, nil
+		}
+
+		// check reply to ID
+		if targetStatus.InReplyToID != "" && (targetStatus.Visibility == gtsmodel.VisibilityFollowersOnly || targetStatus.Visibility == gtsmodel.VisibilityDirect) {
+			followsRepliedAccount, err := f.db.Follows(requestingAccount, relevantAccounts.ReplyToAccount)
+			if err != nil {
+				return false, err
+			}
+			if !followsRepliedAccount {
+				l.Trace("target status is a followers-only reply to an account that is not followed by the requesting account")
+				return false, nil
+			}
+		}
+	}
+
+	// status boosts accounts id
+	if relevantAccounts.BoostedAccount != nil {
+		if blocked, err := f.db.Blocked(relevantAccounts.BoostedAccount.ID, requestingAccount.ID); err != nil {
+			return false, err
+		} else if blocked {
+			l.Trace("a block exists between requesting account and boosted account")
+			return false, nil
+		}
+	}
+
+	// status boosts a reply to account id
+	if relevantAccounts.BoostedReplyToAccount != nil {
+		if blocked, err := f.db.Blocked(relevantAccounts.BoostedReplyToAccount.ID, requestingAccount.ID); err != nil {
+			return false, err
+		} else if blocked {
+			l.Trace("a block exists between requesting account and boosted reply to account")
+			return false, nil
+		}
+	}
+
+	// status mentions accounts
+	for _, a := range relevantAccounts.MentionedAccounts {
+		if blocked, err := f.db.Blocked(a.ID, requestingAccount.ID); err != nil {
+			return false, err
+		} else if blocked {
+			l.Trace("a block exists between requesting account and a mentioned account")
+			return false, nil
+		}
+	}
+
+	// if the requesting account is mentioned in the status it should always be visible
+	for _, acct := range relevantAccounts.MentionedAccounts {
+		if acct.ID == requestingAccount.ID {
+			return true, nil // yep it's mentioned!
+		}
+	}
+
+	// at this point we know neither account blocks the other, or another account mentioned or otherwise referred to in the status
+	// that means it's now just a matter of checking the visibility settings of the status itself
+	switch targetStatus.Visibility {
+	case gtsmodel.VisibilityPublic, gtsmodel.VisibilityUnlocked:
+		// no problem here, just return OK
+		return true, nil
+	case gtsmodel.VisibilityFollowersOnly:
+		// check one-way follow
+		follows, err := f.db.Follows(requestingAccount, targetAccount)
+		if err != nil {
+			return false, err
+		}
+		if !follows {
+			l.Trace("requested status is followers only but requesting account is not a follower")
+			return false, nil
+		}
+		return true, nil
+	case gtsmodel.VisibilityMutualsOnly:
+		// check mutual follow
+		mutuals, err := f.db.Mutuals(requestingAccount, targetAccount)
+		if err != nil {
+			return false, err
+		}
+		if !mutuals {
+			l.Trace("requested status is mutuals only but accounts aren't mufos")
+			return false, nil
+		}
+		return true, nil
+	case gtsmodel.VisibilityDirect:
+		l.Trace("requesting account requests a status it's not mentioned in")
+		return false, nil // it's not mentioned -_-
+	}
+
+	return false, errors.New("reached the end of StatusVisible with no result")
+}
diff --git a/internal/visibility/util.go b/internal/visibility/util.go
new file mode 100644
index 000000000..f52661d0b
--- /dev/null
+++ b/internal/visibility/util.go
@@ -0,0 +1,81 @@
+package visibility
+
+import (
+	"fmt"
+
+	"github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
+)
+
+func (f *filter) pullRelevantAccountsFromStatus(targetStatus *gtsmodel.Status) (*relevantAccounts, error) {
+	accounts := &relevantAccounts{
+		MentionedAccounts: []*gtsmodel.Account{},
+	}
+
+	// get the author account
+	if targetStatus.GTSAuthorAccount == nil {
+		statusAuthor := &gtsmodel.Account{}
+		if err := f.db.GetByID(targetStatus.AccountID, statusAuthor); err != nil {
+			return accounts, fmt.Errorf("PullRelevantAccountsFromStatus: error getting statusAuthor with id %s: %s", targetStatus.AccountID, err)
+		}
+		targetStatus.GTSAuthorAccount = statusAuthor
+	}
+	accounts.StatusAuthor = targetStatus.GTSAuthorAccount
+
+	// get the replied to account from the status and add it to the pile
+	if targetStatus.InReplyToAccountID != "" {
+		repliedToAccount := &gtsmodel.Account{}
+		if err := f.db.GetByID(targetStatus.InReplyToAccountID, repliedToAccount); err != nil {
+			return accounts, fmt.Errorf("PullRelevantAccountsFromStatus: error getting repliedToAcount with id %s: %s", targetStatus.InReplyToAccountID, err)
+		}
+		accounts.ReplyToAccount = repliedToAccount
+	}
+
+	// get the boosted account from the status and add it to the pile
+	if targetStatus.BoostOfID != "" {
+		// retrieve the boosted status first
+		boostedStatus := &gtsmodel.Status{}
+		if err := f.db.GetByID(targetStatus.BoostOfID, boostedStatus); err != nil {
+			return accounts, fmt.Errorf("PullRelevantAccountsFromStatus: error getting boostedStatus with id %s: %s", targetStatus.BoostOfID, err)
+		}
+		boostedAccount := &gtsmodel.Account{}
+		if err := f.db.GetByID(boostedStatus.AccountID, boostedAccount); err != nil {
+			return accounts, fmt.Errorf("PullRelevantAccountsFromStatus: error getting boostedAccount with id %s: %s", boostedStatus.AccountID, err)
+		}
+		accounts.BoostedAccount = boostedAccount
+
+		// the boosted status might be a reply to another account so we should get that too
+		if boostedStatus.InReplyToAccountID != "" {
+			boostedStatusRepliedToAccount := &gtsmodel.Account{}
+			if err := f.db.GetByID(boostedStatus.InReplyToAccountID, boostedStatusRepliedToAccount); err != nil {
+				return accounts, fmt.Errorf("PullRelevantAccountsFromStatus: error getting boostedStatusRepliedToAccount with id %s: %s", boostedStatus.InReplyToAccountID, err)
+			}
+			accounts.BoostedReplyToAccount = boostedStatusRepliedToAccount
+		}
+	}
+
+	// now get all accounts with IDs that are mentioned in the status
+	for _, mentionID := range targetStatus.Mentions {
+
+		mention := &gtsmodel.Mention{}
+		if err := f.db.GetByID(mentionID, mention); err != nil {
+			return accounts, fmt.Errorf("PullRelevantAccountsFromStatus: error getting mention with id %s: %s", mentionID, err)
+		}
+
+		mentionedAccount := &gtsmodel.Account{}
+		if err := f.db.GetByID(mention.TargetAccountID, mentionedAccount); err != nil {
+			return accounts, fmt.Errorf("PullRelevantAccountsFromStatus: error getting mentioned account: %s", err)
+		}
+		accounts.MentionedAccounts = append(accounts.MentionedAccounts, mentionedAccount)
+	}
+
+	return accounts, nil
+}
+
+// relevantAccounts denotes accounts that are replied to, boosted by, or mentioned in a status.
+type relevantAccounts struct {
+	StatusAuthor          *gtsmodel.Account
+	ReplyToAccount        *gtsmodel.Account
+	BoostedAccount        *gtsmodel.Account
+	BoostedReplyToAccount *gtsmodel.Account
+	MentionedAccounts     []*gtsmodel.Account
+}