lexicons, api/tangled: add repoDid field to all repo-scoped lexicons

Signed-off-by: Lewis <[e-mail]>
Lewis: May this revision serve well! <[e-mail]>

api/tangled/actorprofile.go

···
 	// location: Free-form location text.
 	Location *string `json:"location,omitempty" cborgen:"location,omitempty"`
 	// pinnedRepositories: Any ATURI, it is up to appviews to validate these fields.
-	PinnedRepositories []string `json:"pinnedRepositories,omitempty" cborgen:"pinnedRepositories,omitempty"`
+	PinnedRepositories   []string `json:"pinnedRepositories,omitempty" cborgen:"pinnedRepositories,omitempty"`
+	PinnedRepositoryDids []string `json:"pinnedRepositoryDids,omitempty" cborgen:"pinnedRepositoryDids,omitempty"`
 	// preferredHandle: A handle the user prefers to be displayed as.
 	PreferredHandle *string `json:"preferredHandle,omitempty" cborgen:"preferredHandle,omitempty"`
 	// pronouns: Preferred gender pronouns.

api/tangled/cbor_gen.go

···
 	}
 
 	cw := cbg.NewCborWriter(w)
-	fieldCount := 10
+	fieldCount := 11
 
 	if t.Avatar == nil {
 		fieldCount--
···
 	}
 
 	if t.PinnedRepositories == nil {
+		fieldCount--
+	}
+
+	if t.PinnedRepositoryDids == nil {
 		fieldCount--
 	}
 
···
 
 		}
 	}
+
+	// t.PinnedRepositoryDids ([]string) (slice)
+	if t.PinnedRepositoryDids != nil {
+
+		if len("pinnedRepositoryDids") > 1000000 {
+			return xerrors.Errorf("Value in field \"pinnedRepositoryDids\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pinnedRepositoryDids"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("pinnedRepositoryDids")); err != nil {
+			return err
+		}
+
+		if len(t.PinnedRepositoryDids) > 8192 {
+			return xerrors.Errorf("Slice value in field t.PinnedRepositoryDids was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.PinnedRepositoryDids))); err != nil {
+			return err
+		}
+		for _, v := range t.PinnedRepositoryDids {
+			if len(v) > 1000000 {
+				return xerrors.Errorf("Value in field v was too long")
+			}
+
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(v)); err != nil {
+				return err
+			}
+
+		}
+	}
 	return nil
 }
 
···
 
 	n := extra
 
-	nameBuf := make([]byte, 18)
+	nameBuf := make([]byte, 20)
 	for i := uint64(0); i < n; i++ {
 		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
 		if err != nil {
···
 
 				}
 			}
+			// t.PinnedRepositoryDids ([]string) (slice)
+		case "pinnedRepositoryDids":
+
+			maj, extra, err = cr.ReadHeader()
+			if err != nil {
+				return err
+			}
+
+			if extra > 8192 {
+				return fmt.Errorf("t.PinnedRepositoryDids: array too large (%d)", extra)
+			}
+
+			if maj != cbg.MajArray {
+				return fmt.Errorf("expected cbor array")
+			}
+
+			if extra > 0 {
+				t.PinnedRepositoryDids = make([]string, extra)
+			}
+
+			for i := 0; i < int(extra); i++ {
+				{
+					var maj byte
+					var extra uint64
+					var err error
+					_ = maj
+					_ = extra
+					_ = err
+
+					{
+						sval, err := cbg.ReadStringWithMax(cr, 1000000)
+						if err != nil {
+							return err
+						}
+
+						t.PinnedRepositoryDids[i] = string(sval)
+					}
+
+				}
+			}
 
 		default:
 			// Field doesn't exist on this type, so ignore it
···
 	}
 
 	cw := cbg.NewCborWriter(w)
+	fieldCount := 4
 
-	if _, err := cw.Write([]byte{163}); err != nil {
+	if t.Subject == nil {
+		fieldCount--
+	}
+
+	if t.SubjectDid == nil {
+		fieldCount--
+	}
+
+	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
 		return err
 	}
 
···
 	}
 
 	// t.Subject (string) (string)
-	if len("subject") > 1000000 {
-		return xerrors.Errorf("Value in field \"subject\" was too long")
-	}
+	if t.Subject != nil {
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("subject")); err != nil {
-		return err
-	}
+		if len("subject") > 1000000 {
+			return xerrors.Errorf("Value in field \"subject\" was too long")
+		}
 
-	if len(t.Subject) > 1000000 {
-		return xerrors.Errorf("Value in field t.Subject was too long")
-	}
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("subject")); err != nil {
+			return err
+		}
+
+		if t.Subject == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if len(*t.Subject) > 1000000 {
+				return xerrors.Errorf("Value in field t.Subject was too long")
+			}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string(t.Subject)); err != nil {
-		return err
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Subject))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(*t.Subject)); err != nil {
+				return err
+			}
+		}
 	}
 
 	// t.CreatedAt (string) (string)
···
 	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
 		return err
 	}
+
+	// t.SubjectDid (string) (string)
+	if t.SubjectDid != nil {
+
+		if len("subjectDid") > 1000000 {
+			return xerrors.Errorf("Value in field \"subjectDid\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subjectDid"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("subjectDid")); err != nil {
+			return err
+		}
+
+		if t.SubjectDid == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if len(*t.SubjectDid) > 1000000 {
+				return xerrors.Errorf("Value in field t.SubjectDid was too long")
+			}
+
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.SubjectDid))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(*t.SubjectDid)); err != nil {
+				return err
+			}
+		}
+	}
 	return nil
 }
 
