getPostThreadV2 mostly full impl w/ op prio (kinda slow and no sort)

main.go

···
 	"tangled.org/whey.party/red-dwarf-server/microcosm/slingshot"
 	appbskyactordefs "tangled.org/whey.party/red-dwarf-server/shims/lex/app/bsky/actor/defs"
 	appbskyfeeddefs "tangled.org/whey.party/red-dwarf-server/shims/lex/app/bsky/feed/defs"
+	appbskyunspeccedgetpostthreadv2 "tangled.org/whey.party/red-dwarf-server/shims/lex/app/bsky/unspecced/getpostthreadv2"
 	"tangled.org/whey.party/red-dwarf-server/shims/utils"
 	"tangled.org/whey.party/red-dwarf-server/sticket"
 	"tangled.org/whey.party/red-dwarf-server/store"
···
 	cs := constellation.NewConstellation(CONSTELLATION_URL)
 	// spacedust is type definitions only
 	// jetstream types is probably available from jetstream/pkg/models
+
+	//threadGraphCache := make(map[syntax.ATURI]appbskyunspeccedgetpostthreadv2.ThreadGraph)
 
 	router_raw := gin.New()
 	router_raw.Use(gin.Logger())
···
 	}
 	router.GET("/xrpc/app.bsky.unspecced.getPostThreadV2",
 		func(c *gin.Context) {
-			ctx := c.Request.Context()
-
-			rawdid := c.GetString("user_did")
-			var viewer *utils.DID
-			didval, errdid := utils.NewDID(rawdid)
-			if errdid != nil {
-				viewer = nil
-			} else {
-				viewer = &didval
-			}
-
-			threadAnchorURIraw := c.Query("anchor")
-			if threadAnchorURIraw == "" {
-				c.JSON(http.StatusBadRequest, gin.H{"error": "Missing feed param"})
-				return
-			}
-
-			threadAnchorURI, err := syntax.ParseATURI(threadAnchorURIraw)
-			if err != nil {
-				return
-			}
-
-			//var thread []*appbsky.UnspeccedGetPostThreadOtherV2_ThreadItem
-
-			var skeletonposts []string
-
-			emptystrarray := &[]string{}
-			limit := 100
-
-			// recurse to the top
-			parentsMap := map[string]*appbsky.FeedDefs_PostView{}
-			current := threadAnchorURI
-			iteration := 0
-			for true {
-				iteration = iteration + 1
-				if iteration > 10 {
-					break
-				}
-				recordaturi, err := syntax.ParseATURI("at://" + current.Authority().String() + "/" + string(current.Collection()) + "/" + string(current.RecordKey()))
-				if err != nil {
-					break
-				}
-				// loop
-				postView, postRecord, err := appbskyfeeddefs.PostView(ctx, recordaturi.String(), sl, cs, BSKYIMAGECDN_URL, viewer, 3)
-				if err != nil {
-					break
-				}
-				if postView == nil {
-					break
-				}
-				//if iteration != 1 {
-				skeletonposts = append([]string{recordaturi.String()}, skeletonposts...)
-				//}
-				parentsMap[recordaturi.String()] = postView
-				if postRecord != nil && postRecord.Reply != nil && postRecord.Reply.Parent != nil && postRecord.Reply.Root != nil {
-					if postRecord.Reply.Parent.Uri == postRecord.Reply.Root.Uri {
-						//break
-						iteration = 9
-					}
-
-					current, err = syntax.ParseATURI(postRecord.Reply.Parent.Uri)
-					if err != nil {
-						break
-					}
-				} else {
-					log.Println("what huh what hwat")
-					break //whatt
-				}
-
-			}
-
-			//skeletonposts = append(skeletonposts, threadAnchorURI.String())
-			// todo: theres a cursor!!! pagination please!
-			// todo: also i doubt im gonna do proper threadding right now, so make sure to remind me to do it properly some time later thanks
-			//rootReplies, _ := constellation.GetBacklinks(ctx, cs, string(threadAnchorURI), "app.bsky.feed.post:reply.root.uri", *emptystrarray, &limit, nil)
-			parentReplies, _ := constellation.GetBacklinks(ctx, cs, string(threadAnchorURI), "app.bsky.feed.post:reply.parent.uri", *emptystrarray, &limit, nil)
-
-			for _, rec := range parentReplies.Records {
-				recordaturi, err := syntax.ParseATURI("at://" + rec.Did + "/" + rec.Collection + "/" + rec.Rkey)
-				if err != nil {
-					continue
-				}
-				skeletonposts = append(skeletonposts, recordaturi.String())
-			}
-			maplen := len(parentsMap)
-			concurrentResults := MapConcurrent(
-				ctx,
-				skeletonposts,
-				20,
-				func(ctx context.Context, raw string, idx int) (*appbsky.UnspeccedGetPostThreadOtherV2_ThreadItem, error) {
-					var postView *appbsky.FeedDefs_PostView
-					fromParentChain := false
-					postView, ok := parentsMap[raw]
-					if !ok {
-						post, _, err := appbskyfeeddefs.PostView(ctx, raw, sl, cs, BSKYIMAGECDN_URL, viewer, 3)
-						if err != nil {
-							return nil, err
-						}
-						if post == nil {
-							return nil, fmt.Errorf("post not found")
-						}
-						postView = post
-					} else {
-						fromParentChain = true
-					}
-
-					depth := int64(1)
-					if raw == threadAnchorURI.String() {
-						depth = 0
-					}
-					if fromParentChain {
-						depth = int64(0 - maplen + idx + 1)
-					}
-
-					return &appbsky.UnspeccedGetPostThreadOtherV2_ThreadItem{
-						// Depth int64                                           `json:"depth" cborgen:"depth"`
-						Depth: depth, // todo: placeholder
-						// Uri   string                                          `json:"uri" cborgen:"uri"`
-						Uri: raw,
-						// Value *UnspeccedGetPostThreadOtherV2_ThreadItem_Value `json:"value" cborgen:"value"`
-						Value: &appbsky.UnspeccedGetPostThreadOtherV2_ThreadItem_Value{
-							// UnspeccedDefs_ThreadItemPost *UnspeccedDefs_ThreadItemPost
-							UnspeccedDefs_ThreadItemPost: &appbsky.UnspeccedDefs_ThreadItemPost{
-								// LexiconTypeID string `json:"$type" cborgen:"$type,const=app.bsky.unspecced.defs#threadItemPost"`
-								LexiconTypeID: "app.bsky.unspecced.defs#threadItemPost",
-								// // hiddenByThreadgate: The threadgate created by the author indicates this post as a reply to be hidden for everyone consuming the thread.
-								// HiddenByThreadgate bool `json:"hiddenByThreadgate" cborgen:"hiddenByThreadgate"`
-								HiddenByThreadgate: false, // todo: placeholder
-								// // moreParents: This post has more parents that were not present in the response. This is just a boolean, without the number of parents.
-								// MoreParents bool `json:"moreParents" cborgen:"moreParents"`
-								MoreParents: false, // todo: placeholder
-								// // moreReplies: This post has more replies that were not present in the response. This is a numeric value, which is best-effort and might not be accurate.
-								// MoreReplies int64 `json:"moreReplies" cborgen:"moreReplies"`
-								MoreReplies: 0, // todo: placeholder
-								// // mutedByViewer: This is by an account muted by the viewer requesting it.
-								// MutedByViewer bool `json:"mutedByViewer" cborgen:"mutedByViewer"`
-								MutedByViewer: false, // todo: placeholder
-								// // opThread: This post is part of a contiguous thread by the OP from the thread root. Many different OP threads can happen in the same thread.
-								// OpThread bool               `json:"opThread" cborgen:"opThread"`
-								OpThread: false, // todo: placeholder
-								// Post     *FeedDefs_PostView `json:"post" cborgen:"post"`
-								Post: postView,
-							},
-						},
-					}, nil
-				},
-			)
-
-			// build final slice
-			out := make([]*appbsky.UnspeccedGetPostThreadOtherV2_ThreadItem, 0, len(concurrentResults))
-			for _, r := range concurrentResults {
-				if r.Err == nil && r.Value != nil && r.Value.Value != nil && r.Value.Value.UnspeccedDefs_ThreadItemPost != nil && r.Value.Value.UnspeccedDefs_ThreadItemPost.Post != nil {
-					out = append(out, r.Value)
-				}
-			}
-
-			// c.JSON(http.StatusOK, &appbsky.UnspeccedGetPostThreadOtherV2_Output{
-			// 	// Thread []*UnspeccedGetPostThreadOtherV2_ThreadItem `json:"thread" cborgen:"thread"`
-			// 	Thread: out,
-			// 	HasOtherReplies: false,
-			// })
-			resp := &GetPostThreadOtherV2_Output_WithOtherReplies{
-				UnspeccedGetPostThreadOtherV2_Output: appbsky.UnspeccedGetPostThreadOtherV2_Output{
-					Thread: out,
-				},
-				HasOtherReplies: false,
-			}
-			c.JSON(http.StatusOK, resp)
+			//appbskyunspeccedgetpostthreadv2.HandleGetPostThreadV2(c, sl, cs, BSKYIMAGECDN_URL)
+			// V2V2 still doesnt work. should probably make the handler from scratch to fully use the thread grapher.
+			// also the thread grapher is still sequental. pls fix that
+			//appbskyunspeccedgetpostthreadv2.HandleGetPostThreadV2V2(c, sl, cs, BSKYIMAGECDN_URL)
+			appbskyunspeccedgetpostthreadv2.HandleGetPostThreadV2V3(c, sl, cs, BSKYIMAGECDN_URL)
 		})
 
 	// weird stuff

