lexicons,api: new knot lexicon

Signed-off-by: Anirudh Oppiliappan <[e-mail]>

api/tangled/cbor_gen.go

···
 
 	return nil
 }
-func (t *GitRefUpdate) MarshalCBOR(w io.Writer) error {
+func (t *GitRefUpdate_Meta_CommitCount_ByEmail_Elem) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
 		return err
···
 
 	cw := cbg.NewCborWriter(w)
 
-	if _, err := cw.Write([]byte{168}); err != nil {
-		return err
-	}
-
-	// t.Ref (string) (string)
-	if len("ref") > 1000000 {
-		return xerrors.Errorf("Value in field \"ref\" was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ref"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("ref")); err != nil {
-		return err
-	}
-
-	if len(t.Ref) > 1000000 {
-		return xerrors.Errorf("Value in field t.Ref was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Ref))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string(t.Ref)); err != nil {
-		return err
-	}
-
-	// t.Meta (tangled.GitRefUpdate_Meta) (struct)
-	if len("meta") > 1000000 {
-		return xerrors.Errorf("Value in field \"meta\" was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("meta"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("meta")); err != nil {
-		return err
-	}
-
-	if err := t.Meta.MarshalCBOR(cw); 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("sh.tangled.git.refUpdate"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("sh.tangled.git.refUpdate")); err != nil {
-		return err
-	}
-
-	// t.NewSha (string) (string)
-	if len("newSha") > 1000000 {
-		return xerrors.Errorf("Value in field \"newSha\" was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("newSha"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("newSha")); err != nil {
-		return err
-	}
-
-	if len(t.NewSha) > 1000000 {
-		return xerrors.Errorf("Value in field t.NewSha was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.NewSha))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string(t.NewSha)); err != nil {
-		return err
-	}
-
-	// t.OldSha (string) (string)
-	if len("oldSha") > 1000000 {
-		return xerrors.Errorf("Value in field \"oldSha\" was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("oldSha"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("oldSha")); err != nil {
-		return err
-	}
-
-	if len(t.OldSha) > 1000000 {
-		return xerrors.Errorf("Value in field t.OldSha was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.OldSha))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string(t.OldSha)); err != nil {
-		return err
-	}
-
-	// t.RepoDid (string) (string)
-	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 {
+	if _, err := cw.Write([]byte{162}); err != nil {
 		return err
 	}
 
-	if len(t.RepoDid) > 1000000 {
-		return xerrors.Errorf("Value in field t.RepoDid was too long")
+	// t.Count (int64) (int64)
+	if len("count") > 1000000 {
+		return xerrors.Errorf("Value in field \"count\" was too long")
 	}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.RepoDid))); err != nil {
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("count"))); err != nil {
 		return err
 	}
-	if _, err := cw.WriteString(string(t.RepoDid)); err != nil {
+	if _, err := cw.WriteString(string("count")); err != nil {
 		return err
 	}
 
-	// t.RepoName (string) (string)
-	if len("repoName") > 1000000 {
-		return xerrors.Errorf("Value in field \"repoName\" was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoName"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("repoName")); err != nil {
-		return err
-	}
-
-	if len(t.RepoName) > 1000000 {
-		return xerrors.Errorf("Value in field t.RepoName was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.RepoName))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string(t.RepoName)); err != nil {
-		return err
+	if t.Count >= 0 {
+		if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Count)); err != nil {
+			return err
+		}
+	} else {
+		if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Count-1)); err != nil {
+			return err
+		}
 	}
 
-	// t.CommitterDid (string) (string)
-	if len("committerDid") > 1000000 {
-		return xerrors.Errorf("Value in field \"committerDid\" was too long")
+	// t.Email (string) (string)
+	if len("email") > 1000000 {
+		return xerrors.Errorf("Value in field \"email\" was too long")
 	}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("committerDid"))); err != nil {
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("email"))); err != nil {
 		return err
 	}
-	if _, err := cw.WriteString(string("committerDid")); err != nil {
+	if _, err := cw.WriteString(string("email")); err != nil {
 		return err
 	}
 
-	if len(t.CommitterDid) > 1000000 {
-		return xerrors.Errorf("Value in field t.CommitterDid was too long")
+	if len(t.Email) > 1000000 {
+		return xerrors.Errorf("Value in field t.Email was too long")
 	}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CommitterDid))); err != nil {
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Email))); err != nil {
 		return err
 	}
-	if _, err := cw.WriteString(string(t.CommitterDid)); err != nil {
+	if _, err := cw.WriteString(string(t.Email)); err != nil {
 		return err
 	}
 	return nil
 }
 
-func (t *GitRefUpdate) UnmarshalCBOR(r io.Reader) (err error) {
-	*t = GitRefUpdate{}
+func (t *GitRefUpdate_Meta_CommitCount_ByEmail_Elem) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = GitRefUpdate_Meta_CommitCount_ByEmail_Elem{}
 
 	cr := cbg.NewCborReader(r)
 
···
 	}
 
 	if extra > cbg.MaxLength {
-		return fmt.Errorf("GitRefUpdate: map struct too large (%d)", extra)
+		return fmt.Errorf("GitRefUpdate_Meta_CommitCount_ByEmail_Elem: map struct too large (%d)", extra)
 	}
 
 	n := extra
 
-	nameBuf := make([]byte, 12)
+	nameBuf := make([]byte, 5)
 	for i := uint64(0); i < n; i++ {
 		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
 		if err != nil {
···
 		}
 
 		switch string(nameBuf[:nameLen]) {
-		// t.Ref (string) (string)
-		case "ref":
-
+		// t.Count (int64) (int64)
+		case "count":
 			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
-				if err != nil {
-					return err
-				}
-
-				t.Ref = string(sval)
-			}
-			// t.Meta (tangled.GitRefUpdate_Meta) (struct)
-		case "meta":
-
-			{
-
-				b, err := cr.ReadByte()
+				maj, extra, err := cr.ReadHeader()
 				if err != nil {
 					return err
 				}
-				if b != cbg.CborNull[0] {
-					if err := cr.UnreadByte(); err != nil {
-						return err
+				var extraI int64
+				switch maj {
+				case cbg.MajUnsignedInt:
+					extraI = int64(extra)
+					if extraI < 0 {
+						return fmt.Errorf("int64 positive overflow")
 					}
-					t.Meta = new(GitRefUpdate_Meta)
-					if err := t.Meta.UnmarshalCBOR(cr); err != nil {
-						return xerrors.Errorf("unmarshaling t.Meta pointer: %w", err)
+				case cbg.MajNegativeInt:
+					extraI = int64(extra)
+					if extraI < 0 {
+						return fmt.Errorf("int64 negative overflow")
 					}
-				}
-
-			}
-			// t.LexiconTypeID (string) (string)
-		case "$type":
-
-			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
-				if err != nil {
-					return err
-				}
-
-				t.LexiconTypeID = string(sval)
-			}
-			// t.NewSha (string) (string)
-		case "newSha":
-
-			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
-				if err != nil {
-					return err
-				}
-
-				t.NewSha = string(sval)
-			}
-			// t.OldSha (string) (string)
-		case "oldSha":
-
-			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
-				if err != nil {
-					return err
-				}
-
-				t.OldSha = string(sval)
-			}
-			// t.RepoDid (string) (string)
-		case "repoDid":
-
-			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
-				if err != nil {
-					return err
+					extraI = -1 - extraI
+				default:
+					return fmt.Errorf("wrong type for int64 field: %d", maj)
 				}
 
-				t.RepoDid = string(sval)
+				t.Count = int64(extraI)
 			}
-			// t.RepoName (string) (string)
-		case "repoName":
+			// t.Email (string) (string)
+		case "email":
 
 			{
 				sval, err := cbg.ReadStringWithMax(cr, 1000000)
···
 					return err
 				}
 
-				t.RepoName = string(sval)
-			}
-			// t.CommitterDid (string) (string)
-		case "committerDid":
-
-			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
-				if err != nil {
-					return err
-				}
-
-				t.CommitterDid = string(sval)
+				t.Email = string(sval)
 			}
 
 		default:
···
 
 	return nil
 }
-func (t *GitRefUpdate_Meta) MarshalCBOR(w io.Writer) error {
+func (t *GitRefUpdate_Meta_CommitCount) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
 		return err
 	}
 
 	cw := cbg.NewCborWriter(w)
-	fieldCount := 3
+	fieldCount := 1
 
-	if t.LangBreakdown == nil {
+	if t.ByEmail == nil {
 		fieldCount--
 	}
 
···
 		return err
 	}
 
