i wanna see what breaks

lexicons/org/xcvr/notes.lex

···
       title: string, bytes<=640, chars<=64 
       topic?: string, bytes<=2560, chars<=256
       createdAt: string
-      host: handle
+      host: did
 
     sub: record
       channelUri: uri
 
     channelView?: def
       uri: uri
-      host: handle
+      host: did
       creator: org.xcvr.actor.profileView
       title: string, bytes<=640, chars<=64
       topic?: string, bytes<=2560, chars<=256
···
     signet: record
       channelURI: uri
       lrcID: int, [0 4294967295]
-      author: string
+      author: did
+      authorHandle?: string
       startedAt?: date
 
     media: record

migrations/007_addauthor.down.sql

···
+UPDATE signets SET author_handle = '' WHERE author_handle IS NULL;
+ALTER TABLE signets ALTER COLUMN author_handle SET NOT NULL;
+ALTER TABLE signets DROP COLUMN author;

migrations/007_addauthor.up.sql

···
+ALTER TABLE signets ADD COLUMN author TEXT NOT NULL;
+ALTER TABLE signets ALTER COLUMN author_handle DROP NOT NULL;

migrations/008_updatexcvrdid.down.sql

···
+UPDATE did_handles SET did = 'did:plc:mqt7hthieqzpa3mwqwggbqei' WHERE handle = 'xcvr.org';

migrations/008_updatexcvrdid.up.sql

···
+UPDATE did_handles SET did = 'did:web:xcvr.org' WHERE handle = 'xcvr.org';

server/go.mod

···
 	github.com/ipfs/go-cid v0.4.1
 	github.com/jackc/pgx/v5 v5.7.4
 	github.com/joho/godotenv v1.5.1
-	github.com/rachel-mp4/lrcd v0.1.1
-	github.com/rachel-mp4/lrcproto v1.2.0
+	github.com/rachel-mp4/lrcd v0.2.3
+	github.com/rachel-mp4/lrcproto v1.2.1
 	github.com/rivo/uniseg v0.4.7
 	github.com/whyrusleeping/cbor-gen v0.3.1
 	golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028

server/go.sum

···
 github.com/golang-jwt/jwt/v5 v5.2.2 h1:Rl4B7itRWVtYIHFrSNd7vhTiz9UpLdi6gZhZ3wEeDy8=
 github.com/golang-jwt/jwt/v5 v5.2.2/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk=
 github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
-github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/google/go-querystring v1.1.0 h1:AnCroh3fv4ZBgVIf1Iwtovgjaw/GiKJo8M8yD/fhyJ8=
 github.com/google/go-querystring v1.1.0/go.mod h1:Kcdr2DB4koayq7X8pmAG4sNG59So17icRSOU623lUBU=
 github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0=
···
 github.com/prometheus/common v0.54.0/go.mod h1:/TQgMJP5CuVYveyT7n/0Ix8yLNNXy9yRSkhnLTHPDIQ=
 github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc=
 github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk=