···
 
 	n := extra
 
-	nameBuf := make([]byte, 9)
+	nameBuf := make([]byte, 10)
 	for i := uint64(0); i < n; i++ {
 		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
 		if err != nil {
···
 		case "subject":
 
 			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				b, err := cr.ReadByte()
 				if err != nil {
 					return err
 				}
+				if b != cbg.CborNull[0] {
+					if err := cr.UnreadByte(); err != nil {
+						return err
+					}
 
-				t.Subject = string(sval)
+					sval, err := cbg.ReadStringWithMax(cr, 1000000)
+					if err != nil {
+						return err
+					}
+
+					t.Subject = (*string)(&sval)
+				}
 			}
 			// t.CreatedAt (string) (string)
 		case "createdAt":
···
 
 				t.CreatedAt = string(sval)
 			}
+			// t.SubjectDid (string) (string)
+		case "subjectDid":
+
+			{
+				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.SubjectDid = (*string)(&sval)
+				}
+			}
 
 		default:
 			// Field doesn't exist on this type, so ignore it
···
 	}
 
 	cw := cbg.NewCborWriter(w)
+	fieldCount := 9
 
-	if _, err := cw.Write([]byte{168}); err != nil {
+	if t.OwnerDid == nil {
+		fieldCount--
+	}
+
+	if t.RepoDid == nil {
+		fieldCount--
+	}
+
+	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
 		return err
 	}
 
···
 	}
 
 	// t.RepoDid (string) (string)
-	if len("repoDid") > 1000000 {
-		return xerrors.Errorf("Value in field \"repoDid\" was too long")
+	if t.RepoDid != nil {
+
+		if len("repoDid") > 1000000 {
+			return xerrors.Errorf("Value in field \"repoDid\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("repoDid")); err != nil {
+			return err
+		}
+
+		if t.RepoDid == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if len(*t.RepoDid) > 1000000 {
+				return xerrors.Errorf("Value in field t.RepoDid was too long")
+			}
+
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.RepoDid))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(*t.RepoDid)); err != nil {
+				return err
+			}
+		}
 	}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("repoDid")); err != nil {
-		return err
-	}
+	// t.OwnerDid (string) (string)
+	if t.OwnerDid != nil {
 
-	if len(t.RepoDid) > 1000000 {
-		return xerrors.Errorf("Value in field t.RepoDid was too long")
-	}
+		if len("ownerDid") > 1000000 {
+			return xerrors.Errorf("Value in field \"ownerDid\" was too long")
+		}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.RepoDid))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string(t.RepoDid)); err != nil {
-		return err
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ownerDid"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("ownerDid")); err != nil {
+			return err
+		}
+
+		if t.OwnerDid == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if len(*t.OwnerDid) > 1000000 {
+				return xerrors.Errorf("Value in field t.OwnerDid was too long")
+			}
+
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.OwnerDid))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(*t.OwnerDid)); err != nil {
+				return err
+			}
+		}
 	}
 
 	// t.RepoName (string) (string)
···
 		case "repoDid":
 
 			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				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.RepoDid = (*string)(&sval)
+				}
+			}
+			// t.OwnerDid (string) (string)
+		case "ownerDid":
+
+			{
+				b, err := cr.ReadByte()
 				if err != nil {
 					return err
 				}
+				if b != cbg.CborNull[0] {
+					if err := cr.UnreadByte(); err != nil {
+						return err
+					}
 
-				t.RepoDid = string(sval)
+					sval, err := cbg.ReadStringWithMax(cr, 1000000)
+					if err != nil {
+						return err
+					}
+
+					t.OwnerDid = (*string)(&sval)
+				}
 			}
 			// t.RepoName (string) (string)
 		case "repoName":
···
 	}
 
 	cw := cbg.NewCborWriter(w)
+	fieldCount := 5
 
-	if _, err := cw.Write([]byte{164}); err != nil {
+	if t.Repo == nil {
+		fieldCount--
+	}
+
+	if t.RepoDid == nil {
+		fieldCount--
+	}
+
+	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
 		return err
 	}
 
···
 	}
 
 	// t.Repo (string) (string)
-	if len("repo") > 1000000 {
-		return xerrors.Errorf("Value in field \"repo\" was too long")
+	if t.Repo != nil {
+
+		if len("repo") > 1000000 {
+			return xerrors.Errorf("Value in field \"repo\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("repo")); err != nil {
+			return err
+		}
+
+		if t.Repo == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if len(*t.Repo) > 1000000 {
+				return xerrors.Errorf("Value in field t.Repo was too long")
+			}
+
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(*t.Repo)); err != nil {
+				return err
+			}
+		}
 	}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("repo")); err != nil {
-		return err
-	}
+	// t.RepoDid (string) (string)
+	if t.RepoDid != nil {
+
+		if len("repoDid") > 1000000 {
+			return xerrors.Errorf("Value in field \"repoDid\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("repoDid")); err != nil {
+			return err
+		}
 
-	if len(t.Repo) > 1000000 {
-		return xerrors.Errorf("Value in field t.Repo was too long")
-	}
+		if t.RepoDid == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if len(*t.RepoDid) > 1000000 {
+				return xerrors.Errorf("Value in field t.RepoDid was too long")
+			}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string(t.Repo)); err != nil {
-		return err
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.RepoDid))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(*t.RepoDid)); err != nil {
+				return err
+			}
+		}
 	}
 
 	// t.DefaultBranch (string) (string)
