feat(feed): relay body storage + HTTP endpoints (Phase B of v2.0.0)

Phase A (the previous commit) added the on-chain foundations. Phase B is the off-chain layer: post bodies live in a BadgerDB-backed feed mailbox, and a full HTTP surface makes the feed usable from clients. New components relay/feed_mailbox.go (+ tests) - FeedPost: body + content-type + attachment + hashtags + thread refs - Store / Get / Delete with TTL-bounded eviction (30 days default) - View counter (IncrementView / ViewCount) — off-chain because one tx per view would be nonsense - Hashtag inverted index: auto-extracts #tokens from content on Store, lowercased + deduped + capped at 8/post - Author chrono index: PostsByAuthor returns newest-first IDs - RecentPostIDs: scan-by-age helper used by trending/foryou node/api_feed.go POST /feed/publish — author-signed body upload, returns post_id + content_hash + size + hashtags + estimated fee for the follow-up on-chain CREATE_POST tx GET /feed/post/{id} — fetch body (respects on-chain soft delete, returns 410 when deleted) GET /feed/post/{id}/stats — {views, likes, liked_by_me?} POST /feed/post/{id}/view — bump the counter GET /feed/author/{pub} — chain-authoritative post list enriched with body + stats GET /feed/timeline — merged feed from people the user follows (reads chain.Following, fetches each author's recent posts) GET /feed/trending — top-scored posts in last 24h (score = likes × 3 + views) GET /feed/foryou — simple recommendations: recent posts minus authors the user already follows, already-liked posts, and own posts; ranked by engagement GET /feed/hashtag/{tag} — posts tagged with the given #tag cmd/node/main.go wiring - --feed-db flag (DCHAIN_FEED_DB) + --feed-ttl-days (DCHAIN_FEED_TTL_DAYS) - Opens FeedMailbox + registers FeedRoutes alongside RelayRoutes - Threads chain.Post / LikeCount / HasLiked / PostsByAuthor / Following into FeedConfig so HTTP handlers can merge on-chain metadata with off-chain body+stats. Auth & safety - POST /feed/publish: Ed25519 signature over "publish:<post_id>: <content_sha256_hex>:<ts>"; ±5-minute skew window for anti-replay. - content_hash binds body to the on-chain tx — you can't publish body-A off-chain and commit hash-of-body-B on-chain. - Writes wrapped in withSubmitTxGuards (rate-limit + size cap), reads in withReadLimit — same guards as /relay. Trending / recommendations - V1 heuristic (likes × 3 + views) + time window. Documented as v2.2.0 "Feed algorithm" candidate for a proper ranking layer (half-life decay, follow-of-follow boost, hashtag collaborative). Tests - Store round-trip, size enforcement, hashtag indexing (case-insensitive + dedup), view counter increments, author chrono order, delete cleans all indices, RecentPostIDs time-window filter. - Full go test ./... is green (blockchain + consensus + identity + relay + vm all pass). Next (Phase C): client Feed tab — composer, timeline, post detail, profile follow, For You + Trending screens. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
2026-04-18 18:52:22 +03:00
parent 88848efa63
commit 126658f294
4 changed files with 1305 additions and 0 deletions
--- a/node/api_feed.go
+++ b/node/api_feed.go
@@ -0,0 +1,654 @@
+package node
+
+// Feed HTTP endpoints (v2.0.0).
+//
+// Mount points:
+//
+//	POST /feed/publish            — store a post body (authenticated)
+//	GET  /feed/post/{id}          — fetch a post body
+//	GET  /feed/post/{id}/stats    — {views, likes, liked_by_me?} aggregate
+//	POST /feed/post/{id}/view     — increment off-chain view counter
+//	GET  /feed/author/{pub}       — ?limit=N, posts by an author
+//	GET  /feed/timeline           — ?follower=<pub>&limit=N, merged feed of follows
+//	GET  /feed/trending           — ?window=h&limit=N, top by likes + views
+//	GET  /feed/foryou             — ?pub=<pub>&limit=N, recommendations
+//	GET  /feed/hashtag/{tag}      — posts matching a hashtag
+//
+// Publish flow:
+//   1. Client POSTs {content, attachment, post_id, author, sig, ts}.
+//   2. Node verifies sig (Ed25519 over canonical bytes), hashes body,
+//      stores in FeedMailbox, returns hosting_relay + content_hash + size.
+//   3. Client then submits on-chain CREATE_POST tx with that metadata.
+//      Node charges the fee (base + size×byte_fee) and credits the relay.
+//   4. Subsequent GET /feed/post/{id} serves the stored body to anyone.
+//
+// Why the split? On-chain metadata gives us provable authorship + the
+// pay-for-storage incentive; off-chain body storage keeps the block
+// history small. If the hosting relay dies, the on-chain record stays
+// (with a "body unavailable" fallback on the reader side) — authors can
+// re-publish to another relay.
+
+import (
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"sort"
+	"strings"
+	"time"
+
+	"go-blockchain/blockchain"
+	"go-blockchain/identity"
+	"go-blockchain/relay"
+)
+
+// FeedConfig wires feed HTTP endpoints to the relay mailbox and the
+// chain for read-after-write queries.
+type FeedConfig struct {
+	Mailbox *relay.FeedMailbox
+
+	// HostingRelayPub is this node's Ed25519 pubkey — returned from
+	// /feed/publish so the client knows who to put in CREATE_POST tx.
+	HostingRelayPub string
+
+	// Chain lookups (nil-safe; endpoints degrade gracefully).
+	GetPost         func(postID string) (*blockchain.PostRecord, error)
+	LikeCount       func(postID string) (uint64, error)
+	HasLiked        func(postID, likerPub string) (bool, error)
+	PostsByAuthor   func(authorPub string, limit int) ([]*blockchain.PostRecord, error)
+	Following       func(followerPub string) ([]string, error)
+}
+
+// RegisterFeedRoutes wires feed endpoints onto mux. Writes are rate-limited
+// via withSubmitTxGuards; reads via withReadLimit (same limiters as /relay).
+func RegisterFeedRoutes(mux *http.ServeMux, cfg FeedConfig) {
+	if cfg.Mailbox == nil {
+		return
+	}
+	mux.HandleFunc("/feed/publish", withSubmitTxGuards(feedPublish(cfg)))
+	mux.HandleFunc("/feed/post/", withReadLimit(feedPostRouter(cfg)))
+	mux.HandleFunc("/feed/author/", withReadLimit(feedAuthor(cfg)))
+	mux.HandleFunc("/feed/timeline", withReadLimit(feedTimeline(cfg)))
+	mux.HandleFunc("/feed/trending", withReadLimit(feedTrending(cfg)))
+	mux.HandleFunc("/feed/foryou", withReadLimit(feedForYou(cfg)))
+	mux.HandleFunc("/feed/hashtag/", withReadLimit(feedHashtag(cfg)))
+}
+
+// ── POST /feed/publish ────────────────────────────────────────────────────
+
+// feedPublishRequest — what the client sends. Signature is Ed25519 over
+// canonical bytes: "publish:<post_id>:<content_sha256_hex>:<ts>".
+// ts must be within ±5 minutes of server clock.
+type feedPublishRequest struct {
+	PostID         string `json:"post_id"`
+	Author         string `json:"author"`               // hex Ed25519
+	Content        string `json:"content"`
+	ContentType    string `json:"content_type,omitempty"`
+	AttachmentB64  string `json:"attachment_b64,omitempty"`
+	AttachmentMIME string `json:"attachment_mime,omitempty"`
+	ReplyTo        string `json:"reply_to,omitempty"`
+	QuoteOf        string `json:"quote_of,omitempty"`
+	Sig            string `json:"sig"` // base64 Ed25519 sig
+	Ts             int64  `json:"ts"`
+}
+
+type feedPublishResponse struct {
+	PostID         string   `json:"post_id"`
+	HostingRelay   string   `json:"hosting_relay"`
+	ContentHash    string   `json:"content_hash"` // hex sha256
+	Size           uint64   `json:"size"`
+	Hashtags       []string `json:"hashtags"`
+	EstimatedFeeUT uint64   `json:"estimated_fee_ut"` // base + size*byte_fee
+}
+
+func feedPublish(cfg FeedConfig) http.HandlerFunc {
+	const publishSkewSecs = 300
+
+	return func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodPost {
+			jsonErr(w, fmt.Errorf("method not allowed"), 405)
+			return
+		}
+		var req feedPublishRequest
+		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+			jsonErr(w, fmt.Errorf("invalid JSON: %w", err), 400)
+			return
+		}
+		if req.PostID == "" || req.Author == "" || req.Sig == "" || req.Ts == 0 {
+			jsonErr(w, fmt.Errorf("post_id, author, sig, ts are required"), 400)
+			return
+		}
+		if req.Content == "" && req.AttachmentB64 == "" {
+			jsonErr(w, fmt.Errorf("post must have content or attachment"), 400)
+			return
+		}
+		now := time.Now().Unix()
+		if req.Ts < now-publishSkewSecs || req.Ts > now+publishSkewSecs {
+			jsonErr(w, fmt.Errorf("ts out of range (±%ds)", publishSkewSecs), 400)
+			return
+		}
+		if req.ReplyTo != "" && req.QuoteOf != "" {
+			jsonErr(w, fmt.Errorf("reply_to and quote_of are mutually exclusive"), 400)
+			return
+		}
+
+		// Decode attachment.
+		var attachment []byte
+		if req.AttachmentB64 != "" {
+			b, err := base64.StdEncoding.DecodeString(req.AttachmentB64)
+			if err != nil {
+				if b, err = base64.RawURLEncoding.DecodeString(req.AttachmentB64); err != nil {
+					jsonErr(w, fmt.Errorf("attachment_b64: invalid base64"), 400)
+					return
+				}
+			}
+			attachment = b
+		}
+
+		// Content hash binds the body to the on-chain metadata. We hash
+		// content+attachment so the client can't publish body-A off-chain
+		// and commit hash-of-body-B on-chain.
+		h := sha256.New()
+		h.Write([]byte(req.Content))
+		h.Write(attachment)
+		contentHash := h.Sum(nil)
+		contentHashHex := hex.EncodeToString(contentHash)
+
+		// Verify the author's signature over the canonical publish bytes.
+		msg := []byte(fmt.Sprintf("publish:%s:%s:%d", req.PostID, contentHashHex, req.Ts))
+		sigBytes, err := base64.StdEncoding.DecodeString(req.Sig)
+		if err != nil {
+			if sigBytes, err = base64.RawURLEncoding.DecodeString(req.Sig); err != nil {
+				jsonErr(w, fmt.Errorf("sig: invalid base64"), 400)
+				return
+			}
+		}
+		if _, err := hex.DecodeString(req.Author); err != nil {
+			jsonErr(w, fmt.Errorf("author: invalid hex"), 400)
+			return
+		}
+		ok, err := identity.Verify(req.Author, msg, sigBytes)
+		if err != nil || !ok {
+			jsonErr(w, fmt.Errorf("signature invalid"), 403)
+			return
+		}
+
+		post := &relay.FeedPost{
+			PostID:         req.PostID,
+			Author:         req.Author,
+			Content:        req.Content,
+			ContentType:    req.ContentType,
+			Attachment:     attachment,
+			AttachmentMIME: req.AttachmentMIME,
+			ReplyTo:        req.ReplyTo,
+			QuoteOf:        req.QuoteOf,
+		}
+		hashtags, err := cfg.Mailbox.Store(post, req.Ts)
+		if err != nil {
+			if err == relay.ErrPostTooLarge {
+				jsonErr(w, err, 413)
+				return
+			}
+			jsonErr(w, err, 500)
+			return
+		}
+
+		// Report what the client should put into CREATE_POST.
+		size := uint64(len(req.Content)) + uint64(len(attachment)) + 128
+		fee := blockchain.BasePostFee + size*blockchain.PostByteFee
+		jsonOK(w, feedPublishResponse{
+			PostID:         req.PostID,
+			HostingRelay:   cfg.HostingRelayPub,
+			ContentHash:    contentHashHex,
+			Size:           size,
+			Hashtags:       hashtags,
+			EstimatedFeeUT: fee,
+		})
+	}
+}
+
+// ── GET /feed/post/{id}  [+ /stats subroute, POST /view] ─────────────────
+
+// feedPostRouter dispatches /feed/post/{id}, /feed/post/{id}/stats,
+// /feed/post/{id}/view to the right handler.
+func feedPostRouter(cfg FeedConfig) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		rest := strings.TrimPrefix(r.URL.Path, "/feed/post/")
+		rest = strings.Trim(rest, "/")
+		if rest == "" {
+			jsonErr(w, fmt.Errorf("post id required"), 400)
+			return
+		}
+		parts := strings.Split(rest, "/")
+		postID := parts[0]
+		if len(parts) == 1 {
+			feedGetPost(cfg)(w, r, postID)
+			return
+		}
+		switch parts[1] {
+		case "stats":
+			feedPostStats(cfg)(w, r, postID)
+		case "view":
+			feedPostView(cfg)(w, r, postID)
+		default:
+			jsonErr(w, fmt.Errorf("unknown sub-route %q", parts[1]), 404)
+		}
+	}
+}
+
+type postHandler func(w http.ResponseWriter, r *http.Request, postID string)
+
+func feedGetPost(cfg FeedConfig) postHandler {
+	return func(w http.ResponseWriter, r *http.Request, postID string) {
+		if r.Method != http.MethodGet {
+			jsonErr(w, fmt.Errorf("method not allowed"), 405)
+			return
+		}
+		post, err := cfg.Mailbox.Get(postID)
+		if err != nil {
+			jsonErr(w, err, 500)
+			return
+		}
+		if post == nil {
+			jsonErr(w, fmt.Errorf("post %s not found", postID), 404)
+			return
+		}
+		// Respect on-chain soft-delete.
+		if cfg.GetPost != nil {
+			if rec, _ := cfg.GetPost(postID); rec != nil && rec.Deleted {
+				jsonErr(w, fmt.Errorf("post %s deleted", postID), 410)
+				return
+			}
+		}
+		jsonOK(w, post)
+	}
+}
+
+type postStatsResponse struct {
+	PostID    string `json:"post_id"`
+	Views     uint64 `json:"views"`
+	Likes     uint64 `json:"likes"`
+	LikedByMe *bool  `json:"liked_by_me,omitempty"` // set only when ?me=<pub> given
+}
+
+func feedPostStats(cfg FeedConfig) postHandler {
+	return func(w http.ResponseWriter, r *http.Request, postID string) {
+		if r.Method != http.MethodGet {
+			jsonErr(w, fmt.Errorf("method not allowed"), 405)
+			return
+		}
+		views, _ := cfg.Mailbox.ViewCount(postID)
+		var likes uint64
+		if cfg.LikeCount != nil {
+			likes, _ = cfg.LikeCount(postID)
+		}
+		resp := postStatsResponse{
+			PostID: postID,
+			Views:  views,
+			Likes:  likes,
+		}
+		if me := r.URL.Query().Get("me"); me != "" && cfg.HasLiked != nil {
+			if liked, err := cfg.HasLiked(postID, me); err == nil {
+				resp.LikedByMe = &liked
+			}
+		}
+		jsonOK(w, resp)
+	}
+}
+
+func feedPostView(cfg FeedConfig) postHandler {
+	return func(w http.ResponseWriter, r *http.Request, postID string) {
+		if r.Method != http.MethodPost {
+			jsonErr(w, fmt.Errorf("method not allowed"), 405)
+			return
+		}
+		next, err := cfg.Mailbox.IncrementView(postID)
+		if err != nil {
+			jsonErr(w, err, 500)
+			return
+		}
+		jsonOK(w, map[string]any{
+			"post_id": postID,
+			"views":   next,
+		})
+	}
+}
+
+// ── GET /feed/author/{pub} ────────────────────────────────────────────────
+
+func feedAuthor(cfg FeedConfig) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodGet {
+			jsonErr(w, fmt.Errorf("method not allowed"), 405)
+			return
+		}
+		pub := strings.TrimPrefix(r.URL.Path, "/feed/author/")
+		pub = strings.Trim(pub, "/")
+		if pub == "" {
+			jsonErr(w, fmt.Errorf("author pub required"), 400)
+			return
+		}
+		limit := queryInt(r, "limit", 50)
+
+		// Prefer chain-authoritative list (includes soft-deleted flag) so
+		// clients can't be fooled by a stale relay that has an already-
+		// deleted post. If chain isn't wired, fall back to relay index.
+		if cfg.PostsByAuthor != nil {
+			records, err := cfg.PostsByAuthor(pub, limit)
+			if err != nil {
+				jsonErr(w, err, 500)
+				return
+			}
+			out := make([]feedAuthorItem, 0, len(records))
+			for _, rec := range records {
+				if rec == nil || rec.Deleted {
+					continue
+				}
+				out = append(out, buildAuthorItem(cfg, rec))
+			}
+			jsonOK(w, map[string]any{"author": pub, "count": len(out), "posts": out})
+			return
+		}
+		ids, err := cfg.Mailbox.PostsByAuthor(pub, limit)
+		if err != nil {
+			jsonErr(w, err, 500)
+			return
+		}
+		out := expandByID(cfg, ids)
+		jsonOK(w, map[string]any{"author": pub, "count": len(out), "posts": out})
+	}
+}
+
+// feedAuthorItem is a chain record enriched with the body and live stats.
+type feedAuthorItem struct {
+	PostID       string   `json:"post_id"`
+	Author       string   `json:"author"`
+	Content      string   `json:"content,omitempty"`
+	ContentType  string   `json:"content_type,omitempty"`
+	Hashtags     []string `json:"hashtags,omitempty"`
+	ReplyTo      string   `json:"reply_to,omitempty"`
+	QuoteOf      string   `json:"quote_of,omitempty"`
+	CreatedAt    int64    `json:"created_at"`
+	Size         uint64   `json:"size"`
+	HostingRelay string   `json:"hosting_relay"`
+	Views        uint64   `json:"views"`
+	Likes        uint64   `json:"likes"`
+	HasAttachment bool    `json:"has_attachment"`
+}
+
+func buildAuthorItem(cfg FeedConfig, rec *blockchain.PostRecord) feedAuthorItem {
+	item := feedAuthorItem{
+		PostID:       rec.PostID,
+		Author:       rec.Author,
+		ReplyTo:      rec.ReplyTo,
+		QuoteOf:      rec.QuoteOf,
+		CreatedAt:    rec.CreatedAt,
+		Size:         rec.Size,
+		HostingRelay: rec.HostingRelay,
+	}
+	if body, _ := cfg.Mailbox.Get(rec.PostID); body != nil {
+		item.Content = body.Content
+		item.ContentType = body.ContentType
+		item.Hashtags = body.Hashtags
+		item.HasAttachment = len(body.Attachment) > 0
+	}
+	if cfg.LikeCount != nil {
+		item.Likes, _ = cfg.LikeCount(rec.PostID)
+	}
+	item.Views, _ = cfg.Mailbox.ViewCount(rec.PostID)
+	return item
+}
+
+// expandByID fetches bodies+stats for a list of post IDs (no chain record).
+func expandByID(cfg FeedConfig, ids []string) []feedAuthorItem {
+	out := make([]feedAuthorItem, 0, len(ids))
+	for _, id := range ids {
+		body, _ := cfg.Mailbox.Get(id)
+		if body == nil {
+			continue
+		}
+		item := feedAuthorItem{
+			PostID:        id,
+			Author:        body.Author,
+			Content:       body.Content,
+			ContentType:   body.ContentType,
+			Hashtags:      body.Hashtags,
+			ReplyTo:       body.ReplyTo,
+			QuoteOf:       body.QuoteOf,
+			CreatedAt:     body.CreatedAt,
+			HasAttachment: len(body.Attachment) > 0,
+		}
+		if cfg.LikeCount != nil {
+			item.Likes, _ = cfg.LikeCount(id)
+		}
+		item.Views, _ = cfg.Mailbox.ViewCount(id)
+		out = append(out, item)
+	}
+	return out
+}
+
+// ── GET /feed/timeline ────────────────────────────────────────────────────
+
+func feedTimeline(cfg FeedConfig) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodGet {
+			jsonErr(w, fmt.Errorf("method not allowed"), 405)
+			return
+		}
+		follower := r.URL.Query().Get("follower")
+		if follower == "" {
+			jsonErr(w, fmt.Errorf("follower parameter required"), 400)
+			return
+		}
+		if cfg.Following == nil || cfg.PostsByAuthor == nil {
+			jsonErr(w, fmt.Errorf("timeline requires chain queries"), 503)
+			return
+		}
+		limit := queryInt(r, "limit", 50)
+		perAuthor := limit
+		if perAuthor > 30 {
+			perAuthor = 30
+		}
+
+		following, err := cfg.Following(follower)
+		if err != nil {
+			jsonErr(w, err, 500)
+			return
+		}
+		var merged []*blockchain.PostRecord
+		for _, target := range following {
+			posts, err := cfg.PostsByAuthor(target, perAuthor)
+			if err != nil {
+				continue
+			}
+			for _, p := range posts {
+				if p != nil && !p.Deleted {
+					merged = append(merged, p)
+				}
+			}
+		}
+		// Sort newest-first, take top N.
+		sort.Slice(merged, func(i, j int) bool { return merged[i].CreatedAt > merged[j].CreatedAt })
+		if len(merged) > limit {
+			merged = merged[:limit]
+		}
+		out := make([]feedAuthorItem, 0, len(merged))
+		for _, rec := range merged {
+			out = append(out, buildAuthorItem(cfg, rec))
+		}
+		jsonOK(w, map[string]any{"count": len(out), "posts": out})
+	}
+}
+
+// ── GET /feed/trending ────────────────────────────────────────────────────
+
+func feedTrending(cfg FeedConfig) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodGet {
+			jsonErr(w, fmt.Errorf("method not allowed"), 405)
+			return
+		}
+		limit := queryInt(r, "limit", 30)
+		// Window defaults to 24h; cap 7d so a viral post from a week ago
+		// doesn't permanently dominate.
+		windowHours := queryInt(r, "window", 24)
+		if windowHours > 24*7 {
+			windowHours = 24 * 7
+		}
+		if windowHours < 1 {
+			windowHours = 1
+		}
+		ids, err := cfg.Mailbox.RecentPostIDs(int64(windowHours)*3600, 500)
+		if err != nil {
+			jsonErr(w, err, 500)
+			return
+		}
+		// Score each = likes*3 + views, honoring soft-delete.
+		type scored struct {
+			id    string
+			score uint64
+		}
+		scoredList := make([]scored, 0, len(ids))
+		for _, id := range ids {
+			if cfg.GetPost != nil {
+				if rec, _ := cfg.GetPost(id); rec != nil && rec.Deleted {
+					continue
+				}
+			}
+			views, _ := cfg.Mailbox.ViewCount(id)
+			var likes uint64
+			if cfg.LikeCount != nil {
+				likes, _ = cfg.LikeCount(id)
+			}
+			scoredList = append(scoredList, scored{id: id, score: likes*3 + views})
+		}
+		sort.Slice(scoredList, func(i, j int) bool { return scoredList[i].score > scoredList[j].score })
+		if len(scoredList) > limit {
+			scoredList = scoredList[:limit]
+		}
+		pickedIDs := make([]string, len(scoredList))
+		for i, s := range scoredList {
+			pickedIDs[i] = s.id
+		}
+		out := expandByID(cfg, pickedIDs)
+		jsonOK(w, map[string]any{"count": len(out), "posts": out})
+	}
+}
+
+// ── GET /feed/foryou ──────────────────────────────────────────────────────
+//
+// Simple recommendations heuristic for v2.0.0:
+//   1. Compute the set of authors the user already follows.
+//   2. Fetch recent posts from the relay (last 48h).
+//   3. Filter OUT posts from followed authors (those live in /timeline).
+//   4. Filter OUT posts the user has already liked.
+//   5. Rank remaining by (likes × 3 + views) and return top N.
+//
+// Future improvements (tracked as v2.2.0 "Feed algorithm"):
+//   - Weight by "followed-of-followed" signal (friends-of-friends boost).
+//   - Decay by age (exp half-life ~12h).
+//   - Penalise self-engagement (author liking own post).
+//   - Collaborative filtering on hashtag co-occurrence.
+
+func feedForYou(cfg FeedConfig) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodGet {
+			jsonErr(w, fmt.Errorf("method not allowed"), 405)
+			return
+		}
+		pub := r.URL.Query().Get("pub")
+		limit := queryInt(r, "limit", 30)
+
+		// Gather user's follows + likes to exclude from the candidate pool.
+		excludedAuthors := make(map[string]struct{})
+		if cfg.Following != nil && pub != "" {
+			if list, err := cfg.Following(pub); err == nil {
+				for _, a := range list {
+					excludedAuthors[a] = struct{}{}
+				}
+			}
+		}
+		// Post pool: last 48h on this relay.
+		ids, err := cfg.Mailbox.RecentPostIDs(48*3600, 500)
+		if err != nil {
+			jsonErr(w, err, 500)
+			return
+		}
+		type scored struct {
+			id    string
+			score uint64
+		}
+		scoredList := make([]scored, 0, len(ids))
+		for _, id := range ids {
+			body, _ := cfg.Mailbox.Get(id)
+			if body == nil {
+				continue
+			}
+			if _, followed := excludedAuthors[body.Author]; followed {
+				continue
+			}
+			if body.Author == pub {
+				continue // don't recommend user's own posts
+			}
+			if cfg.GetPost != nil {
+				if rec, _ := cfg.GetPost(id); rec != nil && rec.Deleted {
+					continue
+				}
+			}
+			// Skip already-liked.
+			if cfg.HasLiked != nil && pub != "" {
+				if liked, _ := cfg.HasLiked(id, pub); liked {
+					continue
+				}
+			}
+			views, _ := cfg.Mailbox.ViewCount(id)
+			var likes uint64
+			if cfg.LikeCount != nil {
+				likes, _ = cfg.LikeCount(id)
+			}
+			// Small "seed" score so posts with no engagement still get shown
+			// sometimes (otherwise a silent but fresh post can't break in).
+			scoredList = append(scoredList, scored{id: id, score: likes*3 + views + 1})
+		}
+		sort.Slice(scoredList, func(i, j int) bool { return scoredList[i].score > scoredList[j].score })
+		if len(scoredList) > limit {
+			scoredList = scoredList[:limit]
+		}
+		pickedIDs := make([]string, len(scoredList))
+		for i, s := range scoredList {
+			pickedIDs[i] = s.id
+		}
+		out := expandByID(cfg, pickedIDs)
+		jsonOK(w, map[string]any{"count": len(out), "posts": out})
+	}
+}
+
+// ── GET /feed/hashtag/{tag} ──────────────────────────────────────────────
+
+func feedHashtag(cfg FeedConfig) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodGet {
+			jsonErr(w, fmt.Errorf("method not allowed"), 405)
+			return
+		}
+		tag := strings.TrimPrefix(r.URL.Path, "/feed/hashtag/")
+		tag = strings.Trim(tag, "/")
+		if tag == "" {
+			jsonErr(w, fmt.Errorf("tag required"), 400)
+			return
+		}
+		limit := queryInt(r, "limit", 50)
+		ids, err := cfg.Mailbox.PostsByHashtag(tag, limit)
+		if err != nil {
+			jsonErr(w, err, 500)
+			return
+		}
+		out := expandByID(cfg, ids)
+		jsonOK(w, map[string]any{"tag": strings.ToLower(tag), "count": len(out), "posts": out})
+	}
+}
+
+// (queryInt helper is shared with the rest of the node HTTP surface;
+// see api_common.go.)