readme.md

···
 - `app.bsky.feed.getPosts` (post rendering is incomplete)
 - `app.bsky.feed.getFeed` (post rendering is incomplete)
 - `app.bsky.unspecced.getConfig` (placeholder)
-- `app.bsky.unspecced.getPostThreadV2` (thread rendering is incomplete)
+- `app.bsky.unspecced.getPostThreadV2` (mostly working! doesnt use prefered sort, not performant)

shims/lex/app/bsky/actor/defs/profileview.go

···
 import (
 	"context"
 	"encoding/json"
-	"log"
 
 	"github.com/bluesky-social/indigo/api/agnostic"
 	appbsky "github.com/bluesky-social/indigo/api/bsky"
···
 	//viewerProfileURI, err_viewerProfileURI := syntax.ParseATURI("at://" + viewerProfileDID + "/app.bsky.actor.profile/self")
 	//targetProfileURI, err_targetProfileURI := syntax.ParseATURI("at://" + targetProfileDID + "/app.bsky.actor.profile/self")
 
-	log.Println("viewerProfileDID: " + viewerProfileDID + " and targetProfileDID: " + targetProfileDID)
+	//log.Println("viewerProfileDID: " + viewerProfileDID + " and targetProfileDID: " + targetProfileDID)
 
 	if viewerProfileDID != "" && targetProfileDID != "" {
 		blockingBacklink, err_blockingBacklink := constellation.GetBacklinks(ctx, cs, targetProfileDID, "app.bsky.graph.block:subject", []string{viewerProfileDID}, nil, nil)

shims/lex/app/bsky/unspecced/getpostthreadv2/query.go

···
+package appbskyunspeccedgetpostthreadv2
+
+import (
+	"net/http"
+	"strconv"
+	"sync"
+
+	"context"
+	"fmt"
+	"log"
+
+	"github.com/bluesky-social/indigo/atproto/syntax"
+	"github.com/gin-gonic/gin"
+	"tangled.org/whey.party/red-dwarf-server/microcosm"
+	"tangled.org/whey.party/red-dwarf-server/shims/utils"
+
+	"tangled.org/whey.party/red-dwarf-server/microcosm/constellation"
+	appbskyfeeddefs "tangled.org/whey.party/red-dwarf-server/shims/lex/app/bsky/feed/defs"
+
+	appbsky "github.com/bluesky-social/indigo/api/bsky"
+)
+
+func HandleGetPostThreadV2(c *gin.Context, sl *microcosm.MicrocosmClient, cs *microcosm.MicrocosmClient, imgcdn string) {
+	ctx := c.Request.Context()
+
+	rawdid := c.GetString("user_did")
+	var viewer *utils.DID
+	didval, errdid := utils.NewDID(rawdid)
+	if errdid != nil {
+		viewer = nil
+	} else {
+		viewer = &didval
+	}
+
+	threadAnchorURIraw := c.Query("anchor")
+	if threadAnchorURIraw == "" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "Missing feed param"})
+		return
+	}
+
+	threadAnchorURI, err := syntax.ParseATURI(threadAnchorURIraw)
+	if err != nil {
+		return
+	}
+
+	//var thread []*appbsky.UnspeccedGetPostThreadOtherV2_ThreadItem
+
+	var skeletonposts []string
+
+	emptystrarray := &[]string{}
+	limit := 100
+
+	// recurse to the top
+	parentsMap := map[string]*appbsky.FeedDefs_PostView{}
+	current := threadAnchorURI
+	iteration := 0
+	for true {
+		iteration = iteration + 1
+		if iteration > 10 {
+			break
+		}
+		recordaturi, err := syntax.ParseATURI("at://" + current.Authority().String() + "/" + string(current.Collection()) + "/" + string(current.RecordKey()))
+		if err != nil {
+			break
+		}
+		// loop
+		postView, postRecord, err := appbskyfeeddefs.PostView(ctx, recordaturi.String(), sl, cs, imgcdn, viewer, 3)
+		if err != nil {
+			break
+		}
+		if postView == nil {
+			break
+		}
+		//if iteration != 1 {
+		skeletonposts = append([]string{recordaturi.String()}, skeletonposts...)
+		//}
+		parentsMap[recordaturi.String()] = postView
+		if postRecord != nil && postRecord.Reply != nil && postRecord.Reply.Parent != nil && postRecord.Reply.Root != nil {
+			if postRecord.Reply.Parent.Uri == postRecord.Reply.Root.Uri {
+				//break
+				iteration = 9
+			}
+
+			current, err = syntax.ParseATURI(postRecord.Reply.Parent.Uri)
+			if err != nil {
+				break
+			}
+		} else {
+			log.Println("what huh what hwat")
+			break //whatt
+		}
+
+	}
+
+	//skeletonposts = append(skeletonposts, threadAnchorURI.String())
+	// todo: theres a cursor!!! pagination please!
+	// todo: also i doubt im gonna do proper threadding right now, so make sure to remind me to do it properly some time later thanks
+	//rootReplies, _ := constellation.GetBacklinks(ctx, cs, string(threadAnchorURI), "app.bsky.feed.post:reply.root.uri", *emptystrarray, &limit, nil)
+	parentReplies, _ := constellation.GetBacklinks(ctx, cs, string(threadAnchorURI), "app.bsky.feed.post:reply.parent.uri", *emptystrarray, &limit, nil)
+
+	for _, rec := range parentReplies.Records {
+		recordaturi, err := syntax.ParseATURI("at://" + rec.Did + "/" + rec.Collection + "/" + rec.Rkey)
+		if err != nil {
+			continue
+		}
+		skeletonposts = append(skeletonposts, recordaturi.String())
+	}
+	maplen := len(parentsMap)
+	concurrentResults := MapConcurrent(
+		ctx,
+		skeletonposts,
+		20,
+		func(ctx context.Context, raw string, idx int) (*appbsky.UnspeccedGetPostThreadOtherV2_ThreadItem, error) {
+			var postView *appbsky.FeedDefs_PostView
+			fromParentChain := false
+			postView, ok := parentsMap[raw]
+			if !ok {
+				post, _, err := appbskyfeeddefs.PostView(ctx, raw, sl, cs, imgcdn, viewer, 3)
+				if err != nil {
+					return nil, err
+				}
+				if post == nil {
+					return nil, fmt.Errorf("post not found")
+				}
+				postView = post
+			} else {
+				fromParentChain = true
+			}
+
+			depth := int64(1)
+			if raw == threadAnchorURI.String() {
+				depth = 0
+			}
+			if fromParentChain {
+				depth = int64(0 - maplen + idx + 1)
+			}
+
+			return &appbsky.UnspeccedGetPostThreadOtherV2_ThreadItem{
+				// Depth int64                                           `json:"depth" cborgen:"depth"`
+				Depth: depth, // todo: placeholder
+				// Uri   string                                          `json:"uri" cborgen:"uri"`
+				Uri: raw,
+				// Value *UnspeccedGetPostThreadOtherV2_ThreadItem_Value `json:"value" cborgen:"value"`
+				Value: &appbsky.UnspeccedGetPostThreadOtherV2_ThreadItem_Value{
+					// UnspeccedDefs_ThreadItemPost *UnspeccedDefs_ThreadItemPost
+					UnspeccedDefs_ThreadItemPost: &appbsky.UnspeccedDefs_ThreadItemPost{
+						// LexiconTypeID string `json:"$type" cborgen:"$type,const=app.bsky.unspecced.defs#threadItemPost"`
+						LexiconTypeID: "app.bsky.unspecced.defs#threadItemPost",
+						// // hiddenByThreadgate: The threadgate created by the author indicates this post as a reply to be hidden for everyone consuming the thread.
+						// HiddenByThreadgate bool `json:"hiddenByThreadgate" cborgen:"hiddenByThreadgate"`
+						HiddenByThreadgate: false, // todo: placeholder
+						// // moreParents: This post has more parents that were not present in the response. This is just a boolean, without the number of parents.
+						// MoreParents bool `json:"moreParents" cborgen:"moreParents"`
+						MoreParents: false, // todo: placeholder
+						// // moreReplies: This post has more replies that were not present in the response. This is a numeric value, which is best-effort and might not be accurate.
+						// MoreReplies int64 `json:"moreReplies" cborgen:"moreReplies"`
+						MoreReplies: 0, // todo: placeholder
+						// // mutedByViewer: This is by an account muted by the viewer requesting it.
+						// MutedByViewer bool `json:"mutedByViewer" cborgen:"mutedByViewer"`
+						MutedByViewer: false, // todo: placeholder
+						// // opThread: This post is part of a contiguous thread by the OP from the thread root. Many different OP threads can happen in the same thread.
+						// OpThread bool               `json:"opThread" cborgen:"opThread"`
+						OpThread: false, // todo: placeholder
+						// Post     *FeedDefs_PostView `json:"post" cborgen:"post"`
+						Post: postView,
+					},
+				},
+			}, nil
+		},
+	)
+
+	// build final slice
+	out := make([]*appbsky.UnspeccedGetPostThreadOtherV2_ThreadItem, 0, len(concurrentResults))
+	for _, r := range concurrentResults {
+		if r.Err == nil && r.Value != nil && r.Value.Value != nil && r.Value.Value.UnspeccedDefs_ThreadItemPost != nil && r.Value.Value.UnspeccedDefs_ThreadItemPost.Post != nil {
+			out = append(out, r.Value)
+		}
+	}
+
+	// c.JSON(http.StatusOK, &appbsky.UnspeccedGetPostThreadOtherV2_Output{
+	// 	// Thread []*UnspeccedGetPostThreadOtherV2_ThreadItem `json:"thread" cborgen:"thread"`
+	// 	Thread: out,
+	// 	HasOtherReplies: false,
+	// })
+	resp := &GetPostThreadOtherV2_Output_WithOtherReplies{
+		UnspeccedGetPostThreadOtherV2_Output: appbsky.UnspeccedGetPostThreadOtherV2_Output{
+			Thread: out,
+		},
+		HasOtherReplies: false,
+	}
+	c.JSON(http.StatusOK, resp)
+}
+
+type GetPostThreadOtherV2_Output_WithOtherReplies struct {
+	appbsky.UnspeccedGetPostThreadOtherV2_Output
+	HasOtherReplies bool `json:"hasOtherReplies"`
+}
+
+type AsyncResult[T any] struct {
+	Value T
+	Err   error
+}
+
+func MapConcurrent[T any, R any](
+	ctx context.Context,
+	items []T,
+	concurrencyLimit int,
+	mapper func(context.Context, T, int) (R, error),
+) []AsyncResult[R] {
+	if len(items) == 0 {
+		return nil
+	}
+
+	results := make([]AsyncResult[R], len(items))
+	var wg sync.WaitGroup
+
+	sem := make(chan struct{}, concurrencyLimit)
+
+	for i, item := range items {
+		wg.Add(1)
+		go func(idx int, input T) {
+			defer wg.Done()
+
+			sem <- struct{}{}
+			defer func() { <-sem }()
+
+			if ctx.Err() != nil {
+				results[idx] = AsyncResult[R]{Err: ctx.Err()}
+				return
+			}
+
+			val, err := mapper(ctx, input, idx)
+			results[idx] = AsyncResult[R]{Value: val, Err: err}
+		}(i, item)
+	}
+
+	wg.Wait()
+	return results
+}
+
+type SkeletonPost struct {
+	post  syntax.ATURI
+	depth int
+}
+
+func HandleGetPostThreadV2V3(c *gin.Context, sl *microcosm.MicrocosmClient, cs *microcosm.MicrocosmClient, imgcdn string) {
+	ctx := c.Request.Context()
+
+	rawdid := c.GetString("user_did")
+	var viewer *utils.DID
+	didval, errdid := utils.NewDID(rawdid)
+	if errdid != nil {
+		viewer = nil
+	} else {
+		viewer = &didval
+	}
+
+	threadAnchorURIraw := c.Query("anchor")
+	if threadAnchorURIraw == "" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "Missing feed param"})
+		return
+	}
+
+	// "Whether to include parents above the anchor.
+	// bool as string
+	// true as default
+	aboveParam := c.Query("above") // why would you need above = false ?
+	above := true
+	if aboveParam == "false" {
+		above = false
+	}
+
+	// "How many levels of replies to include below the anchor."
+	// integer as string
+	// default: 6, min: 0, max: 20
+	belowParam := c.Query("below") // bskydefault: 10
+	below, err_below := strconv.ParseInt(belowParam, 10, 64)
+	if err_below != nil {
+		below = 6
+	} else {
+		if below > 20 {
+			below = 20
+		}
+		if below < 0 {
+			below = 0
+		}
+	}
+
+	// "Maximum of replies to include at each level of the thread, except for the direct replies to the anchor,
+	// which are (NOTE: currently, during unspecced phase) all returned (NOTE: later they might be paginated)."
+	// integer as string
+	// default: 10, min: 0, max: 100
+	branchingFactorParam := c.Query("branchingFactor") // bskydefault: 1
+	branchingFactor, err_branchingFactor := strconv.ParseInt(branchingFactorParam, 10, 64)
+	if err_branchingFactor != nil {
+		branchingFactor = 10
+	} else {
+		if branchingFactor > 100 {
+			branchingFactor = 100
+		}
+		if branchingFactor < 0 {
+			branchingFactor = 0
+		}
+	}
+
+	// "Sorting for the thread replies"
+	// string (enum) ["newest", "oldest", "top"]
+	// default: "oldest"
+	sortParam := c.Query("sort") // bskydefault: top
+	sort := sortParam
+	if sort != "newest" && sort != "oldest" && sort != "top" {
+		sort = "top"
+	}
+
+	threadAnchorURI, err := syntax.ParseATURI(threadAnchorURIraw)
+	if err != nil {
+		return
+	}
+
+	threadGraph, err := ThreadGrapher(ctx, cs, sl, threadAnchorURI)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": ("failed to graph the thread: " + err.Error())})
+		return
+	}
+	var skeletonposts []SkeletonPost
+
+	// Parent Chain
+	parentChainHeight := 0
+
+	// root := threadGraph.RootURI
+	if above {
+		current := threadAnchorURI
+
+		for true {
+			log.Println("[parent threader] current: " + current.Authority().String() + string(current.Collection()) + string(current.RecordKey()))
+			if parentChainHeight > 20 {
+				// root = current
+				break
+			}
+			parent, ok := threadGraph.ParentsMap[current]
+			if !ok {
+				// root = current
+				break
+			}
+			parentChainHeight = parentChainHeight + 1
+			skeletonposts = append(skeletonposts, SkeletonPost{
+				post:  parent,
+				depth: -parentChainHeight,
+			})
+			current = parent
+		}
+		flipArray(&skeletonposts)
+	}
+
+	// handled by the recurser
+	// // Anchor Post
+	// skeletonposts = append(skeletonposts, SkeletonPost{
+	// 	post:  threadAnchorURI,
+	// 	depth: 0,
+	// })
+
+	// Tree Replies (with OP thread priority)
+	// should probably be recursive
+	recursiveHandleV2V3TreeReplies(threadGraph, &skeletonposts, threadAnchorURI, &below, &branchingFactor, &sort, 0, 0)
+
+	//maplen := len(parentsMap)
+	concurrentResults := MapConcurrent(
+		ctx,
+		skeletonposts,
+		20,
+		func(ctx context.Context, raw SkeletonPost, idx int) (*appbsky.UnspeccedGetPostThreadOtherV2_ThreadItem, error) {
+			var postView *appbsky.FeedDefs_PostView
+			//fromParentChain := false
+			//postView, ok := parentsMap[raw]
+			//if !ok {
+			post, _, err := appbskyfeeddefs.PostView(ctx, raw.post.String(), sl, cs, imgcdn, viewer, 3)
+			if err != nil {
+				return nil, err
+			}
+			if post == nil {
+				return nil, fmt.Errorf("post not found")
+			}
+			postView = post
+			//} else {
+			//	fromParentChain = true
+			//}
+
+			depth := int64(1)
+			// if raw == threadAnchorURI.String() {
+			// 	depth = 0
+			// }
+			// if fromParentChain {
+			// 	depth = int64(0 - parentChainHeight + idx + 1)
+			// }
+			depth = int64(raw.depth)
+
+			return &appbsky.UnspeccedGetPostThreadOtherV2_ThreadItem{
+				// Depth int64                                           `json:"depth" cborgen:"depth"`
+				Depth: depth, // todo: placeholder
+				// Uri   string                                          `json:"uri" cborgen:"uri"`
+				Uri: raw.post.String(),
+				// Value *UnspeccedGetPostThreadOtherV2_ThreadItem_Value `json:"value" cborgen:"value"`
+				Value: &appbsky.UnspeccedGetPostThreadOtherV2_ThreadItem_Value{
+					// UnspeccedDefs_ThreadItemPost *UnspeccedDefs_ThreadItemPost
+					UnspeccedDefs_ThreadItemPost: &appbsky.UnspeccedDefs_ThreadItemPost{
+						// LexiconTypeID string `json:"$type" cborgen:"$type,const=app.bsky.unspecced.defs#threadItemPost"`
+						LexiconTypeID: "app.bsky.unspecced.defs#threadItemPost",
+						// // hiddenByThreadgate: The threadgate created by the author indicates this post as a reply to be hidden for everyone consuming the thread.
+						// HiddenByThreadgate bool `json:"hiddenByThreadgate" cborgen:"hiddenByThreadgate"`
+						HiddenByThreadgate: false, // todo: placeholder
+						// // moreParents: This post has more parents that were not present in the response. This is just a boolean, without the number of parents.
+						// MoreParents bool `json:"moreParents" cborgen:"moreParents"`
+						MoreParents: false, // todo: placeholder
+						// // moreReplies: This post has more replies that were not present in the response. This is a numeric value, which is best-effort and might not be accurate.
+						// MoreReplies int64 `json:"moreReplies" cborgen:"moreReplies"`
+						MoreReplies: 0, // todo: placeholder
+						// // mutedByViewer: This is by an account muted by the viewer requesting it.
+						// MutedByViewer bool `json:"mutedByViewer" cborgen:"mutedByViewer"`
+						MutedByViewer: false, // todo: placeholder
+						// // opThread: This post is part of a contiguous thread by the OP from the thread root. Many different OP threads can happen in the same thread.
+						// OpThread bool               `json:"opThread" cborgen:"opThread"`
+						OpThread: false, // todo: placeholder
+						// Post     *FeedDefs_PostView `json:"post" cborgen:"post"`
+						Post: postView,
+					},
+				},
+			}, nil
+		},
+	)
+
+	// build final slice
+	out := make([]*appbsky.UnspeccedGetPostThreadOtherV2_ThreadItem, 0, len(concurrentResults))
+	for _, r := range concurrentResults {
+		if r.Err == nil && r.Value != nil && r.Value.Value != nil && r.Value.Value.UnspeccedDefs_ThreadItemPost != nil && r.Value.Value.UnspeccedDefs_ThreadItemPost.Post != nil {
+			out = append(out, r.Value)
+		}
+	}
+
+	// c.JSON(http.StatusOK, &appbsky.UnspeccedGetPostThreadOtherV2_Output{
+	// 	// Thread []*UnspeccedGetPostThreadOtherV2_ThreadItem `json:"thread" cborgen:"thread"`
+	// 	Thread: out,
+	// 	HasOtherReplies: false,
+	// })
+	resp := &GetPostThreadOtherV2_Output_WithOtherReplies{
+		UnspeccedGetPostThreadOtherV2_Output: appbsky.UnspeccedGetPostThreadOtherV2_Output{
+			Thread: out,
+		},
+		HasOtherReplies: false,
+	}
+	c.JSON(http.StatusOK, resp)
+}
+
+func flipArray[T any](s *[]T) {
+	for i, j := 0, len(*s)-1; i < j; i, j = i+1, j-1 {
+		(*s)[i], (*s)[j] = (*s)[j], (*s)[i]
+	}
+}
+
+func recursiveHandleV2V3TreeReplies(threadGraph *ThreadGraph, skeletonposts *[]SkeletonPost, current syntax.ATURI, below *int64, branchingFactor *int64, sort *string, verticalPos int64, horizontalPos int64) {
+	log.Println("[V3 Recurse] at y: " + fmt.Sprint(verticalPos) + ", x: " + fmt.Sprint(horizontalPos))
+	// breakings
+	if below != nil && verticalPos > *below {
+		log.Println("[V3 Recurse] exit by too low")
+		return
+	}
+	if branchingFactor != nil && horizontalPos > *branchingFactor && verticalPos > 1 {
+		log.Println("[V3 Recurse] exit by too wide; branchingFactor: " + fmt.Sprint(*branchingFactor) + "; horizontalPos: " + fmt.Sprint(horizontalPos) + "; verticalPos: " + fmt.Sprint(verticalPos))
+		return
+	}
+
+	// the things to do if not recurse
+	if skeletonposts != nil {
+		*skeletonposts = append(*skeletonposts, SkeletonPost{
+			post:  current,
+			depth: int(verticalPos),
+		})
+	} else {
+		log.Println("[V3 Recurse] exit by no skeleton posts")
+		return
+	}
+
+	repliesAtThisPosition, ok := threadGraph.ChildrenMap[current]
+	if !ok {
+		log.Println("[V3 Recurse] exit by no replies")
+		return
+	}
+
+	// recurse
+	op := threadGraph.RootURI.Authority()
+
+	// We need a modifyable copy of the slice because we are about to reorder it
+	// and we don't want to mess up the original map in case it's used elsewhere.
+	sortedReplies := make([]syntax.ATURI, len(repliesAtThisPosition))
+	copy(sortedReplies, repliesAtThisPosition)
+
+	// 1. Find the "best" OP reply (lexicographically smallest rkey usually means oldest)
+	bestOpIndex := -1
+	var bestOpURI syntax.ATURI
+
+	for i, replyURI := range sortedReplies {
+		if replyURI.Authority() == op {
+			// If this is the first OP reply we found, or if it's lexicographically smaller (older) than the previous best
+			if bestOpIndex == -1 || replyURI.String() < bestOpURI.String() {
+				bestOpIndex = i
+				bestOpURI = replyURI
+			}
+		}
+	}
+
+	// 2. If we found an OP reply, move it to index 0
+	if bestOpIndex > 0 { // If it's already 0, no need to move
+		// Remove the best OP reply from its current spot
+		// (Go slice trick: append everything before it + everything after it)
+		withoutBest := append(sortedReplies[:bestOpIndex], sortedReplies[bestOpIndex+1:]...)
+
+		// Prepend it to the front
+		sortedReplies = append([]syntax.ATURI{bestOpURI}, withoutBest...)
+	}
+
+	for idx, reply := range sortedReplies {
+		recursiveHandleV2V3TreeReplies(threadGraph, skeletonposts, reply, below, branchingFactor, sort, verticalPos+1, int64(idx+1))
+	}
+
+	// going up
+}