···
 		case "repo":
 
 			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				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.Repo = (*string)(&sval)
+				}
+			}
+			// t.RepoDid (string) (string)
+		case "repoDid":
+
+			{
+				b, err := cr.ReadByte()
 				if err != nil {
 					return err
 				}
+				if b != cbg.CborNull[0] {
+					if err := cr.UnreadByte(); err != nil {
+						return err
+					}
 
-				t.Repo = string(sval)
+					sval, err := cbg.ReadStringWithMax(cr, 1000000)
+					if err != nil {
+						return err
+					}
+
+					t.RepoDid = (*string)(&sval)
+				}
 			}
 			// t.DefaultBranch (string) (string)
 		case "defaultBranch":
···
 	}
 
 	cw := cbg.NewCborWriter(w)
-	fieldCount := 10
+	fieldCount := 11
 
 	if t.Description == nil {
 		fieldCount--
 	}
 
 	if t.Labels == nil {
+		fieldCount--
+	}
+
+	if t.RepoDid == nil {
 		fieldCount--
 	}
 
···
 		}
 	}
 
+	// t.RepoDid (string) (string)
+	if t.RepoDid != nil {
+
+		if len("repoDid") > 1000000 {
+			return xerrors.Errorf("Value in field \"repoDid\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("repoDid")); err != nil {
+			return err
+		}
+
+		if t.RepoDid == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if len(*t.RepoDid) > 1000000 {
+				return xerrors.Errorf("Value in field t.RepoDid was too long")
+			}
+
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.RepoDid))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(*t.RepoDid)); err != nil {
+				return err
+			}
+		}
+	}
+
 	// t.Spindle (string) (string)
 	if t.Spindle != nil {
 
···
 
 				}
 			}
+			// t.RepoDid (string) (string)
+		case "repoDid":
+
+			{
+				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.RepoDid = (*string)(&sval)
+				}
+			}
 			// t.Spindle (string) (string)
 		case "spindle":
 
···
 	}
 
 	cw := cbg.NewCborWriter(w)
-	fieldCount := 6
+	fieldCount := 7
+
+	if t.Repo == nil {
+		fieldCount--
+	}
+
+	if t.RepoDid == nil {
+		fieldCount--
+	}
 
 	if t.Tag == nil {
 		fieldCount--
···
 	}
 
 	// t.Repo (string) (string)
-	if len("repo") > 1000000 {
-		return xerrors.Errorf("Value in field \"repo\" was too long")
-	}
+	if t.Repo != nil {
+
+		if len("repo") > 1000000 {
+			return xerrors.Errorf("Value in field \"repo\" was too long")
+		}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("repo")); err != nil {
-		return err
-	}
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("repo")); err != nil {
+			return err
+		}
 
-	if len(t.Repo) > 1000000 {
-		return xerrors.Errorf("Value in field t.Repo was too long")
-	}
+		if t.Repo == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if len(*t.Repo) > 1000000 {
+				return xerrors.Errorf("Value in field t.Repo was too long")
+			}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string(t.Repo)); err != nil {
-		return err
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(*t.Repo)); err != nil {
+				return err
+			}
+		}
 	}
 
 	// t.LexiconTypeID (string) (string)
···
 	}
 	if _, err := cw.WriteString(string("sh.tangled.repo.artifact")); err != nil {
 		return err
+	}
+
+	// t.RepoDid (string) (string)
+	if t.RepoDid != nil {
+
+		if len("repoDid") > 1000000 {
+			return xerrors.Errorf("Value in field \"repoDid\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("repoDid")); err != nil {
+			return err
+		}
+
+		if t.RepoDid == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if len(*t.RepoDid) > 1000000 {
+				return xerrors.Errorf("Value in field t.RepoDid was too long")
+			}
+
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.RepoDid))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(*t.RepoDid)); err != nil {
+				return err
+			}
+		}
 	}
 
 	// t.Artifact (util.LexBlob) (struct)
···
 		case "repo":
 
 			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				b, err := cr.ReadByte()
 				if err != nil {
 					return err
 				}
+				if b != cbg.CborNull[0] {
+					if err := cr.UnreadByte(); err != nil {
+						return err
+					}
 
-				t.Repo = string(sval)
+					sval, err := cbg.ReadStringWithMax(cr, 1000000)
+					if err != nil {
+						return err
+					}
+
+					t.Repo = (*string)(&sval)
+				}
 			}
 			// t.LexiconTypeID (string) (string)
 		case "$type":
···
 
 				t.LexiconTypeID = string(sval)
 			}
+			// t.RepoDid (string) (string)
+		case "repoDid":
+
+			{
+				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.RepoDid = (*string)(&sval)
+				}
+			}
 			// t.Artifact (util.LexBlob) (struct)
 		case "artifact":
 
···
 	}
 
 	cw := cbg.NewCborWriter(w)
+	fieldCount := 5
 
-	if _, err := cw.Write([]byte{164}); err != nil {
-		return err
+	if t.Repo == nil {
+		fieldCount--
 	}
 
-	// t.Repo (string) (string)
-	if len("repo") > 1000000 {
-		return xerrors.Errorf("Value in field \"repo\" was too long")
+	if t.RepoDid == nil {
+		fieldCount--
 	}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
+	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
 		return err
 	}
-	if _, err := cw.WriteString(string("repo")); err != nil {
-		return err
-	}
+
+	// t.Repo (string) (string)
+	if t.Repo != nil {
+
+		if len("repo") > 1000000 {
+			return xerrors.Errorf("Value in field \"repo\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("repo")); err != nil {
+			return err
+		}
 
-	if len(t.Repo) > 1000000 {
-		return xerrors.Errorf("Value in field t.Repo was too long")
-	}
+		if t.Repo == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if len(*t.Repo) > 1000000 {
+				return xerrors.Errorf("Value in field t.Repo was too long")
+			}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string(t.Repo)); err != nil {
-		return err
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(*t.Repo)); err != nil {
+				return err
+			}
+		}
 	}
 
 	// t.LexiconTypeID (string) (string)
