lex: write generated code headers, use goimports as library

And some docs, avoid writing empty init blocks (just for prettier
generated code), remove some stutter in Fprintf calls, go mod tidy.

api/atproto/admindefs.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.admin.defs
-
-func init() {
-}
 
 type AdminDefs_ActionReversal struct {
 	CreatedAt string `json:"createdAt" cborgen:"createdAt"`

api/atproto/admindisableInviteCodes.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.admin.disableInviteCodes
-
-func init() {
-}
 
 type AdminDisableInviteCodes_Input struct {
 	Accounts []string `json:"accounts,omitempty" cborgen:"accounts,omitempty"`

api/atproto/admingetInviteCodes.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.admin.getInviteCodes
-
-func init() {
-}
 
 type AdminGetInviteCodes_Output struct {
 	Codes  []*ServerDefs_InviteCode `json:"codes" cborgen:"codes"`

api/atproto/admingetModerationAction.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 
 // schema: com.atproto.admin.getModerationAction
 
-func init() {
-}
 func AdminGetModerationAction(ctx context.Context, c *xrpc.Client, id int64) (*AdminDefs_ActionViewDetail, error) {
 	var out AdminDefs_ActionViewDetail
 

api/atproto/admingetModerationActions.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.admin.getModerationActions
-
-func init() {
-}
 
 type AdminGetModerationActions_Output struct {
 	Actions []*AdminDefs_ActionView `json:"actions" cborgen:"actions"`

api/atproto/admingetModerationReport.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 
 // schema: com.atproto.admin.getModerationReport
 
-func init() {
-}
 func AdminGetModerationReport(ctx context.Context, c *xrpc.Client, id int64) (*AdminDefs_ReportViewDetail, error) {
 	var out AdminDefs_ReportViewDetail
 

api/atproto/admingetModerationReports.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.admin.getModerationReports
-
-func init() {
-}
 
 type AdminGetModerationReports_Output struct {
 	Cursor  *string                 `json:"cursor,omitempty" cborgen:"cursor,omitempty"`

api/atproto/admingetRecord.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 
 // schema: com.atproto.admin.getRecord
 
-func init() {
-}
 func AdminGetRecord(ctx context.Context, c *xrpc.Client, cid string, uri string) (*AdminDefs_RecordViewDetail, error) {
 	var out AdminDefs_RecordViewDetail
 

api/atproto/admingetRepo.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 
 // schema: com.atproto.admin.getRepo
 
-func init() {
-}
 func AdminGetRepo(ctx context.Context, c *xrpc.Client, did string) (*AdminDefs_RepoViewDetail, error) {
 	var out AdminDefs_RepoViewDetail
 

api/atproto/adminresolveModerationReports.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.admin.resolveModerationReports
-
-func init() {
-}
 
 type AdminResolveModerationReports_Input struct {
 	ActionId  int64   `json:"actionId" cborgen:"actionId"`

api/atproto/adminreverseModerationAction.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.admin.reverseModerationAction
-
-func init() {
-}
 
 type AdminReverseModerationAction_Input struct {
 	CreatedBy string `json:"createdBy" cborgen:"createdBy"`

api/atproto/adminsearchRepos.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.admin.searchRepos
-
-func init() {
-}
 
 type AdminSearchRepos_Output struct {
 	Cursor *string               `json:"cursor,omitempty" cborgen:"cursor,omitempty"`

api/atproto/admintakeModerationAction.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.admin.takeModerationAction
-
-func init() {
-}
 
 type AdminTakeModerationAction_Input struct {
 	Action          string                                   `json:"action" cborgen:"action"`

api/atproto/adminupdateAccountEmail.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.admin.updateAccountEmail
-
-func init() {
-}
 
 type AdminUpdateAccountEmail_Input struct {
 	Account string `json:"account" cborgen:"account"`

api/atproto/adminupdateAccountHandle.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.admin.updateAccountHandle
-
-func init() {
-}
 
 type AdminUpdateAccountHandle_Input struct {
 	Did    string `json:"did" cborgen:"did"`

api/atproto/identityresolveHandle.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.identity.resolveHandle
-
-func init() {
-}
 
 type IdentityResolveHandle_Output struct {
 	Did string `json:"did" cborgen:"did"`

api/atproto/identityupdateHandle.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.identity.updateHandle
-
-func init() {
-}
 
 type IdentityUpdateHandle_Input struct {
 	Handle string `json:"handle" cborgen:"handle"`

api/atproto/labeldefs.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 // schema: com.atproto.label.defs
-
-func init() {
-}
 
 type LabelDefs_Label struct {
 	Cid *string `json:"cid,omitempty" cborgen:"cid,omitempty"`

api/atproto/labelqueryLabels.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.label.queryLabels
-
-func init() {
-}
 
 type LabelQueryLabels_Output struct {
 	Cursor *string            `json:"cursor,omitempty" cborgen:"cursor,omitempty"`

api/atproto/labelsubscribeLabels.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 // schema: com.atproto.label.subscribeLabels
-
-func init() {
-}
 
 type LabelSubscribeLabels_Info struct {
 	Message *string `json:"message,omitempty" cborgen:"message,omitempty"`

api/atproto/moderationcreateReport.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.moderation.createReport
-
-func init() {
-}
 
 type ModerationCreateReport_Input struct {
 	Reason     *string                               `json:"reason,omitempty" cborgen:"reason,omitempty"`

api/atproto/moderationdefs.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 // schema: com.atproto.moderation.defs
-
-func init() {
-}

api/atproto/repoapplyWrites.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.repo.applyWrites
-
-func init() {
-}
 
 // RECORDTYPE: RepoApplyWrites_Create
 type RepoApplyWrites_Create struct {

api/atproto/repocreateRecord.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.repo.createRecord
-
-func init() {
-}
 
 type RepoCreateRecord_Input struct {
 	Collection string                   `json:"collection" cborgen:"collection"`

api/atproto/repodeleteRecord.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.repo.deleteRecord
-
-func init() {
-}
 
 type RepoDeleteRecord_Input struct {
 	Collection string  `json:"collection" cborgen:"collection"`

api/atproto/repodescribeRepo.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.repo.describeRepo
-
-func init() {
-}
 
 type RepoDescribeRepo_Output struct {
 	Collections     []string                 `json:"collections" cborgen:"collections"`

api/atproto/repogetRecord.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.repo.getRecord
-
-func init() {
-}
 
 type RepoGetRecord_Output struct {
 	Cid   *string                  `json:"cid,omitempty" cborgen:"cid,omitempty"`

api/atproto/repolistRecords.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.repo.listRecords
-
-func init() {
-}
 
 type RepoListRecords_Output struct {
 	Cursor  *string                   `json:"cursor,omitempty" cborgen:"cursor,omitempty"`

api/atproto/repoputRecord.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.repo.putRecord
-
-func init() {
-}
 
 type RepoPutRecord_Input struct {
 	Collection string                   `json:"collection" cborgen:"collection"`

api/atproto/repostrongRef.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 
 func init() {
 	util.RegisterType("com.atproto.repo.strongRef#main", &RepoStrongRef{})
-}
-
-// RECORDTYPE: RepoStrongRef
+} // RECORDTYPE: RepoStrongRef
 type RepoStrongRef struct {
 	LexiconTypeID string `json:"$type,const=com.atproto.repo.strongRef,omitempty" cborgen:"$type,const=com.atproto.repo.strongRef,omitempty"`
 	Cid           string `json:"cid" cborgen:"cid"`

api/atproto/repouploadBlob.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.repo.uploadBlob
-
-func init() {
-}
 
 type RepoUploadBlob_Output struct {
 	Blob *util.LexBlob `json:"blob" cborgen:"blob"`

api/atproto/servercreateAccount.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.server.createAccount
-
-func init() {
-}
 
 type ServerCreateAccount_Input struct {
 	Email       string  `json:"email" cborgen:"email"`

api/atproto/servercreateAppPassword.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.server.createAppPassword
-
-func init() {
-}
 
 type ServerCreateAppPassword_AppPassword struct {
 	CreatedAt string `json:"createdAt" cborgen:"createdAt"`

api/atproto/servercreateInviteCode.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.server.createInviteCode
-
-func init() {
-}
 
 type ServerCreateInviteCode_Input struct {
 	ForAccount *string `json:"forAccount,omitempty" cborgen:"forAccount,omitempty"`

api/atproto/servercreateInviteCodes.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.server.createInviteCodes
-
-func init() {
-}
 
 type ServerCreateInviteCodes_AccountCodes struct {
 	Account string   `json:"account" cborgen:"account"`

api/atproto/servercreateSession.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.server.createSession
-
-func init() {
-}
 
 type ServerCreateSession_Input struct {
 	Identifier string `json:"identifier" cborgen:"identifier"`

api/atproto/serverdefs.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 // schema: com.atproto.server.defs
-
-func init() {
-}
 
 type ServerDefs_InviteCode struct {
 	Available  int64                       `json:"available" cborgen:"available"`

api/atproto/serverdeleteAccount.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.server.deleteAccount
-
-func init() {
-}
 
 type ServerDeleteAccount_Input struct {
 	Did      string `json:"did" cborgen:"did"`

api/atproto/serverdeleteSession.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 
 // schema: com.atproto.server.deleteSession
 
-func init() {
-}
 func ServerDeleteSession(ctx context.Context, c *xrpc.Client) error {
 	if err := c.Do(ctx, xrpc.Procedure, "", "com.atproto.server.deleteSession", nil, nil, nil); err != nil {
 		return err

api/atproto/serverdescribeServer.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.server.describeServer
-
-func init() {
-}
 
 type ServerDescribeServer_Links struct {
 	PrivacyPolicy  *string `json:"privacyPolicy,omitempty" cborgen:"privacyPolicy,omitempty"`

api/atproto/servergetAccountInviteCodes.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.server.getAccountInviteCodes
-
-func init() {
-}
 
 type ServerGetAccountInviteCodes_Output struct {
 	Codes []*ServerDefs_InviteCode `json:"codes" cborgen:"codes"`

api/atproto/servergetSession.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.server.getSession
-
-func init() {
-}
 
 type ServerGetSession_Output struct {
 	Did    string  `json:"did" cborgen:"did"`

api/atproto/serverlistAppPasswords.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.server.listAppPasswords
-
-func init() {
-}
 
 type ServerListAppPasswords_AppPassword struct {
 	CreatedAt string `json:"createdAt" cborgen:"createdAt"`

api/atproto/serverrefreshSession.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.server.refreshSession
-
-func init() {
-}
 
 type ServerRefreshSession_Output struct {
 	AccessJwt  string `json:"accessJwt" cborgen:"accessJwt"`

api/atproto/serverrequestAccountDelete.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 
 // schema: com.atproto.server.requestAccountDelete
 
-func init() {
-}
 func ServerRequestAccountDelete(ctx context.Context, c *xrpc.Client) error {
 	if err := c.Do(ctx, xrpc.Procedure, "", "com.atproto.server.requestAccountDelete", nil, nil, nil); err != nil {
 		return err

api/atproto/serverrequestPasswordReset.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.server.requestPasswordReset
-
-func init() {
-}
 
 type ServerRequestPasswordReset_Input struct {
 	Email string `json:"email" cborgen:"email"`

api/atproto/serverresetPassword.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.server.resetPassword
-
-func init() {
-}
 
 type ServerResetPassword_Input struct {
 	Password string `json:"password" cborgen:"password"`

api/atproto/serverrevokeAppPassword.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.server.revokeAppPassword
-
-func init() {
-}
 
 type ServerRevokeAppPassword_Input struct {
 	Name string `json:"name" cborgen:"name"`

api/atproto/syncgetBlob.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 
 // schema: com.atproto.sync.getBlob
 
-func init() {
-}
 func SyncGetBlob(ctx context.Context, c *xrpc.Client, cid string, did string) ([]byte, error) {
 	buf := new(bytes.Buffer)
 

api/atproto/syncgetBlocks.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 
 // schema: com.atproto.sync.getBlocks
 
-func init() {
-}
 func SyncGetBlocks(ctx context.Context, c *xrpc.Client, cids []string, did string) ([]byte, error) {
 	buf := new(bytes.Buffer)
 

api/atproto/syncgetCheckout.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 
 // schema: com.atproto.sync.getCheckout
 
-func init() {
-}
 func SyncGetCheckout(ctx context.Context, c *xrpc.Client, commit string, did string) ([]byte, error) {
 	buf := new(bytes.Buffer)
 

api/atproto/syncgetCommitPath.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.sync.getCommitPath
-
-func init() {
-}
 
 type SyncGetCommitPath_Output struct {
 	Commits []string `json:"commits" cborgen:"commits"`

api/atproto/syncgetHead.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.sync.getHead
-
-func init() {
-}
 
 type SyncGetHead_Output struct {
 	Root string `json:"root" cborgen:"root"`

api/atproto/syncgetRecord.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 
 // schema: com.atproto.sync.getRecord
 
-func init() {
-}
 func SyncGetRecord(ctx context.Context, c *xrpc.Client, collection string, commit string, did string, rkey string) ([]byte, error) {
 	buf := new(bytes.Buffer)
 

api/atproto/syncgetRepo.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 
 // schema: com.atproto.sync.getRepo
 
-func init() {
-}
 func SyncGetRepo(ctx context.Context, c *xrpc.Client, did string, earliest string, latest string) ([]byte, error) {
 	buf := new(bytes.Buffer)
 

api/atproto/synclistBlobs.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.sync.listBlobs
-
-func init() {
-}
 
 type SyncListBlobs_Output struct {
 	Cids []string `json:"cids" cborgen:"cids"`

api/atproto/synclistRepos.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.sync.listRepos
-
-func init() {
-}
 
 type SyncListRepos_Output struct {
 	Cursor *string               `json:"cursor,omitempty" cborgen:"cursor,omitempty"`

api/atproto/syncnotifyOfUpdate.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 
 // schema: com.atproto.sync.notifyOfUpdate
 
-func init() {
-}
 func SyncNotifyOfUpdate(ctx context.Context, c *xrpc.Client, hostname string) error {
 
 	params := map[string]interface{}{

api/atproto/syncrequestCrawl.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 
 // schema: com.atproto.sync.requestCrawl
 
-func init() {
-}
 func SyncRequestCrawl(ctx context.Context, c *xrpc.Client, hostname string) error {
 
 	params := map[string]interface{}{

api/atproto/syncsubscribeRepos.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package atproto
 
 import (
···
 )
 
 // schema: com.atproto.sync.subscribeRepos
-
-func init() {
-}
 
 type SyncSubscribeRepos_Commit struct {
 	Blobs  []util.LexLink               `json:"blobs" cborgen:"blobs"`

api/bsky/actordefs.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package bsky
 
 import (
···
 )
 
 // schema: app.bsky.actor.defs
-
-func init() {
-}
 
 type ActorDefs_ProfileView struct {
 	Avatar      *string                            `json:"avatar,omitempty" cborgen:"avatar,omitempty"`

api/bsky/actorgetProfile.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package bsky
 
 import (
···
 
 // schema: app.bsky.actor.getProfile
 
-func init() {
-}
 func ActorGetProfile(ctx context.Context, c *xrpc.Client, actor string) (*ActorDefs_ProfileViewDetailed, error) {
 	var out ActorDefs_ProfileViewDetailed
 

api/bsky/actorgetProfiles.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package bsky
 
 import (
···
 )
 
 // schema: app.bsky.actor.getProfiles
-
-func init() {
-}
 
 type ActorGetProfiles_Output struct {
 	Profiles []*ActorDefs_ProfileViewDetailed `json:"profiles" cborgen:"profiles"`

api/bsky/actorgetSuggestions.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package bsky
 
 import (
···
 )
 
 // schema: app.bsky.actor.getSuggestions
-
-func init() {
-}
 
 type ActorGetSuggestions_Output struct {
 	Actors []*ActorDefs_ProfileView `json:"actors" cborgen:"actors"`

api/bsky/actorprofile.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package bsky
 
 import (
···
 
 func init() {
 	util.RegisterType("app.bsky.actor.profile", &ActorProfile{})
-}
-
-// RECORDTYPE: ActorProfile
+} // RECORDTYPE: ActorProfile
 type ActorProfile struct {
 	LexiconTypeID string        `json:"$type,const=app.bsky.actor.profile" cborgen:"$type,const=app.bsky.actor.profile"`
 	Avatar        *util.LexBlob `json:"avatar,omitempty" cborgen:"avatar,omitempty"`

api/bsky/actorsearchActors.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package bsky
 
 import (
···
 )
 
 // schema: app.bsky.actor.searchActors
-
-func init() {
-}
 
 type ActorSearchActors_Output struct {
 	Actors []*ActorDefs_ProfileView `json:"actors" cborgen:"actors"`

api/bsky/actorsearchActorsTypeahead.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package bsky
 
 import (
···
 )
 
 // schema: app.bsky.actor.searchActorsTypeahead
-
-func init() {
-}
 
 type ActorSearchActorsTypeahead_Output struct {
 	Actors []*ActorDefs_ProfileViewBasic `json:"actors" cborgen:"actors"`

api/bsky/embedexternal.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package bsky
 
 import (
···
 
 func init() {
 	util.RegisterType("app.bsky.embed.external#main", &EmbedExternal{})
-}
-
-// RECORDTYPE: EmbedExternal
+} // RECORDTYPE: EmbedExternal
 type EmbedExternal struct {
 	LexiconTypeID string                  `json:"$type,const=app.bsky.embed.external" cborgen:"$type,const=app.bsky.embed.external"`
 	External      *EmbedExternal_External `json:"external" cborgen:"external"`

api/bsky/embedimages.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package bsky
 
 import (
···
 
 func init() {
 	util.RegisterType("app.bsky.embed.images#main", &EmbedImages{})
-}
-
-// RECORDTYPE: EmbedImages
+} // RECORDTYPE: EmbedImages
 type EmbedImages struct {
 	LexiconTypeID string               `json:"$type,const=app.bsky.embed.images" cborgen:"$type,const=app.bsky.embed.images"`
 	Images        []*EmbedImages_Image `json:"images" cborgen:"images"`

api/bsky/embedrecord.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package bsky
 
 import (
···
 
 func init() {
 	util.RegisterType("app.bsky.embed.record#main", &EmbedRecord{})
-}
-
-// RECORDTYPE: EmbedRecord
+} // RECORDTYPE: EmbedRecord
 type EmbedRecord struct {
 	LexiconTypeID string                         `json:"$type,const=app.bsky.embed.record" cborgen:"$type,const=app.bsky.embed.record"`
 	Record        *comatprototypes.RepoStrongRef `json:"record" cborgen:"record"`

api/bsky/embedrecordWithMedia.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package bsky
 
 import (
···
 
 func init() {
 	util.RegisterType("app.bsky.embed.recordWithMedia#main", &EmbedRecordWithMedia{})
-}
-
-// RECORDTYPE: EmbedRecordWithMedia
+} // RECORDTYPE: EmbedRecordWithMedia
 type EmbedRecordWithMedia struct {
 	LexiconTypeID string                      `json:"$type,const=app.bsky.embed.recordWithMedia" cborgen:"$type,const=app.bsky.embed.recordWithMedia"`
 	Media         *EmbedRecordWithMedia_Media `json:"media" cborgen:"media"`

api/bsky/feeddefs.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package bsky
 
 import (
···
 )
 
 // schema: app.bsky.feed.defs
-
-func init() {
-}
 
 type FeedDefs_FeedViewPost struct {
 	Post   *FeedDefs_PostView            `json:"post" cborgen:"post"`

api/bsky/feedgetAuthorFeed.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package bsky
 
 import (
···
 )
 
 // schema: app.bsky.feed.getAuthorFeed
-
-func init() {
-}
 
 type FeedGetAuthorFeed_Output struct {
 	Cursor *string                  `json:"cursor,omitempty" cborgen:"cursor,omitempty"`

api/bsky/feedgetLikes.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package bsky
 
 import (
···
 )
 
 // schema: app.bsky.feed.getLikes
-
-func init() {
-}
 
 type FeedGetLikes_Like struct {
 	Actor     *ActorDefs_ProfileView `json:"actor" cborgen:"actor"`

api/bsky/feedgetPostThread.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package bsky
 
 import (
···
 )
 
 // schema: app.bsky.feed.getPostThread
-
-func init() {
-}
 
 type FeedGetPostThread_Output struct {
 	Thread *FeedGetPostThread_Output_Thread `json:"thread" cborgen:"thread"`

api/bsky/feedgetPosts.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+package bsky
+
+import (
+	"context"
+
+	"github.com/bluesky-social/indigo/xrpc"
+)
+
+// schema: app.bsky.feed.getPosts
+
+type FeedGetPosts_Output struct {
+	Posts []*FeedDefs_PostView `json:"posts" cborgen:"posts"`
+}
+
+func FeedGetPosts(ctx context.Context, c *xrpc.Client, uris []string) (*FeedGetPosts_Output, error) {
+	var out FeedGetPosts_Output
+
+	params := map[string]interface{}{
+		"uris": uris,
+	}
+	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.feed.getPosts", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/bsky/feedgetRepostedBy.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package bsky
 
 import (
···
 )
 
 // schema: app.bsky.feed.getRepostedBy
-
-func init() {
-}
 
 type FeedGetRepostedBy_Output struct {
 	Cid        *string                  `json:"cid,omitempty" cborgen:"cid,omitempty"`

api/bsky/feedgetTimeline.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package bsky
 
 import (
···
 )
 
 // schema: app.bsky.feed.getTimeline
-
-func init() {
-}
 
 type FeedGetTimeline_Output struct {
 	Cursor *string                  `json:"cursor,omitempty" cborgen:"cursor,omitempty"`

api/bsky/feedlike.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package bsky
 
 import (
···
 
 func init() {
 	util.RegisterType("app.bsky.feed.like", &FeedLike{})
-}
-
-// RECORDTYPE: FeedLike
+} // RECORDTYPE: FeedLike
 type FeedLike struct {
 	LexiconTypeID string                         `json:"$type,const=app.bsky.feed.like" cborgen:"$type,const=app.bsky.feed.like"`
 	CreatedAt     string                         `json:"createdAt" cborgen:"createdAt"`

api/bsky/feedpost.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package bsky
 
 import (
···
 
 func init() {
 	util.RegisterType("app.bsky.feed.post", &FeedPost{})
-}
-
-// RECORDTYPE: FeedPost
+} // RECORDTYPE: FeedPost
 type FeedPost struct {
 	LexiconTypeID string             `json:"$type,const=app.bsky.feed.post" cborgen:"$type,const=app.bsky.feed.post"`
 	CreatedAt     string             `json:"createdAt" cborgen:"createdAt"`

api/bsky/feedrepost.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package bsky
 
 import (
···
 
 func init() {
 	util.RegisterType("app.bsky.feed.repost", &FeedRepost{})
-}
-
-// RECORDTYPE: FeedRepost
+} // RECORDTYPE: FeedRepost
 type FeedRepost struct {
 	LexiconTypeID string                         `json:"$type,const=app.bsky.feed.repost" cborgen:"$type,const=app.bsky.feed.repost"`
 	CreatedAt     string                         `json:"createdAt" cborgen:"createdAt"`

api/bsky/graphfollow.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package bsky
 
 import (
···
 
 func init() {
 	util.RegisterType("app.bsky.graph.follow", &GraphFollow{})
-}
-
-// RECORDTYPE: GraphFollow
+} // RECORDTYPE: GraphFollow
 type GraphFollow struct {
 	LexiconTypeID string `json:"$type,const=app.bsky.graph.follow" cborgen:"$type,const=app.bsky.graph.follow"`
 	CreatedAt     string `json:"createdAt" cborgen:"createdAt"`

api/bsky/graphgetFollowers.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package bsky
 
 import (
···
 )
 
 // schema: app.bsky.graph.getFollowers
-
-func init() {
-}
 
 type GraphGetFollowers_Output struct {
 	Cursor    *string                  `json:"cursor,omitempty" cborgen:"cursor,omitempty"`

api/bsky/graphgetFollows.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package bsky
 
 import (
···
 )
 
 // schema: app.bsky.graph.getFollows
-
-func init() {
-}
 
 type GraphGetFollows_Output struct {
 	Cursor  *string                  `json:"cursor,omitempty" cborgen:"cursor,omitempty"`

api/bsky/graphgetMutes.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package bsky
 
 import (
···
 )
 
 // schema: app.bsky.graph.getMutes
-
-func init() {
-}
 
 type GraphGetMutes_Output struct {
 	Cursor *string                  `json:"cursor,omitempty" cborgen:"cursor,omitempty"`

api/bsky/graphmuteActor.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package bsky
 
 import (
···
 )
 
 // schema: app.bsky.graph.muteActor
-
-func init() {
-}
 
 type GraphMuteActor_Input struct {
 	Actor string `json:"actor" cborgen:"actor"`

api/bsky/graphunmuteActor.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package bsky
 
 import (
···
 )
 
 // schema: app.bsky.graph.unmuteActor
-
-func init() {
-}
 
 type GraphUnmuteActor_Input struct {
 	Actor string `json:"actor" cborgen:"actor"`

api/bsky/notificationgetUnreadCount.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package bsky
 
 import (
···
 )
 
 // schema: app.bsky.notification.getUnreadCount
-
-func init() {
-}
 
 type NotificationGetUnreadCount_Output struct {
 	Count int64 `json:"count" cborgen:"count"`

api/bsky/notificationlistNotifications.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package bsky
 
 import (
···
 )
 
 // schema: app.bsky.notification.listNotifications
-
-func init() {
-}
 
 type NotificationListNotifications_Notification struct {
 	Author        *ActorDefs_ProfileView             `json:"author" cborgen:"author"`

api/bsky/notificationupdateSeen.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package bsky
 
 import (
···
 )
 
 // schema: app.bsky.notification.updateSeen
-
-func init() {
-}
 
 type NotificationUpdateSeen_Input struct {
 	SeenAt string `json:"seenAt" cborgen:"seenAt"`

api/bsky/richtextfacet.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package bsky
 
 import (
···
 )
 
 // schema: app.bsky.richtext.facet
-
-func init() {
-}
 
 type RichtextFacet struct {
 	Features []*RichtextFacet_Features_Elem `json:"features" cborgen:"features"`

api/bsky/unspeccedgetPopular.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
 package bsky
 
 import (
···
 )
 
 // schema: app.bsky.unspecced.getPopular
-
-func init() {
-}
 
 type UnspeccedGetPopular_Output struct {
 	Cursor *string                  `json:"cursor,omitempty" cborgen:"cursor,omitempty"`

go.mod

···
 	go.opentelemetry.io/otel/exporters/jaeger v1.14.0
 	go.opentelemetry.io/otel/sdk v1.14.0
 	golang.org/x/sync v0.1.0
+	golang.org/x/tools v0.8.0
 	golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2
 	gorm.io/driver/postgres v1.5.0
 	gorm.io/driver/sqlite v1.4.4
···
 	github.com/prometheus/procfs v0.9.0 // indirect
 	github.com/prometheus/statsd_exporter v0.23.1 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
-	github.com/sashabaranov/go-openai v1.7.0 // indirect
 	github.com/spaolacci/murmur3 v1.1.0 // indirect
 	github.com/valyala/bytebufferpool v1.0.0 // indirect
 	github.com/valyala/fasttemplate v1.2.2 // indirect
···
 	go.uber.org/zap v1.24.0 // indirect
 	golang.org/x/crypto v0.7.0 // indirect
 	golang.org/x/exp v0.0.0-20230321023759-10a507213a29 // indirect
-	golang.org/x/net v0.8.0 // indirect
-	golang.org/x/sys v0.6.0 // indirect
-	golang.org/x/text v0.8.0 // indirect
+	golang.org/x/mod v0.10.0 // indirect
+	golang.org/x/net v0.9.0 // indirect
+	golang.org/x/sys v0.7.0 // indirect
+	golang.org/x/text v0.9.0 // indirect
 	golang.org/x/time v0.3.0 // indirect
 	google.golang.org/protobuf v1.30.0 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect

go.sum

···
 github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/sashabaranov/go-openai v1.7.0 h1:D1dBXoZhtf/aKNu6WFf0c7Ah2NM30PZ/3Mqly6cZ7fk=
-github.com/sashabaranov/go-openai v1.7.0/go.mod h1:lj5b/K+zjTSFxVLijLSTDZuP7adOgerWeFyZLUhAKRg=
 github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
 github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
 github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
···
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
-golang.org/x/mod v0.8.0 h1:LUYupSeNrTNCGzR/hVBk2NHZO4hXcVaW1k4Qx7rjPx8=
 golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/mod v0.10.0 h1:lFO9qtOdlre5W1jxS3r/4szv2/6iXxScdzjoBMXNhYk=
+golang.org/x/mod v0.10.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
···
 golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
 golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
-golang.org/x/net v0.8.0 h1:Zrh2ngAOFYneWTAIAPethzeaQLuHwhuBkuV6ZiRnUaQ=
 golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc=
+golang.org/x/net v0.9.0 h1:aWJ/m6xSmxWBx+V0XRHTlrYrPG56jKsLdTFmsSsCzOM=
+golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
···
 golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.6.0 h1:MVltZSvRTcU2ljQOhs94SXPftV6DCNnZViHeQps87pQ=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.7.0 h1:3jlCCIQZPdOYu1h8BkNvLz8Kgwtae2cagcG/VamtZRU=
+golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
···
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.8.0 h1:57P1ETyNKtuIjB4SRd15iJxuhj8Gc416Y78H3qgMh68=
 golang.org/x/text v0.8.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
+golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE=
+golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
 golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
···
 golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
 golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
-golang.org/x/tools v0.6.0 h1:BOw41kyTf3PuCW1pVQf8+Cyg8pMlkYB1oo9iJ6D/lKM=
 golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
+golang.org/x/tools v0.8.0 h1:vSDcovVPld282ceKgDimkRSC8kpaH1dgyc9UMzlt84Y=
+golang.org/x/tools v0.8.0/go.mod h1:JxBZ99ISMI5ViVkT1tr6tdNmXeTrcpVSD3vZ1RsRdN4=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

lex/gen.go

···
+// Package lex generates Go code for lexicons.
+//
+// (It is not a lexer.)
 package lex
 
 import (
 	"bytes"
 	"encoding/json"
 	"fmt"
-	"go/format"
 	"html/template"
 	"io"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"sort"
 	"strings"
+
+	"golang.org/x/tools/imports"
 )
 
 const (
···
 	}
 }
 
+func printerf(w io.Writer) func(format string, args ...any) {
+	return func(format string, args ...any) {
+		fmt.Fprintf(w, format, args...)
+	}
+}
+
 func GenCodeForSchema(pkg string, prefix string, fname string, reqcode bool, s *Schema, defmap map[string]*ExtDef, imports map[string]string) error {
 	buf := new(bytes.Buffer)
+	pf := printerf(buf)
 
 	s.prefix = prefix
 	for _, d := range s.Defs {
 		d.prefix = prefix
 	}
 
-	fmt.Fprintf(buf, "package %s\n\n", pkg)
-	fmt.Fprintf(buf, "import (\n")
-	fmt.Fprintf(buf, "\t\"context\"\n")
-	fmt.Fprintf(buf, "\t\"fmt\"\n")
-	fmt.Fprintf(buf, "\t\"encoding/json\"\n")
-	fmt.Fprintf(buf, "\tcbg \"github.com/whyrusleeping/cbor-gen\"\n")
-	fmt.Fprintf(buf, "\t\"github.com/bluesky-social/indigo/xrpc\"\n")
-	fmt.Fprintf(buf, "\t\"github.com/bluesky-social/indigo/lex/util\"\n")
+	// Add the standard Go generated code header as recognized by GitHub, VS Code, etc.
+	// See https://golang.org/s/generatedcode.
+	pf("// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.\n\n")
+
+	pf("package %s\n\n", pkg)
+	pf("import (\n")
+	pf("\t\"context\"\n")
+	pf("\t\"fmt\"\n")
+	pf("\t\"encoding/json\"\n")
+	pf("\tcbg \"github.com/whyrusleeping/cbor-gen\"\n")
+	pf("\t\"github.com/bluesky-social/indigo/xrpc\"\n")
+	pf("\t\"github.com/bluesky-social/indigo/lex/util\"\n")
 	for k, v := range imports {
 		if k != prefix {
-			fmt.Fprintf(buf, "\t%s %q\n", importNameForPrefix(k), v)
+			pf("\t%s %q\n", importNameForPrefix(k), v)
 		}
 	}
-	fmt.Fprintf(buf, ")\n\n")
-	fmt.Fprintf(buf, "// schema: %s\n\n", s.ID)
+	pf(")\n\n")
+	pf("// schema: %s\n\n", s.ID)
 
 	tps := s.AllTypes(prefix, defmap)
 
···
 }
 
 func writeDecoderRegister(w io.Writer, tps []outputType) error {
-	fmt.Fprintln(w, "func init() {")
-	for _, t := range tps {
+	var buf bytes.Buffer
+	outf := printerf(&buf)
 
+	for _, t := range tps {
 		if t.Type.needsType && !strings.Contains(t.Name, "_") {
 			id := t.Type.id
 			if t.Type.defName != "" {
 				id = id + "#" + t.Type.defName
 			}
-			fmt.Fprintf(w, "util.RegisterType(%q, &%s{})\n", id, t.Name)
+			if buf.Len() == 0 {
+				outf("func init() {\n")
+			}
+			outf("util.RegisterType(%q, &%s{})\n", id, t.Name)
 		}
 	}
-	fmt.Fprintln(w, "}")
-
-	return nil
+	if buf.Len() == 0 {
+		return nil
+	}
+	outf("}")
+	_, err := w.Write(buf.Bytes())
+	return err
 }
 
 func writeCodeFile(b []byte, fname string) error {
-	formatted, err := format.Source(b)
+	fixed, err := imports.Process(fname, b, nil)
 	if err != nil {
-		fmt.Println(string(b))
-		return fmt.Errorf("failed to format generated file: %w", err)
-	}
-
-	fixed, err := fixImports(formatted)
-	if err != nil {
-		return err
+		return fmt.Errorf("failed to format output of %q with goimports: %w", fname, err)
 	}
 
 	if err := os.WriteFile(fname, fixed, 0664); err != nil {
···
 	return nil
 }
 
-func fixImports(b []byte) ([]byte, error) {
-	cmd := exec.Command("goimports")
-
-	cmd.Stdin = bytes.NewReader(b)
-	buf := new(bytes.Buffer)
-	cmd.Stdout = buf
-
-	if err := cmd.Run(); err != nil {
-		return nil, err
-	}
-
-	return buf.Bytes(), nil
-}
-
 func writeMethods(typename string, ts *TypeSchema, w io.Writer) error {
 	switch ts.Type {
 	case "token":
···
 }
 
 func (s *TypeSchema) WriteRPC(w io.Writer, typename string) error {
+	pf := printerf(w)
 	fname := typename
 
 	params := "ctx context.Context, c *xrpc.Client"
···
 		}
 	}
 
-	fmt.Fprintf(w, "func %s(%s) %s {\n", fname, params, out)
+	pf("func %s(%s) %s {\n", fname, params, out)
 
 	outvar := "nil"
 	errRet := "err"
···
 	if s.Output != nil {
 		switch s.Output.Encoding {
 		case EncodingCBOR, EncodingCAR, EncodingANY:
-			fmt.Fprintf(w, "buf := new(bytes.Buffer)\n")
+			pf("buf := new(bytes.Buffer)\n")
 			outvar = "buf"
 			errRet = "nil, err"
 			outRet = "buf.Bytes(), nil"
···
 			if s.Output.Schema.Type == "ref" {
 				outname = s.typeNameFromRef(s.Output.Schema.Ref)
 			}
-			fmt.Fprintf(w, "\tvar out %s\n", outname)
+			pf("\tvar out %s\n", outname)
 			outvar = "&out"
 			errRet = "nil, err"
 			outRet = "&out, nil"
···
 	queryparams := "nil"
 	if s.Parameters != nil {
 		queryparams = "params"
-		fmt.Fprintf(w, `
+		pf(`
 	params := map[string]interface{}{
 `)
 		if err := orderedMapIter[*TypeSchema](s.Parameters.Properties, func(name string, t *TypeSchema) error {
-			fmt.Fprintf(w, `"%s": %s,
+			pf(`"%s": %s,
 `, name, name)
 			return nil
 		}); err != nil {
 			return err
 		}
-		fmt.Fprintf(w, "}\n")
+		pf("}\n")
 	}
 
 	var reqtype string
···
 		return fmt.Errorf("can only generate RPC for Query or Procedure (got %s)", s.Type)
 	}
 
-	fmt.Fprintf(w, "\tif err := c.Do(ctx, %s, %q, \"%s\", %s, %s, %s); err != nil {\n", reqtype, inpenc, s.id, queryparams, inpvar, outvar)
-	fmt.Fprintf(w, "\t\treturn %s\n", errRet)
-	fmt.Fprintf(w, "\t}\n\n")
-	fmt.Fprintf(w, "\treturn %s\n", outRet)
-	fmt.Fprintf(w, "}\n\n")
+	pf("\tif err := c.Do(ctx, %s, %q, \"%s\", %s, %s, %s); err != nil {\n", reqtype, inpenc, s.id, queryparams, inpvar, outvar)
+	pf("\t\treturn %s\n", errRet)
+	pf("\t}\n\n")
+	pf("\treturn %s\n", outRet)
+	pf("}\n\n")
 
 	return nil
 }
···
 }
 
 func WriteServerHandlers(w io.Writer, schemas []*Schema, pkg string, impmap map[string]string) error {
-	fmt.Fprintf(w, "package %s\n\n", pkg)
-	fmt.Fprintf(w, "import (\n")
-	fmt.Fprintf(w, "\t\"context\"\n")
-	fmt.Fprintf(w, "\t\"fmt\"\n")
-	fmt.Fprintf(w, "\t\"encoding/json\"\n")
-	fmt.Fprintf(w, "\t\"github.com/bluesky-social/indigo/xrpc\"\n")
+	pf := printerf(w)
+	pf("package %s\n\n", pkg)
+	pf("import (\n")
+	pf("\t\"context\"\n")
+	pf("\t\"fmt\"\n")
+	pf("\t\"encoding/json\"\n")
+	pf("\t\"github.com/bluesky-social/indigo/xrpc\"\n")
 	for k, v := range impmap {
-		fmt.Fprintf(w, "\t%s\"%s\"\n", importNameForPrefix(k), v)
+		pf("\t%s\"%s\"\n", importNameForPrefix(k), v)
 	}
-	fmt.Fprintf(w, ")\n\n")
+	pf(")\n\n")
 
 	for _, s := range schemas {
 
···
 }
 
 func WriteXrpcServer(w io.Writer, schemas []*Schema, pkg string, impmap map[string]string) error {
-	fmt.Fprintf(w, "package %s\n\n", pkg)
-	fmt.Fprintf(w, "import (\n")
-	fmt.Fprintf(w, "\t\"context\"\n")
-	fmt.Fprintf(w, "\t\"fmt\"\n")
-	fmt.Fprintf(w, "\t\"encoding/json\"\n")
-	fmt.Fprintf(w, "\t\"github.com/bluesky-social/indigo/xrpc\"\n")
-	fmt.Fprintf(w, "\t\"github.com/labstack/echo/v4\"\n")
+	pf := printerf(w)
+	pf("package %s\n\n", pkg)
+	pf("import (\n")
+	pf("\t\"context\"\n")
+	pf("\t\"fmt\"\n")
+	pf("\t\"encoding/json\"\n")
+	pf("\t\"github.com/bluesky-social/indigo/xrpc\"\n")
+	pf("\t\"github.com/labstack/echo/v4\"\n")
 
 	var prefixes []string
 	orderedMapIter[string](impmap, func(k, v string) error {
 		prefixes = append(prefixes, k)
-		fmt.Fprintf(w, "\t%s\"%s\"\n", importNameForPrefix(k), v)
+		pf("\t%s\"%s\"\n", importNameForPrefix(k), v)
 		return nil
 	})
-	fmt.Fprintf(w, ")\n\n")
+	pf(")\n\n")
 
 	ssets := make(map[string][]*Schema)
 	for _, s := range schemas {
···
 	for _, p := range prefixes {
 		ss := ssets[p]
 
-		fmt.Fprintf(w, "func (s *Server) RegisterHandlers%s(e *echo.Echo) error {\n", idToTitle(p))
+		pf("func (s *Server) RegisterHandlers%s(e *echo.Echo) error {\n", idToTitle(p))
 		for _, s := range ss {
 
 			main, ok := s.Defs["main"]
···
 				continue
 			}
 
-			fmt.Fprintf(w, "e.%s(\"/xrpc/%s\", s.Handle%s)\n", verb, s.ID, idToTitle(s.ID))
+			pf("e.%s(\"/xrpc/%s\", s.Handle%s)\n", verb, s.ID, idToTitle(s.ID))
 		}
 
-		fmt.Fprintf(w, "return nil\n}\n\n")
+		pf("return nil\n}\n\n")
 
 		for _, s := range ss {
 
···
 }
 
 func (s *TypeSchema) WriteHandlerStub(w io.Writer, fname, shortname, impname string) error {
+	pf := printerf(w)
 	paramtypes := []string{"ctx context.Context"}
 	if s.Type == "query" {
 
···
 		}
 	}
 
-	fmt.Fprintf(w, "func (s *Server) handle%s(%s) %s {\n", fname, strings.Join(paramtypes, ","), returndef)
-	fmt.Fprintf(w, "panic(\"not yet implemented\")\n}\n\n")
+	pf("func (s *Server) handle%s(%s) %s {\n", fname, strings.Join(paramtypes, ","), returndef)
+	pf("panic(\"not yet implemented\")\n}\n\n")
 
 	return nil
 }
 
 func (s *TypeSchema) WriteRPCHandler(w io.Writer, fname, shortname, impname string) error {
+	pf := printerf(w)
 	tname := shortname
 
-	fmt.Fprintf(w, "func (s *Server) Handle%s(c echo.Context) error {\n", fname)
+	pf("func (s *Server) Handle%s(c echo.Context) error {\n", fname)
 
-	fmt.Fprintf(w, "ctx, span := otel.Tracer(\"server\").Start(c.Request().Context(), %q)\n", "Handle"+fname)
-	fmt.Fprintf(w, "defer span.End()\n")
+	pf("ctx, span := otel.Tracer(\"server\").Start(c.Request().Context(), %q)\n", "Handle"+fname)
+	pf("defer span.End()\n")
 
 	paramtypes := []string{"ctx context.Context"}
 	params := []string{"ctx"}
···
 				case "string":
 					params = append(params, k)
 					paramtypes = append(paramtypes, k+" string")
-					fmt.Fprintf(w, "%s := c.QueryParam(\"%s\")\n", k, k)
+					pf("%s := c.QueryParam(\"%s\")\n", k, k)
 				case "integer":
 					params = append(params, k)
 
 					if !required[k] {
 						paramtypes = append(paramtypes, k+" *int")
-						fmt.Fprintf(w, `
+						pf(`
 var %s *int
 if p := c.QueryParam("%s"); p != "" {
 	%s_val, err := strconv.Atoi(p)
···
 `, k, k, k, k, k)
 					} else if t.Default != nil {
 						paramtypes = append(paramtypes, k+" int")
-						fmt.Fprintf(w, `
+						pf(`
 var %s int
 if p := c.QueryParam("%s"); p != "" {
 var err error
···
 					} else {
 
 						paramtypes = append(paramtypes, k+" int")
-						fmt.Fprintf(w, `
+						pf(`
 %s, err := strconv.Atoi(c.QueryParam("%s"))
 if err != nil {
 	return err
···
 					params = append(params, k)
 					if !required[k] {
 						paramtypes = append(paramtypes, k+" *bool")
-						fmt.Fprintf(w, `
+						pf(`
 var %s *bool
 if p := c.QueryParam("%s"); p != "" {
 	%s_val, err := strconv.ParseBool(p)
···
 `, k, k, k, k, k)
 					} else if t.Default != nil {
 						paramtypes = append(paramtypes, k+" bool")
-						fmt.Fprintf(w, `
+						pf(`
 var %s bool
 if p := c.QueryParam("%s"); p != "" {
 var err error
···
 					} else {
 
 						paramtypes = append(paramtypes, k+" bool")
-						fmt.Fprintf(w, `
+						pf(`
 %s, err := strconv.ParseBool(c.QueryParam("%s"))
 if err != nil {
 	return err
···
 					}
 					paramtypes = append(paramtypes, k+" []string")
 					params = append(params, k)
-					fmt.Fprintf(w, `
+					pf(`
 %s := c.QueryParams()["%s"]
 `, k, k)
 
···
 			intname := impname + "." + tname + "_Input"
 			switch s.Input.Encoding {
 			case EncodingJSON:
-				fmt.Fprintf(w, `
+				pf(`
 var body %s
 if err := c.Bind(&body); err != nil {
 	return err
···
 				paramtypes = append(paramtypes, "body *"+intname)
 				params = append(params, "&body")
 			case EncodingCBOR:
-				fmt.Fprintf(w, "body := c.Request().Body\n")
+				pf("body := c.Request().Body\n")
 				paramtypes = append(paramtypes, "r io.Reader")
 				params = append(params, "body")
 			case EncodingANY:
-				fmt.Fprintf(w, "body := c.Request().Body\n")
-				fmt.Fprintf(w, "contentType := c.Request().Header.Get(\"Content-Type\")\n")
+				pf("body := c.Request().Body\n")
+				pf("contentType := c.Request().Header.Get(\"Content-Type\")\n")
 				paramtypes = append(paramtypes, "r io.Reader", "contentType string")
 				params = append(params, "body", "contentType")
 
···
 			if s.Output.Schema.Type == "ref" {
 				outname = s.typeNameFromRef(s.Output.Schema.Ref)
 			}
-			fmt.Fprintf(w, "var out *%s.%s\n", impname, outname)
+			pf("var out *%s.%s\n", impname, outname)
 			returndef = fmt.Sprintf("(*%s.%s, error)", impname, outname)
 		case EncodingCBOR, EncodingCAR, EncodingANY:
 			assign = "out, handleErr"
-			fmt.Fprintf(w, "var out io.Reader\n")
+			pf("var out io.Reader\n")
 			returndef = "(io.Reader, error)"
 		default:
 			return fmt.Errorf("unrecognized output encoding (RPC output handler): %q", s.Output.Encoding)
 		}
 	}
-	fmt.Fprintf(w, "var handleErr error\n")
-	fmt.Fprintf(w, "// func (s *Server) handle%s(%s) %s\n", fname, strings.Join(paramtypes, ","), returndef)
-	fmt.Fprintf(w, "%s = s.handle%s(%s)\n", assign, fname, strings.Join(params, ","))
-	fmt.Fprintf(w, "if handleErr != nil {\nreturn handleErr\n}\n")
+	pf("var handleErr error\n")
+	pf("// func (s *Server) handle%s(%s) %s\n", fname, strings.Join(paramtypes, ","), returndef)
+	pf("%s = s.handle%s(%s)\n", assign, fname, strings.Join(params, ","))
+	pf("if handleErr != nil {\nreturn handleErr\n}\n")
 
 	if s.Output != nil {
 		switch s.Output.Encoding {
 		case EncodingJSON:
-			fmt.Fprintf(w, "return c.JSON(200, out)\n}\n\n")
+			pf("return c.JSON(200, out)\n}\n\n")
 		case EncodingANY:
-			fmt.Fprintf(w, "return c.Stream(200, \"application/octet-stream\", out)\n}\n\n")
+			pf("return c.Stream(200, \"application/octet-stream\", out)\n}\n\n")
 		case EncodingCBOR:
-			fmt.Fprintf(w, "return c.Stream(200, \"application/octet-stream\", out)\n}\n\n")
+			pf("return c.Stream(200, \"application/octet-stream\", out)\n}\n\n")
 		case EncodingCAR:
-			fmt.Fprintf(w, "return c.Stream(200, \"application/vnd.ipld.car\", out)\n}\n\n")
+			pf("return c.Stream(200, \"application/vnd.ipld.car\", out)\n}\n\n")
 		default:
 			return fmt.Errorf("unrecognized output encoding (RPC output handler return): %q", s.Output.Encoding)
 		}
 	} else {
-		fmt.Fprintf(w, "return nil\n}\n\n")
+		pf("return nil\n}\n\n")
 	}
 
 	return nil
···
 }
 
 func (ts *TypeSchema) writeTypeDefinition(name string, w io.Writer) error {
+	pf := printerf(w)
 	switch ts.Type {
 	case "string":
 		// TODO: deal with max length
-		fmt.Fprintf(w, "type %s string\n", name)
+		pf("type %s string\n", name)
 	case "float":
-		fmt.Fprintf(w, "type %s float64\n", name)
+		pf("type %s float64\n", name)
 	case "integer":
-		fmt.Fprintf(w, "type %s int64\n", name)
+		pf("type %s int64\n", name)
 	case "boolean":
-		fmt.Fprintf(w, "type %s bool\n", name)
+		pf("type %s bool\n", name)
 	case "object":
 		if len(ts.Properties) == 0 {
-			fmt.Fprintf(w, "type %s interface{}\n", name)
+			pf("type %s interface{}\n", name)
 			return nil
 		}
 
 		if ts.needsType {
-			fmt.Fprintf(w, "// RECORDTYPE: %s\n", name)
+			pf("// RECORDTYPE: %s\n", name)
 		}
 
-		fmt.Fprintf(w, "type %s struct {\n", name)
+		pf("type %s struct {\n", name)
 
 		if ts.needsType {
 			var omit string
 			if ts.id == "com.atproto.repo.strongRef" { // TODO: hack
 				omit = ",omitempty"
 			}
-			fmt.Fprintf(w, "\tLexiconTypeID string `json:\"$type,const=%s%s\" cborgen:\"$type,const=%s%s\"`\n", ts.id, omit, ts.id, omit)
+			pf("\tLexiconTypeID string `json:\"$type,const=%s%s\" cborgen:\"$type,const=%s%s\"`\n", ts.id, omit, ts.id, omit)
 		} else {
-			//fmt.Fprintf(w, "\tLexiconTypeID string `json:\"$type,omitempty\" cborgen:\"$type,omitempty\"`\n")
+			//pf("\tLexiconTypeID string `json:\"$type,omitempty\" cborgen:\"$type,omitempty\"`\n")
 		}
 
 		required := make(map[string]bool)
···
 				jsonOmit = ",omitempty"
 			}
 
-			fmt.Fprintf(w, "\t%s %s%s `json:\"%s%s\" cborgen:\"%s%s\"`\n", goname, ptr, tname, k, jsonOmit, k, cborOmit)
+			pf("\t%s %s%s `json:\"%s%s\" cborgen:\"%s%s\"`\n", goname, ptr, tname, k, jsonOmit, k, cborOmit)
 			return nil
 		}); err != nil {
 			return err
 		}
 
-		fmt.Fprintf(w, "}\n\n")
+		pf("}\n\n")
 
 	case "array":
 		tname, err := ts.typeNameForField(name, "elem", *ts.Items)
···
 			return err
 		}
 
-		fmt.Fprintf(w, "type %s []%s\n", name, tname)
+		pf("type %s []%s\n", name, tname)
 
 	case "union":
 		if len(ts.Refs) > 0 {
-			fmt.Fprintf(w, "type %s struct {\n", name)
+			pf("type %s struct {\n", name)
 			for _, r := range ts.Refs {
 				tname := ts.typeNameFromRef(r)
-				fmt.Fprintf(w, "\t%s *%s\n", tname, tname)
+				pf("\t%s *%s\n", tname, tname)
 			}
-			fmt.Fprintf(w, "}\n\n")
+			pf("}\n\n")
 		}
 	default:
 		return fmt.Errorf("%s has unrecognized type type %s", name, ts.Type)
···
 }
 
 func (ts *TypeSchema) writeJsonMarshalerEnum(name string, w io.Writer) error {
-	fmt.Fprintf(w, "func (t *%s) MarshalJSON() ([]byte, error) {\n", name)
+	pf := printerf(w)
+	pf("func (t *%s) MarshalJSON() ([]byte, error) {\n", name)
 
 	for _, e := range ts.Refs {
 		tname := ts.typeNameFromRef(e)
···
 			e = ts.id + e
 		}
 
-		fmt.Fprintf(w, "\tif t.%s != nil {\n", tname)
-		fmt.Fprintf(w, "\tt.%s.LexiconTypeID = %q\n", tname, e)
-		fmt.Fprintf(w, "\t\treturn json.Marshal(t.%s)\n\t}\n", tname)
+		pf("\tif t.%s != nil {\n", tname)
+		pf("\tt.%s.LexiconTypeID = %q\n", tname, e)
+		pf("\t\treturn json.Marshal(t.%s)\n\t}\n", tname)
 	}
 
-	fmt.Fprintf(w, "\treturn nil, fmt.Errorf(\"cannot marshal empty enum\")\n}\n")
+	pf("\treturn nil, fmt.Errorf(\"cannot marshal empty enum\")\n}\n")
 	return nil
 }
 
 func (s *TypeSchema) writeJsonUnmarshalerObject(name string, w io.Writer) error {
 	// TODO: would be nice to add some validation...
 	return nil
-	//fmt.Fprintf(w, "func (t *%s) UnmarshalJSON(b []byte) (error) {\n", name)
+	//pf("func (t *%s) UnmarshalJSON(b []byte) (error) {\n", name)
 }
 
 func (ts *TypeSchema) getTypeConstValueForType(ref string) (any, error) {
···
 }
 
 func (ts *TypeSchema) writeJsonUnmarshalerEnum(name string, w io.Writer) error {
-	fmt.Fprintf(w, "func (t *%s) UnmarshalJSON(b []byte) (error) {\n", name)
-	fmt.Fprintf(w, "\ttyp, err := util.TypeExtract(b)\n")
-	fmt.Fprintf(w, "\tif err != nil {\n\t\treturn err\n\t}\n\n")
-	fmt.Fprintf(w, "\tswitch typ {\n")
+	pf := printerf(w)
+	pf("func (t *%s) UnmarshalJSON(b []byte) (error) {\n", name)
+	pf("\ttyp, err := util.TypeExtract(b)\n")
+	pf("\tif err != nil {\n\t\treturn err\n\t}\n\n")
+	pf("\tswitch typ {\n")
 	for _, e := range ts.Refs {
 		if strings.HasPrefix(e, "#") {
 			e = ts.id + e
···
 
 		goname := ts.typeNameFromRef(e)
 
-		fmt.Fprintf(w, "\t\tcase \"%s\":\n", e)
-		fmt.Fprintf(w, "\t\t\tt.%s = new(%s)\n", goname, goname)
-		fmt.Fprintf(w, "\t\t\treturn json.Unmarshal(b, t.%s)\n", goname)
+		pf("\t\tcase \"%s\":\n", e)
+		pf("\t\t\tt.%s = new(%s)\n", goname, goname)
+		pf("\t\t\treturn json.Unmarshal(b, t.%s)\n", goname)
 	}
 
 	if ts.Closed {
-		fmt.Fprintf(w, `
+		pf(`
 			default:
 				return fmt.Errorf("closed enums must have a matching value")
 		`)
 	} else {
-		fmt.Fprintf(w, `
+		pf(`
 			default:
 				return nil
 		`)
 
 	}
 
-	fmt.Fprintf(w, "\t}\n")
-	fmt.Fprintf(w, "}\n\n")
+	pf("\t}\n")
+	pf("}\n\n")
 
 	return nil
 }
 
 func (ts *TypeSchema) writeCborMarshalerEnum(name string, w io.Writer) error {
-	fmt.Fprintf(w, "func (t *%s) MarshalCBOR(w io.Writer) error {\n", name)
-	fmt.Fprintf(w, `
+	pf := printerf(w)
+	pf("func (t *%s) MarshalCBOR(w io.Writer) error {\n", name)
+	pf(`
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
 		return err
···
 
 	for _, e := range ts.Refs {
 		tname := ts.typeNameFromRef(e)
-		fmt.Fprintf(w, "\tif t.%s != nil {\n", tname)
-		fmt.Fprintf(w, "\t\treturn t.%s.MarshalCBOR(w)\n\t}\n", tname)
+		pf("\tif t.%s != nil {\n", tname)
+		pf("\t\treturn t.%s.MarshalCBOR(w)\n\t}\n", tname)
 	}
 
-	fmt.Fprintf(w, "\treturn fmt.Errorf(\"cannot cbor marshal empty enum\")\n}\n")
+	pf("\treturn fmt.Errorf(\"cannot cbor marshal empty enum\")\n}\n")
 	return nil
 }
 
 func (ts *TypeSchema) writeCborUnmarshalerEnum(name string, w io.Writer) error {
-	fmt.Fprintf(w, "func (t *%s) UnmarshalCBOR(r io.Reader) error {\n", name)
-	fmt.Fprintf(w, "\ttyp, b, err := util.CborTypeExtractReader(r)\n")
-	fmt.Fprintf(w, "\tif err != nil {\n\t\treturn err\n\t}\n\n")
-	fmt.Fprintf(w, "\tswitch typ {\n")
+	pf := printerf(w)
+	pf("func (t *%s) UnmarshalCBOR(r io.Reader) error {\n", name)
+	pf("\ttyp, b, err := util.CborTypeExtractReader(r)\n")
+	pf("\tif err != nil {\n\t\treturn err\n\t}\n\n")
+	pf("\tswitch typ {\n")
 	for _, e := range ts.Refs {
 		if strings.HasPrefix(e, "#") {
 			e = ts.id + e
···
 
 		goname := ts.typeNameFromRef(e)
 
-		fmt.Fprintf(w, "\t\tcase \"%s\":\n", e)
-		fmt.Fprintf(w, "\t\t\tt.%s = new(%s)\n", goname, goname)
-		fmt.Fprintf(w, "\t\t\treturn t.%s.UnmarshalCBOR(bytes.NewReader(b))\n", goname)
+		pf("\t\tcase \"%s\":\n", e)
+		pf("\t\t\tt.%s = new(%s)\n", goname, goname)
+		pf("\t\t\treturn t.%s.UnmarshalCBOR(bytes.NewReader(b))\n", goname)
 	}
 
 	if ts.Closed {
-		fmt.Fprintf(w, `
+		pf(`
 			default:
 				return fmt.Errorf("closed enums must have a matching value")
 		`)
 	} else {
-		fmt.Fprintf(w, `
+		pf(`
 			default:
 				return nil
 		`)
 
 	}
 
-	fmt.Fprintf(w, "\t}\n")
-	fmt.Fprintf(w, "}\n\n")
+	pf("\t}\n")
+	pf("}\n\n")
 
 	return nil
 }