-	// t.CommitCount (tangled.GitRefUpdate_Meta_CommitCount) (struct)
-	if len("commitCount") > 1000000 {
-		return xerrors.Errorf("Value in field \"commitCount\" was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("commitCount"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("commitCount")); err != nil {
-		return err
-	}
-
-	if err := t.CommitCount.MarshalCBOR(cw); err != nil {
-		return err
-	}
-
-	// t.IsDefaultRef (bool) (bool)
-	if len("isDefaultRef") > 1000000 {
-		return xerrors.Errorf("Value in field \"isDefaultRef\" was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("isDefaultRef"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("isDefaultRef")); err != nil {
-		return err
-	}
-
-	if err := cbg.WriteBool(w, t.IsDefaultRef); err != nil {
-		return err
-	}
+	// t.ByEmail ([]*tangled.GitRefUpdate_Meta_CommitCount_ByEmail_Elem) (slice)
+	if t.ByEmail != nil {
 
-	// t.LangBreakdown (tangled.GitRefUpdate_Meta_LangBreakdown) (struct)
-	if t.LangBreakdown != nil {
-
-		if len("langBreakdown") > 1000000 {
-			return xerrors.Errorf("Value in field \"langBreakdown\" was too long")
+		if len("byEmail") > 1000000 {
+			return xerrors.Errorf("Value in field \"byEmail\" was too long")
 		}
 
-		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("langBreakdown"))); err != nil {
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("byEmail"))); err != nil {
 			return err
 		}
-		if _, err := cw.WriteString(string("langBreakdown")); err != nil {
+		if _, err := cw.WriteString(string("byEmail")); err != nil {
 			return err
 		}
 
-		if err := t.LangBreakdown.MarshalCBOR(cw); err != nil {
+		if len(t.ByEmail) > 8192 {
+			return xerrors.Errorf("Slice value in field t.ByEmail was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.ByEmail))); err != nil {
 			return err
 		}
+		for _, v := range t.ByEmail {
+			if err := v.MarshalCBOR(cw); err != nil {
+				return err
+			}
+
+		}
 	}
 	return nil
 }
 
-func (t *GitRefUpdate_Meta) UnmarshalCBOR(r io.Reader) (err error) {
-	*t = GitRefUpdate_Meta{}
+func (t *GitRefUpdate_Meta_CommitCount) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = GitRefUpdate_Meta_CommitCount{}
 
 	cr := cbg.NewCborReader(r)
 
···
 	}
 
 	if extra > cbg.MaxLength {
-		return fmt.Errorf("GitRefUpdate_Meta: map struct too large (%d)", extra)
+		return fmt.Errorf("GitRefUpdate_Meta_CommitCount: map struct too large (%d)", extra)
 	}
 
 	n := extra
 
-	nameBuf := make([]byte, 13)
+	nameBuf := make([]byte, 7)
 	for i := uint64(0); i < n; i++ {
 		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
 		if err != nil {
···
 		}
 
 		switch string(nameBuf[:nameLen]) {
-		// t.CommitCount (tangled.GitRefUpdate_Meta_CommitCount) (struct)
-		case "commitCount":
-
-			{
-
-				b, err := cr.ReadByte()
-				if err != nil {
-					return err
-				}
-				if b != cbg.CborNull[0] {
-					if err := cr.UnreadByte(); err != nil {
-						return err
-					}
-					t.CommitCount = new(GitRefUpdate_Meta_CommitCount)
-					if err := t.CommitCount.UnmarshalCBOR(cr); err != nil {
-						return xerrors.Errorf("unmarshaling t.CommitCount pointer: %w", err)
-					}
-				}
-
-			}
-			// t.IsDefaultRef (bool) (bool)
-		case "isDefaultRef":
+		// t.ByEmail ([]*tangled.GitRefUpdate_Meta_CommitCount_ByEmail_Elem) (slice)
+		case "byEmail":
 
 			maj, extra, err = cr.ReadHeader()
 			if err != nil {
 				return err
 			}
-			if maj != cbg.MajOther {
-				return fmt.Errorf("booleans must be major type 7")
+
+			if extra > 8192 {
+				return fmt.Errorf("t.ByEmail: array too large (%d)", extra)
 			}
-			switch extra {
-			case 20:
-				t.IsDefaultRef = false
-			case 21:
-				t.IsDefaultRef = true
-			default:
-				return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
+
+			if maj != cbg.MajArray {
+				return fmt.Errorf("expected cbor array")
 			}
-			// t.LangBreakdown (tangled.GitRefUpdate_Meta_LangBreakdown) (struct)
-		case "langBreakdown":
 
-			{
+			if extra > 0 {
+				t.ByEmail = make([]*GitRefUpdate_Meta_CommitCount_ByEmail_Elem, extra)
+			}
 
-				b, err := cr.ReadByte()
-				if err != nil {
-					return err
-				}
-				if b != cbg.CborNull[0] {
-					if err := cr.UnreadByte(); err != nil {
-						return err
-					}
-					t.LangBreakdown = new(GitRefUpdate_Meta_LangBreakdown)
-					if err := t.LangBreakdown.UnmarshalCBOR(cr); err != nil {
-						return xerrors.Errorf("unmarshaling t.LangBreakdown pointer: %w", err)
+			for i := 0; i < int(extra); i++ {
+				{
+					var maj byte
+					var extra uint64
+					var err error
+					_ = maj
+					_ = extra
+					_ = err
+
+					{
+
+						b, err := cr.ReadByte()
+						if err != nil {
+							return err
+						}
+						if b != cbg.CborNull[0] {
+							if err := cr.UnreadByte(); err != nil {
+								return err
+							}
+							t.ByEmail[i] = new(GitRefUpdate_Meta_CommitCount_ByEmail_Elem)
+							if err := t.ByEmail[i].UnmarshalCBOR(cr); err != nil {
+								return xerrors.Errorf("unmarshaling t.ByEmail[i] pointer: %w", err)
+							}
+						}
+
 					}
-				}
 
+				}
 			}
 
 		default:
···
 
 	return nil
 }
-func (t *GitRefUpdate_Meta_CommitCount) MarshalCBOR(w io.Writer) error {
+func (t *GitRefUpdate_Meta_LangBreakdown) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
 		return err
···
 	cw := cbg.NewCborWriter(w)
 	fieldCount := 1
 
-	if t.ByEmail == nil {
+	if t.Inputs == nil {
 		fieldCount--
 	}
 
···
 		return err
 	}
 
-	// t.ByEmail ([]*tangled.GitRefUpdate_Meta_CommitCount_ByEmail_Elem) (slice)
-	if t.ByEmail != nil {
+	// t.Inputs ([]*tangled.GitRefUpdate_Pair) (slice)
+	if t.Inputs != nil {
 
-		if len("byEmail") > 1000000 {
-			return xerrors.Errorf("Value in field \"byEmail\" was too long")
+		if len("inputs") > 1000000 {
+			return xerrors.Errorf("Value in field \"inputs\" was too long")
 		}
 
-		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("byEmail"))); err != nil {
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("inputs"))); err != nil {
 			return err
 		}
-		if _, err := cw.WriteString(string("byEmail")); err != nil {
+		if _, err := cw.WriteString(string("inputs")); err != nil {
 			return err
 		}
 
-		if len(t.ByEmail) > 8192 {
-			return xerrors.Errorf("Slice value in field t.ByEmail was too long")
+		if len(t.Inputs) > 8192 {
+			return xerrors.Errorf("Slice value in field t.Inputs was too long")
 		}
 
-		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.ByEmail))); err != nil {
+		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Inputs))); err != nil {
 			return err
 		}
-		for _, v := range t.ByEmail {
+		for _, v := range t.Inputs {
 			if err := v.MarshalCBOR(cw); err != nil {
 				return err
 			}
···
 	return nil
 }
 
-func (t *GitRefUpdate_Meta_CommitCount) UnmarshalCBOR(r io.Reader) (err error) {
-	*t = GitRefUpdate_Meta_CommitCount{}
+func (t *GitRefUpdate_Meta_LangBreakdown) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = GitRefUpdate_Meta_LangBreakdown{}
 
 	cr := cbg.NewCborReader(r)
 
···
 	}
 
 	if extra > cbg.MaxLength {
-		return fmt.Errorf("GitRefUpdate_Meta_CommitCount: map struct too large (%d)", extra)
+		return fmt.Errorf("GitRefUpdate_Meta_LangBreakdown: map struct too large (%d)", extra)
 	}
 
 	n := extra
 
-	nameBuf := make([]byte, 7)
+	nameBuf := make([]byte, 6)
 	for i := uint64(0); i < n; i++ {
 		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
 		if err != nil {
···
 		}
 
 		switch string(nameBuf[:nameLen]) {
-		// t.ByEmail ([]*tangled.GitRefUpdate_Meta_CommitCount_ByEmail_Elem) (slice)
-		case "byEmail":
+		// t.Inputs ([]*tangled.GitRefUpdate_Pair) (slice)
+		case "inputs":
 
 			maj, extra, err = cr.ReadHeader()
 			if err != nil {
···
 			}
 
 			if extra > 8192 {
-				return fmt.Errorf("t.ByEmail: array too large (%d)", extra)
+				return fmt.Errorf("t.Inputs: array too large (%d)", extra)
 			}
 
 			if maj != cbg.MajArray {
···
 			}
 
 			if extra > 0 {
-				t.ByEmail = make([]*GitRefUpdate_Meta_CommitCount_ByEmail_Elem, extra)
+				t.Inputs = make([]*GitRefUpdate_Pair, extra)
 			}
 
 			for i := 0; i < int(extra); i++ {
···
 							if err := cr.UnreadByte(); err != nil {
 								return err
 							}
-							t.ByEmail[i] = new(GitRefUpdate_Meta_CommitCount_ByEmail_Elem)
-							if err := t.ByEmail[i].UnmarshalCBOR(cr); err != nil {
-								return xerrors.Errorf("unmarshaling t.ByEmail[i] pointer: %w", err)
+							t.Inputs[i] = new(GitRefUpdate_Pair)
+							if err := t.Inputs[i].UnmarshalCBOR(cr); err != nil {
+								return xerrors.Errorf("unmarshaling t.Inputs[i] pointer: %w", err)
 							}
 						}
 
···
 
 	return nil
 }
-func (t *GitRefUpdate_Meta_CommitCount_ByEmail_Elem) MarshalCBOR(w io.Writer) error {
+func (t *GitRefUpdate_Meta) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
 		return err
 	}
 
 	cw := cbg.NewCborWriter(w)
+	fieldCount := 3
 
-	if _, err := cw.Write([]byte{162}); err != nil {
+	if t.LangBreakdown == nil {
+		fieldCount--
+	}
+
+	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
 		return err
 	}
 
-	// t.Count (int64) (int64)
-	if len("count") > 1000000 {
-		return xerrors.Errorf("Value in field \"count\" was too long")
+	// t.CommitCount (tangled.GitRefUpdate_Meta_CommitCount) (struct)
+	if len("commitCount") > 1000000 {
+		return xerrors.Errorf("Value in field \"commitCount\" was too long")
 	}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("count"))); err != nil {
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("commitCount"))); err != nil {
 		return err
 	}
-	if _, err := cw.WriteString(string("count")); err != nil {
+	if _, err := cw.WriteString(string("commitCount")); err != nil {
 		return err
 	}
 
-	if t.Count >= 0 {
-		if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Count)); err != nil {
-			return err
-		}
-	} else {
-		if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Count-1)); err != nil {
-			return err
-		}
+	if err := t.CommitCount.MarshalCBOR(cw); err != nil {
+		return err
 	}
 
-	// t.Email (string) (string)
-	if len("email") > 1000000 {
-		return xerrors.Errorf("Value in field \"email\" was too long")
+	// t.IsDefaultRef (bool) (bool)
+	if len("isDefaultRef") > 1000000 {
+		return xerrors.Errorf("Value in field \"isDefaultRef\" was too long")
 	}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("email"))); err != nil {
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("isDefaultRef"))); err != nil {
 		return err
 	}
-	if _, err := cw.WriteString(string("email")); err != nil {
+	if _, err := cw.WriteString(string("isDefaultRef")); err != nil {
 		return err
 	}
 
-	if len(t.Email) > 1000000 {
-		return xerrors.Errorf("Value in field t.Email was too long")
+	if err := cbg.WriteBool(w, t.IsDefaultRef); err != nil {
+		return err
 	}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Email))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string(t.Email)); err != nil {
-		return err
+	// t.LangBreakdown (tangled.GitRefUpdate_Meta_LangBreakdown) (struct)
+	if t.LangBreakdown != nil {
+
+		if len("langBreakdown") > 1000000 {
+			return xerrors.Errorf("Value in field \"langBreakdown\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("langBreakdown"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("langBreakdown")); err != nil {
+			return err
+		}
+
+		if err := t.LangBreakdown.MarshalCBOR(cw); err != nil {
+			return err
+		}
 	}
 	return nil
 }
 
-func (t *GitRefUpdate_Meta_CommitCount_ByEmail_Elem) UnmarshalCBOR(r io.Reader) (err error) {
-	*t = GitRefUpdate_Meta_CommitCount_ByEmail_Elem{}
+func (t *GitRefUpdate_Meta) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = GitRefUpdate_Meta{}
 
 	cr := cbg.NewCborReader(r)
 
···
 	}
 
 	if extra > cbg.MaxLength {
-		return fmt.Errorf("GitRefUpdate_Meta_CommitCount_ByEmail_Elem: map struct too large (%d)", extra)
+		return fmt.Errorf("GitRefUpdate_Meta: map struct too large (%d)", extra)
 	}
 
 	n := extra
 
-	nameBuf := make([]byte, 5)
+	nameBuf := make([]byte, 13)
 	for i := uint64(0); i < n; i++ {
 		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
 		if err != nil {
···
 		}
 
 		switch string(nameBuf[:nameLen]) {
-		// t.Count (int64) (int64)
-		case "count":
+		// t.CommitCount (tangled.GitRefUpdate_Meta_CommitCount) (struct)
+		case "commitCount":
+
 			{
-				maj, extra, err := cr.ReadHeader()
+
+				b, err := cr.ReadByte()
 				if err != nil {
 					return err
 				}
-				var extraI int64
-				switch maj {
-				case cbg.MajUnsignedInt:
-					extraI = int64(extra)
-					if extraI < 0 {
-						return fmt.Errorf("int64 positive overflow")
+				if b != cbg.CborNull[0] {
+					if err := cr.UnreadByte(); err != nil {
+						return err
 					}
-				case cbg.MajNegativeInt:
-					extraI = int64(extra)
-					if extraI < 0 {
-						return fmt.Errorf("int64 negative overflow")
+					t.CommitCount = new(GitRefUpdate_Meta_CommitCount)
+					if err := t.CommitCount.UnmarshalCBOR(cr); err != nil {
+						return xerrors.Errorf("unmarshaling t.CommitCount pointer: %w", err)
 					}
-					extraI = -1 - extraI
-				default:
-					return fmt.Errorf("wrong type for int64 field: %d", maj)
 				}
 
-				t.Count = int64(extraI)
+			}
+			// t.IsDefaultRef (bool) (bool)
+		case "isDefaultRef":
+
+			maj, extra, err = cr.ReadHeader()
+			if err != nil {
+				return err
+			}
+			if maj != cbg.MajOther {
+				return fmt.Errorf("booleans must be major type 7")
+			}
+			switch extra {
+			case 20:
+				t.IsDefaultRef = false
+			case 21:
+				t.IsDefaultRef = true
+			default:
+				return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
 			}
-			// t.Email (string) (string)
-		case "email":
+			// t.LangBreakdown (tangled.GitRefUpdate_Meta_LangBreakdown) (struct)
+		case "langBreakdown":
 
 			{
-				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.LangBreakdown = new(GitRefUpdate_Meta_LangBreakdown)
+					if err := t.LangBreakdown.UnmarshalCBOR(cr); err != nil {
+						return xerrors.Errorf("unmarshaling t.LangBreakdown pointer: %w", err)
+					}
+				}
 
-				t.Email = string(sval)
 			}
 
 		default:
···
 
 	return nil
 }
-func (t *GitRefUpdate_Meta_LangBreakdown) MarshalCBOR(w io.Writer) error {
+func (t *GitRefUpdate_Pair) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
 		return err
 	}
 
 	cw := cbg.NewCborWriter(w)
-	fieldCount := 1
+
+	if _, err := cw.Write([]byte{162}); err != nil {
+		return err
+	}
 
-	if t.Inputs == nil {
-		fieldCount--
+	// t.Lang (string) (string)
+	if len("lang") > 1000000 {
+		return xerrors.Errorf("Value in field \"lang\" was too long")
 	}
 
-	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("lang"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("lang")); err != nil {
 		return err
 	}
 
-	// t.Inputs ([]*tangled.GitRefUpdate_Pair) (slice)
-	if t.Inputs != nil {
+	if len(t.Lang) > 1000000 {
+		return xerrors.Errorf("Value in field t.Lang was too long")
+	}
 
-		if len("inputs") > 1000000 {
-			return xerrors.Errorf("Value in field \"inputs\" was too long")
-		}
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Lang))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string(t.Lang)); err != nil {
+		return err
+	}
 
-		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("inputs"))); err != nil {
-			return err
-		}
-		if _, err := cw.WriteString(string("inputs")); err != nil {
-			return err
-		}
+	// t.Size (int64) (int64)
+	if len("size") > 1000000 {
+		return xerrors.Errorf("Value in field \"size\" was too long")
+	}
 
-		if len(t.Inputs) > 8192 {
-			return xerrors.Errorf("Slice value in field t.Inputs was too long")
-		}
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("size"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("size")); err != nil {
+		return err
+	}
 
-		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Inputs))); err != nil {
+	if t.Size >= 0 {
+		if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Size)); err != nil {
 			return err
 		}