···
 		return err
 	}
 
+	// t.RepoDid (string) (string)
+	if t.RepoDid != nil {
+
+		if len("repoDid") > 1000000 {
+			return xerrors.Errorf("Value in field \"repoDid\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("repoDid")); err != nil {
+			return err
+		}
+
+		if t.RepoDid == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if len(*t.RepoDid) > 1000000 {
+				return xerrors.Errorf("Value in field t.RepoDid was too long")
+			}
+
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.RepoDid))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(*t.RepoDid)); err != nil {
+				return err
+			}
+		}
+	}
+
 	// t.Subject (string) (string)
 	if len("subject") > 1000000 {
 		return xerrors.Errorf("Value in field \"subject\" was too long")
···
 		case "repo":
 
 			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				b, err := cr.ReadByte()
 				if err != nil {
 					return err
 				}
+				if b != cbg.CborNull[0] {
+					if err := cr.UnreadByte(); err != nil {
+						return err
+					}
 
-				t.Repo = string(sval)
+					sval, err := cbg.ReadStringWithMax(cr, 1000000)
+					if err != nil {
+						return err
+					}
+
+					t.Repo = (*string)(&sval)
+				}
 			}
 			// t.LexiconTypeID (string) (string)
 		case "$type":
···
 
 				t.LexiconTypeID = string(sval)
 			}
+			// t.RepoDid (string) (string)
+		case "repoDid":
+
+			{
+				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.RepoDid = (*string)(&sval)
+				}
+			}
 			// t.Subject (string) (string)
 		case "subject":
 
···
 	}
 
 	cw := cbg.NewCborWriter(w)
-	fieldCount := 7
+	fieldCount := 8
 
 	if t.Body == nil {
 		fieldCount--
···
 		fieldCount--
 	}
 
+	if t.Repo == nil {
+		fieldCount--
+	}
+
+	if t.RepoDid == nil {
+		fieldCount--
+	}
+
 	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
 		return err
 	}
···
 	}
 
 	// t.Repo (string) (string)
-	if len("repo") > 1000000 {
-		return xerrors.Errorf("Value in field \"repo\" was too long")
-	}
+	if t.Repo != nil {
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("repo")); err != nil {
-		return err
-	}
+		if len("repo") > 1000000 {
+			return xerrors.Errorf("Value in field \"repo\" was too long")
+		}
 
-	if len(t.Repo) > 1000000 {
-		return xerrors.Errorf("Value in field t.Repo was too long")
-	}
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("repo")); err != nil {
+			return err
+		}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string(t.Repo)); err != nil {
-		return err
+		if t.Repo == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if len(*t.Repo) > 1000000 {
+				return xerrors.Errorf("Value in field t.Repo was too long")
+			}
+
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(*t.Repo)); err != nil {
+				return err
+			}
+		}
 	}
 
 	// t.LexiconTypeID (string) (string)
···
 	}
 	if _, err := cw.WriteString(string(t.Title)); err != nil {
 		return err
+	}
+
+	// t.RepoDid (string) (string)
+	if t.RepoDid != nil {
+
+		if len("repoDid") > 1000000 {
+			return xerrors.Errorf("Value in field \"repoDid\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("repoDid")); err != nil {
+			return err
+		}
+
+		if t.RepoDid == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if len(*t.RepoDid) > 1000000 {
+				return xerrors.Errorf("Value in field t.RepoDid was too long")
+			}
+
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.RepoDid))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(*t.RepoDid)); err != nil {
+				return err
+			}
+		}
 	}
 
 	// t.Mentions ([]string) (slice)
···
 		case "repo":
 
 			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				b, err := cr.ReadByte()
 				if err != nil {
 					return err
 				}
+				if b != cbg.CborNull[0] {
+					if err := cr.UnreadByte(); err != nil {
+						return err
+					}
 
-				t.Repo = string(sval)
+					sval, err := cbg.ReadStringWithMax(cr, 1000000)
+					if err != nil {
+						return err
+					}
+
+					t.Repo = (*string)(&sval)
+				}
 			}
 			// t.LexiconTypeID (string) (string)
 		case "$type":
···
 				}
 
 				t.Title = string(sval)
+			}
+			// t.RepoDid (string) (string)
+		case "repoDid":
+
+			{
+				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.RepoDid = (*string)(&sval)
+				}
 			}
 			// t.Mentions ([]string) (slice)
 		case "mentions":
···
 	}
 
 	cw := cbg.NewCborWriter(w)
-	fieldCount := 3
+	fieldCount := 4
 
 	if t.Repo == nil {
+		fieldCount--
+	}
+
+	if t.RepoDid == nil {
 		fieldCount--
 	}
 
···
 	if _, err := cw.WriteString(string(t.Branch)); err != nil {
 		return err
 	}
+
+	// t.RepoDid (string) (string)
+	if t.RepoDid != nil {
+
+		if len("repoDid") > 1000000 {
+			return xerrors.Errorf("Value in field \"repoDid\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("repoDid")); err != nil {
+			return err
+		}
+
+		if t.RepoDid == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if len(*t.RepoDid) > 1000000 {
+				return xerrors.Errorf("Value in field t.RepoDid was too long")
+			}
+
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.RepoDid))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(*t.RepoDid)); err != nil {
+				return err
+			}
+		}
+	}
 	return nil
 }
 