-github.com/rachel-mp4/lrcd v0.0.1 h1:9d5if0HJ/+TLKdupd7Zu9dISA5fF3QRtI/yr+gYVqXM=
-github.com/rachel-mp4/lrcd v0.0.1/go.mod h1:aWUVglSyrLf2RGpQdqTucX498b434yWBFJkD6Yzr0OE=
-github.com/rachel-mp4/lrcd v0.1.0 h1:iW3ux8otqo+9tYpP2Bsxu5VgbhP324Mjy0vOBf3M39Q=
-github.com/rachel-mp4/lrcd v0.1.0/go.mod h1:CyBPWmy94oQ0sTOj24VJjxWoZ9zSnqCKQ/qlR+vhtVE=
-github.com/rachel-mp4/lrcd v0.1.1 h1:2AXK61+pnL71ZqINLnxNfKqX/F0hUw+REFbBFZOjJcY=
-github.com/rachel-mp4/lrcd v0.1.1/go.mod h1:CyBPWmy94oQ0sTOj24VJjxWoZ9zSnqCKQ/qlR+vhtVE=
-github.com/rachel-mp4/lrcproto v0.0.0-20250905154858-2ddb78e31d0c h1:t33xVlfSwvB80nj1jroRXUaq/RTgjWwD4l7p/ISatUQ=
-github.com/rachel-mp4/lrcproto v0.0.0-20250905154858-2ddb78e31d0c/go.mod h1:hQzO36tQELGbkmRnUtKeM6NMU34t79ZcTlhM+MO7pHw=
-github.com/rachel-mp4/lrcproto v1.2.0 h1:nZI80WQKO6yKgX0O5H6OO1cM/tiJqugs0p52KCoIDOw=
-github.com/rachel-mp4/lrcproto v1.2.0/go.mod h1:hQzO36tQELGbkmRnUtKeM6NMU34t79ZcTlhM+MO7pHw=
+github.com/rachel-mp4/lrcd v0.2.3 h1:HT3UjFn2ZK2zpFkS8U7KU1+I9kMA/oBF2FVWd7x0TkM=
+github.com/rachel-mp4/lrcd v0.2.3/go.mod h1:CyBPWmy94oQ0sTOj24VJjxWoZ9zSnqCKQ/qlR+vhtVE=
+github.com/rachel-mp4/lrcproto v1.2.1 h1:oKP/4u8JaRzV9vY/BUn24VTrsN7pgty0S4AP8hWc/JI=
+github.com/rachel-mp4/lrcproto v1.2.1/go.mod h1:hQzO36tQELGbkmRnUtKeM6NMU34t79ZcTlhM+MO7pHw=
 github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
 github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI=
···
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 h1:+cNy6SZtPcJQH3LJVLOSmiC7MMxXNOb3PU/VUEz+EhU=
 golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028/go.mod h1:NDW/Ps6MPRej6fsCIbMTohpP40sJ/P/vI1MoTEGwX90=
-google.golang.org/protobuf v1.36.9 h1:w2gp2mA27hUeUzj9Ex9FBjsBm40zfaDtEWow293U7Iw=
-google.golang.org/protobuf v1.36.9/go.mod h1:fuxRtAxBytpl4zzqUh6/eyUujkJdNiuEkXntxiD/uRU=
 google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE=
 google.golang.org/protobuf v1.36.10/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

server/internal/db/db.go

···
 	"fmt"
 	"os"
 	"rvcx/internal/atputils"
+	"rvcx/internal/lex"
 	"rvcx/internal/types"
 	"time"
 
···
 	return did, nil
 }
 
+func (s *Store) FullResolveHandle(hdl string, ctx context.Context) (string, error) {
+	did, err := s.ResolveHandle(hdl, ctx)
+	if err == nil {
+		return did, nil
+	}
+	did, err = atputils.TryLookupHandle(ctx, hdl)
+	if err != nil {
+		return "", errors.New("couldn't resolve: " + err.Error())
+	}
+	s.StoreDidHandle(did, hdl, ctx)
+	return did, nil
+}
+
 func (s *Store) ResolveDid(did string, ctx context.Context) (string, error) {
 	row := s.pool.QueryRow(ctx, `SELECT h.handle FROM did_handles h WHERE h.did = $1`, did)
 	var handle string
···
 	return
 }
 
