Trends and the directory, from what PrivaPub holds

trends/tags, trends/statuses and trends/links replace the stubs. Hashtags
and links rise with the number of different authors using them today
against the week before, two at least; posts with their favourites, boosts
and replies, halving every twelve hours. Only public posts PrivaPub already
holds count, nothing behind a content warning, and a post trends only if
its author is discoverable. Computed at most every ten minutes.

The directory lists discoverable accounts by their latest public post, or
by the day they say they joined: a persona's published day, never its
creation, with ties broken by a hash of the name, so personas made together
are not told apart by their order.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LsXgEaXee4GCU1hwYgPJXw

PrivaPub/Api/Mastodon/Controllers/SearchController.cs

@@ -87,18 +87,6 @@ namespace PrivaPub.Api.Mastodon.Controllers
 		[HttpGet("/api/v1/announcements"), Microsoft.AspNetCore.Authorization.AllowAnonymous]
 		public IActionResult Announcements() => Json(Array.Empty<object>());
 
-		[HttpGet("/api/v1/trends"), Microsoft.AspNetCore.Authorization.AllowAnonymous]
-		public IActionResult Trends() => Json(Array.Empty<object>());
-
-		[HttpGet("/api/v1/trends/tags"), Microsoft.AspNetCore.Authorization.AllowAnonymous]
-		public IActionResult TrendTags() => Json(Array.Empty<object>());
-
-		[HttpGet("/api/v1/trends/statuses"), Microsoft.AspNetCore.Authorization.AllowAnonymous]
-		public IActionResult TrendStatuses() => Json(Array.Empty<object>());
-
-		[HttpGet("/api/v1/trends/links"), Microsoft.AspNetCore.Authorization.AllowAnonymous]
-		public IActionResult TrendLinks() => Json(Array.Empty<object>());
-
 		[HttpGet("/api/v1/suggestions"), Scope("read")]
 		public IActionResult SuggestionsV1() => Json(Array.Empty<object>());
 
@@ -126,9 +114,6 @@ namespace PrivaPub.Api.Mastodon.Controllers
 
 		// Routes Mastodon answers that we have nothing behind: an empty or default answer lets clients degrade, where a
 		// 404 breaks some of them (Mastodon invariant 5)
-		[HttpGet("/api/v1/directory"), Microsoft.AspNetCore.Authorization.AllowAnonymous]
-		public IActionResult Directory() => Json(Array.Empty<object>());
-
 		[HttpGet("/api/v1/timelines/link"), Microsoft.AspNetCore.Authorization.AllowAnonymous]
 		public IActionResult LinkTimeline() => Json(Array.Empty<object>());
 

PrivaPub/Api/Mastodon/Controllers/TrendsController.cs