-		for _, v := range t.Inputs {
-			if err := v.MarshalCBOR(cw); err != nil {
-				return err
-			}
-
+	} else {
+		if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Size-1)); err != nil {
+			return err
 		}
 	}
+
 	return nil
 }
 
-func (t *GitRefUpdate_Meta_LangBreakdown) UnmarshalCBOR(r io.Reader) (err error) {
-	*t = GitRefUpdate_Meta_LangBreakdown{}
+func (t *GitRefUpdate_Pair) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = GitRefUpdate_Pair{}
 
 	cr := cbg.NewCborReader(r)
 
···
 	}
 
 	if extra > cbg.MaxLength {
-		return fmt.Errorf("GitRefUpdate_Meta_LangBreakdown: map struct too large (%d)", extra)
+		return fmt.Errorf("GitRefUpdate_Pair: map struct too large (%d)", extra)
 	}
 
 	n := extra
 
-	nameBuf := make([]byte, 6)
+	nameBuf := make([]byte, 4)
 	for i := uint64(0); i < n; i++ {
 		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
 		if err != nil {
···
 		}
 
 		switch string(nameBuf[:nameLen]) {
-		// t.Inputs ([]*tangled.GitRefUpdate_Pair) (slice)
-		case "inputs":
-
-			maj, extra, err = cr.ReadHeader()
-			if err != nil {
-				return err
-			}
+		// t.Lang (string) (string)
+		case "lang":
 
-			if extra > 8192 {
-				return fmt.Errorf("t.Inputs: array too large (%d)", extra)
-			}
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
 
-			if maj != cbg.MajArray {
-				return fmt.Errorf("expected cbor array")
+				t.Lang = string(sval)
 			}
-
-			if extra > 0 {
-				t.Inputs = make([]*GitRefUpdate_Pair, extra)
-			}
-
-			for i := 0; i < int(extra); i++ {
-				{
-					var maj byte
-					var extra uint64
-					var err error
-					_ = maj
-					_ = extra
-					_ = err
-
-					{
-
-						b, err := cr.ReadByte()
-						if err != nil {
-							return err
-						}
-						if b != cbg.CborNull[0] {
-							if err := cr.UnreadByte(); err != nil {
-								return err
-							}
-							t.Inputs[i] = new(GitRefUpdate_Pair)
-							if err := t.Inputs[i].UnmarshalCBOR(cr); err != nil {
-								return xerrors.Errorf("unmarshaling t.Inputs[i] pointer: %w", err)
-							}
-						}
-
+			// t.Size (int64) (int64)
+		case "size":
+			{
+				maj, extra, err := cr.ReadHeader()
+				if err != nil {
+					return err
+				}
+				var extraI int64
+				switch maj {
+				case cbg.MajUnsignedInt:
+					extraI = int64(extra)
+					if extraI < 0 {
+						return fmt.Errorf("int64 positive overflow")
 					}
-
+				case cbg.MajNegativeInt:
+					extraI = int64(extra)
+					if extraI < 0 {
+						return fmt.Errorf("int64 negative overflow")
+					}
+					extraI = -1 - extraI
+				default:
+					return fmt.Errorf("wrong type for int64 field: %d", maj)
 				}
+
+				t.Size = int64(extraI)
 			}
 
 		default:
···
 
 	return nil
 }
-func (t *GitRefUpdate_Pair) MarshalCBOR(w io.Writer) error {
+func (t *GitRefUpdate) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
 		return err
···
 
 	cw := cbg.NewCborWriter(w)
 
-	if _, err := cw.Write([]byte{162}); err != nil {
+	if _, err := cw.Write([]byte{168}); err != nil {
 		return err
 	}
 
-	// t.Lang (string) (string)
-	if len("lang") > 1000000 {
-		return xerrors.Errorf("Value in field \"lang\" was too long")
+	// t.Ref (string) (string)
+	if len("ref") > 1000000 {
+		return xerrors.Errorf("Value in field \"ref\" was too long")
 	}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("lang"))); err != nil {
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ref"))); err != nil {
 		return err
 	}
-	if _, err := cw.WriteString(string("lang")); err != nil {
+	if _, err := cw.WriteString(string("ref")); err != nil {
 		return err
 	}
 
-	if len(t.Lang) > 1000000 {
-		return xerrors.Errorf("Value in field t.Lang was too long")
+	if len(t.Ref) > 1000000 {
+		return xerrors.Errorf("Value in field t.Ref was too long")
 	}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Lang))); err != nil {
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Ref))); err != nil {
 		return err
 	}
-	if _, err := cw.WriteString(string(t.Lang)); err != nil {
+	if _, err := cw.WriteString(string(t.Ref)); err != nil {
 		return err
 	}
 
-	// t.Size (int64) (int64)
-	if len("size") > 1000000 {
-		return xerrors.Errorf("Value in field \"size\" was too long")
+	// t.Meta (tangled.GitRefUpdate_Meta) (struct)
+	if len("meta") > 1000000 {
+		return xerrors.Errorf("Value in field \"meta\" was too long")
 	}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("size"))); err != nil {
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("meta"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("meta")); err != nil {
 		return err
 	}
-	if _, err := cw.WriteString(string("size")); err != nil {
+
+	if err := t.Meta.MarshalCBOR(cw); err != nil {
 		return err
 	}
 
-	if t.Size >= 0 {
-		if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Size)); err != nil {
-			return err
-		}
-	} else {
-		if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Size-1)); 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("sh.tangled.git.refUpdate"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("sh.tangled.git.refUpdate")); err != nil {
+		return err
+	}
+
+	// t.NewSha (string) (string)
+	if len("newSha") > 1000000 {
+		return xerrors.Errorf("Value in field \"newSha\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("newSha"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("newSha")); err != nil {
+		return err
+	}
+
+	if len(t.NewSha) > 1000000 {
+		return xerrors.Errorf("Value in field t.NewSha was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.NewSha))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string(t.NewSha)); err != nil {
+		return err
+	}
+
+	// t.OldSha (string) (string)
+	if len("oldSha") > 1000000 {
+		return xerrors.Errorf("Value in field \"oldSha\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("oldSha"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("oldSha")); err != nil {
+		return err
+	}
+
+	if len(t.OldSha) > 1000000 {
+		return xerrors.Errorf("Value in field t.OldSha was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.OldSha))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string(t.OldSha)); err != nil {
+		return err
+	}
+
+	// t.RepoDid (string) (string)
+	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.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.RepoName (string) (string)
+	if len("repoName") > 1000000 {
+		return xerrors.Errorf("Value in field \"repoName\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoName"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("repoName")); err != nil {
+		return err
+	}
+
+	if len(t.RepoName) > 1000000 {
+		return xerrors.Errorf("Value in field t.RepoName was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.RepoName))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string(t.RepoName)); err != nil {
+		return err
+	}
+
+	// t.CommitterDid (string) (string)
+	if len("committerDid") > 1000000 {
+		return xerrors.Errorf("Value in field \"committerDid\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("committerDid"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("committerDid")); err != nil {
+		return err
+	}
+
+	if len(t.CommitterDid) > 1000000 {
+		return xerrors.Errorf("Value in field t.CommitterDid was too long")
 	}
 
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CommitterDid))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string(t.CommitterDid)); err != nil {
+		return err
+	}
 	return nil
 }
 
-func (t *GitRefUpdate_Pair) UnmarshalCBOR(r io.Reader) (err error) {
-	*t = GitRefUpdate_Pair{}
+func (t *GitRefUpdate) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = GitRefUpdate{}
 
 	cr := cbg.NewCborReader(r)
 
···
 	}
 
 	if extra > cbg.MaxLength {
-		return fmt.Errorf("GitRefUpdate_Pair: map struct too large (%d)", extra)
+		return fmt.Errorf("GitRefUpdate: map struct too large (%d)", extra)
 	}
 
 	n := extra
 
-	nameBuf := make([]byte, 4)
+	nameBuf := make([]byte, 12)
 	for i := uint64(0); i < n; i++ {
 		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
 		if err != nil {
···
 		}
 
 		switch string(nameBuf[:nameLen]) {
-		// t.Lang (string) (string)
-		case "lang":
+		// t.Ref (string) (string)
+		case "ref":
 
 			{
 				sval, err := cbg.ReadStringWithMax(cr, 1000000)
···
 					return err
 				}
 
-				t.Lang = string(sval)
+				t.Ref = string(sval)
 			}
-			// t.Size (int64) (int64)
-		case "size":
+			// t.Meta (tangled.GitRefUpdate_Meta) (struct)
+		case "meta":
+
 			{
-				maj, extra, err := cr.ReadHeader()
+
+				b, err := cr.ReadByte()
 				if err != nil {
 					return err
 				}
-				var extraI int64
-				switch maj {
-				case cbg.MajUnsignedInt:
-					extraI = int64(extra)
-					if extraI < 0 {
-						return fmt.Errorf("int64 positive overflow")
+				if b != cbg.CborNull[0] {
+					if err := cr.UnreadByte(); err != nil {
+						return err
 					}
-				case cbg.MajNegativeInt:
-					extraI = int64(extra)
-					if extraI < 0 {
-						return fmt.Errorf("int64 negative overflow")
+					t.Meta = new(GitRefUpdate_Meta)
+					if err := t.Meta.UnmarshalCBOR(cr); err != nil {
+						return xerrors.Errorf("unmarshaling t.Meta pointer: %w", err)
 					}
-					extraI = -1 - extraI
-				default:
-					return fmt.Errorf("wrong type for int64 field: %d", maj)
 				}
 
-				t.Size = int64(extraI)
+			}
+			// t.LexiconTypeID (string) (string)
+		case "$type":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.LexiconTypeID = string(sval)
+			}
+			// t.NewSha (string) (string)
+		case "newSha":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.NewSha = string(sval)
+			}
+			// t.OldSha (string) (string)
+		case "oldSha":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.OldSha = string(sval)
+			}
+			// t.RepoDid (string) (string)
+		case "repoDid":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.RepoDid = string(sval)
+			}
+			// t.RepoName (string) (string)
+		case "repoName":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.RepoName = string(sval)
+			}
+			// t.CommitterDid (string) (string)
+		case "committerDid":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.CommitterDid = string(sval)
 			}
 
 		default:
···
 
 	return nil
 }
-func (t *Pipeline) MarshalCBOR(w io.Writer) error {
+func (t *Knot) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
 		return err
···
 
 	cw := cbg.NewCborWriter(w)
 
-	if _, err := cw.Write([]byte{163}); err != nil {
+	if _, err := cw.Write([]byte{162}); err != nil {
 		return err
 	}
 
···
 		return err
 	}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pipeline"))); err != nil {
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.knot"))); err != nil {
 		return err
 	}
-	if _, err := cw.WriteString(string("sh.tangled.pipeline")); err != nil {
+	if _, err := cw.WriteString(string("sh.tangled.knot")); err != nil {
 		return err
 	}
 
-	// t.Workflows ([]*tangled.Pipeline_Workflow) (slice)
-	if len("workflows") > 1000000 {
-		return xerrors.Errorf("Value in field \"workflows\" was too long")
+	// 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("workflows"))); err != nil {
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
 		return err
 	}
-	if _, err := cw.WriteString(string("workflows")); err != nil {
+	if _, err := cw.WriteString(string("createdAt")); err != nil {
 		return err
 	}
 
-	if len(t.Workflows) > 8192 {
-		return xerrors.Errorf("Slice value in field t.Workflows was too long")
+	if len(t.CreatedAt) > 1000000 {
+		return xerrors.Errorf("Value in field t.CreatedAt was too long")
 	}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Workflows))); err != nil {
+	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
+	}
+	return nil
+}
+
+func (t *Knot) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = Knot{}
+
+	cr := cbg.NewCborReader(r)
+
+	maj, extra, err := cr.ReadHeader()
+	if err != nil {
 		return err
 	}