···
 
 	n := extra
 
-	nameBuf := make([]byte, 6)
+	nameBuf := make([]byte, 7)
 	for i := uint64(0); i < n; i++ {
 		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
 		if err != nil {
···
 
 				t.Branch = string(sval)
 			}
+			// t.RepoDid (string) (string)
+		case "repoDid":
+
+			{
+				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.RepoDid = (*string)(&sval)
+				}
+			}
 
 		default:
 			// Field doesn't exist on this type, so ignore it
···
 	}
 
 	cw := cbg.NewCborWriter(w)
+	fieldCount := 3
 
-	if _, err := cw.Write([]byte{162}); err != nil {
-		return err
+	if t.Repo == nil {
+		fieldCount--
 	}
 
-	// t.Repo (string) (string)
-	if len("repo") > 1000000 {
-		return xerrors.Errorf("Value in field \"repo\" was too long")
+	if t.RepoDid == nil {
+		fieldCount--
 	}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("repo")); err != nil {
+	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
 		return err
 	}
 
-	if len(t.Repo) > 1000000 {
-		return xerrors.Errorf("Value in field t.Repo was too long")
-	}
+	// t.Repo (string) (string)
+	if t.Repo != nil {
+
+		if len("repo") > 1000000 {
+			return xerrors.Errorf("Value in field \"repo\" was too long")
+		}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string(t.Repo)); err != nil {
-		return err
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("repo")); err != nil {
+			return err
+		}
+
+		if t.Repo == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if len(*t.Repo) > 1000000 {
+				return xerrors.Errorf("Value in field t.Repo was too long")
+			}
+
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(*t.Repo)); err != nil {
+				return err
+			}
+		}
 	}
 
 	// t.Branch (string) (string)
···
 	if _, err := cw.WriteString(string(t.Branch)); err != nil {
 		return err
 	}
+
+	// t.RepoDid (string) (string)
+	if t.RepoDid != nil {
+
+		if len("repoDid") > 1000000 {
+			return xerrors.Errorf("Value in field \"repoDid\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("repoDid")); err != nil {
+			return err
+		}
+
+		if t.RepoDid == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if len(*t.RepoDid) > 1000000 {
+				return xerrors.Errorf("Value in field t.RepoDid was too long")
+			}
+
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.RepoDid))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(*t.RepoDid)); err != nil {
+				return err
+			}
+		}
+	}
 	return nil
 }
 
···
 
 	n := extra
 
-	nameBuf := make([]byte, 6)
+	nameBuf := make([]byte, 7)
 	for i := uint64(0); i < n; i++ {
 		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
 		if err != nil {
···
 		case "repo":
 
 			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				b, err := cr.ReadByte()
 				if err != nil {
 					return err
 				}
+				if b != cbg.CborNull[0] {
+					if err := cr.UnreadByte(); err != nil {
+						return err
+					}
 
-				t.Repo = string(sval)
+					sval, err := cbg.ReadStringWithMax(cr, 1000000)
+					if err != nil {
+						return err
+					}
+
+					t.Repo = (*string)(&sval)
+				}
 			}
 			// t.Branch (string) (string)
 		case "branch":
···
 				}
 
 				t.Branch = string(sval)
+			}
+			// t.RepoDid (string) (string)
+		case "repoDid":
+
+			{
+				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.RepoDid = (*string)(&sval)
+				}
 			}
 
 		default:

api/tangled/feedstar.go

···
 } //
 // RECORDTYPE: FeedStar
 type FeedStar struct {
-	LexiconTypeID string `json:"$type,const=sh.tangled.feed.star" cborgen:"$type,const=sh.tangled.feed.star"`
-	CreatedAt     string `json:"createdAt" cborgen:"createdAt"`
-	Subject       string `json:"subject" cborgen:"subject"`
+	LexiconTypeID string  `json:"$type,const=sh.tangled.feed.star" cborgen:"$type,const=sh.tangled.feed.star"`
+	CreatedAt     string  `json:"createdAt" cborgen:"createdAt"`
+	Subject       *string `json:"subject,omitempty" cborgen:"subject,omitempty"`
+	SubjectDid    *string `json:"subjectDid,omitempty" cborgen:"subjectDid,omitempty"`
 }

api/tangled/gitrefUpdate.go

···
 	NewSha string `json:"newSha" cborgen:"newSha"`
 	// oldSha: old SHA of this ref
 	OldSha string `json:"oldSha" cborgen:"oldSha"`
+	// ownerDid: did of the owner of the repo
+	OwnerDid *string `json:"ownerDid,omitempty" cborgen:"ownerDid,omitempty"`
 	// ref: Ref being updated
 	Ref string `json:"ref" cborgen:"ref"`
-	// repoDid: did of the owner of the repo
-	RepoDid string `json:"repoDid" cborgen:"repoDid"`
+	// repoDid: DID of the repo itself
+	RepoDid *string `json:"repoDid,omitempty" cborgen:"repoDid,omitempty"`
 	// repoName: name of the repo
 	RepoName string `json:"repoName" cborgen:"repoName"`
 }

api/tangled/repoartifact.go

···
 	// name: name of the artifact
 	Name string `json:"name" cborgen:"name"`
 	// repo: repo that this artifact is being uploaded to
