feat(feed.session): add app.yoten.feed.session lexicon and logic to parse and save from db and jetstream

api/yoten/actorprofile.go

···
 // schema: app.yoten.actor.profile
 
 import (
-    "github.com/bluesky-social/indigo/lex/util"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 func init() {
-    util.RegisterType("app.yoten.actor.profile", &ActorProfile{})
+	util.RegisterType("app.yoten.actor.profile", &ActorProfile{})
 } //
 // RECORDTYPE: ActorProfile
 type ActorProfile struct {

api/yoten/cbor_gen.go

···
 
 	return nil
 }
+func (t *FeedSession) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+
+	cw := cbg.NewCborWriter(w)
+	fieldCount := 7
+
+	if t.Description == nil {
+		fieldCount--
+	}
+
+	if t.Duration == nil {
+		fieldCount--
+	}
+
+	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
+		return err
+	}
+
+	// t.Date (string) (string)
+	if len("date") > 1000000 {
+		return xerrors.Errorf("Value in field \"date\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("date"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("date")); err != nil {
+		return err
+	}
+
+	if len(t.Date) > 1000000 {
+		return xerrors.Errorf("Value in field t.Date was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Date))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string(t.Date)); err != nil {
+		return err
+	}
+
+	// t.LexiconTypeID (string) (string)
+	if len("$type") > 1000000 {
+		return xerrors.Errorf("Value in field \"$type\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("$type")); err != nil {
+		return err
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("app.yoten.feed.session"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("app.yoten.feed.session")); err != nil {
+		return err
+	}
+
+	// t.Duration (string) (string)
+	if t.Duration != nil {
+
+		if len("duration") > 1000000 {
+			return xerrors.Errorf("Value in field \"duration\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("duration"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("duration")); err != nil {
+			return err
+		}
+
+		if t.Duration == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if len(*t.Duration) > 1000000 {
+				return xerrors.Errorf("Value in field t.Duration was too long")
+			}
+
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Duration))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(*t.Duration)); err != nil {
+				return err
+			}
+		}
+	}
+
+	// t.CreatedAt (string) (string)
+	if len("createdAt") > 1000000 {
+		return xerrors.Errorf("Value in field \"createdAt\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("createdAt")); err != nil {
+		return err
+	}
+
+	if len(t.CreatedAt) > 1000000 {
+		return xerrors.Errorf("Value in field t.CreatedAt was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
+		return err
+	}
+
+	// t.Description (string) (string)
+	if t.Description != nil {
+
+		if len("description") > 1000000 {
+			return xerrors.Errorf("Value in field \"description\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("description")); err != nil {
+			return err
+		}
+
+		if t.Description == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if len(*t.Description) > 1000000 {
+				return xerrors.Errorf("Value in field t.Description was too long")
+			}
+
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(*t.Description)); err != nil {
+				return err
+			}
+		}
+	}
+
+	// t.ActivityName (string) (string)
+	if len("activityName") > 1000000 {
+		return xerrors.Errorf("Value in field \"activityName\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("activityName"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("activityName")); err != nil {
+		return err
+	}
+
+	if len(t.ActivityName) > 1000000 {
+		return xerrors.Errorf("Value in field t.ActivityName was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.ActivityName))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string(t.ActivityName)); err != nil {
+		return err
+	}
+
+	// t.LanguageCode (string) (string)
+	if len("languageCode") > 1000000 {
+		return xerrors.Errorf("Value in field \"languageCode\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("languageCode"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("languageCode")); err != nil {
+		return err
+	}
+
+	if len(t.LanguageCode) > 1000000 {
+		return xerrors.Errorf("Value in field t.LanguageCode was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.LanguageCode))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string(t.LanguageCode)); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (t *FeedSession) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = FeedSession{}
+
+	cr := cbg.NewCborReader(r)
+
+	maj, extra, err := cr.ReadHeader()
+	if err != nil {
+		return err
+	}
+	defer func() {
+		if err == io.EOF {
+			err = io.ErrUnexpectedEOF
+		}
+	}()
+
+	if maj != cbg.MajMap {
+		return fmt.Errorf("cbor input should be of type map")
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("FeedSession: map struct too large (%d)", extra)
+	}
+
+	n := extra
+
+	nameBuf := make([]byte, 12)
+	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
+
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
+				return err
+			}
+			continue
+		}
+
+		switch string(nameBuf[:nameLen]) {
+		// t.Date (string) (string)
+		case "date":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.Date = string(sval)
+			}
+			// t.LexiconTypeID (string) (string)
+		case "$type":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.LexiconTypeID = string(sval)
+			}
+			// t.Duration (string) (string)
+		case "duration":
+
+			{
+				b, err := cr.ReadByte()
+				if err != nil {
+					return err
+				}
+				if b != cbg.CborNull[0] {
+					if err := cr.UnreadByte(); err != nil {
+						return err
+					}
+
+					sval, err := cbg.ReadStringWithMax(cr, 1000000)
+					if err != nil {
+						return err
+					}
+
+					t.Duration = (*string)(&sval)
+				}
+			}
+			// t.CreatedAt (string) (string)
+		case "createdAt":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.CreatedAt = string(sval)
+			}
+			// t.Description (string) (string)
+		case "description":
+
+			{
+				b, err := cr.ReadByte()
+				if err != nil {
+					return err
+				}
+				if b != cbg.CborNull[0] {
+					if err := cr.UnreadByte(); err != nil {
+						return err
+					}
+
+					sval, err := cbg.ReadStringWithMax(cr, 1000000)
+					if err != nil {
+						return err
+					}
+
+					t.Description = (*string)(&sval)
+				}
+			}
+			// t.ActivityName (string) (string)
+		case "activityName":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.ActivityName = string(sval)
+			}
+			// t.LanguageCode (string) (string)
+		case "languageCode":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.LanguageCode = string(sval)
+			}
+
+		default:
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}

api/yoten/feedsession.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+package yoten
+
+// schema: app.yoten.feed.session
+
+import (
+	"github.com/bluesky-social/indigo/lex/util"
+)
+
+func init() {
+	util.RegisterType("app.yoten.feed.session", &FeedSession{})
+} //
+// RECORDTYPE: FeedSession
+type FeedSession struct {
+	LexiconTypeID string `json:"$type,const=app.yoten.feed.session" cborgen:"$type,const=app.yoten.feed.session"`
+	// activityName: A key used to lookup activity type details
+	ActivityName string `json:"activityName" cborgen:"activityName"`
+	CreatedAt    string `json:"createdAt" cborgen:"createdAt"`
+	Date         string `json:"date" cborgen:"date"`
+	// description: Free-form description for the study session.
+	Description *string `json:"description,omitempty" cborgen:"description,omitempty"`
+	Duration    *string `json:"duration,omitempty" cborgen:"duration,omitempty"`
+	// languageCode: An ISO 639-1 two-letter language code (e.g., 'en', 'es', 'ko').
+	LanguageCode string `json:"languageCode" cborgen:"languageCode"`
+}