-	for _, v := range t.Workflows {
-		if err := v.MarshalCBOR(cw); err != nil {
+	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("Knot: map struct too large (%d)", extra)
+	}
+
+	n := extra
+
+	nameBuf := make([]byte, 9)
+	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.LexiconTypeID (string) (string)
+		case "$type":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.LexiconTypeID = string(sval)
+			}
+			// t.CreatedAt (string) (string)
+		case "createdAt":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.CreatedAt = 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
+			}
+		}
 	}
 
-	// t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct)
-	if len("triggerMetadata") > 1000000 {
-		return xerrors.Errorf("Value in field \"triggerMetadata\" was too long")
+	return nil
+}
+func (t *PipelineStatus) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
 	}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("triggerMetadata"))); err != nil {
+	cw := cbg.NewCborWriter(w)
+	fieldCount := 7
+
+	if t.Error == nil {
+		fieldCount--
+	}
+
+	if t.ExitCode == nil {
+		fieldCount--
+	}
+
+	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
 		return err
 	}
-	if _, err := cw.WriteString(string("triggerMetadata")); err != nil {
+
+	// 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 := t.TriggerMetadata.MarshalCBOR(cw); err != nil {
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pipeline.status"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("sh.tangled.pipeline.status")); err != nil {
+		return err
+	}
+
+	// t.Error (string) (string)
+	if t.Error != nil {
+
+		if len("error") > 1000000 {
+			return xerrors.Errorf("Value in field \"error\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("error"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("error")); err != nil {
+			return err
+		}
+
+		if t.Error == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if len(*t.Error) > 1000000 {
+				return xerrors.Errorf("Value in field t.Error was too long")
+			}
+
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Error))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(*t.Error)); err != nil {
+				return err
+			}
+		}
+	}
+
+	// t.Status (string) (string)
+	if len("status") > 1000000 {
+		return xerrors.Errorf("Value in field \"status\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("status")); err != nil {
+		return err
+	}
+
+	if len(t.Status) > 1000000 {
+		return xerrors.Errorf("Value in field t.Status was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string(t.Status)); err != nil {
+		return err
+	}
+
+	// t.ExitCode (int64) (int64)
+	if t.ExitCode != nil {
+
+		if len("exitCode") > 1000000 {
+			return xerrors.Errorf("Value in field \"exitCode\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("exitCode"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("exitCode")); err != nil {
+			return err
+		}
+
+		if t.ExitCode == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if *t.ExitCode >= 0 {
+				if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.ExitCode)); err != nil {
+					return err
+				}
+			} else {
+				if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.ExitCode-1)); err != nil {
+					return err
+				}
+			}
+		}
+
+	}
+
+	// t.Pipeline (string) (string)
+	if len("pipeline") > 1000000 {
+		return xerrors.Errorf("Value in field \"pipeline\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pipeline"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("pipeline")); err != nil {
+		return err
+	}
+
+	if len(t.Pipeline) > 1000000 {
+		return xerrors.Errorf("Value in field t.Pipeline was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pipeline))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string(t.Pipeline)); err != nil {
+		return err
+	}
+
+	// t.Workflow (string) (string)
+	if len("workflow") > 1000000 {
+		return xerrors.Errorf("Value in field \"workflow\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflow"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("workflow")); err != nil {
+		return err
+	}
+
+	if len(t.Workflow) > 1000000 {
+		return xerrors.Errorf("Value in field t.Workflow was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Workflow))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string(t.Workflow)); 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
 	}
 	return nil
 }
 
-func (t *Pipeline) UnmarshalCBOR(r io.Reader) (err error) {
-	*t = Pipeline{}
+func (t *PipelineStatus) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = PipelineStatus{}
 
 	cr := cbg.NewCborReader(r)
 
···
 	}
 
 	if extra > cbg.MaxLength {
-		return fmt.Errorf("Pipeline: map struct too large (%d)", extra)
+		return fmt.Errorf("PipelineStatus: map struct too large (%d)", extra)
 	}
 
 	n := extra
 
-	nameBuf := make([]byte, 15)
+	nameBuf := make([]byte, 9)
 	for i := uint64(0); i < n; i++ {
 		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
 		if err != nil {
···
 
 				t.LexiconTypeID = string(sval)
 			}
-			// t.Workflows ([]*tangled.Pipeline_Workflow) (slice)
-		case "workflows":
+			// t.Error (string) (string)
+		case "error":
 
-			maj, extra, err = cr.ReadHeader()
-			if err != nil {
-				return err
-			}
+			{
+				b, err := cr.ReadByte()
+				if err != nil {
+					return err
+				}
+				if b != cbg.CborNull[0] {
+					if err := cr.UnreadByte(); err != nil {
+						return err
+					}
 
-			if extra > 8192 {
-				return fmt.Errorf("t.Workflows: array too large (%d)", extra)
+					sval, err := cbg.ReadStringWithMax(cr, 1000000)
+					if err != nil {
+						return err
+					}
+
+					t.Error = (*string)(&sval)
+				}
 			}
+			// t.Status (string) (string)
+		case "status":
 
-			if maj != cbg.MajArray {
-				return fmt.Errorf("expected cbor array")
-			}
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
 
-			if extra > 0 {
-				t.Workflows = make([]*Pipeline_Workflow, extra)
+				t.Status = string(sval)
 			}
+			// t.ExitCode (int64) (int64)
+		case "exitCode":
+			{
 
-			for i := 0; i < int(extra); i++ {
-				{
-					var maj byte
-					var extra uint64
-					var err error
-					_ = maj
-					_ = extra
-					_ = err
-
-					{
-
-						b, err := cr.ReadByte()
-						if err != nil {
-							return err
+				b, err := cr.ReadByte()
+				if err != nil {
+					return err
+				}
+				if b != cbg.CborNull[0] {
+					if err := cr.UnreadByte(); err != nil {
+						return err
+					}
+					maj, extra, err := cr.ReadHeader()
+					if err != nil {
+						return err
+					}
+					var extraI int64
+					switch maj {
+					case cbg.MajUnsignedInt:
+						extraI = int64(extra)
+						if extraI < 0 {
+							return fmt.Errorf("int64 positive overflow")
 						}
-						if b != cbg.CborNull[0] {
-							if err := cr.UnreadByte(); err != nil {
-								return err
-							}
-							t.Workflows[i] = new(Pipeline_Workflow)
-							if err := t.Workflows[i].UnmarshalCBOR(cr); err != nil {
-								return xerrors.Errorf("unmarshaling t.Workflows[i] pointer: %w", err)
-							}
+					case cbg.MajNegativeInt:
+						extraI = int64(extra)
+						if extraI < 0 {
+							return fmt.Errorf("int64 negative overflow")
 						}
-
+						extraI = -1 - extraI
+					default:
+						return fmt.Errorf("wrong type for int64 field: %d", maj)
 					}
 
+					t.ExitCode = (*int64)(&extraI)
 				}
 			}
-			// t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct)
-		case "triggerMetadata":
+			// t.Pipeline (string) (string)
+		case "pipeline":
 
 			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
 
-				b, err := cr.ReadByte()
+				t.Pipeline = string(sval)
+			}
+			// t.Workflow (string) (string)
+		case "workflow":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
 				if err != nil {
 					return err
 				}
-				if b != cbg.CborNull[0] {
-					if err := cr.UnreadByte(); err != nil {
-						return err
-					}
-					t.TriggerMetadata = new(Pipeline_TriggerMetadata)
-					if err := t.TriggerMetadata.UnmarshalCBOR(cr); err != nil {
-						return xerrors.Errorf("unmarshaling t.TriggerMetadata pointer: %w", err)
-					}
+
+				t.Workflow = string(sval)
+			}
+			// t.CreatedAt (string) (string)
+		case "createdAt":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
 				}
 
+				t.CreatedAt = string(sval)
 			}
 
 		default:
···
 
 	return nil
 }
-func (t *PipelineStatus) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-
-	cw := cbg.NewCborWriter(w)
-	fieldCount := 7
-
-	if t.Error == nil {
-		fieldCount--
-	}
-
-	if t.ExitCode == nil {
-		fieldCount--
-	}
-
-	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); 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("sh.tangled.pipeline.status"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("sh.tangled.pipeline.status")); err != nil {
-		return err
-	}
-
-	// t.Error (string) (string)
-	if t.Error != nil {
-
-		if len("error") > 1000000 {
-			return xerrors.Errorf("Value in field \"error\" was too long")
-		}
-
-		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("error"))); err != nil {
-			return err
-		}
-		if _, err := cw.WriteString(string("error")); err != nil {
-			return err
-		}
-
-		if t.Error == nil {
-			if _, err := cw.Write(cbg.CborNull); err != nil {
-				return err
-			}
-		} else {
-			if len(*t.Error) > 1000000 {
-				return xerrors.Errorf("Value in field t.Error was too long")
-			}
-
-			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Error))); err != nil {
-				return err
-			}
-			if _, err := cw.WriteString(string(*t.Error)); err != nil {
-				return err
-			}
-		}
-	}
-
-	// t.Status (string) (string)
-	if len("status") > 1000000 {
-		return xerrors.Errorf("Value in field \"status\" was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("status")); err != nil {
-		return err
-	}
-
-	if len(t.Status) > 1000000 {
-		return xerrors.Errorf("Value in field t.Status was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string(t.Status)); err != nil {
-		return err
-	}
-
-	// t.ExitCode (int64) (int64)
-	if t.ExitCode != nil {
-
-		if len("exitCode") > 1000000 {
-			return xerrors.Errorf("Value in field \"exitCode\" was too long")
-		}
-
-		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("exitCode"))); err != nil {
-			return err
-		}
-		if _, err := cw.WriteString(string("exitCode")); err != nil {
-			return err
-		}
-
-		if t.ExitCode == nil {
-			if _, err := cw.Write(cbg.CborNull); err != nil {
-				return err
-			}
-		} else {
-			if *t.ExitCode >= 0 {
-				if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.ExitCode)); err != nil {
-					return err
-				}
-			} else {
-				if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.ExitCode-1)); err != nil {
-					return err
-				}
-			}
-		}
-
-	}
-
-	// t.Pipeline (string) (string)
-	if len("pipeline") > 1000000 {
-		return xerrors.Errorf("Value in field \"pipeline\" was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pipeline"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("pipeline")); err != nil {
-		return err
-	}
-
-	if len(t.Pipeline) > 1000000 {
-		return xerrors.Errorf("Value in field t.Pipeline was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pipeline))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string(t.Pipeline)); err != nil {
-		return err
-	}
-
-	// t.Workflow (string) (string)
-	if len("workflow") > 1000000 {
-		return xerrors.Errorf("Value in field \"workflow\" was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflow"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("workflow")); err != nil {
-		return err
-	}
-
-	if len(t.Workflow) > 1000000 {
-		return xerrors.Errorf("Value in field t.Workflow was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Workflow))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string(t.Workflow)); 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
-	}
-	return nil
-}
-
-func (t *PipelineStatus) UnmarshalCBOR(r io.Reader) (err error) {
-	*t = PipelineStatus{}
-
-	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("PipelineStatus: map struct too large (%d)", extra)
-	}
-
-	n := extra
-
-	nameBuf := make([]byte, 9)
-	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.LexiconTypeID (string) (string)
-		case "$type":
-
-			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
-				if err != nil {
-					return err
-				}
-
-				t.LexiconTypeID = string(sval)
-			}
-			// t.Error (string) (string)
-		case "error":
-
-			{
-				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.Error = (*string)(&sval)
-				}
-			}
-			// t.Status (string) (string)
-		case "status":
-
-			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
-				if err != nil {
-					return err
-				}
-
-				t.Status = string(sval)
-			}
-			// t.ExitCode (int64) (int64)
-		case "exitCode":
-			{
-
-				b, err := cr.ReadByte()
-				if err != nil {
-					return err
-				}
-				if b != cbg.CborNull[0] {
-					if err := cr.UnreadByte(); err != nil {
-						return err
-					}
-					maj, extra, err := cr.ReadHeader()
-					if err != nil {
-						return err
-					}
-					var extraI int64
-					switch maj {
-					case cbg.MajUnsignedInt:
-						extraI = int64(extra)
-						if extraI < 0 {
-							return fmt.Errorf("int64 positive overflow")
-						}
-					case cbg.MajNegativeInt:
-						extraI = int64(extra)
-						if extraI < 0 {
-							return fmt.Errorf("int64 negative overflow")
-						}
-						extraI = -1 - extraI
-					default:
-						return fmt.Errorf("wrong type for int64 field: %d", maj)
-					}
-
-					t.ExitCode = (*int64)(&extraI)
-				}
-			}
-			// t.Pipeline (string) (string)
-		case "pipeline":
-
-			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
-				if err != nil {
-					return err
-				}
-
-				t.Pipeline = string(sval)
-			}
-			// t.Workflow (string) (string)
-		case "workflow":
-
-			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
-				if err != nil {
-					return err
-				}
-
-				t.Workflow = string(sval)
-			}
-			// t.CreatedAt (string) (string)
-		case "createdAt":
-
-			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
-				if err != nil {
-					return err
-				}
-
-				t.CreatedAt = 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
-}
 func (t *Pipeline_Step) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