-	Repo string `json:"repo" cborgen:"repo"`
+	Repo    *string `json:"repo,omitempty" cborgen:"repo,omitempty"`
+	RepoDid *string `json:"repoDid,omitempty" cborgen:"repoDid,omitempty"`
 	// tag: hash of the tag object that this artifact is attached to (only annotated tags are supported)
 	Tag util.LexBytes `json:"tag,omitempty" cborgen:"tag,omitempty"`
 }

api/tangled/repocollaborator.go

···
 	LexiconTypeID string `json:"$type,const=sh.tangled.repo.collaborator" cborgen:"$type,const=sh.tangled.repo.collaborator"`
 	CreatedAt     string `json:"createdAt" cborgen:"createdAt"`
 	// repo: repo to add this user to
-	Repo    string `json:"repo" cborgen:"repo"`
-	Subject string `json:"subject" cborgen:"subject"`
+	Repo    *string `json:"repo,omitempty" cborgen:"repo,omitempty"`
+	RepoDid *string `json:"repoDid,omitempty" cborgen:"repoDid,omitempty"`
+	Subject string  `json:"subject" cborgen:"subject"`
 }

api/tangled/repocreate.go

···
 type RepoCreate_Input struct {
 	// defaultBranch: Default branch to push to
 	DefaultBranch *string `json:"defaultBranch,omitempty" cborgen:"defaultBranch,omitempty"`
+	// name: Name of the repository
+	Name string `json:"name" cborgen:"name"`
+	// repoDid: Optional user-provided did:web to use as the repo identity instead of minting a did:plc.
+	RepoDid *string `json:"repoDid,omitempty" cborgen:"repoDid,omitempty"`
 	// rkey: Rkey of the repository record
 	Rkey string `json:"rkey" cborgen:"rkey"`
 	// source: A source URL to clone from, populate this when forking or importing a repository.
 	Source *string `json:"source,omitempty" cborgen:"source,omitempty"`
+}
+
+// RepoCreate_Output is the output of a sh.tangled.repo.create call.
+type RepoCreate_Output struct {
+	RepoDid *string `json:"repoDid,omitempty" cborgen:"repoDid,omitempty"`
 }
 
 // RepoCreate calls the XRPC method "sh.tangled.repo.create".
-func RepoCreate(ctx context.Context, c util.LexClient, input *RepoCreate_Input) error {
-	if err := c.LexDo(ctx, util.Procedure, "application/json", "sh.tangled.repo.create", nil, input, nil); err != nil {
-		return err
+func RepoCreate(ctx context.Context, c util.LexClient, input *RepoCreate_Input) (*RepoCreate_Output, error) {
+	var out RepoCreate_Output
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "sh.tangled.repo.create", nil, input, &out); err != nil {
+		return nil, err
 	}
 
-	return nil
+	return &out, nil
 }

api/tangled/repoissue.go

···
 	CreatedAt     string   `json:"createdAt" cborgen:"createdAt"`
 	Mentions      []string `json:"mentions,omitempty" cborgen:"mentions,omitempty"`
 	References    []string `json:"references,omitempty" cborgen:"references,omitempty"`
-	Repo          string   `json:"repo" cborgen:"repo"`
+	Repo          *string  `json:"repo,omitempty" cborgen:"repo,omitempty"`
+	RepoDid       *string  `json:"repoDid,omitempty" cborgen:"repoDid,omitempty"`
 	Title         string   `json:"title" cborgen:"title"`
 }

api/tangled/repopull.go

···
 
 // RepoPull_Source is a "source" in the sh.tangled.repo.pull schema.
 type RepoPull_Source struct {
-	Branch string  `json:"branch" cborgen:"branch"`
-	Repo   *string `json:"repo,omitempty" cborgen:"repo,omitempty"`
-	Sha    string  `json:"sha" cborgen:"sha"`
+	Branch  string  `json:"branch" cborgen:"branch"`
+	Repo    *string `json:"repo,omitempty" cborgen:"repo,omitempty"`
+	RepoDid *string `json:"repoDid,omitempty" cborgen:"repoDid,omitempty"`
+	Sha     string  `json:"sha" cborgen:"sha"`
 }
 
 // RepoPull_Target is a "target" in the sh.tangled.repo.pull schema.
 type RepoPull_Target struct {
-	Branch string `json:"branch" cborgen:"branch"`
-	Repo   string `json:"repo" cborgen:"repo"`
+	Branch  string  `json:"branch" cborgen:"branch"`
+	Repo    *string `json:"repo,omitempty" cborgen:"repo,omitempty"`
+	RepoDid *string `json:"repoDid,omitempty" cborgen:"repoDid,omitempty"`
 }

api/tangled/tangledpipeline.go

···
 
 // Pipeline_TriggerRepo is a "triggerRepo" in the sh.tangled.pipeline schema.
 type Pipeline_TriggerRepo struct {
-	DefaultBranch string `json:"defaultBranch" cborgen:"defaultBranch"`
-	Did           string `json:"did" cborgen:"did"`
-	Knot          string `json:"knot" cborgen:"knot"`
-	Repo          string `json:"repo" cborgen:"repo"`
+	DefaultBranch string  `json:"defaultBranch" cborgen:"defaultBranch"`
+	Did           string  `json:"did" cborgen:"did"`
+	Knot          string  `json:"knot" cborgen:"knot"`
+	Repo          *string `json:"repo,omitempty" cborgen:"repo,omitempty"`
+	// repoDid: DID of the repo itself
+	RepoDid *string `json:"repoDid,omitempty" cborgen:"repoDid,omitempty"`
 }
 
 // Pipeline_Workflow is a "workflow" in the sh.tangled.pipeline schema.