+func (s *Store) GetHistory(channelURI string, limit int, cursor *int, ctx context.Context) ([]types.SignedItemView, error) {
+	queryFmt := `
+	SELECT
+		'message' AS content_type,
+		m.uri,
+		m.did,
+		dh.handle,
+		p.display_name,
+		p.status,
+		p.color,
+		p.avatar_cid,
+		p.default_nick,
+		m.body,
+		NULL AS blob_cid,
+		NULL AS blob_mime,
+		NULL AS alt,
+		NULL AS height,
+		NULL AS width,
+		m.nick,
+		m.color,
+		s.uri,
+		s.issuer_did,
+		s.channel_uri,
+		s.message_id,
+		s.author,
+		s.author_handle,
+		s.started_at,
+		m.posted_at
+	FROM signets s
+	JOIN messages m ON s.uri = m.signet_uri
+	JOIN did_handles dh ON m.did = dh.did
+	JOIN profiles p ON m.did = p.did
+	WHERE s.channel_uri = $2 AND m.did = s.author %s
+
+	UNION ALL
+
+	SELECT
+		'image' AS content_type,
+		i.uri,
+		i.did,
+		dh.handle,
+		p.display_name,
+		p.status,
+		p.color,
+		p.avatar_cid,
+		p.default_nick,
+		NULL AS body,
+		i.blob_cid,
+		i.blob_mime,
+		i.alt,
+		i.height,
+		i.width,
+		i.nick,
+		i.color,
+		s.uri,
+		s.issuer_did,
+		s.channel_uri,
+		s.message_id,
+		s.author,
+		s.author_handle,
+		s.started_at,
+		i.posted_at
+	FROM signets s
+	JOIN images i ON s.uri = i.signet_uri
+	JOIN did_handles dh ON i.did = dh.did
+	JOIN profiles p ON i.did = p.did
+	WHERE s.channel_uri = $2 AND i.did = s.author %s
+
+	ORDER BY message_id DESC
+	LIMIT $1
+	`
+	var query string
+	if cursor != nil {
+		query = fmt.Sprintf(queryFmt, "AND s.message_id < $3", "AND s.message_id < $3")
+		return s.evalGetItems(query, ctx, limit, *cursor)
+	} else {
+		query = fmt.Sprintf(queryFmt, "", "")
+		return s.evalGetItems(query, ctx, limit)
+	}
+}
+func (s *Store) evalGetItems(query string, ctx context.Context, limit int, params ...any) ([]types.SignedItemView, error) {
+	args := []any{limit}
+	args = append(args, params...)
+	rows, err := s.pool.Query(ctx, query, args...)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var items = make([]types.SignedItemView, 0)
+	for rows.Next() {
+		var t string
+		var p types.ProfileView
+		var uri string
+		var body string
+		var image types.Image
+		var nick string
+		var color uint32
+		var s types.SignetView
+		var time time.Time
+
+		err := rows.Scan(
+			&t,
+			&uri,
+			&p.DID,
+			&p.Handle,
+			&p.DisplayName,
+			&p.Status,
+			&p.Color,
+			&p.Avatar,
+			&p.DefaultNick,
+			&body,
+			&image.BlobCID,
+			&image.BlobMIME,
+			&image.Alt,
+			&image.Height,
+			&image.Width,
+
+			&nick,
+			&color,
+
+			&s.URI,
+			&s.Issuer,
+			&s.ChannelURI,
+			&s.LrcId,
+			&s.Author,
+			&s.AuthorHandle,
+			&s.StartedAt,
+			&time,
+		)
+		if err != nil {
+			return nil, err
+		}
+		if t == "message" {
+			var msg types.SignedMessageView
+			msg.Body = body
+			if nick != "" {
+				msg.Nick = &nick
+			}
+			if color != 0 {
+				msg.Color = &color
+			}
+			msg.Author = p
+			msg.Signet = s
+			msg.PostedAt = time
+			msg.URI = uri
+
+			items = append(items, msg)
+		} else if t == "image" {
+			var img types.SignedMediaView
+			var imgview types.ImageView
+			if image.Height != nil && image.Width != nil {
+				var aspect lex.AspectRatio
+				aspect.Width = *image.Width
+				aspect.Height = *image.Height
+				imgview.AspectRatio = &aspect
+			}
+			imgview.Alt = image.Alt
+			base := os.Getenv("MY_IDENTITY")
+			src := fmt.Sprintf("https://%s/xrpc/org.xcvr.lrc.getImage?uri=%s", base, uri)
+			imgview.Src = &src
+			img.Image = &imgview
+			if nick != "" {
+				img.Nick = &nick
+			}
+			if color != 0 {
+				img.Color = &color
+			}
+			img.Author = p
+			img.Signet = s
+			img.PostedAt = time
+			img.URI = uri
+
+			items = append(items, img)
+		} else {
+			return nil, errors.New("recieved strange type t: " + t)
+		}
+	}
+	return items, nil
+
+}
+
 func (s *Store) GetMessages(channelURI string, limit int, cursor *int, ctx context.Context) ([]types.SignedMessageView, error) {
 	queryFmt := `
 		SELECT 
···
 			&msg.Color,
 
 			&msg.Signet.URI,
-			&msg.Signet.IssuerHandle,
+			&msg.Signet.Issuer,
 			&msg.Signet.ChannelURI,
 			&msg.Signet.LrcId,
 			&msg.Signet.AuthorHandle,

server/internal/db/lexicon.go

···
 	return
 }
 
+// QuerySignetHandle takes a uri an queries the appropriate signet's handle.
+// Deprecated: i should QuerySignetDid instead
 func (s *Store) QuerySignetHandle(uri string, ctx context.Context) (string, error) {
 	row := s.pool.QueryRow(ctx, `SELECT s.author_handle FROM signets s WHERE s.uri = $1`, uri)
 	var handle string
···
 		return "", errors.New("BOBOBOBOBOBOL " + err.Error())
 	}
 	return handle, nil
+}
+func (s *Store) QuerySignetDid(uri string, ctx context.Context) (string, error) {
+	row := s.pool.QueryRow(ctx, `SELECT s.author FROM signets s WHERE s.uri = $1`, uri)
+	var did string
+	err := row.Scan(&did)
+	if err != nil {
+		return "", errors.New("BOBOBOBOBOBOL " + err.Error())
+	}
+	return did, nil
 }
 
 func (s *Store) QuerySignetChannelIdNum(uri string, ctx context.Context) (channelUri string, messageID uint32, err error) {
···
 		INSERT INTO signets (
 			uri,
 			issuer_did,
+			author,
 			author_handle,
 			channel_uri,
 			message_id,
 			cid,
 			started_at
 		) VALUES (
-		$1, $2, $3, $4, $5, $6, $7
+		$1, $2, $3, $4, $5, $6, $7, $8
 		) ON CONFLICT (uri) DO NOTHING
-		`, signet.URI, signet.IssuerDID, signet.AuthorHandle, signet.ChannelURI, signet.MessageID, signet.CID, signet.StartedAt)
+		`, signet.URI, signet.IssuerDID, signet.Author, signet.AuthorHandle, signet.ChannelURI, signet.MessageID, signet.CID, signet.StartedAt)
 	if err != nil {
 		err = errors.New("SOMETHING BAD HAPPENED: " + err.Error())
 		return
···
 		INSERT INTO signets (
 			uri,
 			issuer_did,
-			AuthorHandle,
+			author,
+			author_handle,
 			channel_uri,
 			message_id,
 			cid,
 			started_at
 		) VALUES (
-		$1, $2, $3, $4, $5, $6, $7
+		$1, $2, $3, $4, $5, $6, $7, $8
 		)
-		`, signet.URI, signet.IssuerDID, signet.AuthorHandle, signet.ChannelURI, signet.MessageID, signet.CID, signet.StartedAt)
+		`, signet.URI, signet.IssuerDID, signet.Author, signet.AuthorHandle, signet.ChannelURI, signet.MessageID, signet.CID, signet.StartedAt)
 	if err != nil {
 		err = errors.New("SOMETHING BAD HAPPENED: " + err.Error())
 	}

server/internal/handler/handler.go

···
 	mux.HandleFunc("GET /xrpc/org.xcvr.feed.getChannels", h.WithCORS(h.getChannels))
 	mux.HandleFunc("GET /xrpc/org.xcvr.feed.getChannel", h.WithCORS(h.getChannel))
 	mux.HandleFunc("GET /xrpc/org.xcvr.lrc.getMessages", h.WithCORS(h.getMessages))
+	mux.HandleFunc("GET /xrpc/org.xcvr.lrc.getHistory", h.WithCORS(h.getHistory))
 	mux.HandleFunc("GET /xrpc/org.xcvr.lrc.getImage", h.WithCORS(h.getImage))
 	mux.HandleFunc("GET /xrpc/org.xcvr.actor.resolveChannel", h.WithCORS(h.resolveChannel))
 	mux.HandleFunc("GET /xrpc/org.xcvr.actor.getProfileView", h.WithCORS(h.getProfileView))

server/internal/handler/lexiconHandlers.go

···
 	encoder.Encode(gmo)
 }
 
+func (h *Handler) getHistory(w http.ResponseWriter, r *http.Request) {
+	limitstr := r.URL.Query().Get("limit")
+	limit := 50
+	if limitstr != "" {
+		l, err := strconv.Atoi(limitstr)
+		if err == nil {
+			limit = max(min(l, 100), 1)
+		}
+	}
+	cursorstr := r.URL.Query().Get("cursor")
+	var cursor *int
+	if cursorstr != "" {
+		c, err := strconv.Atoi(cursorstr)
+		if err == nil {
+			cursor = &c
+		}
+	}
+	channelURI := r.URL.Query().Get("channelURI")
+	items, err := h.db.GetHistory(channelURI, limit, cursor, r.Context())
+	if err != nil {
+		h.serverError(w, errors.New("something went south: "+err.Error()))
+		return
+	}
+	if len(items) != 0 {
+		var signet types.SignetView
+		smv := items[len(items)-1]
+		if smv.IsMedia() {
+			media, _ := smv.ToSignedMediaView()
+			signet = media.Signet
+		} else if smv.IsMessage() {
+			message, _ := smv.ToSignedMessageView()
+			signet = message.Signet
+		} else {
+			h.serverError(w, errors.New("last item is invalid Signed Item"))
+			return
+		}
+		if int(signet.LrcId) > 2 {
+			cursor := strconv.Itoa(int(signet.LrcId))
+			w.Header().Set("Content-Type", "application/json")
+			jsitems, err := types.MarshalItems(items)
+			if err != nil {
+				h.serverError(w, err)
+			}
+			fmt.Fprintf(w, "{\"items\": %s, \"cursor\": %s}", jsitems, cursor)
+			return
+		}
+	}
+	w.Header().Set("Content-Type", "application/json")
+	jsitems, err := types.MarshalItems(items)
+	if err != nil {
+		h.serverError(w, err)
+	}
+	fmt.Fprintf(w, "{\"items\": %s}", jsitems)
+}
+
 func (h *Handler) resolveChannel(w http.ResponseWriter, r *http.Request) {
 	handle := r.URL.Query().Get("handle")
 	did := r.URL.Query().Get("did")

server/internal/lex/lexicons_cbor.go

···
 	}
 
 	cw := cbg.NewCborWriter(w)
-	fieldCount := 5
+	fieldCount := 6
+
+	if t.AuthorHandle == nil {
+		fieldCount--
+	}
 
 	if t.StartedAt == nil {
 		fieldCount--
···
 		return err
 	}
 
+	// t.Author (string) (string)
+	if len("author") > 8192 {
+		return xerrors.Errorf("Value in field \"author\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("author"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("author")); err != nil {
+		return err
+	}
+
+	if len(t.Author) > 8192 {
+		return xerrors.Errorf("Value in field t.Author was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Author))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string(t.Author)); err != nil {
+		return err
+	}
+
 	// t.StartedAt (string) (string)
 	if t.StartedAt != nil {
 
···
 	}
 
 	// t.AuthorHandle (string) (string)
-	if len("authorHandle") > 8192 {
-		return xerrors.Errorf("Value in field \"authorHandle\" was too long")
-	}
+	if t.AuthorHandle != nil {
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("authorHandle"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("authorHandle")); err != nil {
-		return err
-	}
+		if len("authorHandle") > 8192 {
+			return xerrors.Errorf("Value in field \"authorHandle\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("authorHandle"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("authorHandle")); err != nil {
+			return err
+		}
 
-	if len(t.AuthorHandle) > 8192 {
-		return xerrors.Errorf("Value in field t.AuthorHandle was too long")
-	}
+		if t.AuthorHandle == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if len(*t.AuthorHandle) > 8192 {
+				return xerrors.Errorf("Value in field t.AuthorHandle was too long")
+			}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.AuthorHandle))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string(t.AuthorHandle)); err != nil {
-		return err
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.AuthorHandle))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(*t.AuthorHandle)); err != nil {
+				return err
+			}
+		}
 	}
 	return nil
 }
···
 				t.LRCID = uint64(extra)
 
 			}
+			// t.Author (string) (string)
+		case "author":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 8192)
+				if err != nil {
+					return err
+				}
+
+				t.Author = string(sval)
+			}
 			// t.StartedAt (string) (string)
 		case "startedAt":
 
···
 		case "authorHandle":
 
 			{
-				sval, err := cbg.ReadStringWithMax(cr, 8192)
+				b, err := cr.ReadByte()
 				if err != nil {
 					return err
 				}
+				if b != cbg.CborNull[0] {
+					if err := cr.UnreadByte(); err != nil {
+						return err
+					}
 
-				t.AuthorHandle = string(sval)
+					sval, err := cbg.ReadStringWithMax(cr, 8192)
+					if err != nil {
+						return err
+					}
+
+					t.AuthorHandle = (*string)(&sval)
+				}
 			}
 
 		default:

server/internal/lex/types.go

···
 	LexiconTypeID string  `json:"$type,const=org.xcvr.lrc.signet" cborgen:"$type,const=org.xcvr.lrc.signet"`
 	ChannelURI    string  `json:"channelURI" cborgen:"channelURI"`
 	LRCID         uint64  `json:"lrcID" cborgen:"lrcID"`
-	AuthorHandle  string  `json:"authorHandle" cborgen:"authorHandle"`
+	Author        string  `json:"author" cborgen:"author"`
+	AuthorHandle  *string `json:"authorHandle,omitempty" cborgen:"authorHandle,omitempty"`
 	StartedAt     *string `json:"startedAt,omitempty" cborgen:"startedAt,omitempty"`
 }
 

server/internal/model/channel.go

···
 	welcome       string
 	server        *lrcd.Server
 	lastID        uint32
-	initChan      <-chan lrcpb.Event_Init
-	mediainitChan <-chan lrcpb.Event_Mediainit
+	initChan      <-chan lrcd.InitChanMsg
+	mediainitChan <-chan lrcd.MediaInitChanMsg
 	ctx           context.Context
 	cancel        func()
 
···
 		m.logger.Deprintln("i think the server should exist, so i'm making it")
 		var err error
 		lastID := cm.lastID
-		initChan := make(chan lrcpb.Event_Init, 100)
-		mediainitChan := make(chan lrcpb.Event_Mediainit, 100)
+		initChan := make(chan lrcd.InitChanMsg, 100)
+		mediainitChan := make(chan lrcd.MediaInitChanMsg, 100)
 
 		server, err := lrcd.NewServer(
+			lrcd.WithResolver(func(externalID string, ctx context.Context) *string {
+				did, err := m.store.FullResolveHandle(externalID, ctx)
+				if err != nil {
+					select {
+					case <-ctx.Done():
+						return nil
+					default:
+						return &did
+					}
+				}
+				return &did
+			}),
 			lrcd.WithWelcome(cm.welcome),
 			lrcd.WithLogging(os.Stdout, true),
 			lrcd.WithInitialID(lastID),
···
 				cm.logger.Println("this is a weird case!")
 				return
 			}
-			err := m.rm.PostSignet(e, cm.uri, context.Background())
+			err := m.rm.PostSignet(e.ResolvedId, e.Init, cm.uri, context.Background())
 			if err != nil {
 				m.logger.Println("error posting signet: " + err.Error())
 			}
···
 			}
 			e := lrcpb.Event_Init{
 				Init: &lrcpb.Init{
-					Id:         me.Mediainit.Id,
-					ExternalID: me.Mediainit.ExternalID,
+					Id:         me.Mediainit.Mediainit.Id,
+					ExternalID: me.Mediainit.Mediainit.ExternalID,
 				},
 			}
-			err := m.rm.PostSignet(e, cm.uri, context.Background())
+			err := m.rm.PostSignet(me.ResolvedId, e, cm.uri, context.Background())
 			if err != nil {
 				m.logger.Println("error posting signet: " + err.Error())
 			}

server/internal/model/channelLexiconStream.go

···
 	}
 	sv := types.SignetView{
 		URI:          s.URI,
-		IssuerHandle: ihandle,
+		Issuer:       s.IssuerDID,
 		ChannelURI:   s.ChannelURI,
 		LrcId:        s.MessageID,
 		AuthorHandle: s.AuthorHandle,

server/internal/recordmanager/signet.go

···
 	"time"
 )
 
-func (rm *RecordManager) PostSignet(e lrcpb.Event_Init, uri string, ctx context.Context) error {
-	lsr, now, err := rm.validateSignet(e, uri)
+func (rm *RecordManager) PostSignet(resolvedId *string, e lrcpb.Event_Init, uri string, ctx context.Context) error {
+	lsr, now, err := rm.validateSignet(resolvedId, e, uri, ctx)
 	if err != nil {
 		return errors.New("failed to validate signet: " + err.Error())
 	}
···
 	return rm.db.UpdateSignet(s, ctx)
 }
 
-func (rm *RecordManager) validateSignet(e lrcpb.Event_Init, uri string) (*lex.SignetRecord, *time.Time, error) {
+func (rm *RecordManager) validateSignet(resolvedId *string, e lrcpb.Event_Init, uri string, ctx context.Context) (*lex.SignetRecord, *time.Time, error) {
 	signet := lex.SignetRecord{}
 	handle := e.Init.ExternalID
-	if handle == nil {
-		h := ""
-		handle = &h
+	if resolvedId == nil {
+		if handle != nil {
+			did, _ := rm.db.FullResolveHandle(*handle, ctx)
+			signet.Author = did
+		} else {
+			signet.Author = ""
+		}
+	} else {
+		signet.Author = *resolvedId
 	}
-	signet.AuthorHandle = *handle
+	signet.AuthorHandle = handle
 	if e.Init.Id == nil {
 		return nil, nil, errors.New("ID should not be nil")
 	}
···
 	sr := types.Signet{
 		URI:          recorduri,
 		IssuerDID:    atputils.GetMyDid(),
+		Author:       lsr.Author,
 		AuthorHandle: lsr.AuthorHandle,
 		ChannelURI:   lsr.ChannelURI,
 		MessageID:    id,

server/internal/types/lexicons.go

···
 package types
 
 import (
+	"bytes"
 	"encoding/json"
+	"errors"
 	"rvcx/internal/lex"
 	"time"
 )
···
 type Signet struct {
 	URI          string
 	IssuerDID    string
-	AuthorHandle string
+	Author       string
+	AuthorHandle *string
 	ChannelURI   string
 	MessageID    uint32
 	CID          string
···
 type SignetView struct {
 	Type         string    `json:"$type,const=org.xcvr.lrc.defs#signetView"`
 	URI          string    `json:"uri"`
-	IssuerHandle string    `json:"issuerHandle"`
+	Issuer       string    `json:"issuer"`
 	ChannelURI   string    `json:"channelURI"`
 	LrcId        uint32    `json:"lrcID"`
-	AuthorHandle string    `json:"authorHandle"`
+	Author       string    `json:"author"`
+	AuthorHandle *string   `json:"authorHandle,omitempty"`
 	StartedAt    time.Time `json:"startedAt"`
 }
 
···
 		Alias: (*Alias)(&m),
 	})
 }
+
+type SignedItemView interface {
+	IsMedia() bool
+	IsMessage() bool
+	ToSignedMessageView() (*SignedMessageView, error)
+	ToSignedMediaView() (*SignedMediaView, error)
+}
+
+func MarshalItems(items []SignedItemView) ([]byte, error) {
+	bb := make([][]byte, 2*len(items)+1)
+	bb[0] = []byte("[")
+	for i, item := range items {
+		if i != 0 {
+			bb[2*i] = []byte(",")
+		}
+		if item.IsMedia() {
+			smv, err := item.ToSignedMediaView()
+			if err != nil {
+				return nil, err
+			}
+			b, err := smv.MarshalJSON()
+			if err != nil {
+				return nil, err
+			}
+			bb[2*i+1] = b
+		} else if item.IsMessage() {
+			smv, err := item.ToSignedMessageView()
+			if err != nil {
+				return nil, err
+			}
+			b, err := smv.MarshalJSON()
+			if err != nil {
+				return nil, err
+			}
+			bb[2*i+1] = b
+		} else {
+			return nil, errors.New("item is neither media nor message")
+		}
+	}
+	bb[2*len(items)] = []byte("]")
+	return bytes.Join(bb, nil), nil
+}
+
+func (s SignedMediaView) IsMedia() bool {
+	return true
+}
+
+func (s SignedMessageView) IsMedia() bool {
+	return false
+}
+
+func (s SignedMediaView) IsMessage() bool {
+	return false
+}
+
+func (s SignedMessageView) IsMessage() bool {
+	return true
+}
+
+func (s SignedMediaView) ToSignedMessageView() (*SignedMessageView, error) {
+	return nil, errors.New("i am not a message")
+}
+
+func (s SignedMessageView) ToSignedMediaView() (*SignedMediaView, error) {
+	return nil, errors.New("i am not a media")
+}
+func (s SignedMessageView) ToSignedMessageView() (*SignedMessageView, error) {
+	return &s, nil
+}
+
+func (s SignedMediaView) ToSignedMediaView() (*SignedMediaView, error) {
+	return &s, nil
+}