shims/lex/app/bsky/unspecced/getpostthreadv2/threadgrapher.go

···
+package appbskyunspeccedgetpostthreadv2
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+	"sync"
+
+	"github.com/bluesky-social/indigo/api/agnostic"
+	//comatproto "github.com/bluesky-social/indigo/api/atproto"
+	appbsky "github.com/bluesky-social/indigo/api/bsky"
+	"github.com/bluesky-social/indigo/atproto/syntax"
+
+	"tangled.org/whey.party/red-dwarf-server/microcosm"
+	"tangled.org/whey.party/red-dwarf-server/microcosm/constellation"
+)
+
+type ThreadGraph struct {
+	mu sync.RWMutex // Mutex required for thread-safe updates (Firehose)
+
+	RootURI   syntax.ATURI
+	AnchorURI syntax.ATURI
+
+	ParentsMap map[syntax.ATURI]syntax.ATURI
+
+	ChildrenMap map[syntax.ATURI][]syntax.ATURI
+}
+
+func NewThreadGraph() *ThreadGraph {
+	return &ThreadGraph{
+		ParentsMap:  make(map[syntax.ATURI]syntax.ATURI),
+		ChildrenMap: make(map[syntax.ATURI][]syntax.ATURI),
+	}
+}
+
+func ThreadGrapher(ctx context.Context, cs *microcosm.MicrocosmClient, sl *microcosm.MicrocosmClient, threadAnchorURI syntax.ATURI) (*ThreadGraph, error) {
+	tg := NewThreadGraph()
+	tg.AnchorURI = threadAnchorURI
+
+	anchorPostRecordResponse, err := agnostic.RepoGetRecord(ctx, sl, "", "app.bsky.feed.post", threadAnchorURI.Authority().String(), string(threadAnchorURI.RecordKey()))
+	if err != nil {
+		log.Println("[ThreadGrapher] exit by anchor post resolve failure")
+		return nil, fmt.Errorf("failed to fetch anchor: %w", err)
+	}
+
+	var anchorPost appbsky.FeedPost
+	if err := json.Unmarshal(*anchorPostRecordResponse.Value, &anchorPost); err != nil {
+		log.Println("[ThreadGrapher] exit by no json")
+		return nil, fmt.Errorf("error: Failed to parse post record JSON")
+	}
+
+	var rootURI syntax.ATURI
+
+	if anchorPost.Reply != nil && anchorPost.Reply.Root != nil {
+		rURI, err := syntax.ParseATURI(anchorPost.Reply.Root.Uri)
+		if err != nil {
+			log.Println("[ThreadGrapher] exit by invalid root uri")
+			return nil, fmt.Errorf("invalid root uri in record: %w", err)
+		}
+		rootURI = rURI
+
+		// todo: fiine we wont fetch the root post, but we still need to mark it as deleted somehow
+		// rootPostRecordResponse, err := agnostic.RepoGetRecord(ctx, sl, "", "app.bsky.feed.post", rootURI.Authority().String(), string(rootURI.RecordKey()))
+		// if err != nil {
+		// 	log.Println("[ThreadGrapher] exit by cant fetch root")
+		// 	return nil, fmt.Errorf("failed to fetch root: %w", err)
+		// }
+
+		// var rootPost appbsky.FeedPost
+		// if err := json.Unmarshal(*rootPostRecordResponse.Value, &rootPost); err != nil {
+		// 	log.Println("[ThreadGrapher] exit by cant parse root json")
+		// 	return nil, fmt.Errorf("error: Failed to parse post record JSON")
+		// }
+		// if err == nil {
+		// 	tg.AddNode(rootURI, &rootPost)
+		// }
+	} else {
+		rootURI = threadAnchorURI
+	}
+	tg.RootURI = rootURI
+
+	emptystrarray := &[]string{}
+	var allRepliesATURI []syntax.ATURI
+	limit := 100
+	var cursor *string
+	shouldContinue := true
+	for shouldContinue {
+		results, err := constellation.GetBacklinks(ctx, cs, rootURI.String(), "app.bsky.feed.post:reply.root.uri", *emptystrarray, &limit, cursor)
+		if err != nil {
+			log.Println("[ThreadGrapher] [root graphing] exit by backlink failure")
+			return nil, fmt.Errorf("failed to get backlinks: %w", err)
+		}
+		if results.Records != nil {
+			for _, record := range results.Records {
+				aturi, err := syntax.ParseATURI("at://" + record.Did + "/" + record.Collection + "/" + record.Rkey)
+				if err == nil {
+					allRepliesATURI = append(allRepliesATURI, aturi)
+				}
+			}
+		}
+		if results.Cursor != nil {
+			cursor = results.Cursor
+		} else {
+			shouldContinue = false
+		}
+	}
+
+	processingQueue := append([]syntax.ATURI{rootURI}, allRepliesATURI...)
+	for _, aturi := range processingQueue {
+		//tg.Nodes = append(tg.Nodes, aturi)
+		// graphinger
+		emptystrarray := &[]string{}
+		var localRepliesATURI []syntax.ATURI
+		limit := 100
+		var cursor *string
+		shouldContinue := true
+		for shouldContinue {
+			results, err := constellation.GetBacklinks(ctx, cs, aturi.String(), "app.bsky.feed.post:reply.parent.uri", *emptystrarray, &limit, cursor)
+			if err != nil {
+				log.Println("[ThreadGrapher] [parent graphing] exit by no replies")
+				return nil, fmt.Errorf("failed to get backlinks: %w", err)
+			}
+			if results.Records != nil {
+				for _, record := range results.Records {
+					aturi, err := syntax.ParseATURI("at://" + record.Did + "/" + record.Collection + "/" + record.Rkey)
+					if err == nil {
+						localRepliesATURI = append(localRepliesATURI, aturi)
+					}
+				}
+			}
+			if results.Cursor != nil {
+				cursor = results.Cursor
+			} else {
+				shouldContinue = false
+			}
+		}
+		for _, reply := range localRepliesATURI {
+			tg.ParentsMap[reply] = aturi
+			tg.ChildrenMap[aturi] = append(tg.ChildrenMap[aturi], reply)
+		}
+	}
+
+	return tg, nil
+}