@@ -0,0 +1,145 @@
+using Microsoft.AspNetCore.Mvc;
+
+using MongoDB.Driver;
+using MongoDB.Entities;
+
+using PrivaPub.Api.Mastodon.Infrastructure;
+using PrivaPub.Api.Mastodon.Mappers;
+using PrivaPub.Domain.Privacy;
+using PrivaPub.Domain.Social;
+using PrivaPub.Federation.Actors;
+using PrivaPub.Models.User;
+using PrivaPub.StaticServices;
+
+namespace PrivaPub.Api.Mastodon.Controllers
+{
+	// Trends and the directory (owner decision 2026-10-04, back from the cut list), from what PrivaPub already holds
+	// (Trends). The directory lists only accounts that let themselves be discovered.
+	public class TrendsController : MastodonController
+	{
+		readonly Trends _trends;
+		readonly MastodonMapper _mapper;
+		readonly DbEntities _dbEntities;
+		readonly ILocalActorService _localActors;
+
+		public TrendsController(Trends trends, MastodonMapper mapper, DbEntities dbEntities, ILocalActorService localActors)
+		{
+			_trends = trends;
+			_mapper = mapper;
+			_dbEntities = dbEntities;
+			_localActors = localActors;
+		}
+
+		static List<object> History(Trends.Trend trend) => trend.History.Select(h => (object)new
+		{
+			day = new DateTimeOffset(h.Day, TimeSpan.Zero).ToUnixTimeSeconds().ToString(),
+			uses = h.Uses.ToString(),
+			accounts = h.Accounts.ToString()
+		}).ToList();
+
+		IEnumerable<T> Window<T>(IEnumerable<T> items, int fallback, int max) =>
+			items.Skip(Math.Max(0, Params.Int("offset") ?? 0)).Take(Limit(fallback, max));
+
+		[HttpGet("/api/v1/trends"), HttpGet("/api/v1/trends/tags"), Scope("read", requiresUser: false), Microsoft.AspNetCore.Authorization.AllowAnonymous]
+		public async Task<IActionResult> Tags(CancellationToken token)
+		{
+			var followed = MyId == default
+				? new HashSet<string>()
+				: (await DB.Default.Find<Models.Social.FollowedTag>().Match(t => t.AvatarId == MyId).ExecuteAsync(token)).Select(t => t.Name).ToHashSet();
+			return Json(Window(await _trends.Tags(token), 10, 20).Select(t => new
+			{
+				name = t.Key,
+				url = $"{_localActors.BaseAddress}/tags/{Uri.EscapeDataString(t.Key)}",
+				history = History(t),
+				following = MyId == default ? default(bool?) : followed.Contains(t.Key)
+			}).ToList());
+		}
+
+		[HttpGet("/api/v1/trends/statuses"), Scope("read", requiresUser: false), Microsoft.AspNetCore.Authorization.AllowAnonymous]
+		public async Task<IActionResult> Statuses(CancellationToken token)
+		{
+			var ids = Window(await _trends.Statuses(token), 20, 40).ToList();
+			var posts = (await _dbEntities.Posts.Match(p => ids.Contains(p.ID)).Match(VisibilityPolicy.IsShown).ExecuteAsync(token)).ToDictionary(p => p.ID);
+			return Json(await _mapper.Statuses(ids.Where(posts.ContainsKey).Select(id => posts[id]).ToList(), MyId, token));
+		}
+
+		[HttpGet("/api/v1/trends/links"), Scope("read", requiresUser: false), Microsoft.AspNetCore.Authorization.AllowAnonymous]
+		public async Task<IActionResult> Links(CancellationToken token)
+		{
+			var trends = Window(await _trends.Links(token), 10, 20).ToList();
+			var sampleIds = trends.Select(t => t.SamplePostId).ToList();
+			var samples = (await _dbEntities.Posts.Match(p => sampleIds.Contains(p.ID)).ExecuteAsync(token)).ToDictionary(p => p.ID);
+			return Json(trends.Where(t => samples.ContainsKey(t.SamplePostId)).Select(t =>
+			{
+				var link = samples[t.SamplePostId].Link;
+				var card = _mapper.LinkCard(t.Key, link.Title, link.Description, link.ImageURL);
+				return card == default ? default : (object)new
+				{
+					card.Url, card.Title, card.Description, card.Type, card.AuthorName, card.AuthorUrl, card.ProviderName, card.ProviderUrl,
+					card.Html, card.Width, card.Height, card.Image, card.ImageDescription, card.EmbedUrl, card.Blurhash, card.Language,
+					card.PublishedAt, card.Authors, History = History(t)
+				};
+			}).Where(c => c != default).ToList());
+		}
+
+		// order=active: by their latest public post PrivaPub holds; order=new: by when they say they joined, which for a
+		// persona is its published day (never its creation, so personas made together are not told apart by their order)
+		[HttpGet("/api/v1/directory"), Scope("read", requiresUser: false), Microsoft.AspNetCore.Authorization.AllowAnonymous]
+		public async Task<IActionResult> Directory(CancellationToken token)
+		{
+			var offset = Math.Max(0, Params.Int("offset") ?? 0);
+			var limit = Limit(40, 80);
+			var localOnly = Params.Bool("local") == true;
+			var barred = await Counted.BarredPersonas(token);
+			var wanted = offset + limit;
+			var ordered = new List<string>();
+			if (Params.Get("order") == "new")
+			{
+				var personas = (await _dbEntities.Avatars.Match(a => a.Settings.IsDiscoverable && !a.DeletionAt.HasValue && !barred.Contains(a.ID))
+					.Sort(a => a.PublishedOn, Order.Descending).Limit(wanted * 4).ExecuteAsync(token))
+					.Select(a => (a.ID, Joined: a.PublishedOn, Tie: Tie(a.UserName)));
+				var remote = localOnly
+					? Enumerable.Empty<(string ID, DateTime Joined, string Tie)>()
+					: (await _dbEntities.ForeignAvatars.Match(f => f.IsDiscoverable && !f.DeletionAt.HasValue && !f.SuspendedAt.HasValue && f.Published != null)
+						.Sort(f => f.Published, Order.Descending).Limit(wanted).ExecuteAsync(token))
+						.Select(f => (f.ID, Joined: f.Published.Value.Date, Tie: Tie(f.ActorURI)));
+				ordered = personas.Concat(remote).OrderByDescending(a => a.Joined).ThenBy(a => a.Tie, StringComparer.Ordinal)
+					.Select(a => a.ID).Skip(offset).Take(limit).ToList();
+			}
+			else
+			{
+				var discoverableLocal = (await _dbEntities.Avatars.Match(a => a.Settings.IsDiscoverable && !a.DeletionAt.HasValue && !barred.Contains(a.ID))
+					.Project(a => a.Include(x => x.ID)).ExecuteAsync(token)).Select(a => a.ID).ToHashSet();
+				var seen = new HashSet<string>();
+				var maxId = default(string);
+				for (var round = 0; round < 20 && ordered.Count < wanted; round++)
+				{
+					var page = _dbEntities.Posts.Match(p => p.Visibility == Models.Post.PostVisibility.Public && !p.DeletedAt.HasValue && p.ReblogOfPostId == null);
+					if (maxId != default)
+						page.Match(f => f.Lt(p => p.ID, maxId));
+					if (localOnly)
+						page.Match(p => !p.IsFederatedCopy);
+					var batch = await page.Sort(p => p.ID, Order.Descending).Limit(500)
+						.Project(p => p.Include(x => x.ID).Include(x => x.AuthorAccountId).Include(x => x.GroupUserId).Include(x => x.IsFederatedCopy))
+						.ExecuteAsync(token);
+					if (batch.Count == 0)
+						break;
+					maxId = batch[^1].ID;
+					var fresh = batch.Select(p => (Id: p.AuthorAccountId ?? p.GroupUserId, p.IsFederatedCopy)).Where(a => a.Id != default && seen.Add(a.Id)).ToList();
+					var remoteIds = fresh.Where(a => a.IsFederatedCopy).Select(a => a.Id).ToList();
+					var discoverableRemote = remoteIds.Count == 0
+						? new HashSet<string>()
+						: (await _dbEntities.ForeignAvatars.Match(f => remoteIds.Contains(f.ID) && f.IsDiscoverable && !f.DeletionAt.HasValue && !f.SuspendedAt.HasValue)
+							.Project(f => f.Include(x => x.ID)).ExecuteAsync(token)).Select(f => f.ID).ToHashSet();
+					ordered.AddRange(fresh.Where(a => a.IsFederatedCopy ? discoverableRemote.Contains(a.Id) : discoverableLocal.Contains(a.Id)).Select(a => a.Id));
+				}
+				ordered = ordered.Skip(offset).Take(limit).ToList();
+			}
+			var accounts = await _mapper.Accounts(ordered, token);
+			return Json(ordered.Where(accounts.ContainsKey).Select(id => accounts[id]).ToList());
+		}
+
+		static string Tie(string name) =>
+			Convert.ToHexString(System.Security.Cryptography.SHA256.HashData(System.Text.Encoding.UTF8.GetBytes(name ?? string.Empty)));
+	}
+}