···
 
 	return nil
 }
-func (t *PublicKey) MarshalCBOR(w io.Writer) error {
+func (t *Pipeline) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
 		return err
···
 
 	cw := cbg.NewCborWriter(w)
 
-	if _, err := cw.Write([]byte{164}); err != nil {
-		return err
-	}
-
-	// t.Key (string) (string)
-	if len("key") > 1000000 {
-		return xerrors.Errorf("Value in field \"key\" was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("key")); err != nil {
+	if _, err := cw.Write([]byte{163}); err != nil {
 		return err
 	}
 
-	if len(t.Key) > 1000000 {
-		return xerrors.Errorf("Value in field t.Key was too long")
+	// 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(t.Key))); err != nil {
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
 		return err
 	}
-	if _, err := cw.WriteString(string(t.Key)); err != nil {
+	if _, err := cw.WriteString(string("$type")); err != nil {
 		return err
 	}
 
-	// t.Name (string) (string)
-	if len("name") > 1000000 {
-		return xerrors.Errorf("Value in field \"name\" was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.pipeline"))); err != nil {
 		return err
 	}
-	if _, err := cw.WriteString(string("name")); err != nil {
+	if _, err := cw.WriteString(string("sh.tangled.pipeline")); err != nil {
 		return err
 	}
 
-	if len(t.Name) > 1000000 {
-		return xerrors.Errorf("Value in field t.Name was too long")
+	// t.Workflows ([]*tangled.Pipeline_Workflow) (slice)
+	if len("workflows") > 1000000 {
+		return xerrors.Errorf("Value in field \"workflows\" was too long")
 	}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("workflows"))); err != nil {
 		return err
 	}
-	if _, err := cw.WriteString(string(t.Name)); err != nil {
+	if _, err := cw.WriteString(string("workflows")); err != nil {
 		return err
 	}
 
-	// t.LexiconTypeID (string) (string)
-	if len("$type") > 1000000 {
-		return xerrors.Errorf("Value in field \"$type\" was too long")
+	if len(t.Workflows) > 8192 {
+		return xerrors.Errorf("Slice value in field t.Workflows was too long")
 	}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("$type")); err != nil {
+	if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Workflows))); err != nil {
 		return err
 	}
+	for _, v := range t.Workflows {
+		if err := v.MarshalCBOR(cw); err != nil {
+			return err
+		}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.publicKey"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("sh.tangled.publicKey")); err != nil {
-		return err
 	}
 
-	// t.CreatedAt (string) (string)
-	if len("createdAt") > 1000000 {
-		return xerrors.Errorf("Value in field \"createdAt\" was too long")
+	// t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct)
+	if len("triggerMetadata") > 1000000 {
+		return xerrors.Errorf("Value in field \"triggerMetadata\" was too long")
 	}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("triggerMetadata"))); err != nil {
 		return err
 	}
-	if _, err := cw.WriteString(string("createdAt")); err != nil {
+	if _, err := cw.WriteString(string("triggerMetadata")); 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 {
+	if err := t.TriggerMetadata.MarshalCBOR(cw); err != nil {
 		return err
 	}
 	return nil
 }
 
-func (t *PublicKey) UnmarshalCBOR(r io.Reader) (err error) {
-	*t = PublicKey{}
+func (t *Pipeline) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = Pipeline{}
 
 	cr := cbg.NewCborReader(r)
 
···
 	}
 
 	if extra > cbg.MaxLength {
-		return fmt.Errorf("PublicKey: map struct too large (%d)", extra)
+		return fmt.Errorf("Pipeline: map struct too large (%d)", extra)
 	}
 
 	n := extra
 
-	nameBuf := make([]byte, 9)
+	nameBuf := make([]byte, 15)
 	for i := uint64(0); i < n; i++ {
 		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
 		if err != nil {
···
 		}
 
 		switch string(nameBuf[:nameLen]) {
-		// t.Key (string) (string)
-		case "key":
+		// t.LexiconTypeID (string) (string)
+		case "$type":
 
 			{
 				sval, err := cbg.ReadStringWithMax(cr, 1000000)
···
 					return err
 				}
 
-				t.Key = string(sval)
+				t.LexiconTypeID = string(sval)
 			}
-			// t.Name (string) (string)
-		case "name":
+			// t.Workflows ([]*tangled.Pipeline_Workflow) (slice)
+		case "workflows":
 
-			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
-				if err != nil {
-					return err
-				}
+			maj, extra, err = cr.ReadHeader()
+			if err != nil {
+				return err
+			}
 
-				t.Name = string(sval)
+			if extra > 8192 {
+				return fmt.Errorf("t.Workflows: array too large (%d)", extra)
 			}
-			// t.LexiconTypeID (string) (string)
-		case "$type":
 
-			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
-				if err != nil {
-					return err
-				}
+			if maj != cbg.MajArray {
+				return fmt.Errorf("expected cbor array")
+			}
 
-				t.LexiconTypeID = string(sval)
+			if extra > 0 {
+				t.Workflows = make([]*Pipeline_Workflow, extra)
 			}
-			// t.CreatedAt (string) (string)
-		case "createdAt":
+
+			for i := 0; i < int(extra); i++ {
+				{
+					var maj byte
+					var extra uint64
+					var err error
+					_ = maj
+					_ = extra
+					_ = err
+
+					{
+
+						b, err := cr.ReadByte()
+						if err != nil {
+							return err
+						}
+						if b != cbg.CborNull[0] {
+							if err := cr.UnreadByte(); err != nil {
+								return err
+							}
+							t.Workflows[i] = new(Pipeline_Workflow)
+							if err := t.Workflows[i].UnmarshalCBOR(cr); err != nil {
+								return xerrors.Errorf("unmarshaling t.Workflows[i] pointer: %w", err)
+							}
+						}
+
+					}
+
+				}
+			}
+			// t.TriggerMetadata (tangled.Pipeline_TriggerMetadata) (struct)
+		case "triggerMetadata":
 
 			{
-				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.TriggerMetadata = new(Pipeline_TriggerMetadata)
+					if err := t.TriggerMetadata.UnmarshalCBOR(cr); err != nil {
+						return xerrors.Errorf("unmarshaling t.TriggerMetadata pointer: %w", err)
+					}
+				}
 
-				t.CreatedAt = string(sval)
 			}
 
 		default:
···
 
 	return nil
 }
-func (t *Repo) MarshalCBOR(w io.Writer) error {
+func (t *PublicKey) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
 		return err
 	}
 
 	cw := cbg.NewCborWriter(w)
-	fieldCount := 8
 
-	if t.Description == nil {
-		fieldCount--
-	}
-
-	if t.Source == nil {
-		fieldCount--
-	}
-
-	if t.Spindle == nil {
-		fieldCount--
-	}
-
-	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
+	if _, err := cw.Write([]byte{164}); err != nil {
 		return err
 	}
 
-	// t.Knot (string) (string)
-	if len("knot") > 1000000 {
-		return xerrors.Errorf("Value in field \"knot\" was too long")
+	// t.Key (string) (string)
+	if len("key") > 1000000 {
+		return xerrors.Errorf("Value in field \"key\" was too long")
 	}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil {
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
 		return err
 	}
-	if _, err := cw.WriteString(string("knot")); err != nil {
+	if _, err := cw.WriteString(string("key")); err != nil {
 		return err
 	}
 
-	if len(t.Knot) > 1000000 {
-		return xerrors.Errorf("Value in field t.Knot was too long")
+	if len(t.Key) > 1000000 {
+		return xerrors.Errorf("Value in field t.Key was too long")
 	}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil {
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil {
 		return err
 	}
-	if _, err := cw.WriteString(string(t.Knot)); err != nil {
+	if _, err := cw.WriteString(string(t.Key)); err != nil {
 		return err
 	}
 
···
 		return err
 	}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("sh.tangled.repo")); err != nil {
-		return err
-	}
-
-	// t.Owner (string) (string)
-	if len("owner") > 1000000 {
-		return xerrors.Errorf("Value in field \"owner\" was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("owner")); err != nil {
-		return err
-	}
-
-	if len(t.Owner) > 1000000 {
-		return xerrors.Errorf("Value in field t.Owner was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Owner))); err != nil {
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.publicKey"))); err != nil {
 		return err
 	}
-	if _, err := cw.WriteString(string(t.Owner)); err != nil {
+	if _, err := cw.WriteString(string("sh.tangled.publicKey")); err != nil {
 		return err
 	}
 
-	// t.Source (string) (string)
-	if t.Source != nil {
-
-		if len("source") > 1000000 {
-			return xerrors.Errorf("Value in field \"source\" was too long")
-		}
-
-		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil {
-			return err
-		}
-		if _, err := cw.WriteString(string("source")); err != nil {
-			return err
-		}
-
-		if t.Source == nil {
-			if _, err := cw.Write(cbg.CborNull); err != nil {
-				return err
-			}
-		} else {
-			if len(*t.Source) > 1000000 {
-				return xerrors.Errorf("Value in field t.Source was too long")
-			}
-
-			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Source))); err != nil {
-				return err
-			}
-			if _, err := cw.WriteString(string(*t.Source)); err != nil {
-				return err
-			}
-		}
-	}
-
-	// t.Spindle (string) (string)
-	if t.Spindle != nil {
-
-		if len("spindle") > 1000000 {
-			return xerrors.Errorf("Value in field \"spindle\" was too long")
-		}
-
-		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("spindle"))); err != nil {
-			return err
-		}
-		if _, err := cw.WriteString(string("spindle")); err != nil {
-			return err
-		}
-
-		if t.Spindle == nil {
-			if _, err := cw.Write(cbg.CborNull); err != nil {
-				return err
-			}
-		} else {
-			if len(*t.Spindle) > 1000000 {
-				return xerrors.Errorf("Value in field t.Spindle was too long")
-			}
-
-			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Spindle))); err != nil {
-				return err
-			}
-			if _, err := cw.WriteString(string(*t.Spindle)); 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.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
-			}
-		}
-	}
 	return nil
 }
 