api/tangled/tangledrepo.go

···
 	Labels []string `json:"labels,omitempty" cborgen:"labels,omitempty"`
 	// name: name of the repo
 	Name string `json:"name" cborgen:"name"`
+	// repoDid: DID of the repo itself, if assigned
+	RepoDid *string `json:"repoDid,omitempty" cborgen:"repoDid,omitempty"`
 	// source: source of the repo
 	Source *string `json:"source,omitempty" cborgen:"source,omitempty"`
 	// spindle: CI runner to send jobs to and receive results from

knotmirror/knotstream/slurper.go

···
 
 	l := s.logger.With("src", source)
 
-	curr, err := db.GetRepoByName(ctx, s.db, syntax.DID(evt.Event.RepoDid), evt.Event.RepoName)
+	repoDid := ""
+	if evt.Event.RepoDid != nil {
+		repoDid = *evt.Event.RepoDid
+	}
+	curr, err := db.GetRepoByName(ctx, s.db, syntax.DID(repoDid), evt.Event.RepoName)
 	if err != nil {
-		return fmt.Errorf("failed to get repo '%s': %w", evt.Event.RepoDid+"/"+evt.Event.RepoName, err)
+		return fmt.Errorf("failed to get repo '%s': %w", repoDid+"/"+evt.Event.RepoName, err)
 	}
 	if curr == nil {
 		// if repo doesn't exist in DB, just ignore the event. That repo is unknown.
···
 		// But we want to store that in did/rkey in knot-mirror.
 		// Therefore, we should ignore when the repository is unknown.
 		// Hopefully crawler will sync it later.
-		l.Warn("skipping event from unknown repo", "did/name", evt.Event.RepoDid+"/"+evt.Event.RepoName)
+		l.Warn("skipping event from unknown repo", "did/name", repoDid+"/"+evt.Event.RepoName)
 		knotstreamEventsSkipped.Inc()
 		return nil
 	}

lexicons/actor/profile.json

···
             "maxGraphemes": 40,
             "maxLength": 400
           },