PrivaPub/Api/Mastodon/Mappers/MastodonMapper.cs

@@ -523,6 +523,8 @@ namespace PrivaPub.Api.Mastodon.Mappers
 			return default;
 		}
 
+		public PreviewCard LinkCard(string url, string title, string description, string image) => Card(url, title, description, image);
+
 		PreviewCard Card(string url, string title, string description, string image)
 		{
 			if (!Uri.TryCreate(url, UriKind.Absolute, out var uri))

PrivaPub/Domain/Social/Trends.cs

@@ -0,0 +1,126 @@
+using Microsoft.Extensions.Caching.Memory;
+
+using MongoDB.Driver;
+using MongoDB.Entities;
+
+using PrivaPub.Models.Post;
+using PrivaPub.Models.User;
+using PrivaPub.StaticServices;
+
+namespace PrivaPub.Domain.Social
+{
+	// What is being talked about here (owner decision 2026-10-04: trends count only public posts PrivaPub already holds,
+	// and fetch nothing). Hashtags and links rise with the number of different authors using them today against the
+	// week before; posts with their favourites, boosts and replies, halving every twelve hours. A post trends only if its
+	// author is discoverable, and nothing warned about (content warning) trends. Computed at most every ten minutes.
+	public sealed class Trends
+	{
+		public static readonly TimeSpan Fresh = TimeSpan.FromMinutes(10);
+		const int MinAuthors = 2;//one account alone never makes a trend
+		const int Kept = 40;
+
+		readonly DbEntities _dbEntities;
+		readonly IMemoryCache _cache;
+
+		public Trends(DbEntities dbEntities, IMemoryCache cache)
+		{
+			_dbEntities = dbEntities;
+			_cache = cache;
+		}
+
+		// what is computed is forgotten: the next read computes it again
+		public void Forget()
+		{
+			foreach (var key in new[] { "trends:tags", "trends:links", "trends:statuses" })
+				_cache.Remove(key);
+		}
+
+		public sealed record DayUse(DateTime Day, int Uses, int Accounts);
+
+		public sealed record Trend(string Key, List<DayUse> History, string SamplePostId);
+
+		public Task<List<Trend>> Tags(CancellationToken token) =>
+			_cache.GetOrCreateAsync("trends:tags", async entry =>
+			{
+				entry.AbsoluteExpirationRelativeToNow = Fresh;
+				var posts = await Week(p => p.Tags.Count > 0, token);
+				return Rank(posts.SelectMany(p => p.Tags.Distinct().Select(t => (Key: t, Post: p))));
+			});
+
+		public Task<List<Trend>> Links(CancellationToken token) =>
+			_cache.GetOrCreateAsync("trends:links", async entry =>
+			{
+				entry.AbsoluteExpirationRelativeToNow = Fresh;
+				var posts = await Week(p => p.Link != null, token);
+				return Rank(posts.Where(p => Uri.TryCreate(p.Link.Href, UriKind.Absolute, out var uri) && uri.Scheme is "https" or "http")
+					.Select(p => (Key: Normal(p.Link.Href), Post: p)));
+			});
+
+		// the ids of the trending posts, best first
+		public Task<List<string>> Statuses(CancellationToken token) =>
+			_cache.GetOrCreateAsync("trends:statuses", async entry =>
+			{
+				entry.AbsoluteExpirationRelativeToNow = Fresh;
+				var now = DateTime.UtcNow;
+				var since = now.AddHours(-48);
+				var posts = await _dbEntities.Posts
+					.Match(p => p.Visibility == PostVisibility.Public && !p.DeletedAt.HasValue && !p.AuthorGone && !p.HasContentWarning && !p.IsLocalOnly
+						&& p.ReblogOfPostId == null && p.InReplyToURI == null && p.AnsweringToPostId == null && p.CreationDate >= since
+						&& p.FavouritesCount + p.ReblogsCount + p.RepliesCount > 0)
+					.ExecuteAsync(token);
+				var discoverable = await Discoverable(posts.Select(p => p.AuthorAccountId ?? p.GroupUserId), token);
+				return posts.Where(p => discoverable.Contains(p.AuthorAccountId ?? p.GroupUserId))
+					.Select(p => (p.ID, Score: (p.FavouritesCount + 2.0 * p.ReblogsCount + p.RepliesCount) * Math.Pow(0.5, (now - p.CreationDate).TotalHours / 12)))
+					.OrderByDescending(p => p.Score).Take(Kept).Select(p => p.ID).ToList();
+			});
+
+		Task<List<Post>> Week(System.Linq.Expressions.Expression<Func<Post, bool>> with, CancellationToken token)
+		{
+			var since = DateTime.UtcNow.Date.AddDays(-6);
+			return _dbEntities.Posts
+				.Match(p => p.Visibility == PostVisibility.Public && !p.DeletedAt.HasValue && !p.AuthorGone && !p.HasContentWarning && !p.IsLocalOnly
+					&& p.ReblogOfPostId == null && p.CreationDate >= since)
+				.Match(with)
+				.Project(p => p.Include(x => x.ID).Include(x => x.Tags).Include(x => x.Link).Include(x => x.CreationDate)
+					.Include(x => x.AuthorAccountId).Include(x => x.GroupUserId))
+				.ExecuteAsync(token);
+		}
+
+		// rising: today's authors squared over the week's daily average before today, so a new subject beats a steady one
+		static List<Trend> Rank(IEnumerable<(string Key, Post Post)> uses)
+		{
+			var today = DateTime.UtcNow.Date;
+			return uses.GroupBy(u => u.Key)
+				.Select(g =>
+				{
+					var history = Enumerable.Range(0, 7).Select(back => today.AddDays(-back)).Select(day =>
+					{
+						var that = g.Where(u => u.Post.CreationDate >= day && u.Post.CreationDate < day.AddDays(1)).ToList();
+						return new DayUse(day, that.Count, that.Select(u => u.Post.AuthorAccountId ?? u.Post.GroupUserId).Distinct().Count());
+					}).ToList();
+					var recentAuthors = g.Where(u => u.Post.CreationDate >= today.AddDays(-1)).Select(u => u.Post.AuthorAccountId ?? u.Post.GroupUserId).Distinct().Count();
+					var before = history.Skip(1).Average(h => h.Accounts);
+					return (Trend: new Trend(g.Key, history, g.OrderByDescending(u => u.Post.CreationDate).First().Post.ID),
+						Recent: recentAuthors, Score: recentAuthors * recentAuthors / (before + 1));
+				})
+				.Where(t => t.Recent >= MinAuthors)
+				.OrderByDescending(t => t.Score).ThenByDescending(t => t.Recent).ThenBy(t => t.Trend.Key, StringComparer.Ordinal)
+				.Take(Kept).Select(t => t.Trend).ToList();
+		}
+
+		static string Normal(string href) =>
+			Uri.TryCreate(href, UriKind.Absolute, out var uri) ? uri.GetLeftPart(UriPartial.Query).TrimEnd('/') : href;
+
+		// the accounts among these whose owners let them be discovered: personas by their setting, remote accounts by theirs
+		static async Task<HashSet<string>> Discoverable(IEnumerable<string> accountIds, CancellationToken token)
+		{
+			var ids = accountIds.Where(id => !string.IsNullOrEmpty(id)).Distinct().ToList();
+			var barred = await Privacy.Counted.BarredPersonas(token);
+			var local = await DB.Default.Find<Avatar>().Match(a => ids.Contains(a.ID) && a.Settings.IsDiscoverable && !a.DeletionAt.HasValue && !barred.Contains(a.ID))
+				.Project(a => a.Include(x => x.ID)).ExecuteAsync(token);
+			var remote = await DB.Default.Find<ForeignAvatar>().Match(f => ids.Contains(f.ID) && f.IsDiscoverable && !f.DeletionAt.HasValue && !f.SuspendedAt.HasValue)
+				.Project(f => f.Include(x => x.ID)).ExecuteAsync(token);
+			return local.Select(a => a.ID).Concat(remote.Select(f => f.ID)).ToHashSet();
+		}
+	}
+}

PrivaPub/Program.cs

@@ -63,6 +63,7 @@ try
 			.PrivaPubOAuth(builder.Environment)
 			.AddScoped<PrivaPub.Api.Mastodon.Mappers.MastodonMapper>()
 			.AddScoped<PrivaPub.Api.Mastodon.Mappers.AccountSearch>()
+			.AddSingleton<PrivaPub.Domain.Social.Trends>()
 			.Configure<PrivaPub.Domain.Media.MediaOptions>(builder.Configuration.GetSection("Media"))
 			.AddSingleton<PrivaPub.Domain.Media.IMediaService, PrivaPub.Domain.Media.MediaService>()
 			.AddSingleton<PrivaPub.Domain.Media.IMediaProxy, PrivaPub.Domain.Media.MediaProxy>()