-func (t *Repo) UnmarshalCBOR(r io.Reader) (err error) {
-	*t = Repo{}
+func (t *PublicKey) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = PublicKey{}
 
 	cr := cbg.NewCborReader(r)
 
···
 	}
 
 	if extra > cbg.MaxLength {
-		return fmt.Errorf("Repo: map struct too large (%d)", extra)
+		return fmt.Errorf("PublicKey: map struct too large (%d)", extra)
 	}
 
 	n := extra
 
-	nameBuf := make([]byte, 11)
+	nameBuf := make([]byte, 9)
 	for i := uint64(0); i < n; i++ {
 		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
 		if err != nil {
···
 		}
 
 		switch string(nameBuf[:nameLen]) {
-		// t.Knot (string) (string)
-		case "knot":
+		// t.Key (string) (string)
+		case "key":
 
 			{
 				sval, err := cbg.ReadStringWithMax(cr, 1000000)
···
 					return err
 				}
 
-				t.Knot = string(sval)
+				t.Key = string(sval)
 			}
 			// t.Name (string) (string)
 		case "name":
···
 
 				t.LexiconTypeID = string(sval)
 			}
-			// t.Owner (string) (string)
-		case "owner":
-
-			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
-				if err != nil {
-					return err
-				}
-
-				t.Owner = string(sval)
-			}
-			// t.Source (string) (string)
-		case "source":
-
-			{
-				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.Source = (*string)(&sval)
-				}
-			}
-			// t.Spindle (string) (string)
-		case "spindle":
-
-			{
-				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.Spindle = (*string)(&sval)
-				}
-			}
 			// t.CreatedAt (string) (string)
 		case "createdAt":
 
···
 				}
 
 				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)
-				}
 			}
 
 		default:
···
 
 	return nil
 }
-func (t *RepoIssue) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-
-	cw := cbg.NewCborWriter(w)
-	fieldCount := 7
-
-	if t.Body == nil {
-		fieldCount--
-	}
-
-	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
-		return err
-	}
-
-	// t.Body (string) (string)
-	if t.Body != nil {
-
-		if len("body") > 1000000 {
-			return xerrors.Errorf("Value in field \"body\" was too long")
-		}
-
-		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
-			return err
-		}
-		if _, err := cw.WriteString(string("body")); err != nil {
-			return err
-		}
-
-		if t.Body == nil {
-			if _, err := cw.Write(cbg.CborNull); err != nil {
-				return err
-			}
-		} else {
-			if len(*t.Body) > 1000000 {
-				return xerrors.Errorf("Value in field t.Body was too long")
-			}
-
-			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {
-				return err
-			}
-			if _, err := cw.WriteString(string(*t.Body)); err != nil {
-				return err
-			}
-		}
-	}
-
-	// t.Repo (string) (string)
-	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 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 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("sh.tangled.repo.issue"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("sh.tangled.repo.issue")); err != nil {
-		return err
-	}
-
-	// t.Owner (string) (string)
-	if len("owner") > 1000000 {
-		return xerrors.Errorf("Value in field \"owner\" was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("owner")); err != nil {
-		return err
-	}
-
-	if len(t.Owner) > 1000000 {
-		return xerrors.Errorf("Value in field t.Owner was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Owner))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string(t.Owner)); err != nil {
-		return err
-	}
-
-	// t.Title (string) (string)
-	if len("title") > 1000000 {
-		return xerrors.Errorf("Value in field \"title\" was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("title")); err != nil {
-		return err
-	}
-
-	if len(t.Title) > 1000000 {
-		return xerrors.Errorf("Value in field t.Title was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string(t.Title)); err != nil {
-		return err
-	}
-
-	// t.IssueId (int64) (int64)
-	if len("issueId") > 1000000 {
-		return xerrors.Errorf("Value in field \"issueId\" was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issueId"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("issueId")); err != nil {
-		return err
-	}
-
-	if t.IssueId >= 0 {
-		if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.IssueId)); err != nil {
-			return err
-		}
-	} else {
-		if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.IssueId-1)); 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
-	}
-	return nil
-}
-
-func (t *RepoIssue) UnmarshalCBOR(r io.Reader) (err error) {
-	*t = RepoIssue{}
-
-	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("RepoIssue: map struct too large (%d)", extra)
-	}
-
-	n := extra
-
-	nameBuf := make([]byte, 9)
-	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.Body (string) (string)
-		case "body":
-
-			{
-				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.Body = (*string)(&sval)
-				}
-			}
-			// t.Repo (string) (string)
-		case "repo":
-
-			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
-				if err != nil {
-					return err
-				}
-
-				t.Repo = string(sval)
-			}
-			// t.LexiconTypeID (string) (string)
-		case "$type":
-
-			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
-				if err != nil {
-					return err
-				}
-
-				t.LexiconTypeID = string(sval)
-			}
-			// t.Owner (string) (string)
-		case "owner":
-
-			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
-				if err != nil {
-					return err
-				}
-
-				t.Owner = string(sval)
-			}
-			// t.Title (string) (string)
-		case "title":
-
-			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
-				if err != nil {
-					return err
-				}
-
-				t.Title = string(sval)
-			}
-			// t.IssueId (int64) (int64)
-		case "issueId":
-			{
-				maj, extra, err := cr.ReadHeader()
-				if err != nil {
-					return err
-				}
-				var extraI int64
-				switch maj {
-				case cbg.MajUnsignedInt:
-					extraI = int64(extra)
-					if extraI < 0 {
-						return fmt.Errorf("int64 positive overflow")
-					}
-				case cbg.MajNegativeInt:
-					extraI = int64(extra)
-					if extraI < 0 {
-						return fmt.Errorf("int64 negative overflow")
-					}
-					extraI = -1 - extraI
-				default:
-					return fmt.Errorf("wrong type for int64 field: %d", maj)
-				}
-
-				t.IssueId = int64(extraI)
-			}
-			// t.CreatedAt (string) (string)
-		case "createdAt":
-
-			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
-				if err != nil {
-					return err
-				}
-
-				t.CreatedAt = 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
-}
 func (t *RepoIssueComment) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
···
 
 	return nil
 }
-func (t *RepoPull) MarshalCBOR(w io.Writer) error {
+func (t *RepoIssue) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
 		return err
 	}
 
 	cw := cbg.NewCborWriter(w)
-	fieldCount := 9
+	fieldCount := 7
 
 	if t.Body == nil {
-		fieldCount--
-	}
-
-	if t.Source == nil {
 		fieldCount--
 	}
 
···
 		}
 	}
 
+	// t.Repo (string) (string)
+	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 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 len("$type") > 1000000 {
 		return xerrors.Errorf("Value in field \"$type\" was too long")
···
 		return err
 	}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull"))); err != nil {
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.issue"))); err != nil {
 		return err
 	}
-	if _, err := cw.WriteString(string("sh.tangled.repo.pull")); err != nil {
+	if _, err := cw.WriteString(string("sh.tangled.repo.issue")); err != nil {
 		return err
 	}
 
-	// t.Patch (string) (string)
-	if len("patch") > 1000000 {
-		return xerrors.Errorf("Value in field \"patch\" was too long")
+	// t.Owner (string) (string)
+	if len("owner") > 1000000 {
+		return xerrors.Errorf("Value in field \"owner\" was too long")
 	}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("patch"))); err != nil {
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil {
 		return err
 	}
-	if _, err := cw.WriteString(string("patch")); err != nil {
+	if _, err := cw.WriteString(string("owner")); err != nil {
 		return err
 	}
 
-	if len(t.Patch) > 1000000 {
-		return xerrors.Errorf("Value in field t.Patch was too long")
+	if len(t.Owner) > 1000000 {
+		return xerrors.Errorf("Value in field t.Owner was too long")
 	}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Patch))); err != nil {
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Owner))); err != nil {
 		return err
 	}
-	if _, err := cw.WriteString(string(t.Patch)); err != nil {
+	if _, err := cw.WriteString(string(t.Owner)); err != nil {
 		return err
 	}
 
···
 		return err
 	}
 
