`6b1f39a`

Add social follow graph

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 2 days ago

SHA: 6b1f39a769984171266bbaa6f49be01699d171f9
Parents: d6510ce
Tree: a45086f

26 changed files

Status	File	+
M	`internal/actions/sqlc/models.go`	101
M	`internal/admin/sqlc/models.go`	101
M	`internal/auth/audit/audit.go`	2
M	`internal/auth/policy/sqlc/models.go`	101
M	`internal/checks/sqlc/models.go`	101
M	`internal/issues/sqlc/models.go`	101
M	`internal/meta/sqlc/models.go`	101
A	`internal/migrationsfs/migrations/0055_social_feed_trending.sql`	78
M	`internal/notif/sqlc/models.go`	101
M	`internal/orgs/sqlc/models.go`	101
M	`internal/pulls/sqlc/models.go`	101
M	`internal/ratelimit/sqlc/models.go`	101
M	`internal/repos/sqlc/models.go`	101
A	`internal/social/feed.go`	399
A	`internal/social/follows.go`	213
A	`internal/social/queries/feed.sql`	199
A	`internal/social/queries/follows.sql`	109
M	`internal/social/social.go`	2
M	`internal/social/social_test.go`	115
A	`internal/social/sqlc/feed.sql.go`	527
A	`internal/social/sqlc/follows.sql.go`	382
M	`internal/social/sqlc/models.go`	101
M	`internal/social/sqlc/querier.go`	24
M	`internal/users/sqlc/models.go`	101
M	`internal/webhook/sqlc/models.go`	101
M	`internal/worker/sqlc/models.go`	101

internal/actions/sqlc/models.gomodified

  	return string(ns.TransferStatus), nil
+ }
 +type TrendingKind string
++
 +const (
 +	TrendingKindRepos TrendingKind = "repos"
 +	TrendingKindUsers TrendingKind = "users"
 +)