cmd/gen.go

···
 
 	"github.com/bluesky-social/indigo/mst"
 	cbg "github.com/whyrusleeping/cbor-gen"
+
 	"yoten.app/api/yoten"
 )
 
···
 
 	yotenTypes := []any{
 		yoten.ActorProfile{},
+		yoten.FeedSession{},
 	}
 
 	for name, rt := range AllLexTypes() {

generate-lexicons.sh

···
+#! /bin/bash
+
+go run github.com/bluesky-social/indigo/cmd/lexgen \
+    --package yoten \
+    --outdir api/yoten \
+    --build-file lexicon-build-config.json \
+    lexicons/
+
+find ./api/yoten -type f -exec sed -i.bak 's/\tutil/\/\/\tutil/' {} +
+find ./api/yoten -type f -exec sed -i.bak -E 's/^(.+)github(.+)//' {} +
+go run ./cmd/gen.go
+
+go run github.com/bluesky-social/indigo/cmd/lexgen \
+    --package yoten \
+    --outdir api/yoten \
+    --build-file lexicon-build-config.json \
+    lexicons/
+
+rm -rf ./api/yoten/*.bak

internal/web/db/db.go

···
             foreign key (did) references profile(did) on delete cascade
         );
 
+        create table if not exists study_session (
+            -- id
+            did text not null,
+            rkey text not null,
+
+            -- data
+            activity_name text not null,
+            description text,
+            duration integer not null,
+            language_code text not null,
+            date text not null,
+            created text not null default (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+
+            -- constraints
+            check (length(language_code) = 2),
+            foreign key (did) references profile(did) on delete cascade
+            primary key (did, rkey)
+        );
+
         create table if not exists _jetstream (
             id integer primary key autoincrement,
             last_time_us integer not null

internal/web/db/study-session.go

···
+package db
+
+import (
+	"database/sql"
+	"fmt"
+	"log"
+	"time"
+)
+
+type StudySessionCategory int
+
+const (
+	Reading StudySessionCategory = iota
+	Listening
+	Watching
+	Speaking
+	Writing
+	Pronunciation
+	Study
+)
+
+type StudySession struct {
+	Did  string
+	Rkey string
+	// 64 characters
+	Description string
+	Activity    Activity
+	Language    Language
+	Duration    time.Duration
+	Date        time.Time
+	CreatedAt   time.Time
+}
+
+type StudySessionFeedItem struct {
+	StudySession
+	ProfileDisplayName string
+}
+
+type Activity struct {
+	Name        string
+	Description string
+	Categories  []StudySessionCategory
+}
+
+var Activities = map[string]Activity{
+	"Vocab Study":     {Name: "Vocab Study", Description: "Memorizing and reviewing new words and their meanings.", Categories: []StudySessionCategory{Study, Reading}},
+	"Grammar Study":   {Name: "Grammar Study", Description: "Learning and practicing the structural rules of a language.", Categories: []StudySessionCategory{Study, Reading}},
+	"Sound Study":     {Name: "Sound Study", Description: "Learning to hear and make the specific sounds of the language.", Categories: []StudySessionCategory{Study, Listening}},
+	"Alphabet Study":  {Name: "Alphabet Study", Description: "Learning the written symbols and their corresponding sounds.", Categories: []StudySessionCategory{Study, Reading, Listening}},
+	"Character Study": {Name: "Character Study", Description: "Memorizing the individual characters or symbols of a writing system.", Categories: []StudySessionCategory{Study, Reading}},
+
+	"Freeflow Reading":             {Name: "Freeflow Reading", Description: "Reading text continuously without stopping to look up unknown words.", Categories: []StudySessionCategory{Reading}},
+	"Interactive Reading":          {Name: "Interactive Reading", Description: "Actively looking up and engaging with unknown vocabulary and grammar while reading.", Categories: []StudySessionCategory{Reading}},
+	"Freeflow Reading w/ Audio":    {Name: "Freeflow Reading w/ Audio", Description: "Reading along with an accompanying audio track without interruption.", Categories: []StudySessionCategory{Reading, Listening, Watching}},
+	"Interactive Reading w/ Audio": {Name: "Interactive Reading w/ Audio", Description: "Actively engaging with a text and its accompanying audio, pausing to clarify and learn.", Categories: []StudySessionCategory{Reading, Listening, Watching}},
+	"Reading Aloud":                {Name: "Reading Aloud", Description: "Vocalizing a text to practice pronunciation and fluency.", Categories: []StudySessionCategory{Reading, Pronunciation}},
+	"Sentence Mining":              {Name: "Sentence Mining", Description: "Extracting sentences from native material to create flashcards.", Categories: []StudySessionCategory{Reading, Listening, Watching}},
+	"Interlinear Reading":          {Name: "Interlinear Reading", Description: "Reading a text with a line-by-line translation.", Categories: []StudySessionCategory{Reading}},
+	"Video Games":                  {Name: "Video Games", Description: "Learning the language by playing video games.", Categories: []StudySessionCategory{Reading, Listening}},
+
+	"Freeflow Listening":      {Name: "Freeflow Listening", Description: "Listening to audio content without pausing or looking up unknown words.", Categories: []StudySessionCategory{Listening, Watching}},
+	"Interactive Listening":   {Name: "Interactive Listening", Description: "Actively pausing and re-listening to audio to understand and learn new language elements.", Categories: []StudySessionCategory{Listening, Watching}},
+	"Low-Attention Listening": {Name: "Low-Attention Listening", Description: "Playing the language in the background while you do chores or work.", Categories: []StudySessionCategory{Listening}},
+	"Crosstalking":            {Name: "Crosstalking", Description: "A conversational exchange where each person speaks a different language.", Categories: []StudySessionCategory{Listening, Speaking}},
+	"Chorusing":               {Name: "Chorusing", Description: "Speaking words or sentences at the exact same time as a recording.", Categories: []StudySessionCategory{Listening, Speaking, Pronunciation, Study}},
+	"Shadowing":               {Name: "Shadowing", Description: "Copying a native speaker by repeating what they say almost instantly.", Categories: []StudySessionCategory{Listening, Speaking, Pronunciation, Study}},
+	"Listen Looping":          {Name: "Listen Looping", Description: "Repeatedly listening to a short segment of audio to improve comprehension.", Categories: []StudySessionCategory{Listening, Watching, Study}},
+	"Ear Training":            {Name: "Ear Training", Description: "Focusing on distinguishing between similar sounds in the target language.", Categories: []StudySessionCategory{Listening, Study}},
+	"Transcription":           {Name: "Transcription", Description: "Writing down what you hear from an audio or video recording.", Categories: []StudySessionCategory{Listening, Study}},
+
+	"Speaking with Partner": {Name: "Speaking with Partner", Description: "Practicing conversational skills through live interaction with another person.", Categories: []StudySessionCategory{Speaking}},
+	"Speaking Alone":        {Name: "Speaking Alone", Description: "Practicing speaking through conversations with yourself.", Categories: []StudySessionCategory{Speaking}},
+	"Speaking Analysis":     {Name: "Speaking Analysis", Description: "Recording and reviewing your own speech to identify areas for improvement.", Categories: []StudySessionCategory{Speaking, Study}},
+	"Singing":               {Name: "Singing", Description: "Using music and lyrics to practice pronunciation, rhythm, and intonation.", Categories: []StudySessionCategory{Speaking, Pronunciation}},
+	"Phrase Memorization":   {Name: "Phrase Memorization", Description: "ctively learning and recalling common phrases and expressions.", Categories: []StudySessionCategory{Speaking, Study}},
+
+	"Assisted Writing":     {Name: "Assisted Writing", Description: "Composing text with the help of translation tools, dictionaries, or grammar checkers.", Categories: []StudySessionCategory{Writing}},
+	"Unassisted Writing":   {Name: "Unassisted Writing", Description: "Writing freely without any external aids to test your independent skills.", Categories: []StudySessionCategory{Writing}},
+	"Writing Analysis":     {Name: "Writing Analysis", Description: "Reviewing and correcting your written work, often with feedback from others.", Categories: []StudySessionCategory{Writing, Study}},
+	"Copywork":             {Name: "Copywork", Description: "Manually copying well-structured native texts to internalize grammar and style.", Categories: []StudySessionCategory{Writing, Study}},
+	"Typing Practice":      {Name: "Typing Practice", Description: "Improving your speed and accuracy when typing in the target language's script.", Categories: []StudySessionCategory{Writing, Study}},
+	"Handwriting Practice": {Name: "Handwriting Practice", Description: "Practicing the physical act of writing the characters or script of a language.", Categories: []StudySessionCategory{Writing, Study}},
+
+	"Language App":       {Name: "Language App", Description: "Using a mobile or web application for structured language lessons and exercises.", Categories: []StudySessionCategory{Study}},
+	"Language Class":     {Name: "Language Class", Description: "Attending a formal course with an instructor for guided learning.", Categories: []StudySessionCategory{Study}},
+	"Test Prep":          {Name: "Test Prep", Description: "Specifically studying and practicing for a language proficiency examination.", Categories: []StudySessionCategory{Study}},
+	"Flashcard Creation": {Name: "Flashcard Creation", Description: "Making your own digital or physical flashcards for active recall practice.", Categories: []StudySessionCategory{Study}},
+
+	"Other": {Name: "Other", Description: "Any miscellaneous language learning activity that doesn't fit into the other categories.", Categories: []StudySessionCategory{}},
+}
+
+func UpsertStudySession(tx *sql.Tx, session *StudySession, rkey string) error {
+	defer tx.Rollback()
+
+	_, err := tx.Exec(
+		`insert or replace into study_session (
+			did,
+            rkey,
+			activity_name,
+			description,
+			duration,
+            language_code,
+			date
+		)
+		values (?, ?, ?, ?, ?, ?, ?)`,
+		session.Did,
+		rkey,
+		session.Activity.Name,
+		session.Description,
+		session.Duration.Seconds(),
+		session.Language.Code,
+		session.Date.Format(time.RFC3339),
+	)
+	if err != nil {
+		log.Println("failed to insert or update study session", err)
+		return err
+	}
+
+	return tx.Commit()
+}
+
+func GetStudySessionFeed(e Execer, limit, offset int) ([]*StudySessionFeedItem, error) {
+	query := `
+        select
+            ss.did, ss.rkey, ss.activity_name, ss.description, ss.duration, ss.language_code, ss.date, ss.created,
+            p.display_name
+        from study_session as ss
+        join profile as p on ss.did = p.did
+        order by ss.date desc
+        limit ? offset ?`
+
+	rows, err := e.Query(query, limit, offset)
+	if err != nil {
+		return nil, fmt.Errorf("failed to query for activity logs: %w", err)
+	}
+	defer rows.Close()
+
+	var feedItems []*StudySessionFeedItem
+
+	for rows.Next() {
+		var language Language
+		var activity Activity
+		var dateStr string
+		var duration int64
+		var session StudySession
+		var item StudySessionFeedItem
+		var createdAtStr string
+
+		err := rows.Scan(
+			&session.Did, &session.Rkey, &activity.Name,
+			&session.Description, &duration, &language.Code, &dateStr,
+			&createdAtStr, &item.ProfileDisplayName,
+		)
+		if err != nil {
+			return nil, fmt.Errorf("failed to scan activity log row: %w", err)
+		}
+
+		date, err := time.Parse(time.RFC3339, dateStr)
+		if err != nil {
+			return nil, fmt.Errorf("failed to parse date string '%s': %w", dateStr, err)
+		}
+		session.Date = date
+		session.Duration = time.Duration(duration) * time.Second
+
+		createdAt, err := time.Parse(time.RFC3339, createdAtStr)
+		if err != nil {
+			return nil, fmt.Errorf("failed to parse createdAt string '%s': %w", createdAtStr, err)
+		}
+		session.CreatedAt = createdAt
+
+		language, ok := Languages[language.Code]
+		if !ok {
+			return nil, fmt.Errorf("failed to find language '%s'", language.Code)
+		}
+		session.Language = language
+
+		activity, ok = Activities[activity.Name]
+		if !ok {
+			return nil, fmt.Errorf("failed to find activity '%s'", activity.Name)
+		}
+		session.Activity = activity
+
+		item.StudySession = session
+
+		feedItems = append(feedItems, &item)
+	}
+
+	if err = rows.Err(); err != nil {
+		return nil, fmt.Errorf("failed to iterate activity log rows: %w", err)
+	}
+
+	return feedItems, nil
+}
+
+func GetStudySessionLogs(e Execer, did string, limit, offset int) ([]*StudySession, error) {
+	query := `
+		rkey, activity_name, description, duration, date
+		from study_session
+		where profile_did = ?
+		order by date desc
+		limit ? offset ?`
+
+	rows, err := e.Query(query, did, limit, offset)
+	if err != nil {
+		return nil, fmt.Errorf("failed to query for activity logs: %w", err)
+	}
+	defer rows.Close()
+
+	var activityLogs []*StudySession
+
+	for rows.Next() {
+		var language Language
+		var activity Activity
+		var dateStr string
+		var duration int64
+		var session StudySession
+
+		err := rows.Scan(&session.Rkey, &activity.Name, &session.Description, &duration, &language.Code, &dateStr)
+		if err != nil {
+			return nil, fmt.Errorf("failed to scan activity log row: %w", err)
+		}
+
+		parsedTime, err := time.Parse(time.RFC3339, dateStr)
+		if err != nil {
+			return nil, fmt.Errorf("failed to parse date string '%s': %w", dateStr, err)
+		}
+		session.Date = parsedTime
+		session.Duration = time.Duration(duration) * time.Second
+
+		language, ok := Languages[language.Code]
+		if !ok {
+			return nil, fmt.Errorf("failed to find language '%s'", language.Code)
+		}
+		session.Language = language
+
+		activity, ok = Activities[activity.Name]
+		if !ok {
+			return nil, fmt.Errorf("failed to find activity '%s'", activity.Name)
+		}
+		session.Activity = activity
+
+		activityLogs = append(activityLogs, &session)
+	}
+
+	if err = rows.Err(); err != nil {
+		return nil, fmt.Errorf("failed to iterate activity log rows: %w", err)
+	}
+
+	return activityLogs, nil
+}
+
+func DeleteStudySessionByRkey(e Execer, did string, rkey string) error {
+	_, err := e.Exec(`delete from study_session where did = ? and rkey = ?`, did, rkey)
+	return err
+}
+
+func GetStudySessionByRkey(e Execer, did string, rkey string) (*StudySession, error) {
+	var language Language
+	var activity Activity
+	var dateStr string
+	var createdStr string
+	var duration int64
+
+	var session StudySession
+	session.Did = did
+	session.Rkey = rkey
+
+	err := e.QueryRow(
+		`select activity_name, description, duration, language_code, date, created from study_session where did = ? and rkey = ?`,
+		did, rkey,
+	).Scan(&activity.Name, &session.Description, &duration, &language.Code, &dateStr, &createdStr)
+	if err != nil {
+		if err == sql.ErrNoRows {
+			return nil, fmt.Errorf("study session does not exist")
+		}
+		return nil, err
+	}
+
+	date, err := time.Parse(time.RFC3339, dateStr)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse date string '%s': %w", dateStr, err)
+	}
+	session.Date = date
+	session.Duration = time.Duration(duration) * time.Second
+	created, err := time.Parse(time.RFC3339, createdStr)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse created string '%s': %w", dateStr, err)
+	}
+	session.CreatedAt = created
+
+	language, ok := Languages[language.Code]
+	if !ok {
+		return nil, fmt.Errorf("failed to find language '%s'", language.Code)
+	}
+	session.Language = language
+
+	activity, ok = Activities[activity.Name]
+	if !ok {
+		return nil, fmt.Errorf("failed to find activity '%s'", activity.Name)
+	}
+	session.Activity = activity
+
+	return &session, nil
+}

internal/web/ingester/ingester.go

···
 	"encoding/json"
 	"fmt"
 	"log"
+	"strconv"
+	"time"
 
 	"github.com/bluesky-social/jetstream/pkg/models"
 	"yoten.app/api/yoten"
···
 		switch e.Commit.Collection {
 		case "app.yoten.actor.profile":
 			ingestProfile(&d, e)
+		case "app.yoten.feed.session":
+			ingestStudySession(&d, e)
 		}
 
 		return err
···
 
 	return nil
 }
+
+func ingestStudySession(d *db.DbWrapper, e *models.Event) error {
+	did := e.Did
+	var err error
+
+	switch e.Commit.Operation {
+	case models.CommitOperationCreate, models.CommitOperationUpdate:
+		raw := json.RawMessage(e.Commit.Record)
+		record := yoten.FeedSession{}
+		err = json.Unmarshal(raw, &record)
+		if err != nil {
+			log.Printf("invalid record: %s", err)
+			return err
+		}
+
+		description := ""
+		if record.Description != nil {
+			description = *record.Description
+		}
+
+		date, err := time.Parse(time.RFC3339, record.Date)
+		if err != nil {
+			log.Printf("invalid record: %s", err)
+			return err
+		}
+
+		languageCode := record.LanguageCode
+		language, ok := db.Languages[db.LanguageCode(languageCode)]
+		if !ok {
+			return fmt.Errorf("failed to find language '%s'", languageCode)
+		}
+
+		activityName := record.ActivityName
+		activity, ok := db.Activities[activityName]
+		if !ok {
+			return fmt.Errorf("failed to find activity '%s'", activity.Name)
+		}
+
+		var duration int64 = 0
+		if record.Duration != nil {
+			duration, err = strconv.ParseInt(*record.Duration, 10, 64)
+			if err != nil {
+				log.Printf("invalid record: %s", err)
+				return err
+			}
+		}
+
+		session := db.StudySession{
+			Did:         did,
+			Rkey:        e.Commit.RKey,
+			Description: description,
+			Activity:    activity,
+			Language:    language,
+			Duration:    time.Duration(duration) * time.Second,
+			Date:        date,
+		}
+
+		ddb, ok := d.Execer.(*db.DB)
+		if !ok {
+			return fmt.Errorf("failed to index study session record, invalid db cast")
+		}
+
+		tx, err := ddb.Begin()
+		if err != nil {
+			return fmt.Errorf("failed to start transaction")
+		}
+
+		log.Println("Upserting study session")
+		err = db.UpsertStudySession(tx, &session, e.Commit.RKey)
+	case models.CommitOperationDelete:
+		err = db.DeleteStudySessionByRkey(d, did, e.Commit.RKey)
+	}
+	if err != nil {
+		return fmt.Errorf("failed to %s study session record: %w", e.Commit.Operation, err)
+	}
+
+	return nil
+}

internal/web/pages/index.templ

···
 package pages
 
-import "yoten.app/internal/web/pages/templates"
+import (
+	"yoten.app/internal/web/db"
+	"yoten.app/internal/web/pages/partials"
+	"yoten.app/internal/web/pages/templates"
+)
 
 templ Index(params IndexParams) {
-	{{ user := params.User }}
 	@templates.BaseLayout("home") {
 		<span>
 			Hello,
-			if user != nil {
-				{ user.Handle }
+			if params.User != nil {
+				{ params.User.Handle }
 			} else {
 				world
 			}
 		</span>
-		if user != nil {
+		if params.User != nil {
 			<button type="button" hx-post="/logout" hx-swap="none">logout</button>
 		} else {
 			<a href="/login">login</a>
+		}
+		for _, feedItem := range params.StudySessionFeed {
+			if params.User != nil {
+				@partials.StudySession(partials.StudySessionParams{Item: feedItem, Did: db.ToPtr(params.User.Did)})
+			} else {
+				@partials.StudySession(partials.StudySessionParams{Item: feedItem, Did: nil})
+			}
 		}
 	}
 }

internal/web/pages/new-study-session.templ

···
+package pages
+
+import (
+	"yoten.app/internal/web/db"
+	"yoten.app/internal/web/pages/templates"
+)
+
+templ NewStudySession(params NewStudySessionParams) {
+	@templates.BaseLayout("home") {
+		<form hx-post="/session/new" hx-swap="none" hx-disabled-elt="#save-button,#cancel-button">
+			<div>
+				<label for="description">Description</label>
+				<textarea maxlength="256" type="text" name="description" rows="3" placeholder="write a description"></textarea>
+			</div>
+			<div>
+				<label for="date">Date</label>
+				<input type="date" name="date"/>
+			</div>
+			<div>
+				<label for="duration">Duration (HH:MM:SS):</label>
+				<input
+					type="text"
+					id="duration"
+					name="duration"
+					pattern="[0-9]{2}:[0-5][0-9]:[0-5][0-9]"
+					placeholder="hh:mm:ss"
+				/>
+			</div>
+			<div>
+				<select name="language_code">
+					<option disabled selected>Select a language...</option>
+					for c, l := range db.Languages {
+						<option value={ string(c) }>
+							{ l.Name }
+							if l.NativeName != nil {
+								({ *l.NativeName })
+							}
+						</option>
+					}
+				</select>
+			</div>
+			<div>
+				<select name="activity_name">
+					<option disabled selected>Select an activity...</option>
+					for c, a := range db.Activities {
+						<option value={ string(c) }>
+							{ a.Name }
+						</option>
+					}
+				</select>
+			</div>
+			<div>
+				<button id="save-button" type="submit">
+					save
+				</button>
+				<a href="/">
+					<button id="cancel-button" type="button">
+						cancel
+					</button>
+				</a>
+			</div>
+		</form>
+		<p id="create-study-session-msg"></p>
+	}
+}

internal/web/pages/pages.go

···
 
 type IndexParams struct {
 	// The current logged in user.
-	User *oauth.User
+	User             *oauth.User
+	StudySessionFeed []*db.StudySessionFeedItem
 }
 
 func IndexComponent(params IndexParams) templ.Component {
···
 func NotFoundComponent() templ.Component {
 	return NotFound()
 }
+
+type NewStudySessionParams struct {
+}
+
+func NewStudySessionComponent(params NewStudySessionParams) templ.Component {
+	return NewStudySession(params)
+}

internal/web/pages/partials/edit-study-session.templ

···
+package partials
+
+import (
+	"fmt"
+
+	"yoten.app/internal/web"
+	"yoten.app/internal/web/db"
+)
+
+templ EditStudySession(params EditStudySessionParams) {
+	<form
+		hx-post={ fmt.Sprintf("/session/edit/%s", params.StudySession.Rkey) }
+		hx-swap="none"
+		hx-disabled-elt="#delete-button,#save-button,#cancel-button"
+	>
+		<div>
+			<label for="description">Description</label>
+			<textarea maxlength="256" type="text" name="description" rows="3" placeholder="write a description">
+				{ params.StudySession.Description }
+			</textarea>
+		</div>
+		<div>
+			<label for="date">Date</label>
+			<input type="date" name="date" value={ params.StudySession.Date.Format("2006-01-02") }/>
+		</div>
+		<div>
+			<label for="duration">Duration (HH:MM:SS):</label>
+			<input
+				type="text"
+				id="duration"
+				name="duration"
+				pattern="[0-9]{2}:[0-5][0-9]:[0-5][0-9]"
+				placeholder="hh:mm:ss"
+				value={ web.FormatDurationHHMMSS(params.StudySession.Duration) }
+			/>
+		</div>
+		<div>
+			<select name="language_code">
+				<option disabled selected>Select a language...</option>
+				for c, l := range db.Languages {
+					<option value={ string(c) } if c==params.StudySession.Language.Code {
+	selected
+}>
+						{ l.Name }
+						if l.NativeName != nil {
+							({ *l.NativeName })
+						}
+					</option>
+				}
+			</select>
+		</div>
+		<div>
+			<select name="activity_name">
+				<option disabled selected>Select an activity...</option>
+				for k, a := range db.Activities {
+					<option value={ string(k) } if k==params.StudySession.Activity.Name {
+	selected
+}>
+						{ a.Name }
+					</option>
+				}
+			</select>
+		</div>
+		<div>
+			<button
+				id="delete-button"
+				hx-disabled-elt="#delete-button,#save-button,#cancel-button"
+				hx-delete="/session"
+				hx-vals={ fmt.Sprintf("{\"rkey\": \"%s\"}", params.StudySession.Rkey) }
+			>
+				delete
+			</button>
+			<button id="save-button" type="submit">
+				save
+			</button>
+			<a href="/">
+				<button id="cancel-button" type="button">
+					cancel
+				</button>
+			</a>
+		</div>
+	</form>
+	<p id="update-study-session-msg"></p>
+}

internal/web/pages/partials/partials.go

···
 func SelectedLanguagesPartial(params SelectedLanguagesParams) templ.Component {
 	return SelectedLanguages(params)
 }
+
+type StudySessionParams struct {
+	// The Did of the logged in user.
+	Did  *string
+	Item *db.StudySessionFeedItem
+}
+
+func StudySessionPartial(params StudySessionParams) templ.Component {
+	return StudySession(params)
+}
+
+type EditStudySessionParams struct {
+	StudySession *db.StudySession
+}
+
+func EditStudySessionPartial(params EditStudySessionParams) templ.Component {
+	return EditStudySession(params)
+}

internal/web/pages/partials/study-session.templ

···
+package partials
+
+import "fmt"
+
+templ StudySession(params StudySessionParams) {
+	{{ divId := fmt.Sprintf("study-session-%s", params.Item.Rkey) }}
+	<div id={ divId }>
+		<div>
+			<p>{ params.Item.ProfileDisplayName }</p>
+			<p>{ params.Item.Language.Name }</p>
+		</div>
+		<p>
+			<bold>{ params.Item.StudySession.Description }</bold>
+		</p>
+		<small>{ params.Item.StudySession.Activity.Name }</small>
+		<p>{ params.Item.StudySession.Duration.String() }</p>
+		<p>{ params.Item.StudySession.Date.Format("2006-01-02") }</p>
+		if params.Did != nil && params.Item.Did == *params.Did {
+			<div>
+				<button
+					id="remove-session-button"
+					hx-disabled-elt="#edit-session-button,#remove-session-button,#save-button,#cancel-button"
+					hx-delete="/session"
+					hx-vals={ fmt.Sprintf("{\"rkey\": \"%s\"}", params.Item.Rkey) }
+				>
+					delete
+				</button>
+				<button
+					id="edit-session-button"
+					hx-disabled-elt="#edit-session-button,#remove-session-button,#save-button,#cancel-button"
+					hx-swap="innerHTML"
+					hx-target={ fmt.Sprintf("#%s", divId) }
+					hx-get={ fmt.Sprintf("/session/edit/%s",
+            params.Item.Rkey) }
+				>
+					edit
+				</button>
+			</div>
+		}
+	</div>
+}

internal/web/posthog/posthog.go

···
 package posthog
 
 const (
-	UserProfileEditedEvent    string = "user-profile-edited"
-	UserSignedInEvent         string = "user-signed-in"
+	UserProfileEditedEvent string = "user-profile-edited"
+	UserSignedInEvent      string = "user-signed-in"
+
 	ProfileRecordCreatedEvent string = "profile-record-created"
+
+	StudySessionRecordCreatedEvent string = "study-session-record-created"
+	StudySessionRecordDeletedEvent string = "study-session-record-deleted"
+	StudySessionRecordEditedEvent  string = "study-session-record-edited"
 )

internal/web/state/router.go

···
 		r.Post("/remove-language", s.HandleRemoveLanguage)
 	})
 
+	r.Route("/session", func(r chi.Router) {
+		r.Use(middleware.AuthMiddleware(s.oauth))
+		r.Post("/edit/{rkey}", s.HandleEditStudySession)
+		r.Get("/edit/{rkey}", s.HandleEditStudySession)
+		r.Get("/new", s.HandleNewStudySession)
+		r.Post("/new", s.HandleNewStudySession)
+		r.Delete("/", s.HandleDeleteStudySession)
+	})
+
 	return r
 }
 

internal/web/state/state.go

···
 import (
 	"context"
 	"fmt"
+	"log"
 	"log/slog"
 	"net/http"
 
···
 		"appview",
 		[]string{
 			"app.yoten.actor.profile",
+			"app.yoten.feed.session",
 		},
 		nil,
 		slog.Default(),
···
 
 func (s *State) HandleIndex(w http.ResponseWriter, r *http.Request) {
 	user := s.oauth.GetUser(r)
-	pages.IndexComponent(pages.IndexParams{User: user}).Render(r.Context(), w)
+
+	feeds, err := db.GetStudySessionFeed(s.db, 10, 0)
+	if err != nil {
+		log.Println(err)
+		return
+	}
+
+	pages.IndexComponent(pages.IndexParams{
+		User:             user,
+		StudySessionFeed: feeds,
+	}).Render(r.Context(), w)
 }

internal/web/state/study-session.go

···
+package state
+
+import (
+	"log"
+	"net/http"
+	"strconv"
+	"time"
+
+	comatproto "github.com/bluesky-social/indigo/api/atproto"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+	"github.com/go-chi/chi/v5"
+	"github.com/posthog/posthog-go"
+
+	"yoten.app/api/yoten"
+	"yoten.app/internal/web"
+	"yoten.app/internal/web/db"
+	"yoten.app/internal/web/htmx"
+	"yoten.app/internal/web/pages"
+	"yoten.app/internal/web/pages/partials"
+	ph "yoten.app/internal/web/posthog"
+)
+
+func (s *State) HandleEditStudySession(w http.ResponseWriter, r *http.Request) {
+	user := s.oauth.GetUser(r)
+	profile, err := db.GetProfile(s.db, user.Did)
+	if err != nil || profile == nil {
+		log.Printf("failed to find %s in db: %s", user.Did, err)
+		pages.NotFound().Render(r.Context(), w)
+		return
+	}
+
+	rkey := chi.URLParam(r, "rkey")
+	session, err := db.GetStudySessionByRkey(s.db, user.Did, rkey)
+	if err != nil {
+		log.Println("failed to get study session from db", err)
+		htmx.HxOobUpdate(w, "update-study-session-msg", "Failed to update study session, try again later.")
+		return
+	}
+
+	if user.Did != session.Did {
+		log.Println("failed to update study session: user does not own record")
+		htmx.HxOobUpdate(w, "update-study-session-msg", "Failed to update study session, try again later.")
+		return
+	}
+
+	switch r.Method {
+	case http.MethodGet:
+		partials.EditStudySessionPartial(partials.EditStudySessionParams{StudySession: session}).Render(r.Context(), w)
+	case http.MethodPost:
+		description := r.FormValue("description")
+		activityName := r.FormValue("activity_name")
+		dateStr := r.FormValue("date")
+		date, err := time.Parse("2006-01-02", dateStr)
+		if err != nil {
+			log.Println("failed to parse study session date", err)
+			htmx.HxOobUpdate(w, "update-study-session-msg", "Failed to update study session, try again later.")
+			return
+		}
+
+		durationStr := r.FormValue("duration")
+		duration, err := web.ParseDurationHHMMSS(durationStr)
+		if err != nil {
+			log.Println("failed to parse study session duration", err)
+			htmx.HxOobUpdate(w, "update-study-session-msg", "Failed to update study session, try again later.")
+			return
+		}
+
+		languageCode := r.FormValue("language_code")
+
+		client, err := s.oauth.AuthorizedClient(r)
+		if err != nil {
+			log.Println("failed to get authorized client", err)
+			htmx.HxOobUpdate(w, "update-study-session-msg", "Failed to update study session, try again later.")
+			return
+		}
+
+		ex, _ := client.RepoGetRecord(r.Context(), "", "app.yoten.feed.session", user.Did, session.Rkey)
+		var cid *string
+		if ex != nil {
+			cid = ex.Cid
+		}
+
+		language, ok := db.Languages[db.LanguageCode(languageCode)]
+		if !ok {
+			log.Printf("failed to find language '%s'", language.Code)
+			htmx.HxOobUpdate(w, "update-study-session-msg", "Failed to update study session, try again later.")
+			log.Println(err)
+			return
+		}
+
+		activity, ok := db.Activities[activityName]
+		if !ok {
+			log.Println("failed to find activity '%s'", activity.Name)
+			htmx.HxOobUpdate(w, "update-study-session-msg", "Failed to update study session, try again later.")
+		}
+
+		_, err = client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{
+			Collection: "app.yoten.feed.session",
+			Repo:       user.Did,
+			Rkey:       session.Rkey,
+			Record: &lexutil.LexiconTypeDecoder{
+				Val: &yoten.FeedSession{
+					Description:  &description,
+					ActivityName: activityName,
+					Date:         date.Format(time.RFC3339),
+					Duration:     db.ToPtr(strconv.FormatInt(int64(duration.Seconds()), 10)),
+					LanguageCode: languageCode,
+					CreatedAt:    session.CreatedAt.Format(time.RFC3339),
+				}},
+			SwapRecord: cid,
+		})
+		if err != nil {
+			log.Println("failed to update study session record", err)
+			htmx.HxOobUpdate(w, "update-study-session-msg", "Failed to update PDS, try again later.")
+			return
+		}
+
+		updatedSession := db.StudySession{
+			Did:         session.Did,
+			Rkey:        session.Rkey,
+			Description: description,
+			Date:        date,
+			Duration:    duration,
+			Activity:    activity,
+			Language:    language,
+		}
+
+		tx, err := s.db.BeginTx(r.Context(), nil)
+		if err != nil {
+			log.Println("failed to start tx")
+			htmx.HxOobUpdate(w, "update-study-session-msg", "Failed to update study session, try again later.")
+			return
+		}
+
+		err = db.UpsertStudySession(tx, &updatedSession, session.Rkey)
+		if err != nil {
+			// Hopeful ingester updates DB for us.
+			log.Println("failed to update study session", err)
+		}
+
+		log.Println("edited study session")
+		if !s.config.Core.Dev {
+			err = s.posthog.Enqueue(posthog.Capture{
+				DistinctId: user.Did,
+				Event:      ph.StudySessionRecordEditedEvent,
+				Properties: posthog.NewProperties().Set("rkey", session.Rkey),
+			})
+			if err != nil {
+				log.Println("failed to enqueue posthog event:", err)
+			}
+		}
+
+		htmx.HxRedirect(w, "/")
+	}
+}
+
+func (s *State) HandleNewStudySession(w http.ResponseWriter, r *http.Request) {
+	user := s.oauth.GetUser(r)
+	client, err := s.oauth.AuthorizedClient(r)
+	if err != nil {
+		log.Println("failed to get authorized client", err)
+		htmx.HxOobUpdate(w, "create-study-session-msg", "Failed to create study session, try again later.")
+		return
+	}
+
+	switch r.Method {
+	case http.MethodGet:
+		pages.NewStudySessionComponent(pages.NewStudySessionParams{}).Render(r.Context(), w)
+	case http.MethodPost:
+		err := r.ParseForm()
+		if err != nil {
+			log.Println("invalid study session create form", err)
+			htmx.HxOobUpdate(w, "create-study-session-msg", "Failed to create study session, try again later.")
+			return
+		}
+
+		description := r.FormValue("description")
+		dateStr := r.FormValue("date")
+		date, err := time.Parse("2006-01-02", dateStr)
+		if err != nil {
+			log.Println("failed to parse study session date", err)
+			htmx.HxOobUpdate(w, "create-study-session-msg", "Failed to create study session, try again later.")
+			return
+		}
+
+		durationStr := r.FormValue("duration")
+		duration, err := web.ParseDurationHHMMSS(durationStr)
+		if err != nil {
+			log.Println("failed to parse study session duration", err)
+			htmx.HxOobUpdate(w, "create-study-session-msg", "Failed to create study session, try again later.")
+			return
+		}
+
+		languageCode := r.FormValue("language_code")
+		language, ok := db.Languages[db.LanguageCode(languageCode)]
+		if !ok {
+			log.Printf("failed to find language '%s'", language.Code)
+			htmx.HxOobUpdate(w, "create-study-session-msg", "Failed to create study session, try again later.")
+			return
+		}
+
+		activityName := r.FormValue("activity_name")
+		activity, ok := db.Activities[activityName]
+		if !ok {
+			log.Println("failed to find activity '%s'", activity.Name)
+			htmx.HxOobUpdate(w, "create-study-session-msg", "Failed to create study session, try again later.")
+			return
+		}
+
+		createdAt := time.Now().Format(time.RFC3339)
+		rkey := web.TID()
+		_, err = client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{
+			Collection: "app.yoten.feed.session",
+			Repo:       user.Did,
+			Rkey:       rkey,
+			Record: &lexutil.LexiconTypeDecoder{
+				Val: &yoten.FeedSession{
+					Description:  &description,
+					ActivityName: activityName,
+					Date:         date.Format(time.RFC3339),
+					Duration:     db.ToPtr(strconv.FormatInt(int64(duration.Seconds()), 10)),
+					LanguageCode: languageCode,
+					CreatedAt:    createdAt,
+				}},
+		})
+		if err != nil {
+			log.Println("failed to create study session record", err)
+			htmx.HxOobUpdate(w, "create-study-session-msg", "Failed to create study session, try again later.")
+			return
+		}
+
+		session := db.StudySession{
+			Did:         user.Did,
+			Rkey:        rkey,
+			Description: description,
+			Date:        date,
+			Duration:    duration,
+			Activity:    activity,
+			Language:    language,
+		}
+
+		tx, err := s.db.BeginTx(r.Context(), nil)
+		if err != nil {
+			log.Println("failed to start tx")
+			htmx.HxOobUpdate(w, "create-study-session-msg", "Failed to create study session, try again later.")
+			return
+		}
+
+		err = db.UpsertStudySession(tx, &session, session.Rkey)
+		if err != nil {
+			// Hopeful ingester updates DB for us.
+			log.Println("failed to create study session", err)
+		}
+
+		log.Println("created study session")
+		if !s.config.Core.Dev {
+			err = s.posthog.Enqueue(posthog.Capture{
+				DistinctId: user.Did,
+				Event:      ph.StudySessionRecordCreatedEvent,
+				Properties: posthog.NewProperties().Set("rkey", rkey),
+			})
+			if err != nil {
+				log.Println("failed to enqueue posthog event:", err)
+			}
+		}
+
+		htmx.HxRedirect(w, "/")
+	}
+}
+
+func (s *State) HandleDeleteStudySession(w http.ResponseWriter, r *http.Request) {
+	user := s.oauth.GetUser(r)
+
+	client, err := s.oauth.AuthorizedClient(r)
+	if err != nil {
+		log.Println("failed to get authorized client", err)
+		htmx.HxOobUpdate(w, "update-study-session-msg", "Failed to delete study session, try again later.")
+		return
+	}
+
+	switch r.Method {
+	case http.MethodDelete:
+		err := r.ParseForm()
+		if err != nil {
+			log.Println("failed to parse study session delete form", err)
+			htmx.HxOobUpdate(w, "update-study-session-msg", "Failed to delete study session, try again later.")
+			return
+		}
+
+		rkey := r.FormValue("rkey")
+		session, err := db.GetStudySessionByRkey(s.db, user.Did, rkey)
+		if err != nil {
+			log.Println("failed to get study session from db", err)
+			htmx.HxOobUpdate(w, "update-study-session-msg", "Failed to delete study session, try again later.")
+			return
+		}
+
+		if user.Did != session.Did {
+			log.Println("failed to delete study session: user does not own record")
+			htmx.HxOobUpdate(w, "update-study-session-msg", "Failed to delete study session, try again later.")
+			return
+		}
+
+		_, err = client.RepoDeleteRecord(r.Context(), &comatproto.RepoDeleteRecord_Input{
+			Collection: "app.yoten.feed.session",
+			Repo:       user.Did,
+			Rkey:       session.Rkey,
+		})
+		if err != nil {
+			log.Println("failed to delete study session from PDS", err)
+			htmx.HxOobUpdate(w, "update-study-session-msg", "Failed to delete study session, try again later.")
+			return
+		}
+
+		err = db.DeleteStudySessionByRkey(s.db, user.Did, session.Rkey)
+		if err != nil {
+			// Hopeful ingester updates DB for us.
+			log.Println("failed to delete study session", err)
+		}
+
+		log.Println("deleted study session")
+		if !s.config.Core.Dev {
+			err = s.posthog.Enqueue(posthog.Capture{
+				DistinctId: user.Did,
+				Event:      ph.StudySessionRecordDeletedEvent,
+				Properties: posthog.NewProperties().Set("rkey", session.Rkey),
+			})
+			if err != nil {
+				log.Println("failed to enqueue posthog event:", err)
+			}
+		}
+
+		htmx.HxRedirect(w, "/")
+	}
+}

internal/web/tid.go

···
+package web
+
+import (
+	"github.com/bluesky-social/indigo/atproto/syntax"
+)
+
+var c syntax.TIDClock = syntax.NewTIDClock(0)
+
+func TID() string {
+	return c.Next().String()
+}

internal/web/utils.go

···
+package web
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+)
+
+func ParseDurationHHMMSS(durationStr string) (time.Duration, error) {
+	parts := strings.Split(durationStr, ":")
+	if len(parts) != 3 {
+		return 0, fmt.Errorf("invalid duration format: expected HH:MM:SS, got %s", durationStr)
+	}
+
+	hours, err := strconv.Atoi(parts[0])
+	if err != nil {
+		return 0, fmt.Errorf("invalid hours: %v", err)
+	}
+
+	minutes, err := strconv.Atoi(parts[1])
+	if err != nil {
+		return 0, fmt.Errorf("invalid minutes: %v", err)
+	}
+
+	seconds, err := strconv.Atoi(parts[2])
+	if err != nil {
+		return 0, fmt.Errorf("invalid seconds: %v", err)
+	}
+
+	if minutes < 0 || minutes >= 60 {
+		return 0, fmt.Errorf("minutes out of range (0-59): %d", minutes)
+	}
+	if seconds < 0 || seconds >= 60 {
+		return 0, fmt.Errorf("seconds out of range (0-59): %d", seconds)
+	}
+
+	duration := time.Duration(hours)*time.Hour +
+		time.Duration(minutes)*time.Minute +
+		time.Duration(seconds)*time.Second
+
+	return duration, nil
+}
+
+func FormatDurationHHMMSS(d time.Duration) string {
+	d = d.Truncate(time.Second)
+
+	hours := d / time.Hour
+	d -= hours * time.Hour
+
+	minutes := d / time.Minute
+	d -= minutes * time.Minute
+
+	seconds := d / time.Second
+
+	return fmt.Sprintf("%02d:%02d:%02d", hours, minutes, seconds)
+}

internal/web/xrpcclient/xrpc.go

···
 
 	return &out, nil
 }
+
+func (c *Client) RepoDeleteRecord(ctx context.Context, input *atproto.RepoDeleteRecord_Input) (*atproto.RepoDeleteRecord_Output, error) {
+	var out atproto.RepoDeleteRecord_Output
+	if err := c.Do(ctx, c.authArgs, xrpc.Procedure, "application/json", "com.atproto.repo.deleteRecord", nil, input, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

lexicons/feed/session.json

···
+{
+  "lexicon": 1,
+  "id": "app.yoten.feed.session",
+  "needsCbor": true,
+  "needsType": true,
+  "defs": {
+    "main": {
+      "type": "record",
+      "description": "A declaration of a Yōten study session.",
+      "key": "tid",
+      "record": {
+        "type": "object",
+        "required": ["activityName", "languageCode", "date", "createdAt"],
+        "properties": {
+          "description": {
+            "type": "string",
+            "description": "Free-form description for the study session.",
+            "maxGraphemes": 64,
+            "maxLength": 640
+          },
+          "activityName": {
+            "type": "string",
+            "description": "A key used to lookup activity type details",
+            "maxGraphemes": 64,
+            "maxLength": 640
+          },
+          "languageCode": {
+            "type": "string",
+            "description": "An ISO 639-1 two-letter language code (e.g., 'en', 'es', 'ko').",
+            "minLength": 2,
+            "maxLength": 2
+          },
+          "duration": {
+            "type": "string",
+            "description": "The duration of the study session in seconds",
+            "format": "datetime"
+          },
+          "date": {
+            "type": "string",
+            "format": "datetime"
+          },
+          "createdAt": {
+            "type": "string",
+            "format": "datetime"
+          }
+        }
+      }
+    }
+  }
+}
+