-	// t.PullId (int64) (int64)
-	if len("pullId") > 1000000 {
-		return xerrors.Errorf("Value in field \"pullId\" was too long")
+	// t.IssueId (int64) (int64)
+	if len("issueId") > 1000000 {
+		return xerrors.Errorf("Value in field \"issueId\" was too long")
 	}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pullId"))); err != nil {
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issueId"))); err != nil {
 		return err
 	}
-	if _, err := cw.WriteString(string("pullId")); err != nil {
+	if _, err := cw.WriteString(string("issueId")); err != nil {
 		return err
 	}
 
-	if t.PullId >= 0 {
-		if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.PullId)); err != nil {
+	if t.IssueId >= 0 {
+		if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.IssueId)); err != nil {
 			return err
 		}
 	} else {
-		if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.PullId-1)); err != nil {
-			return err
-		}
-	}
-
-	// t.Source (tangled.RepoPull_Source) (struct)
-	if t.Source != nil {
-
-		if len("source") > 1000000 {
-			return xerrors.Errorf("Value in field \"source\" was too long")
-		}
-
-		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil {
-			return err
-		}
-		if _, err := cw.WriteString(string("source")); err != nil {
-			return err
-		}
-
-		if err := t.Source.MarshalCBOR(cw); err != nil {
+		if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.IssueId-1)); err != nil {
 			return err
 		}
 	}
···
 	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
 		return err
 	}
-
-	// t.TargetRepo (string) (string)
-	if len("targetRepo") > 1000000 {
-		return xerrors.Errorf("Value in field \"targetRepo\" was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetRepo"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("targetRepo")); err != nil {
-		return err
-	}
-
-	if len(t.TargetRepo) > 1000000 {
-		return xerrors.Errorf("Value in field t.TargetRepo was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetRepo))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string(t.TargetRepo)); err != nil {
-		return err
-	}
-
-	// t.TargetBranch (string) (string)
-	if len("targetBranch") > 1000000 {
-		return xerrors.Errorf("Value in field \"targetBranch\" was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetBranch"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("targetBranch")); err != nil {
-		return err
-	}
-
-	if len(t.TargetBranch) > 1000000 {
-		return xerrors.Errorf("Value in field t.TargetBranch was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetBranch))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string(t.TargetBranch)); err != nil {
-		return err
-	}
 	return nil
 }
 
-func (t *RepoPull) UnmarshalCBOR(r io.Reader) (err error) {
-	*t = RepoPull{}
+func (t *RepoIssue) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = RepoIssue{}
 
 	cr := cbg.NewCborReader(r)
 
···
 	}
 
 	if extra > cbg.MaxLength {
-		return fmt.Errorf("RepoPull: map struct too large (%d)", extra)
+		return fmt.Errorf("RepoIssue: map struct too large (%d)", extra)
 	}
 
 	n := extra
 
-	nameBuf := make([]byte, 12)
+	nameBuf := make([]byte, 9)
 	for i := uint64(0); i < n; i++ {
 		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
 		if err != nil {
···
 					t.Body = (*string)(&sval)
 				}
 			}
+			// t.Repo (string) (string)
+		case "repo":
+
+			{
+				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.Patch (string) (string)
-		case "patch":
+			// t.Owner (string) (string)
+		case "owner":
 
 			{
 				sval, err := cbg.ReadStringWithMax(cr, 1000000)
···
 					return err
 				}
 
-				t.Patch = string(sval)
+				t.Owner = string(sval)
 			}
 			// t.Title (string) (string)
 		case "title":
···
 
 				t.Title = string(sval)
 			}
-			// t.PullId (int64) (int64)
-		case "pullId":
+			// t.IssueId (int64) (int64)
+		case "issueId":
 			{
 				maj, extra, err := cr.ReadHeader()
 				if err != nil {
···
 					return fmt.Errorf("wrong type for int64 field: %d", maj)
 				}
 
-				t.PullId = int64(extraI)
-			}
-			// t.Source (tangled.RepoPull_Source) (struct)
-		case "source":
-
-			{
-
-				b, err := cr.ReadByte()
-				if err != nil {
-					return err
-				}
-				if b != cbg.CborNull[0] {
-					if err := cr.UnreadByte(); err != nil {
-						return err
-					}
-					t.Source = new(RepoPull_Source)
-					if err := t.Source.UnmarshalCBOR(cr); err != nil {
-						return xerrors.Errorf("unmarshaling t.Source pointer: %w", err)
-					}
-				}
-
+				t.IssueId = int64(extraI)
 			}
 			// t.CreatedAt (string) (string)
 		case "createdAt":
···
 
 				t.CreatedAt = string(sval)
 			}
-			// t.TargetRepo (string) (string)
-		case "targetRepo":
-
-			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
-				if err != nil {
-					return err
-				}
-
-				t.TargetRepo = string(sval)
-			}
-			// t.TargetBranch (string) (string)
-		case "targetBranch":
-
-			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
-				if err != nil {
-					return err
-				}
-
-				t.TargetBranch = string(sval)
-			}
 
 		default:
 			// Field doesn't exist on this type, so ignore it
···
 
 	return nil
 }
+func (t *RepoPullStatus) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+
+	cw := cbg.NewCborWriter(w)
+
+	if _, err := cw.Write([]byte{163}); err != nil {
+		return err
+	}
+
+	// t.Pull (string) (string)
+	if len("pull") > 1000000 {
+		return xerrors.Errorf("Value in field \"pull\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("pull")); err != nil {
+		return err
+	}
+
+	if len(t.Pull) > 1000000 {
+		return xerrors.Errorf("Value in field t.Pull was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string(t.Pull)); 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("sh.tangled.repo.pull.status"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("sh.tangled.repo.pull.status")); err != nil {
+		return err
+	}
+
+	// t.Status (string) (string)
+	if len("status") > 1000000 {
+		return xerrors.Errorf("Value in field \"status\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("status")); err != nil {
+		return err
+	}
+
+	if len(t.Status) > 1000000 {
+		return xerrors.Errorf("Value in field t.Status was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string(t.Status)); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (t *RepoPullStatus) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = RepoPullStatus{}
+
+	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("RepoPullStatus: map struct too large (%d)", extra)
+	}
+
+	n := extra
+
+	nameBuf := make([]byte, 6)
+	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.Pull (string) (string)
+		case "pull":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.Pull = string(sval)
+			}
+			// t.LexiconTypeID (string) (string)
+		case "$type":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.LexiconTypeID = string(sval)
+			}
+			// t.Status (string) (string)
+		case "status":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.Status = 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
+}
 func (t *RepoPull_Source) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
···
 
 	return nil
 }
-func (t *RepoPullStatus) MarshalCBOR(w io.Writer) error {
+func (t *RepoPull) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
 		return err
 	}
 
 	cw := cbg.NewCborWriter(w)
+	fieldCount := 9
 
-	if _, err := cw.Write([]byte{163}); err != nil {
+	if t.Body == nil {
+		fieldCount--
+	}
+
+	if t.Source == nil {
+		fieldCount--
+	}
+
+	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
 		return err
 	}
 
-	// t.Pull (string) (string)
-	if len("pull") > 1000000 {
-		return xerrors.Errorf("Value in field \"pull\" was too long")
+	// t.Body (string) (string)
+	if t.Body != nil {
+
+		if len("body") > 1000000 {
+			return xerrors.Errorf("Value in field \"body\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("body")); err != nil {
+			return err
+		}
+
+		if t.Body == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if len(*t.Body) > 1000000 {
+				return xerrors.Errorf("Value in field t.Body was too long")
+			}
+
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(*t.Body)); err != nil {
+				return err
+			}
+		}
 	}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pull"))); err != nil {
+	// 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("pull")); err != nil {
+	if _, err := cw.WriteString(string("$type")); err != nil {
+		return err
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("sh.tangled.repo.pull")); err != nil {
 		return err
 	}
 
-	if len(t.Pull) > 1000000 {
-		return xerrors.Errorf("Value in field t.Pull was too long")
+	// t.Patch (string) (string)
+	if len("patch") > 1000000 {
+		return xerrors.Errorf("Value in field \"patch\" was too long")
 	}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Pull))); err != nil {
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("patch"))); err != nil {
 		return err
 	}
-	if _, err := cw.WriteString(string(t.Pull)); err != nil {
+	if _, err := cw.WriteString(string("patch")); err != nil {
 		return err
 	}
 
-	// t.LexiconTypeID (string) (string)
-	if len("$type") > 1000000 {
-		return xerrors.Errorf("Value in field \"$type\" was too long")
+	if len(t.Patch) > 1000000 {
+		return xerrors.Errorf("Value in field t.Patch was too long")
 	}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Patch))); err != nil {
 		return err
 	}