+          "pinnedRepositoryDids": {
+            "type": "array",
+            "minLength": 0,
+            "maxLength": 6,
+            "items": {
+              "type": "string",
+              "format": "did"
+            }
+          },
           "pinnedRepositories": {
             "type": "array",
             "description": "Any ATURI, it is up to appviews to validate these fields.",

lexicons/feed/star.json

···
       "record": {
         "type": "object",
         "required": [
-          "subject",
           "createdAt"
         ],
         "properties": {
           "subject": {
             "type": "string",
             "format": "at-uri"
+          },
+          "subjectDid": {
+            "type": "string",
+            "format": "did"
           },
           "createdAt": {
             "type": "string",

lexicons/git/refUpdate.json

···
         "required": [
           "ref",
           "committerDid",
-          "repoDid",
           "repoName",
           "oldSha",
           "newSha",
···
             "description": "did of the user that pushed this ref",
             "format": "did"
           },
+          "ownerDid": {
+            "type": "string",
+            "description": "did of the owner of the repo",
+            "format": "did"
+          },
           "repoDid": {
             "type": "string",
-            "description": "did of the owner of the repo",
+            "description": "DID of the repo itself",
             "format": "did"
           },
           "repoName": {

lexicons/issue/issue.json

···
       "key": "tid",
       "record": {
         "type": "object",
-        "required": ["repo", "title", "createdAt"],
+        "required": ["title", "createdAt"],
         "properties": {
           "repo": {
             "type": "string",
             "format": "at-uri"
+          },
+          "repoDid": {
+            "type": "string",
+            "format": "did"
           },
           "title": {
             "type": "string"

lexicons/pipeline/pipeline.json

···
       "required": [
         "knot",
         "did",
-        "repo",
         "defaultBranch"
       ],
       "properties": {
···
         },
         "did": {
           "type": "string",
+          "format": "did"
+        },
+        "repoDid": {
+          "type": "string",
+          "description": "DID of the repo itself",
           "format": "did"
         },
         "repo": {

lexicons/pulls/pull.json

···
     "target": {
       "type": "object",
       "required": [
-        "repo",
         "branch"
       ],
       "properties": {
         "repo": {
           "type": "string",
           "format": "at-uri"
+        },
+        "repoDid": {
+          "type": "string",
+          "format": "did"
         },
         "branch": {
           "type": "string"
···
         "repo": {
           "type": "string",
           "format": "at-uri"
+        },
+        "repoDid": {
+          "type": "string",
+          "format": "did"
         }
       }
     }

lexicons/repo/artifact.json

···
         "type": "object",
         "required": [
           "name",
-          "repo",
           "tag",
           "createdAt",
           "artifact"
···
             "type": "string",
             "format": "at-uri",
             "description": "repo that this artifact is being uploaded to"
+          },
+          "repoDid": {
+            "type": "string",
+            "format": "did"
           },
           "tag": {
             "type": "bytes",

lexicons/repo/collaborator.json

···
         "type": "object",
         "required": [
           "subject",
-          "repo",
           "createdAt"
         ],
         "properties": {
···
             "type": "string",
             "description": "repo to add this user to",
             "format": "at-uri"
+          },
+          "repoDid": {
+            "type": "string",
+            "format": "did"
           },
           "createdAt": {
             "type": "string",

lexicons/repo/create.json

···
         "schema": {
           "type": "object",
           "required": [
-            "rkey"
+            "rkey",
+            "name"
           ],
           "properties": {
             "rkey": {
               "type": "string",
               "description": "Rkey of the repository record"
             },
+            "name": {
+              "type": "string",
+              "description": "Name of the repository"
+            },
             "defaultBranch": {
               "type": "string",
               "description": "Default branch to push to"
···
             "source": {
               "type": "string",
               "description": "A source URL to clone from, populate this when forking or importing a repository."
+            },
+            "repoDid": {
+              "type": "string",
+              "format": "did",
+              "description": "Optional user-provided did:web to use as the repo identity instead of minting a did:plc."
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "repoDid": {
+              "type": "string",
+              "format": "did"
             }
           }
         }

lexicons/repo/repo.json

···
               "format": "at-uri"
             }
           },
+          "repoDid": {
+            "type": "string",
+            "format": "did",
+            "description": "DID of the repo itself, if assigned"
+          },
           "createdAt": {
             "type": "string",
             "format": "datetime"

spindle/models/clone_test.go

···
 	"tangled.org/core/workflow"
 )
 
+func sp(s string) *string { return &s }
+
 func TestBuildCloneStep_PushTrigger(t *testing.T) {
 	twf := tangled.Pipeline_Workflow{
 		Clone: &tangled.Pipeline_CloneOpts{
···
 		Repo: &tangled.Pipeline_TriggerRepo{
 			Knot: "example.com",
 			Did:  "did:plc:user123",
-			Repo: "my-repo",
+			Repo: sp("my-repo"),
 		},
 	}
 
···
 		Repo: &tangled.Pipeline_TriggerRepo{
 			Knot: "example.com",
 			Did:  "did:plc:user123",
-			Repo: "my-repo",
+			Repo: sp("my-repo"),
 		},
 	}
 
···
 		Repo: &tangled.Pipeline_TriggerRepo{
 			Knot: "example.com",
 			Did:  "did:plc:user123",
-			Repo: "my-repo",
+			Repo: sp("my-repo"),
 		},
 	}
 
···
 		Repo: &tangled.Pipeline_TriggerRepo{
 			Knot: "example.com",
 			Did:  "did:plc:user123",
-			Repo: "my-repo",
+			Repo: sp("my-repo"),
 		},
 	}
 
···
 		Repo: &tangled.Pipeline_TriggerRepo{
 			Knot: "localhost:3000",
 			Did:  "did:plc:user123",
-			Repo: "my-repo",
+			Repo: sp("my-repo"),
 		},
 	}
 
···
 		Repo: &tangled.Pipeline_TriggerRepo{
 			Knot: "example.com",
 			Did:  "did:plc:user123",
-			Repo: "my-repo",
+			Repo: sp("my-repo"),
 		},
 	}
 
···
 		Repo: &tangled.Pipeline_TriggerRepo{
 			Knot: "example.com",
 			Did:  "did:plc:user123",
-			Repo: "my-repo",
+			Repo: sp("my-repo"),
 		},
 	}
 
···
 		Repo: &tangled.Pipeline_TriggerRepo{
 			Knot: "example.com",
 			Did:  "did:plc:user123",
-			Repo: "my-repo",
+			Repo: sp("my-repo"),
 		},
 	}
 
···
 		Repo: &tangled.Pipeline_TriggerRepo{
 			Knot: "example.com",
 			Did:  "did:plc:user123",
-			Repo: "my-repo",
+			Repo: sp("my-repo"),
 		},
 	}
 
···
 		Repo: &tangled.Pipeline_TriggerRepo{
 			Knot: "example.com",
 			Did:  "did:plc:user123",
-			Repo: "my-repo",
+			Repo: sp("my-repo"),
 		},
 	}
 
···
 		Repo: &tangled.Pipeline_TriggerRepo{
 			Knot: "example.com",
 			Did:  "did:plc:user123",
-			Repo: "my-repo",
+			Repo: sp("my-repo"),
 		},
 	}
 

spindle/models/pipeline_env_test.go

···
 		Repo: &tangled.Pipeline_TriggerRepo{
 			Knot:          "example.com",
 			Did:           "did:plc:user123",
-			Repo:          "my-repo",
+			Repo:          sp("my-repo"),
 			DefaultBranch: "main",
 		},
 	}
···
 		Repo: &tangled.Pipeline_TriggerRepo{
 			Knot: "example.com",
 			Did:  "did:plc:user123",
-			Repo: "my-repo",
+			Repo: sp("my-repo"),
 		},
 	}
 	id := PipelineId{
···
 		Repo: &tangled.Pipeline_TriggerRepo{
 			Knot: "example.com",
 			Did:  "did:plc:user123",
-			Repo: "my-repo",
+			Repo: sp("my-repo"),
 		},
 	}
 	id := PipelineId{
···
 		Repo: &tangled.Pipeline_TriggerRepo{
 			Knot: "example.com",
 			Did:  "did:plc:user123",
-			Repo: "my-repo",
+			Repo: sp("my-repo"),
 		},
 	}
 	id := PipelineId{
···
 		Repo: &tangled.Pipeline_TriggerRepo{
 			Knot: "localhost:3000",
 			Did:  "did:plc:user123",
-			Repo: "my-repo",
+			Repo: sp("my-repo"),
 		},
 	}
 	id := PipelineId{
···
 		Repo: &tangled.Pipeline_TriggerRepo{
 			Knot: "example.com",
 			Did:  "did:plc:user123",
-			Repo: "my-repo",
+			Repo: sp("my-repo"),
 		},
 	}
 	id := PipelineId{