[performance] rewrite timelines to rely on new timeline cache type (#3941)

* start work rewriting timeline cache type

* further work rewriting timeline caching

* more work integration new timeline code

* remove old code

* add local timeline, fix up merge conflicts

* remove old use of go-bytes

* implement new timeline code into more areas of codebase, pull in latest go-mangler, go-mutexes, go-structr

* remove old timeline package, add local timeline cache

* remove references to old timeline types that needed starting up in tests

* start adding page validation

* fix test-identified timeline cache package issues

* fix up more tests, fix missing required changes, etc

* add exclusion for test.out in gitignore

* clarify some things better in code comments

* tweak cache size limits

* fix list timeline cache fetching

* further list timeline fixes

* linter, ssssssssshhhhhhhhhhhh please

* fix linter hints

* reslice the output if it's beyond length of 'lim'

* remove old timeline initialization code, bump go-structr to v0.9.4

* continued from previous commit

* improved code comments

* don't allow multiple entries for BoostOfID values to prevent repeated boosts of same boosts

* finish writing more code comments

* some variable renaming, for ease of following

* change the way we update lo,hi paging values during timeline load

* improved code comments for updated / returned lo , hi paging values

* finish writing code comments for the StatusTimeline{} type itself

* fill in more code comments

* update go-structr version to latest with changed timeline unique indexing logic

* have a local and public timeline *per user*

* rewrite calls to public / local timeline calls

* remove the zero length check, as lo, hi values might still be set

* simplify timeline cache loading, fix lo/hi returns, fix timeline invalidation side-effects missing for some federated actions

* swap the lo, hi values :facepalm:

* add (now) missing slice reverse of tag timeline statuses when paging ASC

* remove local / public caches (is out of scope for this work), share more timeline code

* remove unnecessary change

* again, remove more unused code

* remove unused function to appease the linter

* move boost checking to prepare function

* fix use of timeline.lastOrder, fix incorrect range functions used

* remove comments for repeat code

* remove the boost logic from prepare function

* do a maximum of 5 loads, not 10

* add repeat boost filtering logic, update go-structr, general improvements

* more code comments

* add important note

* fix timeline tests now that timelines are returned in page order

* remove unused field

* add StatusTimeline{} tests

* add more status timeline tests

* start adding preloading support

* ensure repeat boosts are marked in preloaded entries

* share a bunch of the database load code in timeline cache, don't clear timelines on relationship change

* add logic to allow dynamic clear / preloading of timelines

* comment-out unused functions, but leave in place as we might end-up using them

* fix timeline preload state check

* much improved status timeline code comments

* more code comments, don't bother inserting statuses if timeline not preloaded

* shift around some logic to make sure things aren't accidentally left set

* finish writing code comments

* remove trim-after-insert behaviour

* fix-up some comments referring to old logic

* remove unsetting of lo, hi

* fix preload repeatBoost checking logic

* don't return on status filter errors, these are usually transient

* better concurrency safety in Clear() and Done()

* fix test broken due to addition of preloader

* fix repeatBoost logic that doesn't account for already-hidden repeatBoosts

* ensure edit submodels are dropped on cache insertion

* update code-comment to expand CAS accronym

* use a plus1hULID() instead of 24h

* remove unused functions

* add note that public / local timeline requester can be nil

* fix incorrect visibility filtering of tag timeline statuses

* ensure we filter home timeline statuses on local only

* some small re-orderings to confirm query params in correct places

* fix the local only home timeline filter func

6 files changed, 345 insertions, 646 deletions

diff --git a/internal/db/bundb/bundb_test.go b/internal/db/bundb/bundb_test.go
index c128eca27..dc22dbcf4 100644
--- a/internal/db/bundb/bundb_test.go
+++ b/internal/db/bundb/bundb_test.go
@@ -20,10 +20,8 @@ package bundb_test
 import (
 	"github.com/stretchr/testify/suite"
 	"github.com/superseriousbusiness/gotosocial/internal/db"
-	"github.com/superseriousbusiness/gotosocial/internal/filter/visibility"
 	"github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
 	"github.com/superseriousbusiness/gotosocial/internal/state"
-	"github.com/superseriousbusiness/gotosocial/internal/typeutils"
 	"github.com/superseriousbusiness/gotosocial/testrig"
 )
 
@@ -90,8 +88,6 @@ func (suite *BunDBStandardTestSuite) SetupTest() {
 	testrig.InitTestLog()
 	suite.state.Caches.Init()
 	suite.db = testrig.NewTestDB(&suite.state)
-	converter := typeutils.NewConverter(&suite.state)
-	testrig.StartTimelines(&suite.state, visibility.NewFilter(&suite.state), converter)
 	testrig.StandardDBSetup(suite.db, suite.testAccounts)
 }
 
diff --git a/internal/db/bundb/list.go b/internal/db/bundb/list.go
index f81c59c42..75296bc57 100644
--- a/internal/db/bundb/list.go
+++ b/internal/db/bundb/list.go
@@ -87,7 +87,7 @@ func (l *listDB) getList(ctx context.Context, lookup string, dbQuery func(*gtsmo
 }
 
 func (l *listDB) GetListsByAccountID(ctx context.Context, accountID string) ([]*gtsmodel.List, error) {
-	listIDs, err := l.getListIDsByAccountID(ctx, accountID)
+	listIDs, err := l.GetListIDsByAccountID(ctx, accountID)
 	if err != nil {
 		return nil, err
 	}
@@ -95,7 +95,7 @@ func (l *listDB) GetListsByAccountID(ctx context.Context, accountID string) ([]*
 }
 
 func (l *listDB) CountListsByAccountID(ctx context.Context, accountID string) (int, error) {
-	listIDs, err := l.getListIDsByAccountID(ctx, accountID)
+	listIDs, err := l.GetListIDsByAccountID(ctx, accountID)
 	return len(listIDs), err
 }
 
@@ -176,10 +176,8 @@ func (l *listDB) UpdateList(ctx context.Context, list *gtsmodel.List, columns ..
 		return err
 	}
 
-	// Invalidate this entire list's timeline.
-	if err := l.state.Timelines.List.RemoveTimeline(ctx, list.ID); err != nil {
-		log.Errorf(ctx, "error invalidating list timeline: %q", err)
-	}
+	// Clear cached timeline associated with list ID.
+	l.state.Caches.Timelines.List.Clear(list.ID)
 
 	return nil
 }
@@ -221,10 +219,13 @@ func (l *listDB) DeleteListByID(ctx context.Context, id string) error {
 	// Invalidate all related entry caches for this list.
 	l.invalidateEntryCaches(ctx, []string{id}, followIDs)
 
+	// Delete the cached timeline of list.
+	l.state.Caches.Timelines.List.Delete(id)
+
 	return nil
 }
 
-func (l *listDB) getListIDsByAccountID(ctx context.Context, accountID string) ([]string, error) {
+func (l *listDB) GetListIDsByAccountID(ctx context.Context, accountID string) ([]string, error) {
 	return l.state.Caches.DB.ListIDs.Load("a"+accountID, func() ([]string, error) {
 		var listIDs []string
 
@@ -461,10 +462,8 @@ func (l *listDB) invalidateEntryCaches(ctx context.Context, listIDs, followIDs [
 			"f"+listID,
 		)
 
-		// Invalidate the timeline for the list this entry belongs to.
-		if err := l.state.Timelines.List.RemoveTimeline(ctx, listID); err != nil {
-			log.Errorf(ctx, "error invalidating list timeline: %q", err)
-		}
+		// Invalidate list timeline cache by ID.
+		l.state.Caches.Timelines.List.Clear(listID)
 	}
 
 	// Invalidate ListedID slice cache entries.
diff --git a/internal/db/bundb/timeline.go b/internal/db/bundb/timeline.go
index 404cb6601..8278de647 100644
--- a/internal/db/bundb/timeline.go
+++ b/internal/db/bundb/timeline.go
@@ -20,15 +20,13 @@ package bundb
 import (
 	"context"
 	"errors"
-	"fmt"
 	"slices"
-	"time"
 
 	"github.com/superseriousbusiness/gotosocial/internal/db"
 	"github.com/superseriousbusiness/gotosocial/internal/gtscontext"
 	"github.com/superseriousbusiness/gotosocial/internal/gtserror"
 	"github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
-	"github.com/superseriousbusiness/gotosocial/internal/id"
+	"github.com/superseriousbusiness/gotosocial/internal/paging"
 	"github.com/superseriousbusiness/gotosocial/internal/state"
 	"github.com/uptrace/bun"
 )
@@ -38,346 +36,147 @@ type timelineDB struct {
 	state *state.State
 }
 
-func (t *timelineDB) GetHomeTimeline(ctx context.Context, accountID string, maxID string, sinceID string, minID string, limit int, local bool) ([]*gtsmodel.Status, error) {
-	// Ensure reasonable
-	if limit < 0 {
-		limit = 0
-	}
-
-	// Make educated guess for slice size
-	var (
-		statusIDs   = make([]string, 0, limit)
-		frontToBack = true
-	)
-
-	// As this is the home timeline, it should be
-	// populated by statuses from accounts followed
-	// by accountID, and posts from accountID itself.
-	//
-	// So, begin by seeing who accountID follows.
-	// It should be a little cheaper to do this in
-	// a separate query like this, rather than using
-	// a join, since followIDs are cached in memory.
-	follows, err := t.state.DB.GetAccountFollows(
-		gtscontext.SetBarebones(ctx),
-		accountID,
-		nil, // select all
-	)
-	if err != nil && !errors.Is(err, db.ErrNoEntries) {
-		return nil, gtserror.Newf("db error getting follows for account %s: %w", accountID, err)
-	}
-
-	// To take account of exclusive lists, get all of
-	// this account's lists, so we can filter out follows
-	// that are in contained in exclusive lists.
-	lists, err := t.state.DB.GetListsByAccountID(ctx, accountID)
-	if err != nil && !errors.Is(err, db.ErrNoEntries) {
-		return nil, gtserror.Newf("db error getting lists for account %s: %w", accountID, err)
-	}
-
-	// Index all follow IDs that fall in exclusive lists.
-	ignoreFollowIDs := make(map[string]struct{})
-	for _, list := range lists {
-		if !*list.Exclusive {
-			// Not exclusive,
-			// we don't care.
-			continue
-		}
-
-		// Fetch all follow IDs of the entries ccontained in this list.
-		listFollowIDs, err := t.state.DB.GetFollowIDsInList(ctx, list.ID, nil)
-		if err != nil && !errors.Is(err, db.ErrNoEntries) {
-			return nil, gtserror.Newf("db error getting list entry follow ids: %w", err)
-		}
-
-		// Exclusive list, index all its follow IDs.
-		for _, followID := range listFollowIDs {
-			ignoreFollowIDs[followID] = struct{}{}
-		}
-	}
-
-	// Extract just the accountID from each follow,
-	// ignoring follows that are in exclusive lists.
-	targetAccountIDs := make([]string, 0, len(follows)+1)
-	for _, f := range follows {
-		_, ignore := ignoreFollowIDs[f.ID]
-		if !ignore {
-			targetAccountIDs = append(
-				targetAccountIDs,
-				f.TargetAccountID,
+func (t *timelineDB) GetHomeTimeline(ctx context.Context, accountID string, page *paging.Page) ([]*gtsmodel.Status, error) {
+	return loadStatusTimelinePage(ctx, t.db, t.state,
+
+		// Paging
+		// params.
+		page,
+
+		// The actual meat of the home-timeline query, outside
+		// of any paging parameters that selects by followings.
+		func(q *bun.SelectQuery) (*bun.SelectQuery, error) {
+
+			// As this is the home timeline, it should be
+			// populated by statuses from accounts followed
+			// by accountID, and posts from accountID itself.
+			//
+			// So, begin by seeing who accountID follows.
+			// It should be a little cheaper to do this in
+			// a separate query like this, rather than using
+			// a join, since followIDs are cached in memory.
+			follows, err := t.state.DB.GetAccountFollows(
+				gtscontext.SetBarebones(ctx),
+				accountID,
+				nil, // select all
+			)
+			if err != nil && !errors.Is(err, db.ErrNoEntries) {
+				return nil, gtserror.Newf("db error getting follows for account %s: %w", accountID, err)
+			}
+
+			// To take account of exclusive lists, get all of
+			// this account's lists, so we can filter out follows
+			// that are in contained in exclusive lists.
+			lists, err := t.state.DB.GetListsByAccountID(ctx, accountID)
+			if err != nil && !errors.Is(err, db.ErrNoEntries) {
+				return nil, gtserror.Newf("db error getting lists for account %s: %w", accountID, err)
+			}
+
+			// Index all follow IDs that fall in exclusive lists.
+			ignoreFollowIDs := make(map[string]struct{})
+			for _, list := range lists {
+				if !*list.Exclusive {
+					// Not exclusive,
+					// we don't care.
+					continue
+				}
+
+				// Fetch all follow IDs of the entries ccontained in this list.
+				listFollowIDs, err := t.state.DB.GetFollowIDsInList(ctx, list.ID, nil)
+				if err != nil && !errors.Is(err, db.ErrNoEntries) {
+					return nil, gtserror.Newf("db error getting list entry follow ids: %w", err)
+				}
+
+				// Exclusive list, index all its follow IDs.
+				for _, followID := range listFollowIDs {
+					ignoreFollowIDs[followID] = struct{}{}
+				}
+			}
+
+			// Extract just the accountID from each follow,
+			// ignoring follows that are in exclusive lists.
+			targetAccountIDs := make([]string, 0, len(follows)+1)
+			for _, f := range follows {
+				_, ignore := ignoreFollowIDs[f.ID]
+				if !ignore {
+					targetAccountIDs = append(
+						targetAccountIDs,
+						f.TargetAccountID,
+					)
+				}
+			}
+
+			// Add accountID itself as a pseudo follow so that
+			// accountID can see its own posts in the timeline.
+			targetAccountIDs = append(targetAccountIDs, accountID)
+
+			// Select only statuses authored by
+			// accounts with IDs in the slice.
+			q = q.Where(
+				"? IN (?)",
+				bun.Ident("account_id"),
+				bun.In(targetAccountIDs),
 			)
-		}
-	}
-
-	// Add accountID itself as a pseudo follow so that
-	// accountID can see its own posts in the timeline.
-	targetAccountIDs = append(targetAccountIDs, accountID)
-
-	// Now start building the database query.
-	q := t.db.
-		NewSelect().
-		TableExpr("? AS ?", bun.Ident("statuses"), bun.Ident("status")).
-		// Select only IDs from table
-		Column("status.id")
-
-	if maxID == "" || maxID >= id.Highest {
-		const future = 24 * time.Hour
-
-		// don't return statuses more than 24hr in the future
-		maxID = id.NewULIDFromTime(time.Now().Add(future))
-	}
-
-	// return only statuses LOWER (ie., older) than maxID
-	q = q.Where("? < ?", bun.Ident("status.id"), maxID)
-
-	if sinceID != "" {
-		// return only statuses HIGHER (ie., newer) than sinceID
-		q = q.Where("? > ?", bun.Ident("status.id"), sinceID)
-	}
-
-	if minID != "" {
-		// return only statuses HIGHER (ie., newer) than minID
-		q = q.Where("? > ?", bun.Ident("status.id"), minID)
-
-		// page up
-		frontToBack = false
-	}
 
-	if local {
-		// return only statuses posted by local account havers
-		q = q.Where("? = ?", bun.Ident("status.local"), local)
-	}
+			// Only include statuses that aren't pending approval.
+			q = q.Where("NOT ? = ?", bun.Ident("pending_approval"), true)
 
-	// Select only statuses authored by
-	// accounts with IDs in the slice.
-	q = q.Where(
-		"? IN (?)",
-		bun.Ident("status.account_id"),
-		bun.In(targetAccountIDs),
+			return q, nil
+		},
 	)
-
-	// Only include statuses that aren't pending approval.
-	q = q.Where("NOT ? = ?", bun.Ident("status.pending_approval"), true)
-
-	if limit > 0 {
-		// limit amount of statuses returned
-		q = q.Limit(limit)
-	}
-
-	if frontToBack {
-		// Page down.
-		q = q.Order("status.id DESC")
-	} else {
-		// Page up.
-		q = q.Order("status.id ASC")
-	}
-
-	if err := q.Scan(ctx, &statusIDs); err != nil {
-		return nil, err
-	}
-
-	if len(statusIDs) == 0 {
-		return nil, nil
-	}
-
-	// If we're paging up, we still want statuses
-	// to be sorted by ID desc, so reverse ids slice.
-	// https://zchee.github.io/golang-wiki/SliceTricks/#reversing
-	if !frontToBack {
-		for l, r := 0, len(statusIDs)-1; l < r; l, r = l+1, r-1 {
-			statusIDs[l], statusIDs[r] = statusIDs[r], statusIDs[l]
-		}
-	}
-
-	// Return status IDs loaded from cache + db.
-	return t.state.DB.GetStatusesByIDs(ctx, statusIDs)
 }
 
-func (t *timelineDB) GetPublicTimeline(
-	ctx context.Context,
-	maxID string,
-	sinceID string,
-	minID string,
-	limit int,
-	local bool,
-) ([]*gtsmodel.Status, error) {
-	// Ensure reasonable
-	if limit < 0 {
-		limit = 0
-	}
+func (t *timelineDB) GetPublicTimeline(ctx context.Context, page *paging.Page) ([]*gtsmodel.Status, error) {
+	return loadStatusTimelinePage(ctx, t.db, t.state,
 
-	if local {
-		return t.getLocalTimeline(
-			ctx,
-			maxID,
-			sinceID,
-			minID,
-			limit,
-		)
-	}
+		// Paging
+		// params.
+		page,
 
-	// Make educated guess for slice size
-	var (
-		statusIDs   = make([]string, 0, limit)
-		frontToBack = true
-	)
+		func(q *bun.SelectQuery) (*bun.SelectQuery, error) {
+			// Public only.
+			q = q.Where("? = ?", bun.Ident("visibility"), gtsmodel.VisibilityPublic)
 
-	q := t.db.
-		NewSelect().
-		TableExpr("? AS ?", bun.Ident("statuses"), bun.Ident("status")).
-		// Public only.
-		Where("? = ?", bun.Ident("status.visibility"), gtsmodel.VisibilityPublic).
-		// Ignore boosts.
-		Where("? IS NULL", bun.Ident("status.boost_of_id")).
-		// Only include statuses that aren't pending approval.
-		Where("? = ?", bun.Ident("status.pending_approval"), false).
-		// Select only IDs from table
-		Column("status.id")
-
-	if maxID == "" || maxID >= id.Highest {
-		const future = 24 * time.Hour
-
-		// don't return statuses more than 24hr in the future
-		maxID = id.NewULIDFromTime(time.Now().Add(future))
-	}
-
-	// return only statuses LOWER (ie., older) than maxID
-	q = q.Where("? < ?", bun.Ident("status.id"), maxID)
-
-	if sinceID != "" {
-		// return only statuses HIGHER (ie., newer) than sinceID
-		q = q.Where("? > ?", bun.Ident("status.id"), sinceID)
-	}
-
-	if minID != "" {
-		// return only statuses HIGHER (ie., newer) than minID
-		q = q.Where("? > ?", bun.Ident("status.id"), minID)
-
-		// page up
-		frontToBack = false
-	}
-
-	if limit > 0 {
-		// limit amount of statuses returned
-		q = q.Limit(limit)
-	}
-
-	if frontToBack {
-		// Page down.
-		q = q.Order("status.id DESC")
-	} else {
-		// Page up.
-		q = q.Order("status.id ASC")
-	}
-
-	if err := q.Scan(ctx, &statusIDs); err != nil {
-		return nil, err
-	}
-
-	if len(statusIDs) == 0 {
-		return nil, nil
-	}
-
-	// If we're paging up, we still want statuses
-	// to be sorted by ID desc, so reverse ids slice.
-	// https://zchee.github.io/golang-wiki/SliceTricks/#reversing
-	if !frontToBack {
-		for l, r := 0, len(statusIDs)-1; l < r; l, r = l+1, r-1 {
-			statusIDs[l], statusIDs[r] = statusIDs[r], statusIDs[l]
-		}
-	}
+			// Ignore boosts.
+			q = q.Where("? IS NULL", bun.Ident("boost_of_id"))
 
-	// Return status IDs loaded from cache + db.
-	return t.state.DB.GetStatusesByIDs(ctx, statusIDs)
-}
+			// Only include statuses that aren't pending approval.
+			q = q.Where("? = ?", bun.Ident("pending_approval"), false)
 
-func (t *timelineDB) getLocalTimeline(
-	ctx context.Context,
-	maxID string,
-	sinceID string,
-	minID string,
-	limit int,
-) ([]*gtsmodel.Status, error) {
-	// Make educated guess for slice size
-	var (
-		statusIDs   = make([]string, 0, limit)
-		frontToBack = true
+			return q, nil
+		},
 	)
+}
 
-	q := t.db.
-		NewSelect().
-		TableExpr("? AS ?", bun.Ident("statuses"), bun.Ident("status")).
-		// Local only.
-		Where("? = ?", bun.Ident("status.local"), true).
-		// Public only.
-		Where("? = ?", bun.Ident("status.visibility"), gtsmodel.VisibilityPublic).
-		// Only include statuses that aren't pending approval.
-		Where("? = ?", bun.Ident("status.pending_approval"), false).
-		// Ignore boosts.
-		Where("? IS NULL", bun.Ident("status.boost_of_id")).
-		// Select only IDs from table
-		Column("status.id")
-
-	if maxID == "" || maxID >= id.Highest {
-		const future = 24 * time.Hour
-
-		// don't return statuses more than 24hr in the future
-		maxID = id.NewULIDFromTime(time.Now().Add(future))
-	}
-
-	// return only statuses LOWER (ie., older) than maxID
-	q = q.Where("? < ?", bun.Ident("status.id"), maxID)
-
-	if sinceID != "" {
-		// return only statuses HIGHER (ie., newer) than sinceID
-		q = q.Where("? > ?", bun.Ident("status.id"), sinceID)
-	}
-
-	if minID != "" {
-		// return only statuses HIGHER (ie., newer) than minID
-		q = q.Where("? > ?", bun.Ident("status.id"), minID)
-
-		// page up
-		frontToBack = false
-	}
+func (t *timelineDB) GetLocalTimeline(ctx context.Context, page *paging.Page) ([]*gtsmodel.Status, error) {
+	return loadStatusTimelinePage(ctx, t.db, t.state,
 
-	if limit > 0 {
-		// limit amount of statuses returned
-		q = q.Limit(limit)
-	}
+		// Paging
+		// params.
+		page,
 
-	if frontToBack {
-		// Page down.
-		q = q.Order("status.id DESC")
-	} else {
-		// Page up.
-		q = q.Order("status.id ASC")
-	}
+		func(q *bun.SelectQuery) (*bun.SelectQuery, error) {
+			// Local only.
+			q = q.Where("? = ?", bun.Ident("local"), true)
 
-	if err := q.Scan(ctx, &statusIDs); err != nil {
-		return nil, err
-	}
+			// Public only.
+			q = q.Where("? = ?", bun.Ident("visibility"), gtsmodel.VisibilityPublic)
 
-	if len(statusIDs) == 0 {
-		return nil, nil
-	}
+			// Only include statuses that aren't pending approval.
+			q = q.Where("? = ?", bun.Ident("pending_approval"), false)
 
-	// If we're paging up, we still want statuses
-	// to be sorted by ID desc, so reverse ids slice.
-	// https://zchee.github.io/golang-wiki/SliceTricks/#reversing
-	if !frontToBack {
-		for l, r := 0, len(statusIDs)-1; l < r; l, r = l+1, r-1 {
-			statusIDs[l], statusIDs[r] = statusIDs[r], statusIDs[l]
-		}
-	}
+			// Ignore boosts.
+			q = q.Where("? IS NULL", bun.Ident("boost_of_id"))
 
-	// Return status IDs loaded from cache + db.
-	return t.state.DB.GetStatusesByIDs(ctx, statusIDs)
+			return q, nil
+		},
+	)
 }
 
 // TODO optimize this query and the logic here, because it's slow as balls -- it takes like a literal second to return with a limit of 20!
 // It might be worth serving it through a timeline instead of raw DB queries, like we do for Home feeds.
 func (t *timelineDB) GetFavedTimeline(ctx context.Context, accountID string, maxID string, minID string, limit int) ([]*gtsmodel.Status, string, string, error) {
+
 	// Ensure reasonable
 	if limit < 0 {
 		limit = 0
@@ -442,205 +241,130 @@ func (t *timelineDB) GetFavedTimeline(ctx context.Context, accountID string, max
 	return statuses, nextMaxID, prevMinID, nil
 }
 
-func (t *timelineDB) GetListTimeline(
-	ctx context.Context,
-	listID string,
-	maxID string,
-	sinceID string,
-	minID string,
-	limit int,
-) ([]*gtsmodel.Status, error) {
-	// Ensure reasonable
-	if limit < 0 {
-		limit = 0
-	}
-
-	// Make educated guess for slice size
-	var (
-		statusIDs   = make([]string, 0, limit)
-		frontToBack = true
-	)
-
-	// Fetch all follow IDs contained in list from DB.
-	followIDs, err := t.state.DB.GetFollowIDsInList(
-		ctx, listID, nil,
-	)
-	if err != nil {
-		return nil, fmt.Errorf("error getting follows in list: %w", err)
-	}
-
-	// If there's no list follows we can't
-	// possibly return anything for this list.
-	if len(followIDs) == 0 {
-		return make([]*gtsmodel.Status, 0), nil
-	}
-
-	// Select target account IDs from follows.
-	subQ := t.db.
-		NewSelect().
-		TableExpr("? AS ?", bun.Ident("follows"), bun.Ident("follow")).
-		Column("follow.target_account_id").
-		Where("? IN (?)", bun.Ident("follow.id"), bun.In(followIDs))
-
-	// Select only status IDs created
-	// by one of the followed accounts.
-	q := t.db.
-		NewSelect().
-		TableExpr("? AS ?", bun.Ident("statuses"), bun.Ident("status")).
-		// Select only IDs from table
-		Column("status.id").
-		Where("? IN (?)", bun.Ident("status.account_id"), subQ)
-
-	if maxID == "" || maxID >= id.Highest {
-		const future = 24 * time.Hour
+func (t *timelineDB) GetListTimeline(ctx context.Context, listID string, page *paging.Page) ([]*gtsmodel.Status, error) {
+	return loadStatusTimelinePage(ctx, t.db, t.state,
 
-		// don't return statuses more than 24hr in the future
-		maxID = id.NewULIDFromTime(time.Now().Add(future))
-	}
-
-	// return only statuses LOWER (ie., older) than maxID
-	q = q.Where("? < ?", bun.Ident("status.id"), maxID)
-
-	if sinceID != "" {
-		// return only statuses HIGHER (ie., newer) than sinceID
-		q = q.Where("? > ?", bun.Ident("status.id"), sinceID)
-	}
+		// Paging
+		// params.
+		page,
 
-	if minID != "" {
-		// return only statuses HIGHER (ie., newer) than minID
-		q = q.Where("? > ?", bun.Ident("status.id"), minID)
+		// The actual meat of the list-timeline query, outside
+		// of any paging parameters, it selects by list entries.
+		func(q *bun.SelectQuery) (*bun.SelectQuery, error) {
 
-		// page up
-		frontToBack = false
-	}
+			// Fetch all follow IDs contained in list from DB.
+			followIDs, err := t.state.DB.GetFollowIDsInList(
+				ctx, listID, nil,
+			)
+			if err != nil {
+				return nil, gtserror.Newf("error getting follows in list: %w", err)
+			}
+
+			// Select target account
+			// IDs from list follows.
+			subQ := t.db.NewSelect().
+				Table("follows").
+				Column("follows.target_account_id").
+				Where("? IN (?)", bun.Ident("follows.id"), bun.In(followIDs))
+			q = q.Where("? IN (?)", bun.Ident("statuses.account_id"), subQ)
+
+			// Only include statuses that aren't pending approval.
+			q = q.Where("NOT ? = ?", bun.Ident("pending_approval"), true)
+
+			return q, nil
+		},
+	)
+}
 
-	// Only include statuses that aren't pending approval.
-	q = q.Where("NOT ? = ?", bun.Ident("status.pending_approval"), true)
+func (t *timelineDB) GetTagTimeline(ctx context.Context, tagID string, page *paging.Page) ([]*gtsmodel.Status, error) {
+	return loadStatusTimelinePage(ctx, t.db, t.state,
 
-	if limit > 0 {
-		// limit amount of statuses returned
-		q = q.Limit(limit)
-	}
+		// Paging
+		// params.
+		page,
 
-	if frontToBack {
-		// Page down.
-		q = q.Order("status.id DESC")
-	} else {
-		// Page up.
-		q = q.Order("status.id ASC")
-	}
+		// The actual meat of the list-timeline query, outside of any
+		// paging params, selects by status tags with public visibility.
+		func(q *bun.SelectQuery) (*bun.SelectQuery, error) {
 
-	if err := q.Scan(ctx, &statusIDs); err != nil {
-		return nil, err
-	}
+			// ...
+			q = q.Join(
+				"INNER JOIN ? ON ? = ?",
+				bun.Ident("status_to_tags"),
+				bun.Ident("statuses.id"), bun.Ident("status_to_tags.status_id"),
+			)
 
-	if len(statusIDs) == 0 {
-		return nil, nil
-	}
+			// This tag only.
+			q = q.Where("? = ?", bun.Ident("status_to_tags.tag_id"), tagID)
 
-	// If we're paging up, we still want statuses
-	// to be sorted by ID desc, so reverse ids slice.
-	// https://zchee.github.io/golang-wiki/SliceTricks/#reversing
-	if !frontToBack {
-		for l, r := 0, len(statusIDs)-1; l < r; l, r = l+1, r-1 {
-			statusIDs[l], statusIDs[r] = statusIDs[r], statusIDs[l]
-		}
-	}
+			// Public only.
+			q = q.Where("? = ?", bun.Ident("visibility"), gtsmodel.VisibilityPublic)
 
-	// Return status IDs loaded from cache + db.
-	return t.state.DB.GetStatusesByIDs(ctx, statusIDs)
+			return q, nil
+		},
+	)
 }
 
-func (t *timelineDB) GetTagTimeline(
+func loadStatusTimelinePage(
 	ctx context.Context,
-	tagID string,
-	maxID string,
-	sinceID string,
-	minID string,
-	limit int,
-) ([]*gtsmodel.Status, error) {
-	// Ensure reasonable
-	if limit < 0 {
-		limit = 0
-	}
-
-	// Make educated guess for slice size
-	var (
-		statusIDs   = make([]string, 0, limit)
-		frontToBack = true
-	)
+	db *bun.DB,
+	state *state.State,
+	page *paging.Page,
+	query func(*bun.SelectQuery) (*bun.SelectQuery, error),
+) (
+	[]*gtsmodel.Status,
+	error,
+) {
+	// Extract page params.
+	minID := page.Min.Value
+	maxID := page.Max.Value
+	limit := page.Limit
+	order := page.Order()
+
+	// Pre-allocate slice of IDs as dest.
+	statusIDs := make([]string, 0, limit)
 
-	q := t.db.
-		NewSelect().
-		TableExpr("? AS ?", bun.Ident("status_to_tags"), bun.Ident("status_to_tag")).
-		Column("status_to_tag.status_id").
-		// Join with statuses for filtering.
-		Join(
-			"INNER JOIN ? AS ? ON ? = ?",
-			bun.Ident("statuses"), bun.Ident("status"),
-			bun.Ident("status.id"), bun.Ident("status_to_tag.status_id"),
-		).
-		// Public only.
-		Where("? = ?", bun.Ident("status.visibility"), gtsmodel.VisibilityPublic).
-		// This tag only.
-		Where("? = ?", bun.Ident("status_to_tag.tag_id"), tagID)
-
-	if maxID == "" || maxID >= id.Highest {
-		const future = 24 * time.Hour
-
-		// don't return statuses more than 24hr in the future
-		maxID = id.NewULIDFromTime(time.Now().Add(future))
+	// Now start building the database query.
+	//
+	// Select the following:
+	// - status ID
+	q := db.NewSelect().
+		Table("statuses").
+		Column("id")
+
+	// Append caller
+	// query details.
+	q, err := query(q)
+	if err != nil {
+		return nil, err
 	}
 
-	// return only statuses LOWER (ie., older) than maxID
-	q = q.Where("? < ?", bun.Ident("status_to_tag.status_id"), maxID)
-
-	if sinceID != "" {
-		// return only statuses HIGHER (ie., newer) than sinceID
-		q = q.Where("? > ?", bun.Ident("status_to_tag.status_id"), sinceID)
+	if maxID != "" {
+		// Set a maximum ID boundary if was given.
+		q = q.Where("? < ?", bun.Ident("id"), maxID)
 	}
 
 	if minID != "" {
-		// return only statuses HIGHER (ie., newer) than minID
-		q = q.Where("? > ?", bun.Ident("status_to_tag.status_id"), minID)
-
-		// page up
-		frontToBack = false
+		// Set a minimum ID boundary if was given.
+		q = q.Where("? > ?", bun.Ident("id"), minID)
 	}
 
-	// Only include statuses that aren't pending approval.
-	q = q.Where("NOT ? = ?", bun.Ident("status.pending_approval"), true)
-
-	if limit > 0 {
-		// limit amount of statuses returned
-		q = q.Limit(limit)
+	// Set query ordering.
+	if order.Ascending() {
+		q = q.OrderExpr("? ASC", bun.Ident("id"))
+	} else /* i.e. descending */ {
+		q = q.OrderExpr("? DESC", bun.Ident("id"))
 	}
 
-	if frontToBack {
-		// Page down.
-		q = q.Order("status_to_tag.status_id DESC")
-	} else {
-		// Page up.
-		q = q.Order("status_to_tag.status_id ASC")
-	}
+	// A limit should always
+	// be supplied for this.
+	q = q.Limit(limit)
 
+	// Finally, perform query into status ID slice.
 	if err := q.Scan(ctx, &statusIDs); err != nil {
 		return nil, err
 	}
 
-	if len(statusIDs) == 0 {
-		return nil, nil
-	}
-
-	// If we're paging up, we still want statuses
-	// to be sorted by ID desc, so reverse ids slice.
-	// https://zchee.github.io/golang-wiki/SliceTricks/#reversing
-	if !frontToBack {
-		for l, r := 0, len(statusIDs)-1; l < r; l, r = l+1, r-1 {
-			statusIDs[l], statusIDs[r] = statusIDs[r], statusIDs[l]
-		}
-	}
-
-	// Return status IDs loaded from cache + db.
-	return t.state.DB.GetStatusesByIDs(ctx, statusIDs)
+	// Fetch statuses from DB / cache with given IDs.
+	return state.DB.GetStatusesByIDs(ctx, statusIDs)
 }
diff --git a/internal/db/bundb/timeline_test.go b/internal/db/bundb/timeline_test.go
index 4988ab362..9652df33a 100644
--- a/internal/db/bundb/timeline_test.go
+++ b/internal/db/bundb/timeline_test.go
@@ -20,14 +20,12 @@ package bundb_test
 import (
 	"context"
 	"testing"
-	"time"
 
-	"codeberg.org/gruf/go-kv"
 	"github.com/stretchr/testify/suite"
-	"github.com/superseriousbusiness/gotosocial/internal/ap"
 	"github.com/superseriousbusiness/gotosocial/internal/gtscontext"
 	"github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
 	"github.com/superseriousbusiness/gotosocial/internal/id"
+	"github.com/superseriousbusiness/gotosocial/internal/paging"
 	"github.com/superseriousbusiness/gotosocial/internal/util"
 )
 
@@ -35,38 +33,6 @@ type TimelineTestSuite struct {
 	BunDBStandardTestSuite
 }
 
-func getFutureStatus() *gtsmodel.Status {
-	theDistantFuture := time.Now().Add(876600 * time.Hour)
-	id := id.NewULIDFromTime(theDistantFuture)
-
-	return &gtsmodel.Status{
-		ID:                       id,
-		URI:                      "http://localhost:8080/users/admin/statuses/" + id,
-		URL:                      "http://localhost:8080/@admin/statuses/" + id,
-		Content:                  "it's the future, wooooooooooooooooooooooooooooooooo",
-		Text:                     "it's the future, wooooooooooooooooooooooooooooooooo",
-		ContentType:              gtsmodel.StatusContentTypePlain,
-		AttachmentIDs:            []string{},
-		TagIDs:                   []string{},
-		MentionIDs:               []string{},
-		EmojiIDs:                 []string{},
-		CreatedAt:                theDistantFuture,
-		Local:                    util.Ptr(true),
-		AccountURI:               "http://localhost:8080/users/admin",
-		AccountID:                "01F8MH17FWEB39HZJ76B6VXSKF",
-		InReplyToID:              "",
-		BoostOfID:                "",
-		ContentWarning:           "",
-		Visibility:               gtsmodel.VisibilityPublic,
-		Sensitive:                util.Ptr(false),
-		Language:                 "en",
-		CreatedWithApplicationID: "01F8MGXQRHYF5QPMTMXP78QC2F",
-		Federated:                util.Ptr(true),
-		InteractionPolicy:        gtsmodel.DefaultInteractionPolicyPublic(),
-		ActivityStreamsType:      ap.ObjectNote,
-	}
-}
-
 func (suite *TimelineTestSuite) publicCount() int {
 	var publicCount int
 	for _, status := range suite.testStatuses {
@@ -92,7 +58,7 @@ func (suite *TimelineTestSuite) localCount() int {
 	return localCount
 }
 
-func (suite *TimelineTestSuite) checkStatuses(statuses []*gtsmodel.Status, maxID string, minID string, expectedLength int) {
+func (suite *TimelineTestSuite) checkStatuses(statuses []*gtsmodel.Status, maxID string, minID string, expectedOrder paging.Order, expectedLength int) {
 	if l := len(statuses); l != expectedLength {
 		suite.FailNowf("", "expected %d statuses in slice, got %d", expectedLength, l)
 	} else if l == 0 {
@@ -100,74 +66,73 @@ func (suite *TimelineTestSuite) checkStatuses(statuses []*gtsmodel.Status, maxID
 		return
 	}
 
-	// Check ordering + bounds of statuses.
-	highest := statuses[0].ID
-	for _, status := range statuses {
-		id := status.ID
+	if expectedOrder.Ascending() {
+		// Check ordering + bounds of statuses.
+		lowest := statuses[0].ID
+		for _, status := range statuses {
+			id := status.ID
 
-		if id >= maxID {
-			suite.FailNowf("", "%s greater than maxID %s", id, maxID)
-		}
+			if id >= maxID {
+				suite.FailNowf("", "%s greater than maxID %s", id, maxID)
+			}
 
-		if id <= minID {
-			suite.FailNowf("", "%s smaller than minID %s", id, minID)
-		}
+			if id <= minID {
+				suite.FailNowf("", "%s smaller than minID %s", id, minID)
+			}
 
-		if id > highest {
-			suite.FailNowf("", "statuses in slice were not ordered highest -> lowest ID")
-		}
+			if id < lowest {
+				suite.FailNowf("", "statuses in slice were not ordered lowest -> highest ID")
+			}
 
-		highest = id
-	}
-}
+			lowest = id
+		}
+	} else {
+		// Check ordering + bounds of statuses.
+		highest := statuses[0].ID
+		for _, status := range statuses {
+			id := status.ID
 
-func (suite *TimelineTestSuite) TestGetPublicTimeline() {
-	ctx := context.Background()
+			if id >= maxID {
+				suite.FailNowf("", "%s greater than maxID %s", id, maxID)
+			}
 
-	s, err := suite.db.GetPublicTimeline(ctx, "", "", "", 20, false)
-	if err != nil {
-		suite.FailNow(err.Error())
-	}
+			if id <= minID {
+				suite.FailNowf("", "%s smaller than minID %s", id, minID)
+			}
 
-	suite.T().Log(kv.Field{
-		K: "statuses", V: s,
-	})
+			if id > highest {
+				suite.FailNowf("", "statuses in slice were not ordered highest -> lowest ID")
+			}
 
-	suite.checkStatuses(s, id.Highest, id.Lowest, suite.publicCount())
+			highest = id
+		}
+	}
 }
 
-func (suite *TimelineTestSuite) TestGetPublicTimelineLocal() {
+func (suite *TimelineTestSuite) TestGetPublicTimeline() {
 	ctx := context.Background()
 
-	s, err := suite.db.GetPublicTimeline(ctx, "", "", "", 20, true)
+	page := toPage("", "", "", 20)
+
+	s, err := suite.db.GetPublicTimeline(ctx, page)
 	if err != nil {
 		suite.FailNow(err.Error())
 	}
 
-	suite.T().Log(kv.Field{
-		K: "statuses", V: s,
-	})
-
-	suite.checkStatuses(s, id.Highest, id.Lowest, suite.localCount())
+	suite.checkStatuses(s, id.Highest, id.Lowest, page.Order(), suite.publicCount())
 }
 
-func (suite *TimelineTestSuite) TestGetPublicTimelineWithFutureStatus() {
+func (suite *TimelineTestSuite) TestGetPublicTimelineLocal() {
 	ctx := context.Background()
 
-	// Insert a status set far in the
-	// future, it shouldn't be retrieved.
-	futureStatus := getFutureStatus()
-	if err := suite.db.PutStatus(ctx, futureStatus); err != nil {
-		suite.FailNow(err.Error())
-	}
+	page := toPage("", "", "", 20)
 
-	s, err := suite.db.GetPublicTimeline(ctx, "", "", "", 20, false)
+	s, err := suite.db.GetLocalTimeline(ctx, page)
 	if err != nil {
 		suite.FailNow(err.Error())
 	}
 
-	suite.NotContains(s, futureStatus)
-	suite.checkStatuses(s, id.Highest, id.Lowest, suite.publicCount())
+	suite.checkStatuses(s, id.Highest, id.Lowest, page.Order(), suite.localCount())
 }
 
 func (suite *TimelineTestSuite) TestGetHomeTimeline() {
@@ -176,12 +141,14 @@ func (suite *TimelineTestSuite) TestGetHomeTimeline() {
 		viewingAccount = suite.testAccounts["local_account_1"]
 	)
 
-	s, err := suite.db.GetHomeTimeline(ctx, viewingAccount.ID, "", "", "", 20, false)
+	page := toPage("", "", "", 20)
+
+	s, err := suite.db.GetHomeTimeline(ctx, viewingAccount.ID, page)
 	if err != nil {
 		suite.FailNow(err.Error())
 	}
 
-	suite.checkStatuses(s, id.Highest, id.Lowest, 20)
+	suite.checkStatuses(s, id.Highest, id.Lowest, page.Order(), 20)
 }
 
 func (suite *TimelineTestSuite) TestGetHomeTimelineIgnoreExclusive() {
@@ -201,13 +168,15 @@ func (suite *TimelineTestSuite) TestGetHomeTimelineIgnoreExclusive() {
 		suite.FailNow(err.Error())
 	}
 
+	page := toPage("", "", "", 20)
+
 	// First try with list just set to exclusive.
 	// We should only get zork's own statuses.
-	s, err := suite.db.GetHomeTimeline(ctx, viewingAccount.ID, "", "", "", 20, false)
+	s, err := suite.db.GetHomeTimeline(ctx, viewingAccount.ID, page)
 	if err != nil {
 		suite.FailNow(err.Error())
 	}
-	suite.checkStatuses(s, id.Highest, id.Lowest, 9)
+	suite.checkStatuses(s, id.Highest, id.Lowest, page.Order(), 9)
 
 	// Remove admin account from the exclusive list.
 	listEntry := suite.testListEntries["local_account_1_list_1_entry_2"]
@@ -217,11 +186,11 @@ func (suite *TimelineTestSuite) TestGetHomeTimelineIgnoreExclusive() {
 
 	// Zork should only see their own
 	// statuses and admin's statuses now.
-	s, err = suite.db.GetHomeTimeline(ctx, viewingAccount.ID, "", "", "", 20, false)
+	s, err = suite.db.GetHomeTimeline(ctx, viewingAccount.ID, page)
 	if err != nil {
 		suite.FailNow(err.Error())
 	}
-	suite.checkStatuses(s, id.Highest, id.Lowest, 13)
+	suite.checkStatuses(s, id.Highest, id.Lowest, page.Order(), 13)
 }
 
 func (suite *TimelineTestSuite) TestGetHomeTimelineNoFollowing() {
@@ -246,36 +215,16 @@ func (suite *TimelineTestSuite) TestGetHomeTimelineNoFollowing() {
 		}
 	}
 
+	page := toPage("", "", "", 20)
+
 	// Query should work fine; though far
 	// fewer statuses will be returned ofc.
-	s, err := suite.db.GetHomeTimeline(ctx, viewingAccount.ID, "", "", "", 20, false)
-	if err != nil {
-		suite.FailNow(err.Error())
-	}
-
-	suite.checkStatuses(s, id.Highest, id.Lowest, 9)
-}
-
-func (suite *TimelineTestSuite) TestGetHomeTimelineWithFutureStatus() {
-	var (
-		ctx            = context.Background()
-		viewingAccount = suite.testAccounts["local_account_1"]
-	)
-
-	// Insert a status set far in the
-	// future, it shouldn't be retrieved.
-	futureStatus := getFutureStatus()
-	if err := suite.db.PutStatus(ctx, futureStatus); err != nil {
-		suite.FailNow(err.Error())
-	}
-
-	s, err := suite.db.GetHomeTimeline(ctx, viewingAccount.ID, "", "", "", 20, false)
+	s, err := suite.db.GetHomeTimeline(ctx, viewingAccount.ID, page)
 	if err != nil {
 		suite.FailNow(err.Error())
 	}
 
-	suite.NotContains(s, futureStatus)
-	suite.checkStatuses(s, id.Highest, id.Lowest, 20)
+	suite.checkStatuses(s, id.Highest, id.Lowest, page.Order(), 9)
 }
 
 func (suite *TimelineTestSuite) TestGetHomeTimelineBackToFront() {
@@ -284,14 +233,16 @@ func (suite *TimelineTestSuite) TestGetHomeTimelineBackToFront() {
 		viewingAccount = suite.testAccounts["local_account_1"]
 	)
 
-	s, err := suite.db.GetHomeTimeline(ctx, viewingAccount.ID, "", "", id.Lowest, 5, false)
+	page := toPage("", "", id.Lowest, 5)
+
+	s, err := suite.db.GetHomeTimeline(ctx, viewingAccount.ID, page)
 	if err != nil {
 		suite.FailNow(err.Error())
 	}
 
-	suite.checkStatuses(s, id.Highest, id.Lowest, 5)
-	suite.Equal("01F8MHAYFKS4KMXF8K5Y1C0KRN", s[0].ID)
-	suite.Equal("01F8MH75CBF9JFX4ZAD54N0W0R", s[len(s)-1].ID)
+	suite.checkStatuses(s, id.Highest, id.Lowest, page.Order(), 5)
+	suite.Equal("01F8MHAYFKS4KMXF8K5Y1C0KRN", s[len(s)-1].ID)
+	suite.Equal("01F8MH75CBF9JFX4ZAD54N0W0R", s[0].ID)
 }
 
 func (suite *TimelineTestSuite) TestGetHomeTimelineFromHighest() {
@@ -300,12 +251,14 @@ func (suite *TimelineTestSuite) TestGetHomeTimelineFromHighest() {
 		viewingAccount = suite.testAccounts["local_account_1"]
 	)
 
-	s, err := suite.db.GetHomeTimeline(ctx, viewingAccount.ID, id.Highest, "", "", 5, false)
+	page := toPage(id.Highest, "", "", 5)
+
+	s, err := suite.db.GetHomeTimeline(ctx, viewingAccount.ID, page)
 	if err != nil {
 		suite.FailNow(err.Error())
 	}
 
-	suite.checkStatuses(s, id.Highest, id.Lowest, 5)
+	suite.checkStatuses(s, id.Highest, id.Lowest, page.Order(), 5)
 	suite.Equal("01JDPZEZ77X1NX0TY9M10BK1HM", s[0].ID)
 	suite.Equal("01HEN2RZ8BG29Y5Z9VJC73HZW7", s[len(s)-1].ID)
 }
@@ -316,12 +269,14 @@ func (suite *TimelineTestSuite) TestGetListTimelineNoParams() {
 		list = suite.testLists["local_account_1_list_1"]
 	)
 
-	s, err := suite.db.GetListTimeline(ctx, list.ID, "", "", "", 20)
+	page := toPage("", "", "", 20)
+
+	s, err := suite.db.GetListTimeline(ctx, list.ID, page)
 	if err != nil {
 		suite.FailNow(err.Error())
 	}
 
-	suite.checkStatuses(s, id.Highest, id.Lowest, 13)
+	suite.checkStatuses(s, id.Highest, id.Lowest, page.Order(), 13)
 }
 
 func (suite *TimelineTestSuite) TestGetListTimelineMaxID() {
@@ -330,12 +285,14 @@ func (suite *TimelineTestSuite) TestGetListTimelineMaxID() {
 		list = suite.testLists["local_account_1_list_1"]
 	)
 
-	s, err := suite.db.GetListTimeline(ctx, list.ID, id.Highest, "", "", 5)
+	page := toPage(id.Highest, "", "", 5)
+
+	s, err := suite.db.GetListTimeline(ctx, list.ID, page)
 	if err != nil {
 		suite.FailNow(err.Error())
 	}
 
-	suite.checkStatuses(s, id.Highest, id.Lowest, 5)
+	suite.checkStatuses(s, id.Highest, id.Lowest, page.Order(), 5)
 	suite.Equal("01JDPZEZ77X1NX0TY9M10BK1HM", s[0].ID)
 	suite.Equal("01FN3VJGFH10KR7S2PB0GFJZYG", s[len(s)-1].ID)
 }
@@ -346,14 +303,16 @@ func (suite *TimelineTestSuite) TestGetListTimelineMinID() {
 		list = suite.testLists["local_account_1_list_1"]
 	)
 
-	s, err := suite.db.GetListTimeline(ctx, list.ID, "", "", id.Lowest, 5)
+	page := toPage("", "", id.Lowest, 5)
+
+	s, err := suite.db.GetListTimeline(ctx, list.ID, page)
 	if err != nil {
 		suite.FailNow(err.Error())
 	}
 
-	suite.checkStatuses(s, id.Highest, id.Lowest, 5)
-	suite.Equal("01F8MHC8VWDRBQR0N1BATDDEM5", s[0].ID)
-	suite.Equal("01F8MH75CBF9JFX4ZAD54N0W0R", s[len(s)-1].ID)
+	suite.checkStatuses(s, id.Highest, id.Lowest, page.Order(), 5)
+	suite.Equal("01F8MHC8VWDRBQR0N1BATDDEM5", s[len(s)-1].ID)
+	suite.Equal("01F8MH75CBF9JFX4ZAD54N0W0R", s[0].ID)
 }
 
 func (suite *TimelineTestSuite) TestGetListTimelineMinIDPagingUp() {
@@ -362,14 +321,16 @@ func (suite *TimelineTestSuite) TestGetListTimelineMinIDPagingUp() {
 		list = suite.testLists["local_account_1_list_1"]
 	)
 
-	s, err := suite.db.GetListTimeline(ctx, list.ID, "", "", "01F8MHC8VWDRBQR0N1BATDDEM5", 5)
+	page := toPage("", "", "01F8MHC8VWDRBQR0N1BATDDEM5", 5)
+
+	s, err := suite.db.GetListTimeline(ctx, list.ID, page)
 	if err != nil {
 		suite.FailNow(err.Error())
 	}
 
-	suite.checkStatuses(s, id.Highest, "01F8MHC8VWDRBQR0N1BATDDEM5", 5)
-	suite.Equal("01G20ZM733MGN8J344T4ZDDFY1", s[0].ID)
-	suite.Equal("01F8MHCP5P2NWYQ416SBA0XSEV", s[len(s)-1].ID)
+	suite.checkStatuses(s, id.Highest, "01F8MHC8VWDRBQR0N1BATDDEM5", page.Order(), 5)
+	suite.Equal("01G20ZM733MGN8J344T4ZDDFY1", s[len(s)-1].ID)
+	suite.Equal("01F8MHCP5P2NWYQ416SBA0XSEV", s[0].ID)
 }
 
 func (suite *TimelineTestSuite) TestGetTagTimelineNoParams() {
@@ -378,15 +339,33 @@ func (suite *TimelineTestSuite) TestGetTagTimelineNoParams() {
 		tag = suite.testTags["welcome"]
 	)
 
-	s, err := suite.db.GetTagTimeline(ctx, tag.ID, "", "", "", 1)
+	page := toPage("", "", "", 1)
+
+	s, err := suite.db.GetTagTimeline(ctx, tag.ID, page)
 	if err != nil {
 		suite.FailNow(err.Error())
 	}
 
-	suite.checkStatuses(s, id.Highest, id.Lowest, 1)
+	suite.checkStatuses(s, id.Highest, id.Lowest, page.Order(), 1)
 	suite.Equal("01F8MH75CBF9JFX4ZAD54N0W0R", s[0].ID)
 }
 
 func TestTimelineTestSuite(t *testing.T) {
 	suite.Run(t, new(TimelineTestSuite))
 }
+
+// toPage is a helper function to wrap a series of paging arguments in paging.Page{}.
+func toPage(maxID, sinceID, minID string, limit int) *paging.Page {
+	var pg paging.Page
+	pg.Limit = limit
+
+	if maxID != "" {
+		pg.Max = paging.MaxID(maxID)
+	}
+
+	if sinceID != "" || minID != "" {
+		pg.Min = paging.EitherMinID(minID, sinceID)
+	}
+
+	return &pg
+}
diff --git a/internal/db/list.go b/internal/db/list.go
index 4ce0ff988..2e74329f1 100644
--- a/internal/db/list.go
+++ b/internal/db/list.go
@@ -34,6 +34,9 @@ type List interface {
 	// GetListsByAccountID gets all lists owned by the given accountID.
 	GetListsByAccountID(ctx context.Context, accountID string) ([]*gtsmodel.List, error)
 
+	// GetListIDsByAccountID gets the IDs of all lists owned by the given accountID.
+	GetListIDsByAccountID(ctx context.Context, accountID string) ([]string, error)
+
 	// CountListsByAccountID counts the number of lists owned by the given accountID.
 	CountListsByAccountID(ctx context.Context, accountID string) (int, error)
 
diff --git a/internal/db/timeline.go b/internal/db/timeline.go
index 43ac655d0..b97095246 100644
--- a/internal/db/timeline.go
+++ b/internal/db/timeline.go
@@ -21,20 +21,20 @@ import (
 	"context"
 
 	"github.com/superseriousbusiness/gotosocial/internal/gtsmodel"
+	"github.com/superseriousbusiness/gotosocial/internal/paging"
 )
 
 // Timeline contains functionality for retrieving home/public/faved etc timelines for an account.
 type Timeline interface {
 	// GetHomeTimeline returns a slice of statuses from accounts that are followed by the given account id.
-	//
-	// Statuses should be returned in descending order of when they were created (newest first).
-	GetHomeTimeline(ctx context.Context, accountID string, maxID string, sinceID string, minID string, limit int, local bool) ([]*gtsmodel.Status, error)
+	GetHomeTimeline(ctx context.Context, accountID string, page *paging.Page) ([]*gtsmodel.Status, error)
 
 	// GetPublicTimeline fetches the account's PUBLIC timeline -- ie., posts and replies that are public.
 	// It will use the given filters and try to return as many statuses as possible up to the limit.
-	//
-	// Statuses should be returned in descending order of when they were created (newest first).
-	GetPublicTimeline(ctx context.Context, maxID string, sinceID string, minID string, limit int, local bool) ([]*gtsmodel.Status, error)
+	GetPublicTimeline(ctx context.Context, page *paging.Page) ([]*gtsmodel.Status, error)
+
+	// GetLocalTimeline fetches the account's LOCAL timeline -- i.e. PUBLIC posts by LOCAL users.
+	GetLocalTimeline(ctx context.Context, page *paging.Page) ([]*gtsmodel.Status, error)
 
 	// GetFavedTimeline fetches the account's FAVED timeline -- ie., posts and replies that the requesting account has faved.
 	// It will use the given filters and try to return as many statuses as possible up to the limit.
@@ -46,10 +46,8 @@ type Timeline interface {
 	GetFavedTimeline(ctx context.Context, accountID string, maxID string, minID string, limit int) ([]*gtsmodel.Status, string, string, error)
 
 	// GetListTimeline returns a slice of statuses from followed accounts collected within the list with the given listID.
-	// Statuses should be returned in descending order of when they were created (newest first).
-	GetListTimeline(ctx context.Context, listID string, maxID string, sinceID string, minID string, limit int) ([]*gtsmodel.Status, error)
+	GetListTimeline(ctx context.Context, listID string, page *paging.Page) ([]*gtsmodel.Status, error)
 
 	// GetTagTimeline returns a slice of public-visibility statuses that use the given tagID.
-	// Statuses should be returned in descending order of when they were created (newest first).
-	GetTagTimeline(ctx context.Context, tagID string, maxID string, sinceID string, minID string, limit int) ([]*gtsmodel.Status, error)
+	GetTagTimeline(ctx context.Context, tagID string, page *paging.Page) ([]*gtsmodel.Status, error)
 }