-	if _, err := cw.WriteString(string("$type")); err != nil {
+	if _, err := cw.WriteString(string(t.Patch)); err != nil {
 		return err
 	}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo.pull.status"))); err != nil {
+	// t.Title (string) (string)
+	if len("title") > 1000000 {
+		return xerrors.Errorf("Value in field \"title\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil {
 		return err
 	}
-	if _, err := cw.WriteString(string("sh.tangled.repo.pull.status")); err != nil {
+	if _, err := cw.WriteString(string("title")); err != nil {
 		return err
 	}
 
-	// t.Status (string) (string)
-	if len("status") > 1000000 {
-		return xerrors.Errorf("Value in field \"status\" was too long")
+	if len(t.Title) > 1000000 {
+		return xerrors.Errorf("Value in field t.Title was too long")
 	}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil {
 		return err
 	}
-	if _, err := cw.WriteString(string("status")); err != nil {
+	if _, err := cw.WriteString(string(t.Title)); err != nil {
 		return err
 	}
 
-	if len(t.Status) > 1000000 {
-		return xerrors.Errorf("Value in field t.Status was too long")
+	// t.PullId (int64) (int64)
+	if len("pullId") > 1000000 {
+		return xerrors.Errorf("Value in field \"pullId\" was too long")
 	}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil {
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pullId"))); err != nil {
 		return err
 	}
-	if _, err := cw.WriteString(string(t.Status)); err != nil {
+	if _, err := cw.WriteString(string("pullId")); err != nil {
+		return err
+	}
+
+	if t.PullId >= 0 {
+		if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.PullId)); err != nil {
+			return err
+		}
+	} else {
+		if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.PullId-1)); err != nil {
+			return err
+		}
+	}
+
+	// t.Source (tangled.RepoPull_Source) (struct)
+	if t.Source != nil {
+
+		if len("source") > 1000000 {
+			return xerrors.Errorf("Value in field \"source\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("source")); err != nil {
+			return err
+		}
+
+		if err := t.Source.MarshalCBOR(cw); 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.TargetRepo (string) (string)
+	if len("targetRepo") > 1000000 {
+		return xerrors.Errorf("Value in field \"targetRepo\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetRepo"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("targetRepo")); err != nil {
+		return err
+	}
+
+	if len(t.TargetRepo) > 1000000 {
+		return xerrors.Errorf("Value in field t.TargetRepo was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetRepo))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string(t.TargetRepo)); err != nil {
+		return err
+	}
+
+	// t.TargetBranch (string) (string)
+	if len("targetBranch") > 1000000 {
+		return xerrors.Errorf("Value in field \"targetBranch\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetBranch"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("targetBranch")); err != nil {
+		return err
+	}
+
+	if len(t.TargetBranch) > 1000000 {
+		return xerrors.Errorf("Value in field t.TargetBranch was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetBranch))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string(t.TargetBranch)); err != nil {
 		return err
 	}
 	return nil
 }
 
-func (t *RepoPullStatus) UnmarshalCBOR(r io.Reader) (err error) {
-	*t = RepoPullStatus{}
+func (t *RepoPull) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = RepoPull{}
 
 	cr := cbg.NewCborReader(r)
 
···
 	}
 
 	if extra > cbg.MaxLength {
-		return fmt.Errorf("RepoPullStatus: map struct too large (%d)", extra)
+		return fmt.Errorf("RepoPull: map struct too large (%d)", extra)
 	}
 
 	n := extra
 
-	nameBuf := make([]byte, 6)
+	nameBuf := make([]byte, 12)
 	for i := uint64(0); i < n; i++ {
 		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
 		if err != nil {
···
 		}
 
 		switch string(nameBuf[:nameLen]) {
-		// t.Pull (string) (string)
-		case "pull":
+		// t.Body (string) (string)
+		case "body":
 
 			{
-				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.Pull = string(sval)
+					sval, err := cbg.ReadStringWithMax(cr, 1000000)
+					if err != nil {
+						return err
+					}
+
+					t.Body = (*string)(&sval)
+				}
 			}
 			// t.LexiconTypeID (string) (string)
 		case "$type":
···
 
 				t.LexiconTypeID = string(sval)
 			}
-			// t.Status (string) (string)
-		case "status":
+			// t.Patch (string) (string)
+		case "patch":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.Patch = string(sval)
+			}
+			// t.Title (string) (string)
+		case "title":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.Title = string(sval)
+			}
+			// t.PullId (int64) (int64)
+		case "pullId":
+			{
+				maj, extra, err := cr.ReadHeader()
+				if err != nil {
+					return err
+				}
+				var extraI int64
+				switch maj {
+				case cbg.MajUnsignedInt:
+					extraI = int64(extra)
+					if extraI < 0 {
+						return fmt.Errorf("int64 positive overflow")
+					}
+				case cbg.MajNegativeInt:
+					extraI = int64(extra)
+					if extraI < 0 {
+						return fmt.Errorf("int64 negative overflow")
+					}
+					extraI = -1 - extraI
+				default:
+					return fmt.Errorf("wrong type for int64 field: %d", maj)
+				}
+
+				t.PullId = int64(extraI)
+			}
+			// t.Source (tangled.RepoPull_Source) (struct)
+		case "source":
+
+			{
+
+				b, err := cr.ReadByte()
+				if err != nil {
+					return err
+				}
+				if b != cbg.CborNull[0] {
+					if err := cr.UnreadByte(); err != nil {
+						return err
+					}
+					t.Source = new(RepoPull_Source)
+					if err := t.Source.UnmarshalCBOR(cr); err != nil {
+						return xerrors.Errorf("unmarshaling t.Source pointer: %w", err)
+					}
+				}
+
+			}
+			// t.CreatedAt (string) (string)
+		case "createdAt":
 
 			{
 				sval, err := cbg.ReadStringWithMax(cr, 1000000)
···
 					return err
 				}
 
-				t.Status = string(sval)
+				t.CreatedAt = string(sval)
+			}
+			// t.TargetRepo (string) (string)
+		case "targetRepo":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.TargetRepo = string(sval)
+			}
+			// t.TargetBranch (string) (string)
+		case "targetBranch":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.TargetBranch = string(sval)
 			}
 
 		default:
···
 
 	return nil
 }
-func (t *Spindle) MarshalCBOR(w io.Writer) error {
+func (t *Repo) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
 		return err
 	}
 
 	cw := cbg.NewCborWriter(w)
+	fieldCount := 8
 
-	if _, err := cw.Write([]byte{162}); err != nil {
+	if t.Description == nil {
+		fieldCount--
+	}
+
+	if t.Source == nil {
+		fieldCount--
+	}
+
+	if t.Spindle == nil {
+		fieldCount--
+	}
+
+	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
+		return err
+	}
+
+	// t.Knot (string) (string)
+	if len("knot") > 1000000 {
+		return xerrors.Errorf("Value in field \"knot\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("knot")); err != nil {
+		return err
+	}
+
+	if len(t.Knot) > 1000000 {
+		return xerrors.Errorf("Value in field t.Knot was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string(t.Knot)); err != nil {
+		return err
+	}
+
+	// t.Name (string) (string)
+	if len("name") > 1000000 {
+		return xerrors.Errorf("Value in field \"name\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("name")); err != nil {
+		return err
+	}
+
+	if len(t.Name) > 1000000 {
+		return xerrors.Errorf("Value in field t.Name was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string(t.Name)); err != nil {
 		return err
 	}
 
···
 		return err
 	}
 
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.spindle"))); err != nil {
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo"))); err != nil {
 		return err
 	}
-	if _, err := cw.WriteString(string("sh.tangled.spindle")); err != nil {
+	if _, err := cw.WriteString(string("sh.tangled.repo")); err != nil {
 		return err
 	}
 
+	// t.Owner (string) (string)
+	if len("owner") > 1000000 {
+		return xerrors.Errorf("Value in field \"owner\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("owner")); err != nil {
+		return err
+	}
+
+	if len(t.Owner) > 1000000 {
+		return xerrors.Errorf("Value in field t.Owner was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Owner))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string(t.Owner)); err != nil {
+		return err
+	}
+
+	// t.Source (string) (string)
+	if t.Source != nil {
+
+		if len("source") > 1000000 {
+			return xerrors.Errorf("Value in field \"source\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("source"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("source")); err != nil {
+			return err
+		}
+
+		if t.Source == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if len(*t.Source) > 1000000 {
+				return xerrors.Errorf("Value in field t.Source was too long")
+			}
+
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Source))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(*t.Source)); err != nil {
+				return err
+			}
+		}
+	}
+
+	// t.Spindle (string) (string)
+	if t.Spindle != nil {
+
+		if len("spindle") > 1000000 {
+			return xerrors.Errorf("Value in field \"spindle\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("spindle"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("spindle")); err != nil {
+			return err
+		}
+
+		if t.Spindle == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if len(*t.Spindle) > 1000000 {
+				return xerrors.Errorf("Value in field t.Spindle was too long")
+			}
+
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Spindle))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(*t.Spindle)); 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.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
+			}
+		}
+	}
 	return nil
 }
 
-func (t *Spindle) UnmarshalCBOR(r io.Reader) (err error) {
-	*t = Spindle{}
+func (t *Repo) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = Repo{}
 
 	cr := cbg.NewCborReader(r)
 
···
 	}
 
 	if extra > cbg.MaxLength {
-		return fmt.Errorf("Spindle: map struct too large (%d)", extra)
+		return fmt.Errorf("Repo: map struct too large (%d)", extra)
 	}
 
 	n := extra
 
-	nameBuf := make([]byte, 9)
+	nameBuf := make([]byte, 11)
 	for i := uint64(0); i < n; i++ {
 		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
 		if err != nil {
···
 		}
 
 		switch string(nameBuf[:nameLen]) {
-		// t.LexiconTypeID (string) (string)
+		// t.Knot (string) (string)
+		case "knot":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.Knot = string(sval)
+			}
+			// t.Name (string) (string)
+		case "name":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.Name = string(sval)
+			}
+			// t.LexiconTypeID (string) (string)
 		case "$type":
 
 			{
···
 
 				t.LexiconTypeID = string(sval)
 			}
+			// t.Owner (string) (string)
+		case "owner":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.Owner = string(sval)
+			}
+			// t.Source (string) (string)
+		case "source":
+
+			{
+				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.Source = (*string)(&sval)
+				}
+			}
+			// t.Spindle (string) (string)
+		case "spindle":
+
+			{
+				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.Spindle = (*string)(&sval)
+				}
+			}
 			// t.CreatedAt (string) (string)
 		case "createdAt":
 
···
 				}
 
 				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)
+				}
 			}
 
 		default:
···
 				}
 
 				t.Instance = string(sval)
+			}
+			// t.CreatedAt (string) (string)
+		case "createdAt":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.CreatedAt = 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
+}
+func (t *Spindle) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+
+	cw := cbg.NewCborWriter(w)
+
+	if _, err := cw.Write([]byte{162}); 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("sh.tangled.spindle"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("sh.tangled.spindle")); 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
+	}
+	return nil
+}
+
+func (t *Spindle) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = Spindle{}
+
+	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("Spindle: map struct too large (%d)", extra)
+	}
+
+	n := extra
+
+	nameBuf := make([]byte, 9)
+	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.LexiconTypeID (string) (string)
+		case "$type":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.LexiconTypeID = string(sval)
 			}
 			// t.CreatedAt (string) (string)
 		case "createdAt":

api/tangled/tangledknot.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+package tangled
+
+// schema: sh.tangled.knot
+
+import (
+	"github.com/bluesky-social/indigo/lex/util"
+)
+
+const (
+	KnotNSID = "sh.tangled.knot"
+)
+
+func init() {
+	util.RegisterType("sh.tangled.knot", &Knot{})
+} //
+// RECORDTYPE: Knot
+type Knot struct {
+	LexiconTypeID string `json:"$type,const=sh.tangled.knot" cborgen:"$type,const=sh.tangled.knot"`
+	CreatedAt     string `json:"createdAt" cborgen:"createdAt"`
+}

cmd/gen.go

···
 		tangled.ActorProfile{},
 		tangled.FeedReaction{},
 		tangled.FeedStar{},
-		tangled.GitRefUpdate{},
-		tangled.GitRefUpdate_Meta{},
-		tangled.GitRefUpdate_Meta_CommitCount{},
 		tangled.GitRefUpdate_Meta_CommitCount_ByEmail_Elem{},
+		tangled.GitRefUpdate_Meta_CommitCount{},
 		tangled.GitRefUpdate_Meta_LangBreakdown{},
+		tangled.GitRefUpdate_Meta{},
 		tangled.GitRefUpdate_Pair{},
+		tangled.GitRefUpdate{},
 		tangled.GraphFollow{},
 		tangled.KnotMember{},
-		tangled.Pipeline{},
+		tangled.Knot{},
+		tangled.PipelineStatus{},
 		tangled.Pipeline_CloneOpts{},
 		tangled.Pipeline_Dependency{},
 		tangled.Pipeline_ManualTriggerData{},
 		tangled.Pipeline_Pair{},
 		tangled.Pipeline_PullRequestTriggerData{},
 		tangled.Pipeline_PushTriggerData{},
-		tangled.PipelineStatus{},
 		tangled.Pipeline_Step{},
 		tangled.Pipeline_TriggerMetadata{},
 		tangled.Pipeline_TriggerRepo{},
 		tangled.Pipeline_Workflow{},
+		tangled.Pipeline{},
 		tangled.PublicKey{},
-		tangled.Repo{},
 		tangled.RepoArtifact{},
 		tangled.RepoCollaborator{},
-		tangled.RepoIssue{},
 		tangled.RepoIssueComment{},
 		tangled.RepoIssueState{},
-		tangled.RepoPull{},
+		tangled.RepoIssue{},
 		tangled.RepoPullComment{},
-		tangled.RepoPull_Source{},
 		tangled.RepoPullStatus{},
-		tangled.Spindle{},
+		tangled.RepoPull_Source{},
+		tangled.RepoPull{},
+		tangled.Repo{},
 		tangled.SpindleMember{},
+		tangled.Spindle{},
 		tangled.String{},
 	); err != nil {
 		panic(err)

lexicons/knot.json

···
+{
+  "lexicon": 1,
+  "id": "sh.tangled.knot",
+  "needsCbor": true,
+  "needsType": true,
+  "defs": {
+    "main": {
+      "type": "record",
+      "key": "any",
+      "record": {
+        "type": "object",
+        "required": ["createdAt"],
+        "properties": {
+          "createdAt": {
+            "type": "string",
+            "format": "datetime"
+          }
+        }
+      }
+    }
+  }
+}