++
 +func (e *TrendingKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = TrendingKind(s)
 +	case string:
 +		*e = TrendingKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for TrendingKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullTrendingKind struct {
 +	TrendingKind TrendingKind
 +	Valid        bool // Valid is true if TrendingKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullTrendingKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.TrendingKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.TrendingKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullTrendingKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.TrendingKind), nil
 +}
++
 +type TrendingScope string
++
 +const (
 +	TrendingScopeDay   TrendingScope = "day"
 +	TrendingScopeWeek  TrendingScope = "week"
 +	TrendingScopeMonth TrendingScope = "month"
 +)
++
 +func (e *TrendingScope) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = TrendingScope(s)
 +	case string:
 +		*e = TrendingScope(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for TrendingScope: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullTrendingScope struct {
 +	TrendingScope TrendingScope
 +	Valid         bool // Valid is true if TrendingScope is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullTrendingScope) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.TrendingScope, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.TrendingScope.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullTrendingScope) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.TrendingScope), nil
 +}
++
  type WatchLevel string
  const (
  	CreatedAt   pgtype.Timestamptz
+ }
 +type Follow struct {
 +	ID             int64
 +	FollowerUserID int64
 +	FolloweeUserID pgtype.Int8
 +	FolloweeOrgID  pgtype.Int8
 +	FollowedAt     pgtype.Timestamptz
 +}
++
  type Issue struct {
  	ID                int64
  	RepoID            int64
  	DeliveredAt     pgtype.Timestamptz
+ }
 +type TrendingSnapshot struct {
 +	ID         int64
 +	Scope      TrendingScope
 +	Kind       TrendingKind
 +	CapturedAt pgtype.Timestamptz
 +	Payload    []byte
 +}
++
  type User struct {
  	ID                int64
  	Username          string

internal/admin/sqlc/models.gomodified

  	return string(ns.TransferStatus), nil
+ }
 +type TrendingKind string
++
 +const (
 +	TrendingKindRepos TrendingKind = "repos"
 +	TrendingKindUsers TrendingKind = "users"
 +)
++
 +func (e *TrendingKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = TrendingKind(s)
 +	case string:
 +		*e = TrendingKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for TrendingKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullTrendingKind struct {
 +	TrendingKind TrendingKind
 +	Valid        bool // Valid is true if TrendingKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullTrendingKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.TrendingKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.TrendingKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullTrendingKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.TrendingKind), nil
 +}
++
 +type TrendingScope string
++
 +const (
 +	TrendingScopeDay   TrendingScope = "day"
 +	TrendingScopeWeek  TrendingScope = "week"
 +	TrendingScopeMonth TrendingScope = "month"
 +)
++
 +func (e *TrendingScope) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = TrendingScope(s)
 +	case string:
 +		*e = TrendingScope(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for TrendingScope: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullTrendingScope struct {
 +	TrendingScope TrendingScope
 +	Valid         bool // Valid is true if TrendingScope is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullTrendingScope) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.TrendingScope, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.TrendingScope.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullTrendingScope) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.TrendingScope), nil
 +}
++
  type WatchLevel string
  const (
  	CreatedAt   pgtype.Timestamptz
+ }
 +type Follow struct {
 +	ID             int64
 +	FollowerUserID int64
 +	FolloweeUserID pgtype.Int8
 +	FolloweeOrgID  pgtype.Int8
 +	FollowedAt     pgtype.Timestamptz
 +}
++
  type Issue struct {
  	ID                int64
  	RepoID            int64
  	DeliveredAt     pgtype.Timestamptz
+ }
 +type TrendingSnapshot struct {
 +	ID         int64
 +	Scope      TrendingScope
 +	Kind       TrendingKind
 +	CapturedAt pgtype.Timestamptz
 +	Payload    []byte
 +}
++
  type User struct {
  	ID                int64
  	Username          string

internal/auth/audit/audit.gomodified

  	ActionStarDeleted           Action = "star_deleted"
  	ActionWatchSet              Action = "watch_set"
  	ActionWatchUnset            Action = "watch_unset"
 +	ActionFollowCreated         Action = "follow_created"
 +	ActionFollowDeleted         Action = "follow_deleted"
  	ActionRepoForked            Action = "repo_forked"
  	ActionRepoForkSynced        Action = "repo_fork_synced"

internal/auth/policy/sqlc/models.gomodified

  	return string(ns.TransferStatus), nil
+ }
 +type TrendingKind string
++
 +const (
 +	TrendingKindRepos TrendingKind = "repos"
 +	TrendingKindUsers TrendingKind = "users"
 +)
++
 +func (e *TrendingKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = TrendingKind(s)
 +	case string:
 +		*e = TrendingKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for TrendingKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullTrendingKind struct {
 +	TrendingKind TrendingKind
 +	Valid        bool // Valid is true if TrendingKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullTrendingKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.TrendingKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.TrendingKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullTrendingKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.TrendingKind), nil
 +}
++
 +type TrendingScope string
++
 +const (
 +	TrendingScopeDay   TrendingScope = "day"
 +	TrendingScopeWeek  TrendingScope = "week"
 +	TrendingScopeMonth TrendingScope = "month"
 +)
++
 +func (e *TrendingScope) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = TrendingScope(s)
 +	case string:
 +		*e = TrendingScope(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for TrendingScope: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullTrendingScope struct {
 +	TrendingScope TrendingScope
 +	Valid         bool // Valid is true if TrendingScope is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullTrendingScope) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.TrendingScope, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.TrendingScope.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullTrendingScope) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.TrendingScope), nil
 +}
++
  type WatchLevel string
  const (
  	CreatedAt   pgtype.Timestamptz
+ }
 +type Follow struct {
 +	ID             int64
 +	FollowerUserID int64
 +	FolloweeUserID pgtype.Int8
 +	FolloweeOrgID  pgtype.Int8
 +	FollowedAt     pgtype.Timestamptz
 +}
++
  type Issue struct {
  	ID                int64
  	RepoID            int64
  	DeliveredAt     pgtype.Timestamptz
+ }
 +type TrendingSnapshot struct {
 +	ID         int64
 +	Scope      TrendingScope
 +	Kind       TrendingKind
 +	CapturedAt pgtype.Timestamptz
 +	Payload    []byte
 +}
++
  type User struct {
  	ID                int64
  	Username          string

internal/checks/sqlc/models.gomodified

  	return string(ns.TransferStatus), nil
+ }
 +type TrendingKind string
++
 +const (
 +	TrendingKindRepos TrendingKind = "repos"
 +	TrendingKindUsers TrendingKind = "users"
 +)
++
 +func (e *TrendingKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = TrendingKind(s)
 +	case string:
 +		*e = TrendingKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for TrendingKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullTrendingKind struct {
 +	TrendingKind TrendingKind
 +	Valid        bool // Valid is true if TrendingKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullTrendingKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.TrendingKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.TrendingKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullTrendingKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.TrendingKind), nil
 +}
++
 +type TrendingScope string
++
 +const (
 +	TrendingScopeDay   TrendingScope = "day"
 +	TrendingScopeWeek  TrendingScope = "week"
 +	TrendingScopeMonth TrendingScope = "month"
 +)
++
 +func (e *TrendingScope) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = TrendingScope(s)
 +	case string:
 +		*e = TrendingScope(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for TrendingScope: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullTrendingScope struct {
 +	TrendingScope TrendingScope
 +	Valid         bool // Valid is true if TrendingScope is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullTrendingScope) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.TrendingScope, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.TrendingScope.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullTrendingScope) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.TrendingScope), nil
 +}
++
  type WatchLevel string
  const (
  	CreatedAt   pgtype.Timestamptz
+ }
 +type Follow struct {
 +	ID             int64
 +	FollowerUserID int64
 +	FolloweeUserID pgtype.Int8
 +	FolloweeOrgID  pgtype.Int8
 +	FollowedAt     pgtype.Timestamptz
 +}
++
  type Issue struct {
  	ID                int64
  	RepoID            int64
  	DeliveredAt     pgtype.Timestamptz
+ }
 +type TrendingSnapshot struct {
 +	ID         int64
 +	Scope      TrendingScope
 +	Kind       TrendingKind
 +	CapturedAt pgtype.Timestamptz
 +	Payload    []byte
 +}
++
  type User struct {
  	ID                int64
  	Username          string

internal/issues/sqlc/models.gomodified

  	return string(ns.TransferStatus), nil
+ }
 +type TrendingKind string
++
 +const (
 +	TrendingKindRepos TrendingKind = "repos"
 +	TrendingKindUsers TrendingKind = "users"
 +)
++
 +func (e *TrendingKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = TrendingKind(s)
 +	case string:
 +		*e = TrendingKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for TrendingKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullTrendingKind struct {
 +	TrendingKind TrendingKind
 +	Valid        bool // Valid is true if TrendingKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullTrendingKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.TrendingKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.TrendingKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullTrendingKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.TrendingKind), nil
 +}
++
 +type TrendingScope string
++
 +const (
 +	TrendingScopeDay   TrendingScope = "day"
 +	TrendingScopeWeek  TrendingScope = "week"
 +	TrendingScopeMonth TrendingScope = "month"
 +)
++
 +func (e *TrendingScope) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = TrendingScope(s)
 +	case string:
 +		*e = TrendingScope(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for TrendingScope: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullTrendingScope struct {
 +	TrendingScope TrendingScope
 +	Valid         bool // Valid is true if TrendingScope is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullTrendingScope) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.TrendingScope, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.TrendingScope.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullTrendingScope) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.TrendingScope), nil
 +}
++
  type WatchLevel string
  const (
  	CreatedAt   pgtype.Timestamptz
+ }
 +type Follow struct {
 +	ID             int64
 +	FollowerUserID int64
 +	FolloweeUserID pgtype.Int8
 +	FolloweeOrgID  pgtype.Int8
 +	FollowedAt     pgtype.Timestamptz
 +}
++
  type Issue struct {
  	ID                int64
  	RepoID            int64
  	DeliveredAt     pgtype.Timestamptz
+ }
 +type TrendingSnapshot struct {
 +	ID         int64
 +	Scope      TrendingScope
 +	Kind       TrendingKind
 +	CapturedAt pgtype.Timestamptz
 +	Payload    []byte
 +}
++
  type User struct {
  	ID                int64
  	Username          string

internal/meta/sqlc/models.gomodified

  	return string(ns.TransferStatus), nil
+ }
 +type TrendingKind string
++
 +const (
 +	TrendingKindRepos TrendingKind = "repos"
 +	TrendingKindUsers TrendingKind = "users"
 +)
++
 +func (e *TrendingKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = TrendingKind(s)
 +	case string:
 +		*e = TrendingKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for TrendingKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullTrendingKind struct {
 +	TrendingKind TrendingKind
 +	Valid        bool // Valid is true if TrendingKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullTrendingKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.TrendingKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.TrendingKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullTrendingKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.TrendingKind), nil
 +}
++
 +type TrendingScope string
++
 +const (
 +	TrendingScopeDay   TrendingScope = "day"
 +	TrendingScopeWeek  TrendingScope = "week"
 +	TrendingScopeMonth TrendingScope = "month"
 +)
++
 +func (e *TrendingScope) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = TrendingScope(s)
 +	case string:
 +		*e = TrendingScope(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for TrendingScope: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullTrendingScope struct {
 +	TrendingScope TrendingScope
 +	Valid         bool // Valid is true if TrendingScope is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullTrendingScope) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.TrendingScope, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.TrendingScope.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullTrendingScope) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.TrendingScope), nil
 +}
++
  type WatchLevel string
  const (
  	CreatedAt   pgtype.Timestamptz
+ }
 +type Follow struct {
 +	ID             int64
 +	FollowerUserID int64
 +	FolloweeUserID pgtype.Int8
 +	FolloweeOrgID  pgtype.Int8
 +	FollowedAt     pgtype.Timestamptz
 +}
++
  type Issue struct {
  	ID                int64
  	RepoID            int64
  	DeliveredAt     pgtype.Timestamptz
+ }
 +type TrendingSnapshot struct {
 +	ID         int64
 +	Scope      TrendingScope
 +	Kind       TrendingKind
 +	CapturedAt pgtype.Timestamptz
 +	Payload    []byte
 +}
++
  type User struct {
  	ID                int64
  	Username          string

internal/migrationsfs/migrations/0055_social_feed_trending.sqladded

 +-- SPDX-License-Identifier: AGPL-3.0-or-later
 +--
 +-- S42 — Social feed and trending.
 +--
 +-- Follows are user-initiated social edges. S42's core contract is
 +-- user->user follows; shithub also supports user->org follows so org
 +-- activity can participate in the same feed without a later table split.
 +--
 +-- Trending snapshots store denormalized rankings produced by the worker.
 +-- The web UI may fall back to live rankings when no snapshot exists yet.
++
 +-- +goose Up
++
 +CREATE TABLE follows (
 +    id               bigserial   PRIMARY KEY,
 +    follower_user_id bigint      NOT NULL REFERENCES users(id) ON DELETE CASCADE,
 +    followee_user_id bigint      REFERENCES users(id) ON DELETE CASCADE,
 +    followee_org_id  bigint      REFERENCES orgs(id) ON DELETE CASCADE,
 +    followed_at      timestamptz NOT NULL DEFAULT now(),
++
 +    CONSTRAINT follows_target_xor CHECK (
 +        (followee_user_id IS NOT NULL AND followee_org_id IS NULL)
 +     OR (followee_user_id IS NULL     AND followee_org_id IS NOT NULL)
 +    ),
 +    CONSTRAINT follows_no_self_user CHECK (
 +        followee_user_id IS NULL OR followee_user_id <> follower_user_id
 +    )
 +);
++
 +CREATE UNIQUE INDEX follows_user_target_unique
 +    ON follows (follower_user_id, followee_user_id)
 +    WHERE followee_user_id IS NOT NULL;
++
 +CREATE UNIQUE INDEX follows_org_target_unique
 +    ON follows (follower_user_id, followee_org_id)
 +    WHERE followee_org_id IS NOT NULL;
++
 +CREATE INDEX follows_following_idx
 +    ON follows (follower_user_id, followed_at DESC);
++
 +CREATE INDEX follows_user_followers_idx
 +    ON follows (followee_user_id, followed_at DESC)
 +    WHERE followee_user_id IS NOT NULL;
++
 +CREATE INDEX follows_org_followers_idx
 +    ON follows (followee_org_id, followed_at DESC)
 +    WHERE followee_org_id IS NOT NULL;
++
 +CREATE TYPE trending_scope AS ENUM ('day', 'week', 'month');
 +CREATE TYPE trending_kind AS ENUM ('repos', 'users');
++
 +CREATE TABLE trending_snapshots (
 +    id          bigserial       PRIMARY KEY,
 +    scope       trending_scope  NOT NULL,
 +    kind        trending_kind   NOT NULL,
 +    captured_at timestamptz     NOT NULL DEFAULT now(),
 +    payload     jsonb           NOT NULL DEFAULT '{}'::jsonb,
++
 +    CONSTRAINT trending_snapshots_payload_object_or_array CHECK (
 +        jsonb_typeof(payload) IN ('object', 'array')
 +    )
 +);
++
 +CREATE INDEX trending_snapshots_latest_idx
 +    ON trending_snapshots (scope, kind, captured_at DESC);
++
 +-- +goose Down
 +DROP INDEX IF EXISTS trending_snapshots_latest_idx;
 +DROP TABLE IF EXISTS trending_snapshots;
 +DROP TYPE IF EXISTS trending_kind;
 +DROP TYPE IF EXISTS trending_scope;
++
 +DROP INDEX IF EXISTS follows_org_followers_idx;
 +DROP INDEX IF EXISTS follows_user_followers_idx;
 +DROP INDEX IF EXISTS follows_following_idx;
 +DROP INDEX IF EXISTS follows_org_target_unique;
 +DROP INDEX IF EXISTS follows_user_target_unique;
 +DROP TABLE IF EXISTS follows;

internal/notif/sqlc/models.gomodified

  	return string(ns.TransferStatus), nil
+ }
 +type TrendingKind string
++
 +const (
 +	TrendingKindRepos TrendingKind = "repos"
 +	TrendingKindUsers TrendingKind = "users"
 +)
++
 +func (e *TrendingKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = TrendingKind(s)
 +	case string:
 +		*e = TrendingKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for TrendingKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullTrendingKind struct {
 +	TrendingKind TrendingKind
 +	Valid        bool // Valid is true if TrendingKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullTrendingKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.TrendingKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.TrendingKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullTrendingKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.TrendingKind), nil
 +}
++
 +type TrendingScope string
++
 +const (
 +	TrendingScopeDay   TrendingScope = "day"
 +	TrendingScopeWeek  TrendingScope = "week"
 +	TrendingScopeMonth TrendingScope = "month"
 +)
++
 +func (e *TrendingScope) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = TrendingScope(s)
 +	case string:
 +		*e = TrendingScope(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for TrendingScope: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullTrendingScope struct {
 +	TrendingScope TrendingScope
 +	Valid         bool // Valid is true if TrendingScope is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullTrendingScope) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.TrendingScope, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.TrendingScope.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullTrendingScope) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.TrendingScope), nil
 +}
++
  type WatchLevel string
  const (
  	CreatedAt   pgtype.Timestamptz
+ }
 +type Follow struct {
 +	ID             int64
 +	FollowerUserID int64
 +	FolloweeUserID pgtype.Int8
 +	FolloweeOrgID  pgtype.Int8
 +	FollowedAt     pgtype.Timestamptz
 +}
++
  type Issue struct {
  	ID                int64
  	RepoID            int64
  	DeliveredAt     pgtype.Timestamptz
+ }
 +type TrendingSnapshot struct {
 +	ID         int64
 +	Scope      TrendingScope
 +	Kind       TrendingKind
 +	CapturedAt pgtype.Timestamptz
 +	Payload    []byte
 +}
++
  type User struct {
  	ID                int64
  	Username          string

internal/orgs/sqlc/models.gomodified

  	return string(ns.TransferStatus), nil
+ }
 +type TrendingKind string
++
 +const (
 +	TrendingKindRepos TrendingKind = "repos"
 +	TrendingKindUsers TrendingKind = "users"
 +)
++
 +func (e *TrendingKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = TrendingKind(s)
 +	case string:
 +		*e = TrendingKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for TrendingKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullTrendingKind struct {
 +	TrendingKind TrendingKind
 +	Valid        bool // Valid is true if TrendingKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullTrendingKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.TrendingKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.TrendingKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullTrendingKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.TrendingKind), nil
 +}
++
 +type TrendingScope string
++
 +const (
 +	TrendingScopeDay   TrendingScope = "day"
 +	TrendingScopeWeek  TrendingScope = "week"
 +	TrendingScopeMonth TrendingScope = "month"
 +)
++
 +func (e *TrendingScope) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = TrendingScope(s)
 +	case string:
 +		*e = TrendingScope(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for TrendingScope: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullTrendingScope struct {
 +	TrendingScope TrendingScope
 +	Valid         bool // Valid is true if TrendingScope is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullTrendingScope) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.TrendingScope, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.TrendingScope.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullTrendingScope) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.TrendingScope), nil
 +}
++
  type WatchLevel string
  const (
  	CreatedAt   pgtype.Timestamptz
+ }
 +type Follow struct {
 +	ID             int64
 +	FollowerUserID int64
 +	FolloweeUserID pgtype.Int8
 +	FolloweeOrgID  pgtype.Int8
 +	FollowedAt     pgtype.Timestamptz
 +}
++
  type Issue struct {
  	ID                int64
  	RepoID            int64
  	DeliveredAt     pgtype.Timestamptz
+ }
 +type TrendingSnapshot struct {
 +	ID         int64
 +	Scope      TrendingScope
 +	Kind       TrendingKind
 +	CapturedAt pgtype.Timestamptz
 +	Payload    []byte
 +}
++
  type User struct {
  	ID                int64
  	Username          string

internal/pulls/sqlc/models.gomodified

  	return string(ns.TransferStatus), nil
+ }
 +type TrendingKind string
++
 +const (
 +	TrendingKindRepos TrendingKind = "repos"
 +	TrendingKindUsers TrendingKind = "users"
 +)
++
 +func (e *TrendingKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = TrendingKind(s)
 +	case string:
 +		*e = TrendingKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for TrendingKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullTrendingKind struct {
 +	TrendingKind TrendingKind
 +	Valid        bool // Valid is true if TrendingKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullTrendingKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.TrendingKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.TrendingKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullTrendingKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.TrendingKind), nil
 +}
++
 +type TrendingScope string
++
 +const (
 +	TrendingScopeDay   TrendingScope = "day"
 +	TrendingScopeWeek  TrendingScope = "week"
 +	TrendingScopeMonth TrendingScope = "month"
 +)
++
 +func (e *TrendingScope) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = TrendingScope(s)
 +	case string:
 +		*e = TrendingScope(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for TrendingScope: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullTrendingScope struct {
 +	TrendingScope TrendingScope
 +	Valid         bool // Valid is true if TrendingScope is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullTrendingScope) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.TrendingScope, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.TrendingScope.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullTrendingScope) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.TrendingScope), nil
 +}
++
  type WatchLevel string
  const (
  	CreatedAt   pgtype.Timestamptz
+ }
 +type Follow struct {
 +	ID             int64
 +	FollowerUserID int64
 +	FolloweeUserID pgtype.Int8
 +	FolloweeOrgID  pgtype.Int8
 +	FollowedAt     pgtype.Timestamptz
 +}
++
  type Issue struct {
  	ID                int64
  	RepoID            int64
  	DeliveredAt     pgtype.Timestamptz
+ }
 +type TrendingSnapshot struct {
 +	ID         int64
 +	Scope      TrendingScope
 +	Kind       TrendingKind
 +	CapturedAt pgtype.Timestamptz
 +	Payload    []byte
 +}
++
  type User struct {
  	ID                int64
  	Username          string

internal/ratelimit/sqlc/models.gomodified

  	return string(ns.TransferStatus), nil
+ }
 +type TrendingKind string
++
 +const (
 +	TrendingKindRepos TrendingKind = "repos"
 +	TrendingKindUsers TrendingKind = "users"
 +)
++
 +func (e *TrendingKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = TrendingKind(s)
 +	case string:
 +		*e = TrendingKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for TrendingKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullTrendingKind struct {
 +	TrendingKind TrendingKind
 +	Valid        bool // Valid is true if TrendingKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullTrendingKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.TrendingKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.TrendingKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullTrendingKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.TrendingKind), nil
 +}
++
 +type TrendingScope string
++
 +const (
 +	TrendingScopeDay   TrendingScope = "day"
 +	TrendingScopeWeek  TrendingScope = "week"
 +	TrendingScopeMonth TrendingScope = "month"
 +)
++
 +func (e *TrendingScope) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = TrendingScope(s)
 +	case string:
 +		*e = TrendingScope(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for TrendingScope: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullTrendingScope struct {
 +	TrendingScope TrendingScope
 +	Valid         bool // Valid is true if TrendingScope is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullTrendingScope) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.TrendingScope, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.TrendingScope.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullTrendingScope) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.TrendingScope), nil
 +}
++
  type WatchLevel string
  const (
  	CreatedAt   pgtype.Timestamptz
+ }
 +type Follow struct {
 +	ID             int64
 +	FollowerUserID int64
 +	FolloweeUserID pgtype.Int8
 +	FolloweeOrgID  pgtype.Int8
 +	FollowedAt     pgtype.Timestamptz
 +}
++
  type Issue struct {
  	ID                int64
  	RepoID            int64
  	DeliveredAt     pgtype.Timestamptz
+ }
 +type TrendingSnapshot struct {
 +	ID         int64
 +	Scope      TrendingScope
 +	Kind       TrendingKind
 +	CapturedAt pgtype.Timestamptz
 +	Payload    []byte
 +}
++
  type User struct {
  	ID                int64
  	Username          string

internal/repos/sqlc/models.gomodified

  	return string(ns.TransferStatus), nil
+ }
 +type TrendingKind string
++
 +const (
 +	TrendingKindRepos TrendingKind = "repos"
 +	TrendingKindUsers TrendingKind = "users"
 +)
++
 +func (e *TrendingKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = TrendingKind(s)
 +	case string:
 +		*e = TrendingKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for TrendingKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullTrendingKind struct {
 +	TrendingKind TrendingKind
 +	Valid        bool // Valid is true if TrendingKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullTrendingKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.TrendingKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.TrendingKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullTrendingKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.TrendingKind), nil
 +}
++
 +type TrendingScope string
++
 +const (
 +	TrendingScopeDay   TrendingScope = "day"
 +	TrendingScopeWeek  TrendingScope = "week"
 +	TrendingScopeMonth TrendingScope = "month"
 +)
++
 +func (e *TrendingScope) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = TrendingScope(s)
 +	case string:
 +		*e = TrendingScope(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for TrendingScope: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullTrendingScope struct {
 +	TrendingScope TrendingScope
 +	Valid         bool // Valid is true if TrendingScope is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullTrendingScope) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.TrendingScope, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.TrendingScope.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullTrendingScope) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.TrendingScope), nil
 +}
++
  type WatchLevel string
  const (
  	CreatedAt   pgtype.Timestamptz
+ }
 +type Follow struct {
 +	ID             int64
 +	FollowerUserID int64
 +	FolloweeUserID pgtype.Int8
 +	FolloweeOrgID  pgtype.Int8
 +	FollowedAt     pgtype.Timestamptz
 +}
++
  type Issue struct {
  	ID                int64
  	RepoID            int64
  	DeliveredAt     pgtype.Timestamptz
+ }
 +type TrendingSnapshot struct {
 +	ID         int64
 +	Scope      TrendingScope
 +	Kind       TrendingKind
 +	CapturedAt pgtype.Timestamptz
 +	Payload    []byte
 +}
++
  type User struct {
  	ID                int64
  	Username          string

internal/social/feed.goadded

 +// SPDX-License-Identifier: AGPL-3.0-or-later
++
 +package social
++
 +import (
 +	"context"
 +	"encoding/json"
 +	"fmt"
 +	"strconv"
 +	"strings"
 +	"time"
++
 +	"github.com/jackc/pgx/v5/pgtype"
++
 +	socialdb "github.com/tenseleyFlow/shithub/internal/social/sqlc"
 +)
++
 +const (
 +	defaultFeedLimit     int32 = 30
 +	defaultTrendingLimit int32 = 10
 +)
++
 +// FeedCursor is S42's keyset cursor over (created_at, event_id).
 +type FeedCursor struct {
 +	BeforeCreatedAt time.Time
 +	BeforeID        int64
 +}
++
 +type FeedRepo struct {
 +	ID              int64
 +	Owner           string
 +	Name            string
 +	Description     string
 +	PrimaryLanguage string
 +	StarCount       int64
 +	ForkCount       int64
 +}
++
 +type FeedItem struct {
 +	ID               int64
 +	Kind             string
 +	Verb             string
 +	ActorUsername    string
 +	ActorDisplayName string
 +	CreatedAt        time.Time
 +	Repo             *FeedRepo
 +	RepoFullName     string
 +	RepoURL          string
 +	SourceName       string
 +	SourceURL        string
 +	ItemTitle        string
 +	ItemURL          string
 +}
++
 +type DashboardRepo struct {
 +	ID              int64
 +	Name            string
 +	Description     string
 +	Visibility      string
 +	PrimaryLanguage string
 +	StarCount       int64
 +	ForkCount       int64
 +	UpdatedAt       time.Time
 +}
++
 +type TrendingRepo struct {
 +	RepoID          int64  `json:"repo_id"`
 +	Owner           string `json:"owner"`
 +	Name            string `json:"name"`
 +	Description     string `json:"description"`
 +	PrimaryLanguage string `json:"primary_language,omitempty"`
 +	StarCount       int64  `json:"star_count"`
 +	ForkCount       int64  `json:"fork_count"`
 +	Score           int64  `json:"score"`
 +}
++
 +type TrendingUser struct {
 +	UserID        int64  `json:"user_id"`
 +	Username      string `json:"username"`
 +	DisplayName   string `json:"display_name"`
 +	Score         int64  `json:"score"`
 +	FollowerDelta int64  `json:"follower_delta"`
 +	EventCount    int64  `json:"event_count"`
 +}
++
 +// DashboardFeed returns public feed rows from followed users, followed
 +// orgs, watched repos, and the viewer's own public activity.
 +func DashboardFeed(ctx context.Context, deps Deps, viewerUserID int64, cursor FeedCursor, limit int32) ([]FeedItem, error) {
 +	if viewerUserID == 0 {
 +		return nil, ErrNotLoggedIn
 +	}
 +	if limit <= 0 || limit > 100 {
 +		limit = defaultFeedLimit
 +	}
 +	params := socialdb.ListDashboardFeedEventsParams{
 +		ViewerUserID: viewerUserID,
 +		LimitCount:   limit,
 +	}
 +	if !cursor.BeforeCreatedAt.IsZero() && cursor.BeforeID > 0 {
 +		params.BeforeCreatedAt = pgtype.Timestamptz{Time: cursor.BeforeCreatedAt, Valid: true}
 +		params.BeforeID = pgtype.Int8{Int64: cursor.BeforeID, Valid: true}
 +	}
 +	rows, err := socialdb.New().ListDashboardFeedEvents(ctx, deps.Pool, params)
 +	if err != nil {
 +		return nil, fmt.Errorf("dashboard feed: %w", err)
 +	}
 +	out := make([]FeedItem, 0, len(rows))
 +	for _, row := range rows {
 +		out = append(out, feedItemFromDashboardRow(row))
 +	}
 +	return out, nil
 +}
++
 +// PublicFeed returns the global public activity feed used by Explore.
 +func PublicFeed(ctx context.Context, deps Deps, cursor FeedCursor, limit int32) ([]FeedItem, error) {
 +	if limit <= 0 || limit > 100 {
 +		limit = defaultFeedLimit
 +	}
 +	params := socialdb.ListPublicFeedEventsParams{LimitCount: limit}
 +	if !cursor.BeforeCreatedAt.IsZero() && cursor.BeforeID > 0 {
 +		params.BeforeCreatedAt = pgtype.Timestamptz{Time: cursor.BeforeCreatedAt, Valid: true}
 +		params.BeforeID = pgtype.Int8{Int64: cursor.BeforeID, Valid: true}
 +	}
 +	rows, err := socialdb.New().ListPublicFeedEvents(ctx, deps.Pool, params)
 +	if err != nil {
 +		return nil, fmt.Errorf("public feed: %w", err)
 +	}
 +	out := make([]FeedItem, 0, len(rows))
 +	for _, row := range rows {
 +		out = append(out, feedItemFromPublicRow(row))
 +	}
 +	return out, nil
 +}
++
 +func DashboardRepos(ctx context.Context, deps Deps, viewerUserID int64, limit int32) ([]DashboardRepo, error) {
 +	if limit <= 0 || limit > 20 {
 +		limit = 8
 +	}
 +	rows, err := socialdb.New().ListDashboardReposForUser(ctx, deps.Pool, socialdb.ListDashboardReposForUserParams{
 +		OwnerUserID: pgtype.Int8{Int64: viewerUserID, Valid: true},
 +		Limit:       limit,
 +	})
 +	if err != nil {
 +		return nil, fmt.Errorf("dashboard repos: %w", err)
 +	}
 +	out := make([]DashboardRepo, 0, len(rows))
 +	for _, row := range rows {
 +		out = append(out, DashboardRepo{
 +			ID: row.RepoID, Name: row.Name, Description: row.Description,
 +			Visibility: string(row.Visibility), PrimaryLanguage: row.PrimaryLanguage,
 +			StarCount: row.StarCount, ForkCount: row.ForkCount,
 +			UpdatedAt: timeFromPG(row.UpdatedAt),
 +		})
 +	}
 +	return out, nil
 +}
++
 +func TrendingRepos(ctx context.Context, deps Deps, windowDays, limit int32) ([]TrendingRepo, error) {
 +	if windowDays <= 0 {
 +		windowDays = 7
 +	}
 +	if limit <= 0 || limit > 50 {
 +		limit = defaultTrendingLimit
 +	}
 +	rows, err := socialdb.New().ListTrendingRepos(ctx, deps.Pool, socialdb.ListTrendingReposParams{
 +		LimitCount: limit,
 +		WindowDays: windowDays,
 +	})
 +	if err != nil {
 +		return nil, fmt.Errorf("trending repos: %w", err)
 +	}
 +	out := make([]TrendingRepo, 0, len(rows))
 +	for _, row := range rows {
 +		out = append(out, TrendingRepo{
 +			RepoID: row.RepoID, Owner: row.Owner, Name: row.Name,
 +			Description: row.Description, PrimaryLanguage: row.PrimaryLanguage,
 +			StarCount: row.StarCount, ForkCount: row.ForkCount, Score: row.Score,
 +		})
 +	}
 +	return out, nil
 +}
++
 +func TrendingUsers(ctx context.Context, deps Deps, windowDays, limit int32) ([]TrendingUser, error) {
 +	if windowDays <= 0 {
 +		windowDays = 7
 +	}
 +	if limit <= 0 || limit > 50 {
 +		limit = defaultTrendingLimit
 +	}
 +	rows, err := socialdb.New().ListTrendingUsers(ctx, deps.Pool, socialdb.ListTrendingUsersParams{
 +		LimitCount: limit,
 +		WindowDays: windowDays,
 +	})
 +	if err != nil {
 +		return nil, fmt.Errorf("trending users: %w", err)
 +	}
 +	out := make([]TrendingUser, 0, len(rows))
 +	for _, row := range rows {
 +		out = append(out, TrendingUser{
 +			UserID: row.UserID, Username: row.Username, DisplayName: row.DisplayName,
 +			Score: row.Score, FollowerDelta: row.FollowerDelta, EventCount: row.EventCount,
 +		})
 +	}
 +	return out, nil
 +}
++
 +// CaptureTrendingSnapshots computes the S42 denormalized rankings for
 +// day/week/month windows. It is idempotent in behavior: inserting a new
 +// snapshot never mutates prior rows, so stale readers still have a valid
 +// last-known ranking.
 +func CaptureTrendingSnapshots(ctx context.Context, deps Deps) error {
 +	q := socialdb.New()
 +	windows := []struct {
 +		scope socialdb.TrendingScope
 +		days  int32
 +	}{
 +		{scope: socialdb.TrendingScopeDay, days: 1},
 +		{scope: socialdb.TrendingScopeWeek, days: 7},
 +		{scope: socialdb.TrendingScopeMonth, days: 30},
 +	}
 +	for _, window := range windows {
 +		repos, err := TrendingRepos(ctx, deps, window.days, 50)
 +		if err != nil {
 +			return err
 +		}
 +		body, err := json.Marshal(repos)
 +		if err != nil {
 +			return fmt.Errorf("marshal trending repos: %w", err)
 +		}
 +		if _, err := q.InsertTrendingSnapshot(ctx, deps.Pool, socialdb.InsertTrendingSnapshotParams{
 +			Scope: window.scope, Kind: socialdb.TrendingKindRepos, Payload: body,
 +		}); err != nil {
 +			return fmt.Errorf("insert trending repos snapshot: %w", err)
 +		}
++
 +		users, err := TrendingUsers(ctx, deps, window.days, 50)
 +		if err != nil {
 +			return err
 +		}
 +		body, err = json.Marshal(users)
 +		if err != nil {
 +			return fmt.Errorf("marshal trending users: %w", err)
 +		}
 +		if _, err := q.InsertTrendingSnapshot(ctx, deps.Pool, socialdb.InsertTrendingSnapshotParams{
 +			Scope: window.scope, Kind: socialdb.TrendingKindUsers, Payload: body,
 +		}); err != nil {
 +			return fmt.Errorf("insert trending users snapshot: %w", err)
 +		}
 +	}
 +	return nil
 +}
++
 +func feedItemFromDashboardRow(row socialdb.ListDashboardFeedEventsRow) FeedItem {
 +	return feedItemFromParts(feedParts{
 +		id: row.ID, kind: row.Kind, actorUsername: row.ActorUsername,
 +		actorDisplayName: row.ActorDisplayName, createdAt: row.CreatedAt,
 +		repoID: row.RepoID, repoOwner: row.RepoOwner, repoName: row.RepoName,
 +		repoDescription: row.RepoDescription, repoPrimaryLanguage: row.RepoPrimaryLanguage,
 +		repoStarCount: row.RepoStarCount, repoForkCount: row.RepoForkCount,
 +		sourceName: row.SourceName, payload: row.Payload,
 +	})
 +}
++
 +func feedItemFromPublicRow(row socialdb.ListPublicFeedEventsRow) FeedItem {
 +	return feedItemFromParts(feedParts{
 +		id: row.ID, kind: row.Kind, actorUsername: row.ActorUsername,
 +		actorDisplayName: row.ActorDisplayName, createdAt: row.CreatedAt,
 +		repoID: row.RepoID, repoOwner: row.RepoOwner, repoName: row.RepoName,
 +		repoDescription: row.RepoDescription, repoPrimaryLanguage: row.RepoPrimaryLanguage,
 +		repoStarCount: row.RepoStarCount, repoForkCount: row.RepoForkCount,
 +		sourceName: row.SourceName, payload: row.Payload,
 +	})
 +}
++
 +type feedParts struct {
 +	id                  int64
 +	kind                string
 +	actorUsername       string
 +	actorDisplayName    string
 +	createdAt           pgtype.Timestamptz
 +	repoID              pgtype.Int8
 +	repoOwner           string
 +	repoName            string
 +	repoDescription     string
 +	repoPrimaryLanguage string
 +	repoStarCount       int64
 +	repoForkCount       int64
 +	sourceName          string
 +	payload             []byte
 +}
++
 +func feedItemFromParts(p feedParts) FeedItem {
 +	item := FeedItem{
 +		ID: p.id, Kind: p.kind, Verb: feedVerb(p.kind),
 +		ActorUsername: p.actorUsername, ActorDisplayName: p.actorDisplayName,
 +		CreatedAt: timeFromPG(p.createdAt), SourceName: p.sourceName,
 +	}
 +	if p.repoID.Valid && p.repoOwner != "" && p.repoName != "" {
 +		item.Repo = &FeedRepo{
 +			ID: p.repoID.Int64, Owner: p.repoOwner, Name: p.repoName,
 +			Description: p.repoDescription, PrimaryLanguage: p.repoPrimaryLanguage,
 +			StarCount: p.repoStarCount, ForkCount: p.repoForkCount,
 +		}
 +		item.RepoFullName = p.repoOwner + "/" + p.repoName
 +		item.RepoURL = "/" + item.RepoFullName
 +	}
 +	item.ItemTitle, item.ItemURL = feedItemTarget(p.kind, p.payload, item)
 +	if item.SourceName != "" {
 +		item.SourceURL = "/" + item.SourceName
 +	}
 +	return item
 +}
++
 +func feedVerb(kind string) string {
 +	switch kind {
 +	case "star":
 +		return "starred"
 +	case "unstar":
 +		return "unstarred"
 +	case "forked":
 +		return "forked"
 +	case "push":
 +		return "pushed to"
 +	case "repo_created":
 +		return "created"
 +	case "issue_created":
 +		return "opened an issue in"
 +	case "issue_comment_created":
 +		return "commented on an issue in"
 +	case "issue_closed":
 +		return "closed an issue in"
 +	case "issue_reopened":
 +		return "reopened an issue in"
 +	case "pr_opened":
 +		return "opened a pull request in"
 +	case "pr_comment_created":
 +		return "commented on a pull request in"
 +	case "pr_closed":
 +		return "closed a pull request in"
 +	case "pr_reopened":
 +		return "reopened a pull request in"
 +	case "pr_merged":
 +		return "merged a pull request in"
 +	case "followed_user", "followed_org":
 +		return "followed"
 +	default:
 +		return strings.ReplaceAll(kind, "_", " ")
 +	}
 +}
++
 +func feedItemTarget(kind string, payload []byte, item FeedItem) (string, string) {
 +	switch kind {
 +	case "followed_user", "followed_org":
 +		if item.SourceName != "" {
 +			return item.SourceName, "/" + item.SourceName
 +		}
 +		return "a profile", ""
 +	}
 +	data := map[string]any{}
 +	_ = json.Unmarshal(payload, &data)
 +	if title, _ := data["issue_title"].(string); title != "" {
 +		if item.RepoURL == "" {
 +			return title, ""
 +		}
 +		if n, ok := jsonNumberToInt(data["issue_number"]); ok {
 +			section := "issues"
 +			if strings.HasPrefix(kind, "pr_") {
 +				section = "pulls"
 +			}
 +			return title, item.RepoURL + "/" + section + "/" + strconv.FormatInt(n, 10)
 +		}
 +		return title, item.RepoURL
 +	}
 +	if item.RepoFullName != "" {
 +		return item.RepoFullName, item.RepoURL
 +	}
 +	return "", ""
 +}
++
 +func jsonNumberToInt(v any) (int64, bool) {
 +	switch n := v.(type) {
 +	case float64:
 +		return int64(n), true
 +	case int64:
 +		return n, true
 +	case string:
 +		i, err := strconv.ParseInt(n, 10, 64)
 +		return i, err == nil
 +	default:
 +		return 0, false
 +	}
 +}
++
 +func timeFromPG(t pgtype.Timestamptz) time.Time {
 +	if !t.Valid {
 +		return time.Time{}
 +	}
 +	return t.Time
 +}

internal/social/follows.goadded

 +// SPDX-License-Identifier: AGPL-3.0-or-later
++
 +package social
++
 +import (
 +	"context"
 +	"fmt"
 +	"time"
++
 +	"github.com/jackc/pgx/v5/pgtype"
++
 +	"github.com/tenseleyFlow/shithub/internal/auth/audit"
 +	"github.com/tenseleyFlow/shithub/internal/auth/throttle"
 +	socialdb "github.com/tenseleyFlow/shithub/internal/social/sqlc"
 +)
++
 +const (
 +	followRateMax    = 200
 +	followRateWindow = time.Hour
 +)
++
 +// FollowUser idempotently records actorUserID following targetUserID.
 +// On a new edge it emits a public user-scoped domain event so S42 feed
 +// surfaces can show "alice followed bob" style rows.
 +func FollowUser(ctx context.Context, deps Deps, actorUserID, targetUserID int64) error {
 +	if actorUserID == 0 {
 +		return ErrNotLoggedIn
 +	}
 +	if actorUserID == targetUserID {
 +		return ErrCannotFollowSelf
 +	}
 +	if err := hitFollowLimit(ctx, deps, actorUserID); err != nil {
 +		return err
 +	}
++
 +	tx, err := deps.Pool.Begin(ctx)
 +	if err != nil {
 +		return err
 +	}
 +	committed := false
 +	defer func() {
 +		if !committed {
 +			_ = tx.Rollback(ctx)
 +		}
 +	}()
++
 +	q := socialdb.New()
 +	inserted, err := q.FollowUser(ctx, tx, socialdb.FollowUserParams{
 +		FollowerUserID: actorUserID,
 +		FolloweeUserID: pgtype.Int8{Int64: targetUserID, Valid: true},
 +	})
 +	if err != nil {
 +		return fmt.Errorf("follow user: %w", err)
 +	}
 +	if inserted {
 +		if _, err := q.InsertDomainEvent(ctx, tx, socialdb.InsertDomainEventParams{
 +			ActorUserID: pgInt(actorUserID),
 +			Kind:        "followed_user",
 +			RepoID:      pgInt(0),
 +			SourceKind:  "user",
 +			SourceID:    targetUserID,
 +			Public:      true,
 +			Payload:     []byte("{}"),
 +		}); err != nil {
 +			return fmt.Errorf("follow event: %w", err)
 +		}
 +	}
 +	if err := tx.Commit(ctx); err != nil {
 +		return err
 +	}
 +	committed = true
++
 +	if inserted && deps.Audit != nil {
 +		_ = deps.Audit.Record(ctx, deps.Pool, actorUserID,
 +			audit.ActionFollowCreated, audit.TargetUser, targetUserID, nil)
 +	}
 +	return nil
 +}
++
 +// UnfollowUser removes the actor->user follow edge. The operation is
 +// idempotent so duplicate form submits are harmless.
 +func UnfollowUser(ctx context.Context, deps Deps, actorUserID, targetUserID int64) error {
 +	if actorUserID == 0 {
 +		return ErrNotLoggedIn
 +	}
 +	if err := hitFollowLimit(ctx, deps, actorUserID); err != nil {
 +		return err
 +	}
 +	rows, err := socialdb.New().UnfollowUser(ctx, deps.Pool, socialdb.UnfollowUserParams{
 +		FollowerUserID: actorUserID,
 +		FolloweeUserID: pgtype.Int8{Int64: targetUserID, Valid: true},
 +	})
 +	if err != nil {
 +		return fmt.Errorf("unfollow user: %w", err)
 +	}
 +	if rows > 0 && deps.Audit != nil {
 +		_ = deps.Audit.Record(ctx, deps.Pool, actorUserID,
 +			audit.ActionFollowDeleted, audit.TargetUser, targetUserID, nil)
 +	}
 +	return nil
 +}
++
 +// FollowOrg idempotently records actorUserID following an organization.
 +// This is an S42-compatible extension over the user-only sprint text so
 +// org-owned repos can participate in the same social feed.
 +func FollowOrg(ctx context.Context, deps Deps, actorUserID, orgID int64) error {
 +	if actorUserID == 0 {
 +		return ErrNotLoggedIn
 +	}
 +	if err := hitFollowLimit(ctx, deps, actorUserID); err != nil {
 +		return err
 +	}
++
 +	tx, err := deps.Pool.Begin(ctx)
 +	if err != nil {
 +		return err
 +	}
 +	committed := false
 +	defer func() {
 +		if !committed {
 +			_ = tx.Rollback(ctx)
 +		}
 +	}()
++
 +	q := socialdb.New()
 +	inserted, err := q.FollowOrg(ctx, tx, socialdb.FollowOrgParams{
 +		FollowerUserID: actorUserID,
 +		FolloweeOrgID:  pgtype.Int8{Int64: orgID, Valid: true},
 +	})
 +	if err != nil {
 +		return fmt.Errorf("follow org: %w", err)
 +	}
 +	if inserted {
 +		if _, err := q.InsertDomainEvent(ctx, tx, socialdb.InsertDomainEventParams{
 +			ActorUserID: pgInt(actorUserID),
 +			Kind:        "followed_org",
 +			RepoID:      pgInt(0),
 +			SourceKind:  "org",
 +			SourceID:    orgID,
 +			Public:      true,
 +			Payload:     []byte("{}"),
 +		}); err != nil {
 +			return fmt.Errorf("follow event: %w", err)
 +		}
 +	}
 +	if err := tx.Commit(ctx); err != nil {
 +		return err
 +	}
 +	committed = true
++
 +	if inserted && deps.Audit != nil {
 +		_ = deps.Audit.Record(ctx, deps.Pool, actorUserID,
 +			audit.ActionFollowCreated, audit.TargetOrg, orgID, nil)
 +	}
 +	return nil
 +}
++
 +// UnfollowOrg removes an actor->org follow edge.
 +func UnfollowOrg(ctx context.Context, deps Deps, actorUserID, orgID int64) error {
 +	if actorUserID == 0 {
 +		return ErrNotLoggedIn
 +	}
 +	if err := hitFollowLimit(ctx, deps, actorUserID); err != nil {
 +		return err
 +	}
 +	rows, err := socialdb.New().UnfollowOrg(ctx, deps.Pool, socialdb.UnfollowOrgParams{
 +		FollowerUserID: actorUserID,
 +		FolloweeOrgID:  pgtype.Int8{Int64: orgID, Valid: true},
 +	})
 +	if err != nil {
 +		return fmt.Errorf("unfollow org: %w", err)
 +	}
 +	if rows > 0 && deps.Audit != nil {
 +		_ = deps.Audit.Record(ctx, deps.Pool, actorUserID,
 +			audit.ActionFollowDeleted, audit.TargetOrg, orgID, nil)
 +	}
 +	return nil
 +}
++
 +func IsFollowingUser(ctx context.Context, deps Deps, followerUserID, targetUserID int64) (bool, error) {
 +	if followerUserID == 0 {
 +		return false, nil
 +	}
 +	return socialdb.New().IsFollowingUser(ctx, deps.Pool, socialdb.IsFollowingUserParams{
 +		FollowerUserID: followerUserID,
 +		FolloweeUserID: pgtype.Int8{Int64: targetUserID, Valid: true},
 +	})
 +}
++
 +func IsFollowingOrg(ctx context.Context, deps Deps, followerUserID, orgID int64) (bool, error) {
 +	if followerUserID == 0 {
 +		return false, nil
 +	}
 +	return socialdb.New().IsFollowingOrg(ctx, deps.Pool, socialdb.IsFollowingOrgParams{
 +		FollowerUserID: followerUserID,
 +		FolloweeOrgID:  pgtype.Int8{Int64: orgID, Valid: true},
 +	})
 +}
++
 +func hitFollowLimit(ctx context.Context, deps Deps, userID int64) error {
 +	if deps.Limiter == nil {
 +		return nil
 +	}
 +	if err := deps.Limiter.Hit(ctx, deps.Pool, throttle.Limit{
 +		Scope:      "follow",
 +		Identifier: fmt.Sprintf("user:%d", userID),
 +		Max:        followRateMax,
 +		Window:     followRateWindow,
 +	}); err != nil {
 +		return ErrFollowRateLimit
 +	}
 +	return nil
 +}

internal/social/queries/feed.sqladded

 +-- ─── activity feed / trending ─────────────────────────────────────
++
 +-- name: ListDashboardFeedEvents :many
 +SELECT
 +    de.id, de.actor_user_id, de.kind, de.repo_id, de.source_kind,
 +    de.source_id, de.public, de.payload, de.created_at,
 +    actor.username AS actor_username,
 +    actor.display_name AS actor_display_name,
 +    COALESCE(r.name::text, '')::text AS repo_name,
 +    COALESCE(r.description, '') AS repo_description,
 +    COALESCE(r.primary_language, '') AS repo_primary_language,
 +    COALESCE(r.star_count, 0)::bigint AS repo_star_count,
 +    COALESCE(r.fork_count, 0)::bigint AS repo_fork_count,
 +    COALESCE(owner_user.username::text, owner_org.slug::text, '')::text AS repo_owner,
 +    COALESCE(source_user.username::text, source_org.slug::text, '')::text AS source_name
 +FROM domain_events de
 +JOIN users actor ON actor.id = de.actor_user_id
 +LEFT JOIN repos r ON r.id = de.repo_id AND r.deleted_at IS NULL
 +LEFT JOIN users owner_user ON owner_user.id = r.owner_user_id
 +LEFT JOIN orgs owner_org ON owner_org.id = r.owner_org_id
 +LEFT JOIN users source_user ON de.source_kind = 'user' AND source_user.id = de.source_id
 +LEFT JOIN orgs source_org ON de.source_kind = 'org' AND source_org.id = de.source_id
 +WHERE de.public = true
 +  AND actor.suspended_at IS NULL
 +  AND actor.deleted_at IS NULL
 +  AND (
 +      de.repo_id IS NULL
 +      OR (r.id IS NOT NULL AND r.visibility = 'public')
 +  )
 +  AND (
 +      de.actor_user_id = sqlc.arg(viewer_user_id)::bigint
 +      OR de.actor_user_id IN (
 +          SELECT followee_user_id FROM follows
 +          WHERE follower_user_id = sqlc.arg(viewer_user_id)::bigint
 +            AND followee_user_id IS NOT NULL
 +      )
 +      OR de.repo_id IN (
 +          SELECT repo_id FROM watches
 +          WHERE user_id = sqlc.arg(viewer_user_id)::bigint
 +            AND level <> 'ignore'
 +      )
 +      OR (
 +          r.owner_org_id IN (
 +              SELECT followee_org_id FROM follows
 +              WHERE follower_user_id = sqlc.arg(viewer_user_id)::bigint
 +                AND followee_org_id IS NOT NULL
 +          )
 +      )
 +      OR (
 +          de.source_kind = 'org'
 +          AND de.source_id IN (
 +              SELECT followee_org_id FROM follows
 +              WHERE follower_user_id = sqlc.arg(viewer_user_id)::bigint
 +                AND followee_org_id IS NOT NULL
 +          )
 +      )
 +  )
 +  AND (
 +      sqlc.narg(before_created_at)::timestamptz IS NULL
 +      OR (de.created_at, de.id) < (
 +          sqlc.narg(before_created_at)::timestamptz,
 +          sqlc.narg(before_id)::bigint
 +      )
 +  )
 +ORDER BY de.created_at DESC, de.id DESC
 +LIMIT sqlc.arg(limit_count)::int;
++
 +-- name: ListPublicFeedEvents :many
 +SELECT
 +    de.id, de.actor_user_id, de.kind, de.repo_id, de.source_kind,
 +    de.source_id, de.public, de.payload, de.created_at,
 +    actor.username AS actor_username,
 +    actor.display_name AS actor_display_name,
 +    COALESCE(r.name::text, '')::text AS repo_name,
 +    COALESCE(r.description, '') AS repo_description,
 +    COALESCE(r.primary_language, '') AS repo_primary_language,
 +    COALESCE(r.star_count, 0)::bigint AS repo_star_count,
 +    COALESCE(r.fork_count, 0)::bigint AS repo_fork_count,
 +    COALESCE(owner_user.username::text, owner_org.slug::text, '')::text AS repo_owner,
 +    COALESCE(source_user.username::text, source_org.slug::text, '')::text AS source_name
 +FROM domain_events de
 +JOIN users actor ON actor.id = de.actor_user_id
 +LEFT JOIN repos r ON r.id = de.repo_id AND r.deleted_at IS NULL
 +LEFT JOIN users owner_user ON owner_user.id = r.owner_user_id
 +LEFT JOIN orgs owner_org ON owner_org.id = r.owner_org_id
 +LEFT JOIN users source_user ON de.source_kind = 'user' AND source_user.id = de.source_id
 +LEFT JOIN orgs source_org ON de.source_kind = 'org' AND source_org.id = de.source_id
 +WHERE de.public = true
 +  AND actor.suspended_at IS NULL
 +  AND actor.deleted_at IS NULL
 +  AND (
 +      de.repo_id IS NULL
 +      OR (r.id IS NOT NULL AND r.visibility = 'public')
 +  )
 +  AND (
 +      sqlc.narg(before_created_at)::timestamptz IS NULL
 +      OR (de.created_at, de.id) < (
 +          sqlc.narg(before_created_at)::timestamptz,
 +          sqlc.narg(before_id)::bigint
 +      )
 +  )
 +ORDER BY de.created_at DESC, de.id DESC
 +LIMIT sqlc.arg(limit_count)::int;
++
 +-- name: ListTrendingRepos :many
 +WITH recent AS (
 +    SELECT
 +        repo_id,
 +        (
 +            COUNT(*) FILTER (WHERE kind = 'star') * 3
 +          + COUNT(*) FILTER (WHERE kind = 'forked') * 2
 +          + COUNT(DISTINCT actor_user_id) FILTER (WHERE kind = 'push')
 +        )::bigint AS score
 +    FROM domain_events
 +    WHERE public = true
 +      AND repo_id IS NOT NULL
 +      AND created_at >= now() - make_interval(days => sqlc.arg(window_days)::int)
 +    GROUP BY repo_id
 +)
 +SELECT
 +    r.id AS repo_id,
 +    COALESCE(owner_user.username::text, owner_org.slug::text, '')::text AS owner,
 +    r.name::text AS name,
 +    r.description,
 +    COALESCE(r.primary_language, '') AS primary_language,
 +    r.star_count,
 +    r.fork_count,
 +    COALESCE(recent.score, 0)::bigint AS score,
 +    r.updated_at
 +FROM repos r
 +LEFT JOIN recent ON recent.repo_id = r.id
 +LEFT JOIN users owner_user ON owner_user.id = r.owner_user_id
 +LEFT JOIN orgs owner_org ON owner_org.id = r.owner_org_id
 +WHERE r.visibility = 'public'
 +  AND r.deleted_at IS NULL
 +  AND r.is_archived = false
 +ORDER BY COALESCE(recent.score, 0) DESC, r.star_count DESC, r.updated_at DESC
 +LIMIT sqlc.arg(limit_count)::int;
++
 +-- name: ListTrendingUsers :many
 +WITH recent_events AS (
 +    SELECT actor_user_id AS user_id, COUNT(*)::bigint AS event_count
 +    FROM domain_events
 +    WHERE public = true
 +      AND actor_user_id IS NOT NULL
 +      AND created_at >= now() - make_interval(days => sqlc.arg(window_days)::int)
 +    GROUP BY actor_user_id
 +),
 +recent_followers AS (
 +    SELECT followee_user_id AS user_id, COUNT(*)::bigint AS follower_count
 +    FROM follows
 +    WHERE followee_user_id IS NOT NULL
 +      AND followed_at >= now() - make_interval(days => sqlc.arg(window_days)::int)
 +    GROUP BY followee_user_id
 +)
 +SELECT
 +    u.id AS user_id,
 +    u.username,
 +    u.display_name,
 +    (COALESCE(recent_followers.follower_count, 0) * 2 + COALESCE(recent_events.event_count, 0))::bigint AS score,
 +    COALESCE(recent_followers.follower_count, 0)::bigint AS follower_delta,
 +    COALESCE(recent_events.event_count, 0)::bigint AS event_count
 +FROM users u
 +LEFT JOIN recent_events ON recent_events.user_id = u.id
 +LEFT JOIN recent_followers ON recent_followers.user_id = u.id
 +WHERE u.suspended_at IS NULL
 +  AND u.deleted_at IS NULL
 +  AND (COALESCE(recent_followers.follower_count, 0) > 0 OR COALESCE(recent_events.event_count, 0) > 0)
 +ORDER BY score DESC, u.created_at DESC
 +LIMIT sqlc.arg(limit_count)::int;
++
 +-- name: ListDashboardReposForUser :many
 +SELECT
 +    r.id AS repo_id,
 +    r.name::text AS name,
 +    r.description,
 +    r.visibility,
 +    COALESCE(r.primary_language, '') AS primary_language,
 +    r.star_count,
 +    r.fork_count,
 +    r.updated_at
 +FROM repos r
 +WHERE r.owner_user_id = $1
 +  AND r.deleted_at IS NULL
 +ORDER BY r.updated_at DESC
 +LIMIT $2;
++
 +-- name: InsertTrendingSnapshot :one
 +INSERT INTO trending_snapshots (scope, kind, payload)
 +VALUES ($1, $2, $3)
 +RETURNING id, scope, kind, captured_at, payload;
++
 +-- name: LatestTrendingSnapshot :one
 +SELECT id, scope, kind, captured_at, payload
 +FROM trending_snapshots
 +WHERE scope = $1
 +  AND kind = $2
 +ORDER BY captured_at DESC
 +LIMIT 1;

internal/social/queries/follows.sqladded

 +-- ─── follows ───────────────────────────────────────────────────────
++
 +-- name: FollowUser :one
 +WITH inserted AS (
 +    INSERT INTO follows (follower_user_id, followee_user_id)
 +    VALUES ($1, $2)
 +    ON CONFLICT (follower_user_id, followee_user_id)
 +        WHERE followee_user_id IS NOT NULL
 +    DO NOTHING
 +    RETURNING 1
 +)
 +SELECT EXISTS (SELECT 1 FROM inserted) AS inserted;
++
 +-- name: UnfollowUser :execrows
 +DELETE FROM follows
 +WHERE follower_user_id = $1
 +  AND followee_user_id = $2;
++
 +-- name: FollowOrg :one
 +WITH inserted AS (
 +    INSERT INTO follows (follower_user_id, followee_org_id)
 +    VALUES ($1, $2)
 +    ON CONFLICT (follower_user_id, followee_org_id)
 +        WHERE followee_org_id IS NOT NULL
 +    DO NOTHING
 +    RETURNING 1
 +)
 +SELECT EXISTS (SELECT 1 FROM inserted) AS inserted;
++
 +-- name: UnfollowOrg :execrows
 +DELETE FROM follows
 +WHERE follower_user_id = $1
 +  AND followee_org_id = $2;
++
 +-- name: IsFollowingUser :one
 +SELECT EXISTS (
 +    SELECT 1 FROM follows
 +    WHERE follower_user_id = $1
 +      AND followee_user_id = $2
 +) AS following;
++
 +-- name: IsFollowingOrg :one
 +SELECT EXISTS (
 +    SELECT 1 FROM follows
 +    WHERE follower_user_id = $1
 +      AND followee_org_id = $2
 +) AS following;
++
 +-- name: CountFollowersForUser :one
 +SELECT COUNT(*) FROM follows f
 +JOIN users u ON u.id = f.follower_user_id
 +WHERE f.followee_user_id = $1
 +  AND u.suspended_at IS NULL
 +  AND u.deleted_at IS NULL;
++
 +-- name: CountFollowingForUser :one
 +SELECT COUNT(*) FROM follows f
 +LEFT JOIN users u ON u.id = f.followee_user_id
 +LEFT JOIN orgs o ON o.id = f.followee_org_id
 +WHERE f.follower_user_id = $1
 +  AND (f.followee_user_id IS NULL OR (u.suspended_at IS NULL AND u.deleted_at IS NULL))
 +  AND (f.followee_org_id IS NULL OR (o.suspended_at IS NULL AND o.deleted_at IS NULL));
++
 +-- name: CountFollowersForOrg :one
 +SELECT COUNT(*) FROM follows f
 +JOIN users u ON u.id = f.follower_user_id
 +WHERE f.followee_org_id = $1
 +  AND u.suspended_at IS NULL
 +  AND u.deleted_at IS NULL;
++
 +-- name: ListFollowersForUser :many
 +SELECT f.follower_user_id AS user_id, f.followed_at, u.username, u.display_name
 +FROM follows f
 +JOIN users u ON u.id = f.follower_user_id
 +WHERE f.followee_user_id = $1
 +  AND u.suspended_at IS NULL
 +  AND u.deleted_at IS NULL
 +ORDER BY f.followed_at DESC, f.id DESC
 +LIMIT $2 OFFSET $3;
++
 +-- name: ListFollowingUsersForUser :many
 +SELECT f.followee_user_id AS user_id, f.followed_at, u.username, u.display_name
 +FROM follows f
 +JOIN users u ON u.id = f.followee_user_id
 +WHERE f.follower_user_id = $1
 +  AND u.suspended_at IS NULL
 +  AND u.deleted_at IS NULL
 +ORDER BY f.followed_at DESC, f.id DESC
 +LIMIT $2 OFFSET $3;
++
 +-- name: ListFollowingOrgsForUser :many
 +SELECT f.followee_org_id AS org_id, f.followed_at, o.slug, o.display_name
 +FROM follows f
 +JOIN orgs o ON o.id = f.followee_org_id
 +WHERE f.follower_user_id = $1
 +  AND o.suspended_at IS NULL
 +  AND o.deleted_at IS NULL
 +ORDER BY f.followed_at DESC, f.id DESC
 +LIMIT $2 OFFSET $3;
++
 +-- name: ListFollowersForOrg :many
 +SELECT f.follower_user_id AS user_id, f.followed_at, u.username, u.display_name
 +FROM follows f
 +JOIN users u ON u.id = f.follower_user_id
 +WHERE f.followee_org_id = $1
 +  AND u.suspended_at IS NULL
 +  AND u.deleted_at IS NULL
 +ORDER BY f.followed_at DESC, f.id DESC
 +LIMIT $2 OFFSET $3;

internal/social/social_test.gomodified

  import (
  	"context"
 +	"errors"
  	"io"
  	"log/slog"
  	"testing"
  	"github.com/jackc/pgx/v5/pgtype"
  	"github.com/jackc/pgx/v5/pgxpool"
 +	orgsdb "github.com/tenseleyFlow/shithub/internal/orgs/sqlc"
  	reposdb "github.com/tenseleyFlow/shithub/internal/repos/sqlc"
  	"github.com/tenseleyFlow/shithub/internal/social"
  	socialdb "github.com/tenseleyFlow/shithub/internal/social/sqlc"
  	return u.ID
+ }
 +func mustCreateOrg(t *testing.T, pool *pgxpool.Pool, slug string, creatorID int64) int64 {
 +	t.Helper()
 +	o, err := orgsdb.New().CreateOrg(context.Background(), pool, orgsdb.CreateOrgParams{
 +		Slug:            slug,
 +		DisplayName:     slug,
 +		BillingEmail:    slug + "@example.test",
 +		CreatedByUserID: pgtype.Int8{Int64: creatorID, Valid: creatorID != 0},
 +	})
 +	if err != nil {
 +		t.Fatalf("CreateOrg %s: %v", slug, err)
 +	}
 +	return o.ID
 +}
++
  func repoStarCount(t *testing.T, pool *pgxpool.Pool, repoID int64) int64 {
  	t.Helper()
  	r, err := reposdb.New().GetRepoByID(context.Background(), pool, repoID)
+ 	}
+ }
 +func TestFollowUser_IdempotentCountsAndEvent(t *testing.T) {
 +	pool, deps, targetID, _ := setup(t)
 +	followerID := mustCreateUser(t, pool, "bob")
 +	ctx := context.Background()
++
 +	if err := social.FollowUser(ctx, deps, followerID, targetID); err != nil {
 +		t.Fatalf("FollowUser: %v", err)
 +	}
 +	if err := social.FollowUser(ctx, deps, followerID, targetID); err != nil {
 +		t.Fatalf("FollowUser duplicate: %v", err)
 +	}
 +	q := socialdb.New()
 +	followers, err := q.CountFollowersForUser(ctx, pool, pgtype.Int8{Int64: targetID, Valid: true})
 +	if err != nil {
 +		t.Fatalf("CountFollowersForUser: %v", err)
 +	}
 +	if followers != 1 {
 +		t.Fatalf("followers = %d, want 1", followers)
 +	}
 +	following, err := q.CountFollowingForUser(ctx, pool, followerID)
 +	if err != nil {
 +		t.Fatalf("CountFollowingForUser: %v", err)
 +	}
 +	if following != 1 {
 +		t.Fatalf("following = %d, want 1", following)
 +	}
 +	var eventCount int
 +	if err := pool.QueryRow(ctx,
 +		`SELECT count(*) FROM domain_events WHERE actor_user_id = $1 AND kind = 'followed_user'`,
 +		followerID,
 +	).Scan(&eventCount); err != nil {
 +		t.Fatalf("count follow events: %v", err)
 +	}
 +	if eventCount != 1 {
 +		t.Fatalf("event count = %d, want 1", eventCount)
 +	}
 +}
++
 +func TestFollowUser_RejectsSelf(t *testing.T) {
 +	_, deps, userID, _ := setup(t)
 +	if err := social.FollowUser(context.Background(), deps, userID, userID); !errors.Is(err, social.ErrCannotFollowSelf) {
 +		t.Fatalf("FollowUser self err = %v, want ErrCannotFollowSelf", err)
 +	}
 +}
++
 +func TestFollowOrg_IdempotentCountsAndEvent(t *testing.T) {
 +	pool, deps, creatorID, _ := setup(t)
 +	followerID := mustCreateUser(t, pool, "bob")
 +	orgID := mustCreateOrg(t, pool, "octo-org", creatorID)
 +	ctx := context.Background()
++
 +	if err := social.FollowOrg(ctx, deps, followerID, orgID); err != nil {
 +		t.Fatalf("FollowOrg: %v", err)
 +	}
 +	if err := social.FollowOrg(ctx, deps, followerID, orgID); err != nil {
 +		t.Fatalf("FollowOrg duplicate: %v", err)
 +	}
 +	followers, err := socialdb.New().CountFollowersForOrg(ctx, pool, pgtype.Int8{Int64: orgID, Valid: true})
 +	if err != nil {
 +		t.Fatalf("CountFollowersForOrg: %v", err)
 +	}
 +	if followers != 1 {
 +		t.Fatalf("org followers = %d, want 1", followers)
 +	}
 +	var eventCount int
 +	if err := pool.QueryRow(ctx,
 +		`SELECT count(*) FROM domain_events WHERE actor_user_id = $1 AND kind = 'followed_org'`,
 +		followerID,
 +	).Scan(&eventCount); err != nil {
 +		t.Fatalf("count org follow events: %v", err)
 +	}
 +	if eventCount != 1 {
 +		t.Fatalf("event count = %d, want 1", eventCount)
 +	}
 +}
++
 +func TestUnfollowUser_Idempotent(t *testing.T) {
 +	pool, deps, targetID, _ := setup(t)
 +	followerID := mustCreateUser(t, pool, "bob")
 +	ctx := context.Background()
++
 +	if err := social.FollowUser(ctx, deps, followerID, targetID); err != nil {
 +		t.Fatalf("FollowUser: %v", err)
 +	}
 +	if err := social.UnfollowUser(ctx, deps, followerID, targetID); err != nil {
 +		t.Fatalf("UnfollowUser: %v", err)
 +	}
 +	if err := social.UnfollowUser(ctx, deps, followerID, targetID); err != nil {
 +		t.Fatalf("UnfollowUser duplicate: %v", err)
 +	}
 +	followers, err := socialdb.New().CountFollowersForUser(ctx, pool, pgtype.Int8{Int64: targetID, Valid: true})
 +	if err != nil {
 +		t.Fatalf("CountFollowersForUser: %v", err)
 +	}
 +	if followers != 0 {
 +		t.Fatalf("followers = %d, want 0", followers)
 +	}
 +}
++
  func TestUnstar_DecrementsCount_AndIsIdempotent(t *testing.T) {
  	pool, deps, _, repoID := setup(t)
  	uid := mustCreateUser(t, pool, "bob")

internal/social/sqlc/feed.sql.goadded

 +// Code generated by sqlc. DO NOT EDIT.
 +// versions:
 +//   sqlc v1.31.1
 +// source: feed.sql
++
 +package socialdb
++
 +import (
 +	"context"
++
 +	"github.com/jackc/pgx/v5/pgtype"
 +)
++
 +const insertTrendingSnapshot = `-- name: InsertTrendingSnapshot :one
 +INSERT INTO trending_snapshots (scope, kind, payload)
 +VALUES ($1, $2, $3)
 +RETURNING id, scope, kind, captured_at, payload
 +`
++
 +type InsertTrendingSnapshotParams struct {
 +	Scope   TrendingScope
 +	Kind    TrendingKind
 +	Payload []byte
 +}
++
 +func (q *Queries) InsertTrendingSnapshot(ctx context.Context, db DBTX, arg InsertTrendingSnapshotParams) (TrendingSnapshot, error) {
 +	row := db.QueryRow(ctx, insertTrendingSnapshot, arg.Scope, arg.Kind, arg.Payload)
 +	var i TrendingSnapshot
 +	err := row.Scan(
 +		&i.ID,
 +		&i.Scope,
 +		&i.Kind,
 +		&i.CapturedAt,
 +		&i.Payload,
 +	)
 +	return i, err
 +}
++
 +const latestTrendingSnapshot = `-- name: LatestTrendingSnapshot :one
 +SELECT id, scope, kind, captured_at, payload
 +FROM trending_snapshots
 +WHERE scope = $1
 +  AND kind = $2
 +ORDER BY captured_at DESC
 +LIMIT 1
 +`
++
 +type LatestTrendingSnapshotParams struct {
 +	Scope TrendingScope
 +	Kind  TrendingKind
 +}
++
 +func (q *Queries) LatestTrendingSnapshot(ctx context.Context, db DBTX, arg LatestTrendingSnapshotParams) (TrendingSnapshot, error) {
 +	row := db.QueryRow(ctx, latestTrendingSnapshot, arg.Scope, arg.Kind)
 +	var i TrendingSnapshot
 +	err := row.Scan(
 +		&i.ID,
 +		&i.Scope,
 +		&i.Kind,
 +		&i.CapturedAt,
 +		&i.Payload,
 +	)
 +	return i, err
 +}
++
 +const listDashboardFeedEvents = `-- name: ListDashboardFeedEvents :many
++
 +SELECT
 +    de.id, de.actor_user_id, de.kind, de.repo_id, de.source_kind,
 +    de.source_id, de.public, de.payload, de.created_at,
 +    actor.username AS actor_username,
 +    actor.display_name AS actor_display_name,
 +    COALESCE(r.name::text, '')::text AS repo_name,
 +    COALESCE(r.description, '') AS repo_description,
 +    COALESCE(r.primary_language, '') AS repo_primary_language,
 +    COALESCE(r.star_count, 0)::bigint AS repo_star_count,
 +    COALESCE(r.fork_count, 0)::bigint AS repo_fork_count,
 +    COALESCE(owner_user.username::text, owner_org.slug::text, '')::text AS repo_owner,
 +    COALESCE(source_user.username::text, source_org.slug::text, '')::text AS source_name
 +FROM domain_events de
 +JOIN users actor ON actor.id = de.actor_user_id
 +LEFT JOIN repos r ON r.id = de.repo_id AND r.deleted_at IS NULL
 +LEFT JOIN users owner_user ON owner_user.id = r.owner_user_id
 +LEFT JOIN orgs owner_org ON owner_org.id = r.owner_org_id
 +LEFT JOIN users source_user ON de.source_kind = 'user' AND source_user.id = de.source_id
 +LEFT JOIN orgs source_org ON de.source_kind = 'org' AND source_org.id = de.source_id
 +WHERE de.public = true
 +  AND actor.suspended_at IS NULL
 +  AND actor.deleted_at IS NULL
 +  AND (
 +      de.repo_id IS NULL
 +      OR (r.id IS NOT NULL AND r.visibility = 'public')
 +  )
 +  AND (
 +      de.actor_user_id = $1::bigint
 +      OR de.actor_user_id IN (
 +          SELECT followee_user_id FROM follows
 +          WHERE follower_user_id = $1::bigint
 +            AND followee_user_id IS NOT NULL
 +      )
 +      OR de.repo_id IN (
 +          SELECT repo_id FROM watches
 +          WHERE user_id = $1::bigint
 +            AND level <> 'ignore'
 +      )
 +      OR (
 +          r.owner_org_id IN (
 +              SELECT followee_org_id FROM follows
 +              WHERE follower_user_id = $1::bigint
 +                AND followee_org_id IS NOT NULL
 +          )
 +      )
 +      OR (
 +          de.source_kind = 'org'
 +          AND de.source_id IN (
 +              SELECT followee_org_id FROM follows
 +              WHERE follower_user_id = $1::bigint
 +                AND followee_org_id IS NOT NULL
 +          )
 +      )
 +  )
 +  AND (
 +      $2::timestamptz IS NULL
 +      OR (de.created_at, de.id) < (
 +          $2::timestamptz,
 +          $3::bigint
 +      )
 +  )
 +ORDER BY de.created_at DESC, de.id DESC
 +LIMIT $4::int
 +`
++
 +type ListDashboardFeedEventsParams struct {
 +	ViewerUserID    int64
 +	BeforeCreatedAt pgtype.Timestamptz
 +	BeforeID        pgtype.Int8
 +	LimitCount      int32
 +}
++
 +type ListDashboardFeedEventsRow struct {
 +	ID                  int64
 +	ActorUserID         pgtype.Int8
 +	Kind                string
 +	RepoID              pgtype.Int8
 +	SourceKind          string
 +	SourceID            int64
 +	Public              bool
 +	Payload             []byte
 +	CreatedAt           pgtype.Timestamptz
 +	ActorUsername       string
 +	ActorDisplayName    string
 +	RepoName            string
 +	RepoDescription     string
 +	RepoPrimaryLanguage string
 +	RepoStarCount       int64
 +	RepoForkCount       int64
 +	RepoOwner           string
 +	SourceName          string
 +}
++
 +// ─── activity feed / trending ─────────────────────────────────────
 +func (q *Queries) ListDashboardFeedEvents(ctx context.Context, db DBTX, arg ListDashboardFeedEventsParams) ([]ListDashboardFeedEventsRow, error) {
 +	rows, err := db.Query(ctx, listDashboardFeedEvents,
 +		arg.ViewerUserID,
 +		arg.BeforeCreatedAt,
 +		arg.BeforeID,
 +		arg.LimitCount,
 +	)
 +	if err != nil {
 +		return nil, err
 +	}
 +	defer rows.Close()
 +	items := []ListDashboardFeedEventsRow{}
 +	for rows.Next() {
 +		var i ListDashboardFeedEventsRow
 +		if err := rows.Scan(
 +			&i.ID,
 +			&i.ActorUserID,
 +			&i.Kind,
 +			&i.RepoID,
 +			&i.SourceKind,
 +			&i.SourceID,
 +			&i.Public,
 +			&i.Payload,
 +			&i.CreatedAt,
 +			&i.ActorUsername,
 +			&i.ActorDisplayName,
 +			&i.RepoName,
 +			&i.RepoDescription,
 +			&i.RepoPrimaryLanguage,
 +			&i.RepoStarCount,
 +			&i.RepoForkCount,
 +			&i.RepoOwner,
 +			&i.SourceName,
 +		); err != nil {
 +			return nil, err
 +		}
 +		items = append(items, i)
 +	}
 +	if err := rows.Err(); err != nil {
 +		return nil, err
 +	}
 +	return items, nil
 +}
++
 +const listDashboardReposForUser = `-- name: ListDashboardReposForUser :many
 +SELECT
 +    r.id AS repo_id,
 +    r.name::text AS name,
 +    r.description,
 +    r.visibility,
 +    COALESCE(r.primary_language, '') AS primary_language,
 +    r.star_count,
 +    r.fork_count,
 +    r.updated_at
 +FROM repos r
 +WHERE r.owner_user_id = $1
 +  AND r.deleted_at IS NULL
 +ORDER BY r.updated_at DESC
 +LIMIT $2
 +`
++
 +type ListDashboardReposForUserParams struct {
 +	OwnerUserID pgtype.Int8
 +	Limit       int32
 +}
++
 +type ListDashboardReposForUserRow struct {
 +	RepoID          int64
 +	Name            string
 +	Description     string
 +	Visibility      RepoVisibility
 +	PrimaryLanguage string
 +	StarCount       int64
 +	ForkCount       int64
 +	UpdatedAt       pgtype.Timestamptz
 +}
++
 +func (q *Queries) ListDashboardReposForUser(ctx context.Context, db DBTX, arg ListDashboardReposForUserParams) ([]ListDashboardReposForUserRow, error) {
 +	rows, err := db.Query(ctx, listDashboardReposForUser, arg.OwnerUserID, arg.Limit)
 +	if err != nil {
 +		return nil, err
 +	}
 +	defer rows.Close()
 +	items := []ListDashboardReposForUserRow{}
 +	for rows.Next() {
 +		var i ListDashboardReposForUserRow
 +		if err := rows.Scan(
 +			&i.RepoID,
 +			&i.Name,
 +			&i.Description,
 +			&i.Visibility,
 +			&i.PrimaryLanguage,
 +			&i.StarCount,
 +			&i.ForkCount,
 +			&i.UpdatedAt,
 +		); err != nil {
 +			return nil, err
 +		}
 +		items = append(items, i)
 +	}
 +	if err := rows.Err(); err != nil {
 +		return nil, err
 +	}
 +	return items, nil
 +}
++
 +const listPublicFeedEvents = `-- name: ListPublicFeedEvents :many
 +SELECT
 +    de.id, de.actor_user_id, de.kind, de.repo_id, de.source_kind,
 +    de.source_id, de.public, de.payload, de.created_at,
 +    actor.username AS actor_username,
 +    actor.display_name AS actor_display_name,
 +    COALESCE(r.name::text, '')::text AS repo_name,
 +    COALESCE(r.description, '') AS repo_description,
 +    COALESCE(r.primary_language, '') AS repo_primary_language,
 +    COALESCE(r.star_count, 0)::bigint AS repo_star_count,
 +    COALESCE(r.fork_count, 0)::bigint AS repo_fork_count,
 +    COALESCE(owner_user.username::text, owner_org.slug::text, '')::text AS repo_owner,
 +    COALESCE(source_user.username::text, source_org.slug::text, '')::text AS source_name
 +FROM domain_events de
 +JOIN users actor ON actor.id = de.actor_user_id
 +LEFT JOIN repos r ON r.id = de.repo_id AND r.deleted_at IS NULL
 +LEFT JOIN users owner_user ON owner_user.id = r.owner_user_id
 +LEFT JOIN orgs owner_org ON owner_org.id = r.owner_org_id
 +LEFT JOIN users source_user ON de.source_kind = 'user' AND source_user.id = de.source_id
 +LEFT JOIN orgs source_org ON de.source_kind = 'org' AND source_org.id = de.source_id
 +WHERE de.public = true
 +  AND actor.suspended_at IS NULL
 +  AND actor.deleted_at IS NULL
 +  AND (
 +      de.repo_id IS NULL
 +      OR (r.id IS NOT NULL AND r.visibility = 'public')
 +  )
 +  AND (
 +      $1::timestamptz IS NULL
 +      OR (de.created_at, de.id) < (
 +          $1::timestamptz,
 +          $2::bigint
 +      )
 +  )
 +ORDER BY de.created_at DESC, de.id DESC
 +LIMIT $3::int
 +`
++
 +type ListPublicFeedEventsParams struct {
 +	BeforeCreatedAt pgtype.Timestamptz
 +	BeforeID        pgtype.Int8
 +	LimitCount      int32
 +}
++
 +type ListPublicFeedEventsRow struct {
 +	ID                  int64
 +	ActorUserID         pgtype.Int8
 +	Kind                string
 +	RepoID              pgtype.Int8
 +	SourceKind          string
 +	SourceID            int64
 +	Public              bool
 +	Payload             []byte
 +	CreatedAt           pgtype.Timestamptz
 +	ActorUsername       string
 +	ActorDisplayName    string
 +	RepoName            string
 +	RepoDescription     string
 +	RepoPrimaryLanguage string
 +	RepoStarCount       int64
 +	RepoForkCount       int64
 +	RepoOwner           string
 +	SourceName          string
 +}
++
 +func (q *Queries) ListPublicFeedEvents(ctx context.Context, db DBTX, arg ListPublicFeedEventsParams) ([]ListPublicFeedEventsRow, error) {
 +	rows, err := db.Query(ctx, listPublicFeedEvents, arg.BeforeCreatedAt, arg.BeforeID, arg.LimitCount)
 +	if err != nil {
 +		return nil, err
 +	}
 +	defer rows.Close()
 +	items := []ListPublicFeedEventsRow{}
 +	for rows.Next() {
 +		var i ListPublicFeedEventsRow
 +		if err := rows.Scan(
 +			&i.ID,
 +			&i.ActorUserID,
 +			&i.Kind,
 +			&i.RepoID,
 +			&i.SourceKind,
 +			&i.SourceID,
 +			&i.Public,
 +			&i.Payload,
 +			&i.CreatedAt,
 +			&i.ActorUsername,
 +			&i.ActorDisplayName,
 +			&i.RepoName,
 +			&i.RepoDescription,
 +			&i.RepoPrimaryLanguage,
 +			&i.RepoStarCount,
 +			&i.RepoForkCount,
 +			&i.RepoOwner,
 +			&i.SourceName,
 +		); err != nil {
 +			return nil, err
 +		}
 +		items = append(items, i)
 +	}
 +	if err := rows.Err(); err != nil {
 +		return nil, err
 +	}
 +	return items, nil
 +}
++
 +const listTrendingRepos = `-- name: ListTrendingRepos :many
 +WITH recent AS (
 +    SELECT
 +        repo_id,
 +        (
 +            COUNT(*) FILTER (WHERE kind = 'star') * 3
 +          + COUNT(*) FILTER (WHERE kind = 'forked') * 2
 +          + COUNT(DISTINCT actor_user_id) FILTER (WHERE kind = 'push')
 +        )::bigint AS score
 +    FROM domain_events
 +    WHERE public = true
 +      AND repo_id IS NOT NULL
 +      AND created_at >= now() - make_interval(days => $2::int)
 +    GROUP BY repo_id
 +)
 +SELECT
 +    r.id AS repo_id,
 +    COALESCE(owner_user.username::text, owner_org.slug::text, '')::text AS owner,
 +    r.name::text AS name,
 +    r.description,
 +    COALESCE(r.primary_language, '') AS primary_language,
 +    r.star_count,
 +    r.fork_count,
 +    COALESCE(recent.score, 0)::bigint AS score,
 +    r.updated_at
 +FROM repos r
 +LEFT JOIN recent ON recent.repo_id = r.id
 +LEFT JOIN users owner_user ON owner_user.id = r.owner_user_id
 +LEFT JOIN orgs owner_org ON owner_org.id = r.owner_org_id
 +WHERE r.visibility = 'public'
 +  AND r.deleted_at IS NULL
 +  AND r.is_archived = false
 +ORDER BY COALESCE(recent.score, 0) DESC, r.star_count DESC, r.updated_at DESC
 +LIMIT $1::int
 +`
++
 +type ListTrendingReposParams struct {
 +	LimitCount int32
 +	WindowDays int32
 +}
++
 +type ListTrendingReposRow struct {
 +	RepoID          int64
 +	Owner           string
 +	Name            string
 +	Description     string
 +	PrimaryLanguage string
 +	StarCount       int64
 +	ForkCount       int64
 +	Score           int64
 +	UpdatedAt       pgtype.Timestamptz
 +}
++
 +func (q *Queries) ListTrendingRepos(ctx context.Context, db DBTX, arg ListTrendingReposParams) ([]ListTrendingReposRow, error) {
 +	rows, err := db.Query(ctx, listTrendingRepos, arg.LimitCount, arg.WindowDays)
 +	if err != nil {
 +		return nil, err
 +	}
 +	defer rows.Close()
 +	items := []ListTrendingReposRow{}
 +	for rows.Next() {
 +		var i ListTrendingReposRow
 +		if err := rows.Scan(
 +			&i.RepoID,
 +			&i.Owner,
 +			&i.Name,
 +			&i.Description,
 +			&i.PrimaryLanguage,
 +			&i.StarCount,
 +			&i.ForkCount,
 +			&i.Score,
 +			&i.UpdatedAt,
 +		); err != nil {
 +			return nil, err
 +		}
 +		items = append(items, i)
 +	}
 +	if err := rows.Err(); err != nil {
 +		return nil, err
 +	}
 +	return items, nil
 +}
++
 +const listTrendingUsers = `-- name: ListTrendingUsers :many
 +WITH recent_events AS (
 +    SELECT actor_user_id AS user_id, COUNT(*)::bigint AS event_count
 +    FROM domain_events
 +    WHERE public = true
 +      AND actor_user_id IS NOT NULL
 +      AND created_at >= now() - make_interval(days => $2::int)
 +    GROUP BY actor_user_id
 +),
 +recent_followers AS (
 +    SELECT followee_user_id AS user_id, COUNT(*)::bigint AS follower_count
 +    FROM follows
 +    WHERE followee_user_id IS NOT NULL
 +      AND followed_at >= now() - make_interval(days => $2::int)
 +    GROUP BY followee_user_id
 +)
 +SELECT
 +    u.id AS user_id,
 +    u.username,
 +    u.display_name,
 +    (COALESCE(recent_followers.follower_count, 0) * 2 + COALESCE(recent_events.event_count, 0))::bigint AS score,
 +    COALESCE(recent_followers.follower_count, 0)::bigint AS follower_delta,
 +    COALESCE(recent_events.event_count, 0)::bigint AS event_count
 +FROM users u
 +LEFT JOIN recent_events ON recent_events.user_id = u.id
 +LEFT JOIN recent_followers ON recent_followers.user_id = u.id
 +WHERE u.suspended_at IS NULL
 +  AND u.deleted_at IS NULL
 +  AND (COALESCE(recent_followers.follower_count, 0) > 0 OR COALESCE(recent_events.event_count, 0) > 0)
 +ORDER BY score DESC, u.created_at DESC
 +LIMIT $1::int
 +`
++
 +type ListTrendingUsersParams struct {
 +	LimitCount int32
 +	WindowDays int32
 +}
++
 +type ListTrendingUsersRow struct {
 +	UserID        int64
 +	Username      string
 +	DisplayName   string
 +	Score         int64
 +	FollowerDelta int64
 +	EventCount    int64
 +}
++
 +func (q *Queries) ListTrendingUsers(ctx context.Context, db DBTX, arg ListTrendingUsersParams) ([]ListTrendingUsersRow, error) {
 +	rows, err := db.Query(ctx, listTrendingUsers, arg.LimitCount, arg.WindowDays)
 +	if err != nil {
 +		return nil, err
 +	}
 +	defer rows.Close()
 +	items := []ListTrendingUsersRow{}
 +	for rows.Next() {
 +		var i ListTrendingUsersRow
 +		if err := rows.Scan(
 +			&i.UserID,
 +			&i.Username,
 +			&i.DisplayName,
 +			&i.Score,
 +			&i.FollowerDelta,
 +			&i.EventCount,
 +		); err != nil {
 +			return nil, err
 +		}
 +		items = append(items, i)
 +	}
 +	if err := rows.Err(); err != nil {
 +		return nil, err
 +	}
 +	return items, nil
 +}

internal/social/sqlc/follows.sql.goadded

 +// Code generated by sqlc. DO NOT EDIT.
 +// versions:
 +//   sqlc v1.31.1
 +// source: follows.sql
++
 +package socialdb
++
 +import (
 +	"context"
++
 +	"github.com/jackc/pgx/v5/pgtype"
 +)
++
 +const countFollowersForOrg = `-- name: CountFollowersForOrg :one
 +SELECT COUNT(*) FROM follows f
 +JOIN users u ON u.id = f.follower_user_id
 +WHERE f.followee_org_id = $1
 +  AND u.suspended_at IS NULL
 +  AND u.deleted_at IS NULL
 +`
++
 +func (q *Queries) CountFollowersForOrg(ctx context.Context, db DBTX, followeeOrgID pgtype.Int8) (int64, error) {
 +	row := db.QueryRow(ctx, countFollowersForOrg, followeeOrgID)
 +	var count int64
 +	err := row.Scan(&count)
 +	return count, err
 +}
++
 +const countFollowersForUser = `-- name: CountFollowersForUser :one
 +SELECT COUNT(*) FROM follows f
 +JOIN users u ON u.id = f.follower_user_id
 +WHERE f.followee_user_id = $1
 +  AND u.suspended_at IS NULL
 +  AND u.deleted_at IS NULL
 +`
++
 +func (q *Queries) CountFollowersForUser(ctx context.Context, db DBTX, followeeUserID pgtype.Int8) (int64, error) {
 +	row := db.QueryRow(ctx, countFollowersForUser, followeeUserID)
 +	var count int64
 +	err := row.Scan(&count)
 +	return count, err
 +}
++
 +const countFollowingForUser = `-- name: CountFollowingForUser :one
 +SELECT COUNT(*) FROM follows f
 +LEFT JOIN users u ON u.id = f.followee_user_id
 +LEFT JOIN orgs o ON o.id = f.followee_org_id
 +WHERE f.follower_user_id = $1
 +  AND (f.followee_user_id IS NULL OR (u.suspended_at IS NULL AND u.deleted_at IS NULL))
 +  AND (f.followee_org_id IS NULL OR (o.suspended_at IS NULL AND o.deleted_at IS NULL))
 +`
++
 +func (q *Queries) CountFollowingForUser(ctx context.Context, db DBTX, followerUserID int64) (int64, error) {
 +	row := db.QueryRow(ctx, countFollowingForUser, followerUserID)
 +	var count int64
 +	err := row.Scan(&count)
 +	return count, err
 +}
++
 +const followOrg = `-- name: FollowOrg :one
 +WITH inserted AS (
 +    INSERT INTO follows (follower_user_id, followee_org_id)
 +    VALUES ($1, $2)
 +    ON CONFLICT (follower_user_id, followee_org_id)
 +        WHERE followee_org_id IS NOT NULL
 +    DO NOTHING
 +    RETURNING 1
 +)
 +SELECT EXISTS (SELECT 1 FROM inserted) AS inserted
 +`
++
 +type FollowOrgParams struct {
 +	FollowerUserID int64
 +	FolloweeOrgID  pgtype.Int8
 +}
++
 +func (q *Queries) FollowOrg(ctx context.Context, db DBTX, arg FollowOrgParams) (bool, error) {
 +	row := db.QueryRow(ctx, followOrg, arg.FollowerUserID, arg.FolloweeOrgID)
 +	var inserted bool
 +	err := row.Scan(&inserted)
 +	return inserted, err
 +}
++
 +const followUser = `-- name: FollowUser :one
++
 +WITH inserted AS (
 +    INSERT INTO follows (follower_user_id, followee_user_id)
 +    VALUES ($1, $2)
 +    ON CONFLICT (follower_user_id, followee_user_id)
 +        WHERE followee_user_id IS NOT NULL
 +    DO NOTHING
 +    RETURNING 1
 +)
 +SELECT EXISTS (SELECT 1 FROM inserted) AS inserted
 +`
++
 +type FollowUserParams struct {
 +	FollowerUserID int64
 +	FolloweeUserID pgtype.Int8
 +}
++
 +// ─── follows ───────────────────────────────────────────────────────
 +func (q *Queries) FollowUser(ctx context.Context, db DBTX, arg FollowUserParams) (bool, error) {
 +	row := db.QueryRow(ctx, followUser, arg.FollowerUserID, arg.FolloweeUserID)
 +	var inserted bool
 +	err := row.Scan(&inserted)
 +	return inserted, err
 +}
++
 +const isFollowingOrg = `-- name: IsFollowingOrg :one
 +SELECT EXISTS (
 +    SELECT 1 FROM follows
 +    WHERE follower_user_id = $1
 +      AND followee_org_id = $2
 +) AS following
 +`
++
 +type IsFollowingOrgParams struct {
 +	FollowerUserID int64
 +	FolloweeOrgID  pgtype.Int8
 +}
++
 +func (q *Queries) IsFollowingOrg(ctx context.Context, db DBTX, arg IsFollowingOrgParams) (bool, error) {
 +	row := db.QueryRow(ctx, isFollowingOrg, arg.FollowerUserID, arg.FolloweeOrgID)
 +	var following bool
 +	err := row.Scan(&following)
 +	return following, err
 +}
++
 +const isFollowingUser = `-- name: IsFollowingUser :one
 +SELECT EXISTS (
 +    SELECT 1 FROM follows
 +    WHERE follower_user_id = $1
 +      AND followee_user_id = $2
 +) AS following
 +`
++
 +type IsFollowingUserParams struct {
 +	FollowerUserID int64
 +	FolloweeUserID pgtype.Int8
 +}
++
 +func (q *Queries) IsFollowingUser(ctx context.Context, db DBTX, arg IsFollowingUserParams) (bool, error) {
 +	row := db.QueryRow(ctx, isFollowingUser, arg.FollowerUserID, arg.FolloweeUserID)
 +	var following bool
 +	err := row.Scan(&following)
 +	return following, err
 +}
++
 +const listFollowersForOrg = `-- name: ListFollowersForOrg :many
 +SELECT f.follower_user_id AS user_id, f.followed_at, u.username, u.display_name
 +FROM follows f
 +JOIN users u ON u.id = f.follower_user_id
 +WHERE f.followee_org_id = $1
 +  AND u.suspended_at IS NULL
 +  AND u.deleted_at IS NULL
 +ORDER BY f.followed_at DESC, f.id DESC
 +LIMIT $2 OFFSET $3
 +`
++
 +type ListFollowersForOrgParams struct {
 +	FolloweeOrgID pgtype.Int8
 +	Limit         int32
 +	Offset        int32
 +}
++
 +type ListFollowersForOrgRow struct {
 +	UserID      int64
 +	FollowedAt  pgtype.Timestamptz
 +	Username    string
 +	DisplayName string
 +}
++
 +func (q *Queries) ListFollowersForOrg(ctx context.Context, db DBTX, arg ListFollowersForOrgParams) ([]ListFollowersForOrgRow, error) {
 +	rows, err := db.Query(ctx, listFollowersForOrg, arg.FolloweeOrgID, arg.Limit, arg.Offset)
 +	if err != nil {
 +		return nil, err
 +	}
 +	defer rows.Close()
 +	items := []ListFollowersForOrgRow{}
 +	for rows.Next() {
 +		var i ListFollowersForOrgRow
 +		if err := rows.Scan(
 +			&i.UserID,
 +			&i.FollowedAt,
 +			&i.Username,
 +			&i.DisplayName,
 +		); err != nil {
 +			return nil, err
 +		}
 +		items = append(items, i)
 +	}
 +	if err := rows.Err(); err != nil {
 +		return nil, err
 +	}
 +	return items, nil
 +}
++
 +const listFollowersForUser = `-- name: ListFollowersForUser :many
 +SELECT f.follower_user_id AS user_id, f.followed_at, u.username, u.display_name
 +FROM follows f
 +JOIN users u ON u.id = f.follower_user_id
 +WHERE f.followee_user_id = $1
 +  AND u.suspended_at IS NULL
 +  AND u.deleted_at IS NULL
 +ORDER BY f.followed_at DESC, f.id DESC
 +LIMIT $2 OFFSET $3
 +`
++
 +type ListFollowersForUserParams struct {
 +	FolloweeUserID pgtype.Int8
 +	Limit          int32
 +	Offset         int32
 +}
++
 +type ListFollowersForUserRow struct {
 +	UserID      int64
 +	FollowedAt  pgtype.Timestamptz
 +	Username    string
 +	DisplayName string
 +}
++
 +func (q *Queries) ListFollowersForUser(ctx context.Context, db DBTX, arg ListFollowersForUserParams) ([]ListFollowersForUserRow, error) {
 +	rows, err := db.Query(ctx, listFollowersForUser, arg.FolloweeUserID, arg.Limit, arg.Offset)
 +	if err != nil {
 +		return nil, err
 +	}
 +	defer rows.Close()
 +	items := []ListFollowersForUserRow{}
 +	for rows.Next() {
 +		var i ListFollowersForUserRow
 +		if err := rows.Scan(
 +			&i.UserID,
 +			&i.FollowedAt,
 +			&i.Username,
 +			&i.DisplayName,
 +		); err != nil {
 +			return nil, err
 +		}
 +		items = append(items, i)
 +	}
 +	if err := rows.Err(); err != nil {
 +		return nil, err
 +	}
 +	return items, nil
 +}
++
 +const listFollowingOrgsForUser = `-- name: ListFollowingOrgsForUser :many
 +SELECT f.followee_org_id AS org_id, f.followed_at, o.slug, o.display_name
 +FROM follows f
 +JOIN orgs o ON o.id = f.followee_org_id
 +WHERE f.follower_user_id = $1
 +  AND o.suspended_at IS NULL
 +  AND o.deleted_at IS NULL
 +ORDER BY f.followed_at DESC, f.id DESC
 +LIMIT $2 OFFSET $3
 +`
++
 +type ListFollowingOrgsForUserParams struct {
 +	FollowerUserID int64
 +	Limit          int32
 +	Offset         int32
 +}
++
 +type ListFollowingOrgsForUserRow struct {
 +	OrgID       pgtype.Int8
 +	FollowedAt  pgtype.Timestamptz
 +	Slug        string
 +	DisplayName string
 +}
++
 +func (q *Queries) ListFollowingOrgsForUser(ctx context.Context, db DBTX, arg ListFollowingOrgsForUserParams) ([]ListFollowingOrgsForUserRow, error) {
 +	rows, err := db.Query(ctx, listFollowingOrgsForUser, arg.FollowerUserID, arg.Limit, arg.Offset)
 +	if err != nil {
 +		return nil, err
 +	}
 +	defer rows.Close()
 +	items := []ListFollowingOrgsForUserRow{}
 +	for rows.Next() {
 +		var i ListFollowingOrgsForUserRow
 +		if err := rows.Scan(
 +			&i.OrgID,
 +			&i.FollowedAt,
 +			&i.Slug,
 +			&i.DisplayName,
 +		); err != nil {
 +			return nil, err
 +		}
 +		items = append(items, i)
 +	}
 +	if err := rows.Err(); err != nil {
 +		return nil, err
 +	}
 +	return items, nil
 +}
++
 +const listFollowingUsersForUser = `-- name: ListFollowingUsersForUser :many
 +SELECT f.followee_user_id AS user_id, f.followed_at, u.username, u.display_name
 +FROM follows f
 +JOIN users u ON u.id = f.followee_user_id
 +WHERE f.follower_user_id = $1
 +  AND u.suspended_at IS NULL
 +  AND u.deleted_at IS NULL
 +ORDER BY f.followed_at DESC, f.id DESC
 +LIMIT $2 OFFSET $3
 +`
++
 +type ListFollowingUsersForUserParams struct {
 +	FollowerUserID int64
 +	Limit          int32
 +	Offset         int32
 +}
++
 +type ListFollowingUsersForUserRow struct {
 +	UserID      pgtype.Int8
 +	FollowedAt  pgtype.Timestamptz
 +	Username    string
 +	DisplayName string
 +}
++
 +func (q *Queries) ListFollowingUsersForUser(ctx context.Context, db DBTX, arg ListFollowingUsersForUserParams) ([]ListFollowingUsersForUserRow, error) {
 +	rows, err := db.Query(ctx, listFollowingUsersForUser, arg.FollowerUserID, arg.Limit, arg.Offset)
 +	if err != nil {
 +		return nil, err
 +	}
 +	defer rows.Close()
 +	items := []ListFollowingUsersForUserRow{}
 +	for rows.Next() {
 +		var i ListFollowingUsersForUserRow
 +		if err := rows.Scan(
 +			&i.UserID,
 +			&i.FollowedAt,
 +			&i.Username,
 +			&i.DisplayName,
 +		); err != nil {
 +			return nil, err
 +		}
 +		items = append(items, i)
 +	}
 +	if err := rows.Err(); err != nil {
 +		return nil, err
 +	}
 +	return items, nil
 +}
++
 +const unfollowOrg = `-- name: UnfollowOrg :execrows
 +DELETE FROM follows
 +WHERE follower_user_id = $1
 +  AND followee_org_id = $2
 +`
++
 +type UnfollowOrgParams struct {
 +	FollowerUserID int64
 +	FolloweeOrgID  pgtype.Int8
 +}
++
 +func (q *Queries) UnfollowOrg(ctx context.Context, db DBTX, arg UnfollowOrgParams) (int64, error) {
 +	result, err := db.Exec(ctx, unfollowOrg, arg.FollowerUserID, arg.FolloweeOrgID)
 +	if err != nil {
 +		return 0, err
 +	}
 +	return result.RowsAffected(), nil
 +}
++
 +const unfollowUser = `-- name: UnfollowUser :execrows
 +DELETE FROM follows
 +WHERE follower_user_id = $1
 +  AND followee_user_id = $2
 +`
++
 +type UnfollowUserParams struct {
 +	FollowerUserID int64
 +	FolloweeUserID pgtype.Int8
 +}
++
 +func (q *Queries) UnfollowUser(ctx context.Context, db DBTX, arg UnfollowUserParams) (int64, error) {
 +	result, err := db.Exec(ctx, unfollowUser, arg.FollowerUserID, arg.FolloweeUserID)
 +	if err != nil {
 +		return 0, err
 +	}
 +	return result.RowsAffected(), nil
 +}

internal/social/sqlc/models.gomodified

  	return string(ns.TransferStatus), nil
+ }
 +type TrendingKind string
++
 +const (
 +	TrendingKindRepos TrendingKind = "repos"
 +	TrendingKindUsers TrendingKind = "users"
 +)
++
 +func (e *TrendingKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = TrendingKind(s)
 +	case string:
 +		*e = TrendingKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for TrendingKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullTrendingKind struct {
 +	TrendingKind TrendingKind
 +	Valid        bool // Valid is true if TrendingKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullTrendingKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.TrendingKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.TrendingKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullTrendingKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.TrendingKind), nil
 +}
++
 +type TrendingScope string
++
 +const (
 +	TrendingScopeDay   TrendingScope = "day"
 +	TrendingScopeWeek  TrendingScope = "week"
 +	TrendingScopeMonth TrendingScope = "month"
 +)
++
 +func (e *TrendingScope) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = TrendingScope(s)
 +	case string:
 +		*e = TrendingScope(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for TrendingScope: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullTrendingScope struct {
 +	TrendingScope TrendingScope
 +	Valid         bool // Valid is true if TrendingScope is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullTrendingScope) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.TrendingScope, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.TrendingScope.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullTrendingScope) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.TrendingScope), nil
 +}
++
  type WatchLevel string
  const (
  	CreatedAt   pgtype.Timestamptz
+ }
 +type Follow struct {
 +	ID             int64
 +	FollowerUserID int64
 +	FolloweeUserID pgtype.Int8
 +	FolloweeOrgID  pgtype.Int8
 +	FollowedAt     pgtype.Timestamptz
 +}
++
  type Issue struct {
  	ID                int64
  	RepoID            int64
  	DeliveredAt     pgtype.Timestamptz
+ }
 +type TrendingSnapshot struct {
 +	ID         int64
 +	Scope      TrendingScope
 +	Kind       TrendingKind
 +	CapturedAt pgtype.Timestamptz
 +	Payload    []byte
 +}
++
  type User struct {
  	ID                int64
  	Username          string

internal/social/sqlc/querier.gomodified

  import (
  	"context"
++
 +	"github.com/jackc/pgx/v5/pgtype"
+ )
  type Querier interface {
 +	CountFollowersForOrg(ctx context.Context, db DBTX, followeeOrgID pgtype.Int8) (int64, error)
 +	CountFollowersForUser(ctx context.Context, db DBTX, followeeUserID pgtype.Int8) (int64, error)
 +	CountFollowingForUser(ctx context.Context, db DBTX, followerUserID int64) (int64, error)
  	CountStargazersForRepo(ctx context.Context, db DBTX, repoID int64) (int64, error)
  	CountStarsForUser(ctx context.Context, db DBTX, userID int64) (int64, error)
  	CountWatchersForRepo(ctx context.Context, db DBTX, repoID int64) (int64, error)
  	// implicit `participating` default). Trigger drops the watcher_count
  	// when the prior level wasn't 'ignore'.
  	DeleteWatch(ctx context.Context, db DBTX, arg DeleteWatchParams) error
 +	FollowOrg(ctx context.Context, db DBTX, arg FollowOrgParams) (bool, error)
 +	// ─── follows ───────────────────────────────────────────────────────
 +	FollowUser(ctx context.Context, db DBTX, arg FollowUserParams) (bool, error)
  	// ─── watches ───────────────────────────────────────────────────────
  	GetWatch(ctx context.Context, db DBTX, arg GetWatchParams) (Watch, error)
  	HasStar(ctx context.Context, db DBTX, arg HasStarParams) (bool, error)
  	// already-starred repo doesn't double-increment the count (the
  	// AFTER INSERT trigger only fires on actual insert).
  	InsertStar(ctx context.Context, db DBTX, arg InsertStarParams) error
 +	InsertTrendingSnapshot(ctx context.Context, db DBTX, arg InsertTrendingSnapshotParams) (TrendingSnapshot, error)
  	// Auto-watch flow: only insert if the user doesn't already have a
  	// preference. ON CONFLICT DO NOTHING preserves the user's chosen
  	// level when the trigger fires repeatedly.
  	InsertWatchIfAbsent(ctx context.Context, db DBTX, arg InsertWatchIfAbsentParams) error
 +	IsFollowingOrg(ctx context.Context, db DBTX, arg IsFollowingOrgParams) (bool, error)
 +	IsFollowingUser(ctx context.Context, db DBTX, arg IsFollowingUserParams) (bool, error)
 +	LatestTrendingSnapshot(ctx context.Context, db DBTX, arg LatestTrendingSnapshotParams) (TrendingSnapshot, error)
 +	// ─── activity feed / trending ─────────────────────────────────────
 +	ListDashboardFeedEvents(ctx context.Context, db DBTX, arg ListDashboardFeedEventsParams) ([]ListDashboardFeedEventsRow, error)
 +	ListDashboardReposForUser(ctx context.Context, db DBTX, arg ListDashboardReposForUserParams) ([]ListDashboardReposForUserRow, error)
  	// Repo-scoped events, recency-sorted. No visibility filter — the
  	// caller has already established read access to the repo.
  	ListEventsForRepo(ctx context.Context, db DBTX, arg ListEventsForRepoParams) ([]DomainEvent, error)
 +	ListFollowersForOrg(ctx context.Context, db DBTX, arg ListFollowersForOrgParams) ([]ListFollowersForOrgRow, error)
 +	ListFollowersForUser(ctx context.Context, db DBTX, arg ListFollowersForUserParams) ([]ListFollowersForUserRow, error)
 +	ListFollowingOrgsForUser(ctx context.Context, db DBTX, arg ListFollowingOrgsForUserParams) ([]ListFollowingOrgsForUserRow, error)
 +	ListFollowingUsersForUser(ctx context.Context, db DBTX, arg ListFollowingUsersForUserParams) ([]ListFollowingUsersForUserRow, error)
  	// Public activity-feed slice for a user's profile. Returns only
  	// public rows, recency-sorted. The handler additionally filters by
  	// repo visibility against the viewer (a public event row on a repo
  	// whose visibility flipped to private must not leak).
  	ListPublicEventsForActor(ctx context.Context, db DBTX, arg ListPublicEventsForActorParams) ([]DomainEvent, error)
 +	ListPublicFeedEvents(ctx context.Context, db DBTX, arg ListPublicFeedEventsParams) ([]ListPublicFeedEventsRow, error)
  	// S29 notification-routing consumer: for fan-out, get every watcher
  	// of a repo at the requested level (e.g. `level='all'` for new-issue
  	// events). This is the cross-package read; expose the user_ids
  	// user starred and lets the handler decide what to render. Sort axis
  	// is the spec's day-1 lean: most-recently-starred first.
  	ListStarsForUser(ctx context.Context, db DBTX, arg ListStarsForUserParams) ([]ListStarsForUserRow, error)
 +	ListTrendingRepos(ctx context.Context, db DBTX, arg ListTrendingReposParams) ([]ListTrendingReposRow, error)
 +	ListTrendingUsers(ctx context.Context, db DBTX, arg ListTrendingUsersParams) ([]ListTrendingUsersRow, error)
  	// Watchers list. `level <> 'ignore'` excludes users who have actively
  	// muted the repo. Excludes suspended users from public surfaces.
  	ListWatchersForRepo(ctx context.Context, db DBTX, arg ListWatchersForRepoParams) ([]ListWatchersForRepoRow, error)
 +	UnfollowOrg(ctx context.Context, db DBTX, arg UnfollowOrgParams) (int64, error)
 +	UnfollowUser(ctx context.Context, db DBTX, arg UnfollowUserParams) (int64, error)
  	// Always-write upsert. The AFTER trigger handles the watcher_count
  	// delta on transition into / out of `ignore`.
  	UpsertWatch(ctx context.Context, db DBTX, arg UpsertWatchParams) error

internal/users/sqlc/models.gomodified

  	return string(ns.TransferStatus), nil
+ }
 +type TrendingKind string
++
 +const (
 +	TrendingKindRepos TrendingKind = "repos"
 +	TrendingKindUsers TrendingKind = "users"
 +)
++
 +func (e *TrendingKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = TrendingKind(s)
 +	case string:
 +		*e = TrendingKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for TrendingKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullTrendingKind struct {
 +	TrendingKind TrendingKind
 +	Valid        bool // Valid is true if TrendingKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullTrendingKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.TrendingKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.TrendingKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullTrendingKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.TrendingKind), nil
 +}
++
 +type TrendingScope string
++
 +const (
 +	TrendingScopeDay   TrendingScope = "day"
 +	TrendingScopeWeek  TrendingScope = "week"
 +	TrendingScopeMonth TrendingScope = "month"
 +)
++
 +func (e *TrendingScope) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = TrendingScope(s)
 +	case string:
 +		*e = TrendingScope(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for TrendingScope: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullTrendingScope struct {
 +	TrendingScope TrendingScope
 +	Valid         bool // Valid is true if TrendingScope is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullTrendingScope) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.TrendingScope, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.TrendingScope.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullTrendingScope) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.TrendingScope), nil
 +}
++
  type WatchLevel string
  const (
  	CreatedAt   pgtype.Timestamptz
+ }
 +type Follow struct {
 +	ID             int64
 +	FollowerUserID int64
 +	FolloweeUserID pgtype.Int8
 +	FolloweeOrgID  pgtype.Int8
 +	FollowedAt     pgtype.Timestamptz
 +}
++
  type Issue struct {
  	ID                int64
  	RepoID            int64
  	DeliveredAt     pgtype.Timestamptz
+ }
 +type TrendingSnapshot struct {
 +	ID         int64
 +	Scope      TrendingScope
 +	Kind       TrendingKind
 +	CapturedAt pgtype.Timestamptz
 +	Payload    []byte
 +}
++
  type User struct {
  	ID                int64
  	Username          string

internal/webhook/sqlc/models.gomodified

  	return string(ns.TransferStatus), nil
+ }
 +type TrendingKind string
++
 +const (
 +	TrendingKindRepos TrendingKind = "repos"
 +	TrendingKindUsers TrendingKind = "users"
 +)
++
 +func (e *TrendingKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = TrendingKind(s)
 +	case string:
 +		*e = TrendingKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for TrendingKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullTrendingKind struct {
 +	TrendingKind TrendingKind
 +	Valid        bool // Valid is true if TrendingKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullTrendingKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.TrendingKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.TrendingKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullTrendingKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.TrendingKind), nil
 +}
++
 +type TrendingScope string
++
 +const (
 +	TrendingScopeDay   TrendingScope = "day"
 +	TrendingScopeWeek  TrendingScope = "week"
 +	TrendingScopeMonth TrendingScope = "month"
 +)
++
 +func (e *TrendingScope) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = TrendingScope(s)
 +	case string:
 +		*e = TrendingScope(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for TrendingScope: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullTrendingScope struct {
 +	TrendingScope TrendingScope
 +	Valid         bool // Valid is true if TrendingScope is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullTrendingScope) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.TrendingScope, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.TrendingScope.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullTrendingScope) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.TrendingScope), nil
 +}
++
  type WatchLevel string
  const (
  	CreatedAt   pgtype.Timestamptz
+ }
 +type Follow struct {
 +	ID             int64
 +	FollowerUserID int64
 +	FolloweeUserID pgtype.Int8
 +	FolloweeOrgID  pgtype.Int8
 +	FollowedAt     pgtype.Timestamptz
 +}
++
  type Issue struct {
  	ID                int64
  	RepoID            int64
  	DeliveredAt     pgtype.Timestamptz
+ }
 +type TrendingSnapshot struct {
 +	ID         int64
 +	Scope      TrendingScope
 +	Kind       TrendingKind
 +	CapturedAt pgtype.Timestamptz
 +	Payload    []byte
 +}
++
  type User struct {
  	ID                int64
  	Username          string

internal/worker/sqlc/models.gomodified

  	return string(ns.TransferStatus), nil
+ }
 +type TrendingKind string
++
 +const (
 +	TrendingKindRepos TrendingKind = "repos"
 +	TrendingKindUsers TrendingKind = "users"
 +)
++
 +func (e *TrendingKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = TrendingKind(s)
 +	case string:
 +		*e = TrendingKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for TrendingKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullTrendingKind struct {
 +	TrendingKind TrendingKind
 +	Valid        bool // Valid is true if TrendingKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullTrendingKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.TrendingKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.TrendingKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullTrendingKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.TrendingKind), nil
 +}
++
 +type TrendingScope string
++
 +const (
 +	TrendingScopeDay   TrendingScope = "day"
 +	TrendingScopeWeek  TrendingScope = "week"
 +	TrendingScopeMonth TrendingScope = "month"
 +)
++
 +func (e *TrendingScope) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = TrendingScope(s)
 +	case string:
 +		*e = TrendingScope(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for TrendingScope: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullTrendingScope struct {
 +	TrendingScope TrendingScope
 +	Valid         bool // Valid is true if TrendingScope is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullTrendingScope) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.TrendingScope, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.TrendingScope.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullTrendingScope) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.TrendingScope), nil
 +}
++
  type WatchLevel string
  const (
  	CreatedAt   pgtype.Timestamptz
+ }
 +type Follow struct {
 +	ID             int64
 +	FollowerUserID int64
 +	FolloweeUserID pgtype.Int8
 +	FolloweeOrgID  pgtype.Int8
 +	FollowedAt     pgtype.Timestamptz
 +}
++
  type Issue struct {
  	ID                int64
  	RepoID            int64
  	DeliveredAt     pgtype.Timestamptz
+ }
 +type TrendingSnapshot struct {
 +	ID         int64
 +	Scope      TrendingScope
 +	Kind       TrendingKind
 +	CapturedAt pgtype.Timestamptz
 +	Payload    []byte
 +}
++
  type User struct {
  	ID                int64
  	Username          string

  // Errors surfaced to handlers.
  var (
  	ErrNotLoggedIn       = errors.New("social: login required")
 +	ErrCannotFollowSelf  = errors.New("social: cannot follow yourself")
  	ErrInvalidWatchLevel = errors.New("social: watch level must be all, participating, or ignore")
  	ErrStarRateLimit     = errors.New("social: star/unstar rate limit exceeded")
 +	ErrFollowRateLimit   = errors.New("social: follow/unfollow rate limit exceeded")
+ )