feat(lexicon-doc): add pull command functionality

.changeset/four-bees-double.md

···
+---
+'@atcute/lex-cli': minor
+---
+
+add pull command functionality
+
+this is useful if you're consuming someone else's lexicons
+
+```js
+// lex.config.js
+import { defineLexiconConfig } from '@atcute/lex-cli';
+
+export default defineLexiconConfig({
+	files: ['lexicons/**/*.json'],
+	outdir: 'lib/lexicons/',
+	imports: ['@atcute/atproto'],
+
+	pull: {
+		outdir: 'lexicons/',
+		clean: true,
+		sources: [
+			{
+				type: 'git',
+				remote: 'https://github.com/bluesky-social/atproto.git',
+				pattern: ['lexicons/app/bsky/**/*.json', 'lexicons/chat/bsky/**/*.json'],
+			},
+		],
+	},
+});
+```
+
+then run
+
+```
+pnpm lex-cli pull -c lex.config.js
+```

.changeset/wet-rats-admire.md

···
+---
+'@atcute/frontpage': major
+---
+
+pull latest Frontpage lexicons
+
+normally this would've been a patch change, but this change alters Frontpage's types are exported to
+accomodate for the new `fyi.frontpage.*` namespace.
+
+another major change may occur if the old namespace is fully removed.

lexdocs/bluemoji/README.md

···
-https://github.com/aendra-rininsland/bluemoji/tree/802a236415645e765a40fb02b6dc1e04344058f5/schema/

lexdocs/bluesky/README.md

···
-https://github.com/bluesky-social/atproto/tree/39b5c08e0799468eba0c3bf50f4f5a8104c35f34/lexicons/

lexdocs/bluesky/app/bsky/actor/defs.json packages/definitions/bluesky/lexicons/app/bsky/actor/defs.json

···
 			"type": "object",
 			"required": ["did", "handle"],
 			"properties": {
-				"did": { "type": "string", "format": "did" },
-				"handle": { "type": "string", "format": "handle" },
+				"did": {
+					"type": "string",
+					"format": "did"
+				},
+				"handle": {
+					"type": "string",
+					"format": "handle"
+				},
 				"displayName": {
 					"type": "string",
 					"maxGraphemes": 64,
 					"maxLength": 640
 				},
-				"pronouns": { "type": "string" },
-				"avatar": { "type": "string", "format": "uri" },
+				"pronouns": {
+					"type": "string"
+				},
+				"avatar": {
+					"type": "string",
+					"format": "uri"
+				},
 				"associated": {
 					"type": "ref",
 					"ref": "#profileAssociated"
 				},
-				"viewer": { "type": "ref", "ref": "#viewerState" },
+				"viewer": {
+					"type": "ref",
+					"ref": "#viewerState"
+				},
 				"labels": {
 					"type": "array",
-					"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+					"items": {
+						"type": "ref",
+						"ref": "com.atproto.label.defs#label"
+					}
+				},
+				"createdAt": {
+					"type": "string",
+					"format": "datetime"
 				},
-				"createdAt": { "type": "string", "format": "datetime" },
 				"verification": {
 					"type": "ref",
 					"ref": "#verificationState"
···
 			"type": "object",
 			"required": ["did", "handle"],
 			"properties": {
-				"did": { "type": "string", "format": "did" },
-				"handle": { "type": "string", "format": "handle" },
+				"did": {
+					"type": "string",
+					"format": "did"
+				},
+				"handle": {
+					"type": "string",
+					"format": "handle"
+				},
 				"displayName": {
 					"type": "string",
 					"maxGraphemes": 64,
 					"maxLength": 640
 				},
-				"pronouns": { "type": "string" },
+				"pronouns": {
+					"type": "string"
+				},
 				"description": {
 					"type": "string",
 					"maxGraphemes": 256,
 					"maxLength": 2560
 				},
-				"avatar": { "type": "string", "format": "uri" },
+				"avatar": {
+					"type": "string",
+					"format": "uri"
+				},
 				"associated": {
 					"type": "ref",
 					"ref": "#profileAssociated"
 				},
-				"indexedAt": { "type": "string", "format": "datetime" },
-				"createdAt": { "type": "string", "format": "datetime" },
-				"viewer": { "type": "ref", "ref": "#viewerState" },
+				"indexedAt": {
+					"type": "string",
+					"format": "datetime"
+				},
+				"createdAt": {
+					"type": "string",
+					"format": "datetime"
+				},
+				"viewer": {
+					"type": "ref",
+					"ref": "#viewerState"
+				},
 				"labels": {
 					"type": "array",
-					"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+					"items": {
+						"type": "ref",
+						"ref": "com.atproto.label.defs#label"
+					}
 				},
 				"verification": {
 					"type": "ref",
···
 			"type": "object",
 			"required": ["did", "handle"],
 			"properties": {
-				"did": { "type": "string", "format": "did" },
-				"handle": { "type": "string", "format": "handle" },
+				"did": {
+					"type": "string",
+					"format": "did"
+				},
+				"handle": {
+					"type": "string",
+					"format": "handle"
+				},
 				"displayName": {
 					"type": "string",
 					"maxGraphemes": 64,
···
 					"maxGraphemes": 256,
 					"maxLength": 2560
 				},
-				"pronouns": { "type": "string" },
-				"website": { "type": "string", "format": "uri" },
-				"avatar": { "type": "string", "format": "uri" },
-				"banner": { "type": "string", "format": "uri" },
-				"followersCount": { "type": "integer" },
-				"followsCount": { "type": "integer" },
-				"postsCount": { "type": "integer" },
+				"pronouns": {
+					"type": "string"
+				},
+				"website": {
+					"type": "string",
+					"format": "uri"
+				},
+				"avatar": {
+					"type": "string",
+					"format": "uri"
+				},
+				"banner": {
+					"type": "string",
+					"format": "uri"
+				},
+				"followersCount": {
+					"type": "integer"
+				},
+				"followsCount": {
+					"type": "integer"
+				},
+				"postsCount": {
+					"type": "integer"
+				},
 				"associated": {
 					"type": "ref",
 					"ref": "#profileAssociated"
···
 					"type": "ref",
 					"ref": "app.bsky.graph.defs#starterPackViewBasic"
 				},
-				"indexedAt": { "type": "string", "format": "datetime" },
-				"createdAt": { "type": "string", "format": "datetime" },
-				"viewer": { "type": "ref", "ref": "#viewerState" },
+				"indexedAt": {
+					"type": "string",
+					"format": "datetime"
+				},
+				"createdAt": {
+					"type": "string",
+					"format": "datetime"
+				},
+				"viewer": {
+					"type": "ref",
+					"ref": "#viewerState"
+				},
 				"labels": {
 					"type": "array",
-					"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+					"items": {
+						"type": "ref",
+						"ref": "com.atproto.label.defs#label"
+					}
 				},
 				"pinnedPost": {
 					"type": "ref",
···
 		"profileAssociated": {
 			"type": "object",
 			"properties": {
-				"lists": { "type": "integer" },
-				"feedgens": { "type": "integer" },
-				"starterPacks": { "type": "integer" },
-				"labeler": { "type": "boolean" },
-				"chat": { "type": "ref", "ref": "#profileAssociatedChat" },
+				"lists": {
+					"type": "integer"
+				},
+				"feedgens": {
+					"type": "integer"
+				},
+				"starterPacks": {
+					"type": "integer"
+				},
+				"labeler": {
+					"type": "boolean"
+				},
+				"chat": {
+					"type": "ref",
+					"ref": "#profileAssociatedChat"
+				},
 				"activitySubscription": {
 					"type": "ref",
 					"ref": "#profileAssociatedActivitySubscription"
···
 			"type": "object",
 			"description": "Metadata about the requesting account's relationship with the subject account. Only has meaningful content for authed requests.",
 			"properties": {
-				"muted": { "type": "boolean" },
+				"muted": {
+					"type": "boolean"
+				},
 				"mutedByList": {
 					"type": "ref",
 					"ref": "app.bsky.graph.defs#listViewBasic"
 				},
-				"blockedBy": { "type": "boolean" },
-				"blocking": { "type": "string", "format": "at-uri" },
+				"blockedBy": {
+					"type": "boolean"
+				},
+				"blocking": {
+					"type": "string",
+					"format": "at-uri"
+				},
 				"blockingByList": {
 					"type": "ref",
 					"ref": "app.bsky.graph.defs#listViewBasic"
 				},
-				"following": { "type": "string", "format": "at-uri" },
-				"followedBy": { "type": "string", "format": "at-uri" },
+				"following": {
+					"type": "string",
+					"format": "at-uri"
+				},
+				"followedBy": {
+					"type": "string",
+					"format": "at-uri"
+				},
 				"knownFollowers": {
 					"description": "This property is present only in selected cases, as an optimization.",
 					"type": "ref",
···
 			"description": "The subject's followers whom you also follow",
 			"required": ["count", "followers"],
 			"properties": {
-				"count": { "type": "integer" },
+				"count": {
+					"type": "integer"
+				},
 				"followers": {
 					"type": "array",
 					"minLength": 0,
···
 				"verifications": {
 					"type": "array",
 					"description": "All verifications issued by trusted verifiers on behalf of this user. Verifications by untrusted verifiers are not included.",
-					"items": { "type": "ref", "ref": "#verificationView" }
+					"items": {
+						"type": "ref",
+						"ref": "#verificationView"
+					}
 				},
 				"verifiedStatus": {
 					"type": "string",
···
 			"type": "object",
 			"required": ["enabled"],
 			"properties": {
-				"enabled": { "type": "boolean", "default": false }
+				"enabled": {
+					"type": "boolean",
+					"default": false
+				}
 			}
 		},
 		"contentLabelPref": {
···
 					"description": "Which labeler does this preference apply to? If undefined, applies globally.",
 					"format": "did"
 				},
-				"label": { "type": "string" },
+				"label": {
+					"type": "string"
+				},
 				"visibility": {
 					"type": "string",
 					"knownValues": ["ignore", "show", "warn", "hide"]
···
 				"tags": {
 					"type": "array",
 					"maxLength": 100,
-					"items": { "type": "string", "maxLength": 640, "maxGraphemes": 64 },
+					"items": {
+						"type": "string",
+						"maxLength": 640,
+						"maxGraphemes": 64
+					},
 					"description": "A list of tags which describe the account owner's interests gathered during onboarding."
 				}
 			}
···
 			"description": "A word that the account owner has muted.",
 			"required": ["value", "targets"],
 			"properties": {
-				"id": { "type": "string" },
+				"id": {
+					"type": "string"
+				},
 				"value": {
 					"type": "string",
 					"description": "The muted word itself.",
···
 			"properties": {
 				"items": {
 					"type": "array",
-					"items": { "type": "string", "format": "at-uri" },
+					"items": {
+						"type": "string",
+						"format": "at-uri"
+					},
 					"description": "A list of URIs of posts the account owner has hidden."
 				}
 			}
···
 					"description": "An array of tokens which identify nudges (modals, popups, tours, highlight dots) that should be shown to the user.",
 					"type": "array",
 					"maxLength": 1000,
-					"items": { "type": "string", "maxLength": 100 }
+					"items": {
+						"type": "string",
+						"maxLength": 100
+					}
 				},
 				"nuxs": {
 					"description": "Storage for NUXs the user has encountered.",
···
 			"type": "object",
 			"required": ["guide"],
 			"properties": {
-				"guide": { "type": "string", "maxLength": 100 }
+				"guide": {
+					"type": "string",
+					"maxLength": 100
+				}
 			}
 		},
 		"nux": {
···
 					"description": "The status for the account.",
 					"knownValues": ["app.bsky.actor.status#live"]
 				},
-				"record": { "type": "unknown" },
+				"record": {
+					"type": "unknown"
+				},
 				"embed": {
 					"type": "union",
 					"description": "An optional embed associated with the status.",

lexdocs/bluesky/app/bsky/actor/getProfiles.json packages/definitions/bluesky/lexicons/app/bsky/actor/getProfiles.json

···
 				"properties": {
 					"actors": {
 						"type": "array",
-						"items": { "type": "string", "format": "at-identifier" },
+						"items": {
+							"type": "string",
+							"format": "at-identifier"
+						},
 						"maxLength": 25
 					}
 				}

lexdocs/bluesky/app/bsky/actor/getSuggestions.json packages/definitions/bluesky/lexicons/app/bsky/actor/getSuggestions.json

···
 						"maximum": 100,
 						"default": 50
 					},
-					"cursor": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 					"type": "object",
 					"required": ["actors"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"actors": {
 							"type": "array",
 							"items": {

lexdocs/bluesky/app/bsky/actor/profile.json packages/definitions/bluesky/lexicons/app/bsky/actor/profile.json

···
 						"maxGraphemes": 20,
 						"maxLength": 200
 					},
-					"website": { "type": "string", "format": "uri" },
+					"website": {
+						"type": "string",
+						"format": "uri"
+					},
 					"avatar": {
 						"type": "blob",
 						"description": "Small image to be displayed next to posts from account. AKA, 'profile picture'",
···
 						"type": "ref",
 						"ref": "com.atproto.repo.strongRef"
 					},
-					"createdAt": { "type": "string", "format": "datetime" }
+					"createdAt": {
+						"type": "string",
+						"format": "datetime"
+					}
 				}
 			}
 		}

lexdocs/bluesky/app/bsky/actor/searchActors.json packages/definitions/bluesky/lexicons/app/bsky/actor/searchActors.json

···
 						"maximum": 100,
 						"default": 25
 					},
-					"cursor": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 					"type": "object",
 					"required": ["actors"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"actors": {
 							"type": "array",
 							"items": {

lexdocs/bluesky/app/bsky/actor/status.json packages/definitions/bluesky/lexicons/app/bsky/actor/status.json

···
 						"description": "The duration of the status in minutes. Applications can choose to impose minimum and maximum limits.",
 						"minimum": 1
 					},
-					"createdAt": { "type": "string", "format": "datetime" }
+					"createdAt": {
+						"type": "string",
+						"format": "datetime"
+					}
 				}
 			}
 		},

lexdocs/bluesky/app/bsky/bookmark/createBookmark.json packages/definitions/bluesky/lexicons/app/bsky/bookmark/createBookmark.json

···
 					"type": "object",
 					"required": ["uri", "cid"],
 					"properties": {
-						"uri": { "type": "string", "format": "at-uri" },
-						"cid": { "type": "string", "format": "cid" }
+						"uri": {
+							"type": "string",
+							"format": "at-uri"
+						},
+						"cid": {
+							"type": "string",
+							"format": "cid"
+						}
 					}
 				}
 			},

lexdocs/bluesky/app/bsky/bookmark/defs.json packages/definitions/bluesky/lexicons/app/bsky/bookmark/defs.json

···
 					"type": "ref",
 					"ref": "com.atproto.repo.strongRef"
 				},
-				"createdAt": { "type": "string", "format": "datetime" },
+				"createdAt": {
+					"type": "string",
+					"format": "datetime"
+				},
 				"item": {
 					"type": "union",
 					"refs": [

lexdocs/bluesky/app/bsky/bookmark/deleteBookmark.json packages/definitions/bluesky/lexicons/app/bsky/bookmark/deleteBookmark.json

···
 					"type": "object",
 					"required": ["uri"],
 					"properties": {
-						"uri": { "type": "string", "format": "at-uri" }
+						"uri": {
+							"type": "string",
+							"format": "at-uri"
+						}
 					}
 				}
 			},

lexdocs/bluesky/app/bsky/bookmark/getBookmarks.json packages/definitions/bluesky/lexicons/app/bsky/bookmark/getBookmarks.json

···
 						"maximum": 100,
 						"default": 50
 					},
-					"cursor": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 					"type": "object",
 					"required": ["bookmarks"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"bookmarks": {
 							"type": "array",
 							"items": {

lexdocs/bluesky/app/bsky/embed/defs.json packages/definitions/bluesky/lexicons/app/bsky/embed/defs.json

···
 			"description": "width:height represents an aspect ratio. It may be approximate, and may not correspond to absolute dimensions in any given unit.",
 			"required": ["width", "height"],
 			"properties": {
-				"width": { "type": "integer", "minimum": 1 },
-				"height": { "type": "integer", "minimum": 1 }
+				"width": {
+					"type": "integer",
+					"minimum": 1
+				},
+				"height": {
+					"type": "integer",
+					"minimum": 1
+				}
 			}
 		}
 	}

lexdocs/bluesky/app/bsky/embed/external.json packages/definitions/bluesky/lexicons/app/bsky/embed/external.json

···
 			"type": "object",
 			"required": ["uri", "title", "description"],
 			"properties": {
-				"uri": { "type": "string", "format": "uri" },
-				"title": { "type": "string" },
-				"description": { "type": "string" },
+				"uri": {
+					"type": "string",
+					"format": "uri"
+				},
+				"title": {
+					"type": "string"
+				},
+				"description": {
+					"type": "string"
+				},
 				"thumb": {
 					"type": "blob",
 					"accept": ["image/*"],
···
 			"type": "object",
 			"required": ["uri", "title", "description"],
 			"properties": {
-				"uri": { "type": "string", "format": "uri" },
-				"title": { "type": "string" },
-				"description": { "type": "string" },
-				"thumb": { "type": "string", "format": "uri" }
+				"uri": {
+					"type": "string",
+					"format": "uri"
+				},
+				"title": {
+					"type": "string"
+				},
+				"description": {
+					"type": "string"
+				},
+				"thumb": {
+					"type": "string",
+					"format": "uri"
+				}
 			}
 		}
 	}

lexdocs/bluesky/app/bsky/embed/images.json packages/definitions/bluesky/lexicons/app/bsky/embed/images.json

···
 			"properties": {
 				"images": {
 					"type": "array",
-					"items": { "type": "ref", "ref": "#image" },
+					"items": {
+						"type": "ref",
+						"ref": "#image"
+					},
 					"maxLength": 4
 				}
 			}
···
 			"properties": {
 				"images": {
 					"type": "array",
-					"items": { "type": "ref", "ref": "#viewImage" },
+					"items": {
+						"type": "ref",
+						"ref": "#viewImage"
+					},
 					"maxLength": 4
 				}
 			}

lexdocs/bluesky/app/bsky/embed/record.json packages/definitions/bluesky/lexicons/app/bsky/embed/record.json

···
 			"type": "object",
 			"required": ["record"],
 			"properties": {
-				"record": { "type": "ref", "ref": "com.atproto.repo.strongRef" }
+				"record": {
+					"type": "ref",
+					"ref": "com.atproto.repo.strongRef"
+				}
 			}
 		},
 		"view": {
···
 			"type": "object",
 			"required": ["uri", "cid", "author", "value", "indexedAt"],
 			"properties": {
-				"uri": { "type": "string", "format": "at-uri" },
-				"cid": { "type": "string", "format": "cid" },
+				"uri": {
+					"type": "string",
+					"format": "at-uri"
+				},
+				"cid": {
+					"type": "string",
+					"format": "cid"
+				},
 				"author": {
 					"type": "ref",
 					"ref": "app.bsky.actor.defs#profileViewBasic"
···
 				},
 				"labels": {
 					"type": "array",
-					"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+					"items": {
+						"type": "ref",
+						"ref": "com.atproto.label.defs#label"
+					}
+				},
+				"replyCount": {
+					"type": "integer"
+				},
+				"repostCount": {
+					"type": "integer"
+				},
+				"likeCount": {
+					"type": "integer"
 				},
-				"replyCount": { "type": "integer" },
-				"repostCount": { "type": "integer" },
-				"likeCount": { "type": "integer" },
-				"quoteCount": { "type": "integer" },
+				"quoteCount": {
+					"type": "integer"
+				},
 				"embeds": {
 					"type": "array",
 					"items": {
···
 						]
 					}
 				},
-				"indexedAt": { "type": "string", "format": "datetime" }
+				"indexedAt": {
+					"type": "string",
+					"format": "datetime"
+				}
 			}
 		},
 		"viewNotFound": {
 			"type": "object",
 			"required": ["uri", "notFound"],
 			"properties": {
-				"uri": { "type": "string", "format": "at-uri" },
-				"notFound": { "type": "boolean", "const": true }
+				"uri": {
+					"type": "string",
+					"format": "at-uri"
+				},
+				"notFound": {
+					"type": "boolean",
+					"const": true
+				}
 			}
 		},
 		"viewBlocked": {
 			"type": "object",
 			"required": ["uri", "blocked", "author"],
 			"properties": {
-				"uri": { "type": "string", "format": "at-uri" },
-				"blocked": { "type": "boolean", "const": true },
-				"author": { "type": "ref", "ref": "app.bsky.feed.defs#blockedAuthor" }
+				"uri": {
+					"type": "string",
+					"format": "at-uri"
+				},
+				"blocked": {
+					"type": "boolean",
+					"const": true
+				},
+				"author": {
+					"type": "ref",
+					"ref": "app.bsky.feed.defs#blockedAuthor"
+				}
 			}
 		},
 		"viewDetached": {
 			"type": "object",
 			"required": ["uri", "detached"],
 			"properties": {
-				"uri": { "type": "string", "format": "at-uri" },
-				"detached": { "type": "boolean", "const": true }
+				"uri": {
+					"type": "string",
+					"format": "at-uri"
+				},
+				"detached": {
+					"type": "boolean",
+					"const": true
+				}
 			}
 		}
 	}

lexdocs/bluesky/app/bsky/embed/video.json packages/definitions/bluesky/lexicons/app/bsky/embed/video.json

···
 				},
 				"captions": {
 					"type": "array",
-					"items": { "type": "ref", "ref": "#caption" },
+					"items": {
+						"type": "ref",
+						"ref": "#caption"
+					},
 					"maxLength": 20
 				},
 				"alt": {
···
 			"type": "object",
 			"required": ["cid", "playlist"],
 			"properties": {
-				"cid": { "type": "string", "format": "cid" },
-				"playlist": { "type": "string", "format": "uri" },
-				"thumbnail": { "type": "string", "format": "uri" },
+				"cid": {
+					"type": "string",
+					"format": "cid"
+				},
+				"playlist": {
+					"type": "string",
+					"format": "uri"
+				},
+				"thumbnail": {
+					"type": "string",
+					"format": "uri"
+				},
 				"alt": {
 					"type": "string",
 					"maxGraphemes": 1000,

lexdocs/bluesky/app/bsky/feed/defs.json packages/definitions/bluesky/lexicons/app/bsky/feed/defs.json

···
 			"type": "object",
 			"required": ["uri", "cid", "author", "record", "indexedAt"],
 			"properties": {
-				"uri": { "type": "string", "format": "at-uri" },
-				"cid": { "type": "string", "format": "cid" },
+				"uri": {
+					"type": "string",
+					"format": "at-uri"
+				},
+				"cid": {
+					"type": "string",
+					"format": "cid"
+				},
 				"author": {
 					"type": "ref",
 					"ref": "app.bsky.actor.defs#profileViewBasic"
 				},
-				"record": { "type": "unknown" },
+				"record": {
+					"type": "unknown"
+				},
 				"embed": {
 					"type": "union",
 					"refs": [
···
 						"app.bsky.embed.recordWithMedia#view"
 					]
 				},
-				"bookmarkCount": { "type": "integer" },
-				"replyCount": { "type": "integer" },
-				"repostCount": { "type": "integer" },
-				"likeCount": { "type": "integer" },
-				"quoteCount": { "type": "integer" },
-				"indexedAt": { "type": "string", "format": "datetime" },
-				"viewer": { "type": "ref", "ref": "#viewerState" },
+				"bookmarkCount": {
+					"type": "integer"
+				},
+				"replyCount": {
+					"type": "integer"
+				},
+				"repostCount": {
+					"type": "integer"
+				},
+				"likeCount": {
+					"type": "integer"
+				},
+				"quoteCount": {
+					"type": "integer"
+				},
+				"indexedAt": {
+					"type": "string",
+					"format": "datetime"
+				},
+				"viewer": {
+					"type": "ref",
+					"ref": "#viewerState"
+				},
 				"labels": {
 					"type": "array",
-					"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+					"items": {
+						"type": "ref",
+						"ref": "com.atproto.label.defs#label"
+					}
+				},
+				"threadgate": {
+					"type": "ref",
+					"ref": "#threadgateView"
 				},
-				"threadgate": { "type": "ref", "ref": "#threadgateView" },
 				"debug": {
 					"type": "unknown",
 					"description": "Debug information for internal development"
···
 			"type": "object",
 			"description": "Metadata about the requesting account's relationship with the subject content. Only has meaningful content for authed requests.",
 			"properties": {
-				"repost": { "type": "string", "format": "at-uri" },
-				"like": { "type": "string", "format": "at-uri" },
-				"bookmarked": { "type": "boolean" },
-				"threadMuted": { "type": "boolean" },
-				"replyDisabled": { "type": "boolean" },
-				"embeddingDisabled": { "type": "boolean" },
-				"pinned": { "type": "boolean" }
+				"repost": {
+					"type": "string",
+					"format": "at-uri"
+				},
+				"like": {
+					"type": "string",
+					"format": "at-uri"
+				},
+				"bookmarked": {
+					"type": "boolean"
+				},
+				"threadMuted": {
+					"type": "boolean"
+				},
+				"replyDisabled": {
+					"type": "boolean"
+				},
+				"embeddingDisabled": {
+					"type": "boolean"
+				},
+				"pinned": {
+					"type": "boolean"
+				}
 			}
 		},
 		"threadContext": {
 			"type": "object",
 			"description": "Metadata about this post within the context of the thread it is in.",
 			"properties": {
-				"rootAuthorLike": { "type": "string", "format": "at-uri" }
+				"rootAuthorLike": {
+					"type": "string",
+					"format": "at-uri"
+				}
 			}
 		},
 		"feedViewPost": {
 			"type": "object",
 			"required": ["post"],
 			"properties": {
-				"post": { "type": "ref", "ref": "#postView" },
-				"reply": { "type": "ref", "ref": "#replyRef" },
-				"reason": { "type": "union", "refs": ["#reasonRepost", "#reasonPin"] },
+				"post": {
+					"type": "ref",
+					"ref": "#postView"
+				},
+				"reply": {
+					"type": "ref",
+					"ref": "#replyRef"
+				},
+				"reason": {
+					"type": "union",
+					"refs": ["#reasonRepost", "#reasonPin"]
+				},
 				"feedContext": {
 					"type": "string",
 					"description": "Context provided by feed generator that may be passed back alongside interactions.",
···
 			"type": "object",
 			"required": ["by", "indexedAt"],
 			"properties": {
-				"by": { "type": "ref", "ref": "app.bsky.actor.defs#profileViewBasic" },
-				"uri": { "type": "string", "format": "at-uri" },
-				"cid": { "type": "string", "format": "cid" },
-				"indexedAt": { "type": "string", "format": "datetime" }
+				"by": {
+					"type": "ref",
+					"ref": "app.bsky.actor.defs#profileViewBasic"
+				},
+				"uri": {
+					"type": "string",
+					"format": "at-uri"
+				},
+				"cid": {
+					"type": "string",
+					"format": "cid"
+				},
+				"indexedAt": {
+					"type": "string",
+					"format": "datetime"
+				}
 			}
 		},
 		"reasonPin": {
···
 			"type": "object",
 			"required": ["post"],
 			"properties": {
-				"post": { "type": "ref", "ref": "#postView" },
+				"post": {
+					"type": "ref",
+					"ref": "#postView"
+				},
 				"parent": {
 					"type": "union",
 					"refs": ["#threadViewPost", "#notFoundPost", "#blockedPost"]
···
 						"refs": ["#threadViewPost", "#notFoundPost", "#blockedPost"]
 					}
 				},
-				"threadContext": { "type": "ref", "ref": "#threadContext" }
+				"threadContext": {
+					"type": "ref",
+					"ref": "#threadContext"
+				}
 			}
 		},
 		"notFoundPost": {
 			"type": "object",
 			"required": ["uri", "notFound"],
 			"properties": {
-				"uri": { "type": "string", "format": "at-uri" },
-				"notFound": { "type": "boolean", "const": true }
+				"uri": {
+					"type": "string",
+					"format": "at-uri"
+				},
+				"notFound": {
+					"type": "boolean",
+					"const": true
+				}
 			}
 		},
 		"blockedPost": {
 			"type": "object",
 			"required": ["uri", "blocked", "author"],
 			"properties": {
-				"uri": { "type": "string", "format": "at-uri" },
-				"blocked": { "type": "boolean", "const": true },
-				"author": { "type": "ref", "ref": "#blockedAuthor" }
+				"uri": {
+					"type": "string",
+					"format": "at-uri"
+				},
+				"blocked": {
+					"type": "boolean",
+					"const": true
+				},
+				"author": {
+					"type": "ref",
+					"ref": "#blockedAuthor"
+				}
 			}
 		},
 		"blockedAuthor": {
 			"type": "object",
 			"required": ["did"],
 			"properties": {
-				"did": { "type": "string", "format": "did" },
-				"viewer": { "type": "ref", "ref": "app.bsky.actor.defs#viewerState" }
+				"did": {
+					"type": "string",
+					"format": "did"
+				},
+				"viewer": {
+					"type": "ref",
+					"ref": "app.bsky.actor.defs#viewerState"
+				}
 			}
 		},
 		"generatorView": {
 			"type": "object",
 			"required": ["uri", "cid", "did", "creator", "displayName", "indexedAt"],
 			"properties": {
-				"uri": { "type": "string", "format": "at-uri" },
-				"cid": { "type": "string", "format": "cid" },
-				"did": { "type": "string", "format": "did" },
-				"creator": { "type": "ref", "ref": "app.bsky.actor.defs#profileView" },
-				"displayName": { "type": "string" },
+				"uri": {
+					"type": "string",
+					"format": "at-uri"
+				},
+				"cid": {
+					"type": "string",
+					"format": "cid"
+				},
+				"did": {
+					"type": "string",
+					"format": "did"
+				},
+				"creator": {
+					"type": "ref",
+					"ref": "app.bsky.actor.defs#profileView"
+				},
+				"displayName": {
+					"type": "string"
+				},
 				"description": {
 					"type": "string",
 					"maxGraphemes": 300,
···
 				},
 				"descriptionFacets": {
 					"type": "array",
-					"items": { "type": "ref", "ref": "app.bsky.richtext.facet" }
+					"items": {
+						"type": "ref",
+						"ref": "app.bsky.richtext.facet"
+					}
+				},
+				"avatar": {
+					"type": "string",
+					"format": "uri"
+				},
+				"likeCount": {
+					"type": "integer",
+					"minimum": 0
+				},
+				"acceptsInteractions": {
+					"type": "boolean"
 				},
-				"avatar": { "type": "string", "format": "uri" },
-				"likeCount": { "type": "integer", "minimum": 0 },
-				"acceptsInteractions": { "type": "boolean" },
 				"labels": {
 					"type": "array",
-					"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+					"items": {
+						"type": "ref",
+						"ref": "com.atproto.label.defs#label"
+					}
+				},
+				"viewer": {
+					"type": "ref",
+					"ref": "#generatorViewerState"
 				},
-				"viewer": { "type": "ref", "ref": "#generatorViewerState" },
 				"contentMode": {
 					"type": "string",
 					"knownValues": ["app.bsky.feed.defs#contentModeUnspecified", "app.bsky.feed.defs#contentModeVideo"]
 				},
-				"indexedAt": { "type": "string", "format": "datetime" }
+				"indexedAt": {
+					"type": "string",
+					"format": "datetime"
+				}
 			}
 		},
 		"generatorViewerState": {
 			"type": "object",
 			"properties": {
-				"like": { "type": "string", "format": "at-uri" }
+				"like": {
+					"type": "string",
+					"format": "at-uri"
+				}
 			}
 		},
 		"skeletonFeedPost": {
 			"type": "object",
 			"required": ["post"],
 			"properties": {
-				"post": { "type": "string", "format": "at-uri" },
+				"post": {
+					"type": "string",
+					"format": "at-uri"
+				},
 				"reason": {
 					"type": "union",
 					"refs": ["#skeletonReasonRepost", "#skeletonReasonPin"]
···
 			"type": "object",
 			"required": ["repost"],
 			"properties": {
-				"repost": { "type": "string", "format": "at-uri" }
+				"repost": {
+					"type": "string",
+					"format": "at-uri"
+				}
 			}
 		},
 		"skeletonReasonPin": {
···
 		"threadgateView": {
 			"type": "object",
 			"properties": {
-				"uri": { "type": "string", "format": "at-uri" },
-				"cid": { "type": "string", "format": "cid" },
-				"record": { "type": "unknown" },
+				"uri": {
+					"type": "string",
+					"format": "at-uri"
+				},
+				"cid": {
+					"type": "string",
+					"format": "cid"
+				},
+				"record": {
+					"type": "unknown"
+				},
 				"lists": {
 					"type": "array",
-					"items": { "type": "ref", "ref": "app.bsky.graph.defs#listViewBasic" }
+					"items": {
+						"type": "ref",
+						"ref": "app.bsky.graph.defs#listViewBasic"
+					}
 				}
 			}
 		},
 		"interaction": {
 			"type": "object",
 			"properties": {
-				"item": { "type": "string", "format": "at-uri" },
+				"item": {
+					"type": "string",
+					"format": "at-uri"
+				},
 				"event": {
 					"type": "string",
 					"knownValues": [

lexdocs/bluesky/app/bsky/feed/describeFeedGenerator.json packages/definitions/bluesky/lexicons/app/bsky/feed/describeFeedGenerator.json

···
 					"type": "object",
 					"required": ["did", "feeds"],
 					"properties": {
-						"did": { "type": "string", "format": "did" },
+						"did": {
+							"type": "string",
+							"format": "did"
+						},
 						"feeds": {
 							"type": "array",
-							"items": { "type": "ref", "ref": "#feed" }
+							"items": {
+								"type": "ref",
+								"ref": "#feed"
+							}
 						},
-						"links": { "type": "ref", "ref": "#links" }
+						"links": {
+							"type": "ref",
+							"ref": "#links"
+						}
 					}
 				}
 			}
···
 			"type": "object",
 			"required": ["uri"],
 			"properties": {
-				"uri": { "type": "string", "format": "at-uri" }
+				"uri": {
+					"type": "string",
+					"format": "at-uri"
+				}
 			}
 		},
 		"links": {
 			"type": "object",
 			"properties": {
-				"privacyPolicy": { "type": "string" },
-				"termsOfService": { "type": "string" }
+				"privacyPolicy": {
+					"type": "string"
+				},
+				"termsOfService": {
+					"type": "string"
+				}
 			}
 		}
 	}

lexdocs/bluesky/app/bsky/feed/generator.json packages/definitions/bluesky/lexicons/app/bsky/feed/generator.json

···
 				"type": "object",
 				"required": ["did", "displayName", "createdAt"],
 				"properties": {
-					"did": { "type": "string", "format": "did" },
+					"did": {
+						"type": "string",
+						"format": "did"
+					},
 					"displayName": {
 						"type": "string",
 						"maxGraphemes": 24,
···
 					},
 					"descriptionFacets": {
 						"type": "array",
-						"items": { "type": "ref", "ref": "app.bsky.richtext.facet" }
+						"items": {
+							"type": "ref",
+							"ref": "app.bsky.richtext.facet"
+						}
 					},
 					"avatar": {
 						"type": "blob",
···
 							"app.bsky.feed.defs#contentModeVideo"
 						]
 					},
-					"createdAt": { "type": "string", "format": "datetime" }
+					"createdAt": {
+						"type": "string",
+						"format": "datetime"
+					}
 				}
 			}
 		}

lexdocs/bluesky/app/bsky/feed/getActorFeeds.json packages/definitions/bluesky/lexicons/app/bsky/feed/getActorFeeds.json

···
 				"type": "params",
 				"required": ["actor"],
 				"properties": {
-					"actor": { "type": "string", "format": "at-identifier" },
+					"actor": {
+						"type": "string",
+						"format": "at-identifier"
+					},
 					"limit": {
 						"type": "integer",
 						"minimum": 1,
 						"maximum": 100,
 						"default": 50
 					},
-					"cursor": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 					"type": "object",
 					"required": ["feeds"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"feeds": {
 							"type": "array",
 							"items": {

lexdocs/bluesky/app/bsky/feed/getActorLikes.json packages/definitions/bluesky/lexicons/app/bsky/feed/getActorLikes.json

···
 				"type": "params",
 				"required": ["actor"],
 				"properties": {
-					"actor": { "type": "string", "format": "at-identifier" },
+					"actor": {
+						"type": "string",
+						"format": "at-identifier"
+					},
 					"limit": {
 						"type": "integer",
 						"minimum": 1,
 						"maximum": 100,
 						"default": 50
 					},
-					"cursor": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 					"type": "object",
 					"required": ["feed"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"feed": {
 							"type": "array",
 							"items": {
···
 					}
 				}
 			},
-			"errors": [{ "name": "BlockedActor" }, { "name": "BlockedByActor" }]
+			"errors": [
+				{
+					"name": "BlockedActor"
+				},
+				{
+					"name": "BlockedByActor"
+				}
+			]
 		}
 	}
 }

lexdocs/bluesky/app/bsky/feed/getAuthorFeed.json packages/definitions/bluesky/lexicons/app/bsky/feed/getAuthorFeed.json

···
 				"type": "params",
 				"required": ["actor"],
 				"properties": {
-					"actor": { "type": "string", "format": "at-identifier" },
+					"actor": {
+						"type": "string",
+						"format": "at-identifier"
+					},
 					"limit": {
 						"type": "integer",
 						"minimum": 1,
 						"maximum": 100,
 						"default": 50
 					},
-					"cursor": { "type": "string" },
+					"cursor": {
+						"type": "string"
+					},
 					"filter": {
 						"type": "string",
 						"description": "Combinations of post/repost types to include in response.",
···
 					"type": "object",
 					"required": ["feed"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"feed": {
 							"type": "array",
 							"items": {
···
 					}
 				}
 			},
-			"errors": [{ "name": "BlockedActor" }, { "name": "BlockedByActor" }]
+			"errors": [
+				{
+					"name": "BlockedActor"
+				},
+				{
+					"name": "BlockedByActor"
+				}
+			]
 		}
 	}
 }

lexdocs/bluesky/app/bsky/feed/getFeed.json packages/definitions/bluesky/lexicons/app/bsky/feed/getFeed.json

···
 				"type": "params",
 				"required": ["feed"],
 				"properties": {
-					"feed": { "type": "string", "format": "at-uri" },
+					"feed": {
+						"type": "string",
+						"format": "at-uri"
+					},
 					"limit": {
 						"type": "integer",
 						"minimum": 1,
 						"maximum": 100,
 						"default": 50
 					},
-					"cursor": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 					"type": "object",
 					"required": ["feed"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"feed": {
 							"type": "array",
 							"items": {
···
 					}
 				}
 			},
-			"errors": [{ "name": "UnknownFeed" }]
+			"errors": [
+				{
+					"name": "UnknownFeed"
+				}
+			]
 		}
 	}
 }

lexdocs/bluesky/app/bsky/feed/getFeedGenerators.json packages/definitions/bluesky/lexicons/app/bsky/feed/getFeedGenerators.json

···
 				"properties": {
 					"feeds": {
 						"type": "array",
-						"items": { "type": "string", "format": "at-uri" }
+						"items": {
+							"type": "string",
+							"format": "at-uri"
+						}
 					}
 				}
 			},

lexdocs/bluesky/app/bsky/feed/getFeedSkeleton.json packages/definitions/bluesky/lexicons/app/bsky/feed/getFeedSkeleton.json

···
 						"maximum": 100,
 						"default": 50
 					},
-					"cursor": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 					"type": "object",
 					"required": ["feed"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"feed": {
 							"type": "array",
 							"items": {
···
 					}
 				}
 			},
-			"errors": [{ "name": "UnknownFeed" }]
+			"errors": [
+				{
+					"name": "UnknownFeed"
+				}
+			]
 		}
 	}
 }

lexdocs/bluesky/app/bsky/feed/getLikes.json packages/definitions/bluesky/lexicons/app/bsky/feed/getLikes.json

···
 						"maximum": 100,
 						"default": 50
 					},
-					"cursor": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 					"type": "object",
 					"required": ["uri", "likes"],
 					"properties": {
-						"uri": { "type": "string", "format": "at-uri" },
-						"cid": { "type": "string", "format": "cid" },
-						"cursor": { "type": "string" },
+						"uri": {
+							"type": "string",
+							"format": "at-uri"
+						},
+						"cid": {
+							"type": "string",
+							"format": "cid"
+						},
+						"cursor": {
+							"type": "string"
+						},
 						"likes": {
 							"type": "array",
-							"items": { "type": "ref", "ref": "#like" }
+							"items": {
+								"type": "ref",
+								"ref": "#like"
+							}
 						}
 					}
 				}
···
 			"type": "object",
 			"required": ["indexedAt", "createdAt", "actor"],
 			"properties": {
-				"indexedAt": { "type": "string", "format": "datetime" },
-				"createdAt": { "type": "string", "format": "datetime" },
-				"actor": { "type": "ref", "ref": "app.bsky.actor.defs#profileView" }
+				"indexedAt": {
+					"type": "string",
+					"format": "datetime"
+				},
+				"createdAt": {
+					"type": "string",
+					"format": "datetime"
+				},
+				"actor": {
+					"type": "ref",
+					"ref": "app.bsky.actor.defs#profileView"
+				}
 			}
 		}
 	}

lexdocs/bluesky/app/bsky/feed/getListFeed.json packages/definitions/bluesky/lexicons/app/bsky/feed/getListFeed.json

···
 						"maximum": 100,
 						"default": 50
 					},
-					"cursor": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 					"type": "object",
 					"required": ["feed"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"feed": {
 							"type": "array",
 							"items": {
···
 					}
 				}
 			},
-			"errors": [{ "name": "UnknownList" }]
+			"errors": [
+				{
+					"name": "UnknownList"
+				}
+			]
 		}
 	}
 }

lexdocs/bluesky/app/bsky/feed/getPostThread.json packages/definitions/bluesky/lexicons/app/bsky/feed/getPostThread.json

···
 					}
 				}
 			},
-			"errors": [{ "name": "NotFound" }]
+			"errors": [
+				{
+					"name": "NotFound"
+				}
+			]
 		}
 	}
 }

lexdocs/bluesky/app/bsky/feed/getPosts.json packages/definitions/bluesky/lexicons/app/bsky/feed/getPosts.json

···
 					"uris": {
 						"type": "array",
 						"description": "List of post AT-URIs to return hydrated views for.",
-						"items": { "type": "string", "format": "at-uri" },
+						"items": {
+							"type": "string",
+							"format": "at-uri"
+						},
 						"maxLength": 25
 					}
 				}
···
 					"properties": {
 						"posts": {
 							"type": "array",
-							"items": { "type": "ref", "ref": "app.bsky.feed.defs#postView" }
+							"items": {
+								"type": "ref",
+								"ref": "app.bsky.feed.defs#postView"
+							}
 						}
 					}
 				}

lexdocs/bluesky/app/bsky/feed/getQuotes.json packages/definitions/bluesky/lexicons/app/bsky/feed/getQuotes.json

···
 						"maximum": 100,
 						"default": 50
 					},
-					"cursor": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 					"type": "object",
 					"required": ["uri", "posts"],
 					"properties": {
-						"uri": { "type": "string", "format": "at-uri" },
-						"cid": { "type": "string", "format": "cid" },
-						"cursor": { "type": "string" },
+						"uri": {
+							"type": "string",
+							"format": "at-uri"
+						},
+						"cid": {
+							"type": "string",
+							"format": "cid"
+						},
+						"cursor": {
+							"type": "string"
+						},
 						"posts": {
 							"type": "array",
 							"items": {

lexdocs/bluesky/app/bsky/feed/getRepostedBy.json packages/definitions/bluesky/lexicons/app/bsky/feed/getRepostedBy.json

···
 						"maximum": 100,
 						"default": 50
 					},
-					"cursor": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 					"type": "object",
 					"required": ["uri", "repostedBy"],
 					"properties": {
-						"uri": { "type": "string", "format": "at-uri" },
-						"cid": { "type": "string", "format": "cid" },
-						"cursor": { "type": "string" },
+						"uri": {
+							"type": "string",
+							"format": "at-uri"
+						},
+						"cid": {
+							"type": "string",
+							"format": "cid"
+						},
+						"cursor": {
+							"type": "string"
+						},
 						"repostedBy": {
 							"type": "array",
 							"items": {

lexdocs/bluesky/app/bsky/feed/getSuggestedFeeds.json packages/definitions/bluesky/lexicons/app/bsky/feed/getSuggestedFeeds.json

···
 						"maximum": 100,
 						"default": 50
 					},
-					"cursor": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 					"type": "object",
 					"required": ["feeds"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"feeds": {
 							"type": "array",
 							"items": {

lexdocs/bluesky/app/bsky/feed/getTimeline.json packages/definitions/bluesky/lexicons/app/bsky/feed/getTimeline.json

···
 						"maximum": 100,
 						"default": 50
 					},
-					"cursor": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 					"type": "object",
 					"required": ["feed"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"feed": {
 							"type": "array",
 							"items": {

lexdocs/bluesky/app/bsky/feed/like.json

···
-{
-	"lexicon": 1,
-	"id": "app.bsky.feed.like",
-	"defs": {
-		"main": {
-			"type": "record",
-			"description": "Record declaring a 'like' of a piece of subject content.",
-			"key": "tid",
-			"record": {
-				"type": "object",
-				"required": ["subject", "createdAt"],
-				"properties": {
-					"subject": { "type": "ref", "ref": "com.atproto.repo.strongRef" },
-					"createdAt": { "type": "string", "format": "datetime" },
-					"via": { "type": "ref", "ref": "com.atproto.repo.strongRef" }
-				}
-			}
-		}
-	}
-}

lexdocs/bluesky/app/bsky/feed/post.json packages/definitions/bluesky/lexicons/app/bsky/feed/post.json

···
 					"entities": {
 						"type": "array",
 						"description": "DEPRECATED: replaced by app.bsky.richtext.facet.",
-						"items": { "type": "ref", "ref": "#entity" }
+						"items": {
+							"type": "ref",
+							"ref": "#entity"
+						}
 					},
 					"facets": {
 						"type": "array",
 						"description": "Annotations of text (mentions, URLs, hashtags, etc)",
-						"items": { "type": "ref", "ref": "app.bsky.richtext.facet" }
+						"items": {
+							"type": "ref",
+							"ref": "app.bsky.richtext.facet"
+						}
 					},
-					"reply": { "type": "ref", "ref": "#replyRef" },
+					"reply": {
+						"type": "ref",
+						"ref": "#replyRef"
+					},
 					"embed": {
 						"type": "union",
 						"refs": [
···
 						"type": "array",
 						"description": "Indicates human language of post primary text content.",
 						"maxLength": 3,
-						"items": { "type": "string", "format": "language" }
+						"items": {
+							"type": "string",
+							"format": "language"
+						}
 					},
 					"labels": {
 						"type": "union",
···
 						"type": "array",
 						"description": "Additional hashtags, in addition to any included in post text and facets.",
 						"maxLength": 8,
-						"items": { "type": "string", "maxLength": 640, "maxGraphemes": 64 }
+						"items": {
+							"type": "string",
+							"maxLength": 640,
+							"maxGraphemes": 64
+						}
 					},
 					"createdAt": {
 						"type": "string",
···
 			"type": "object",
 			"required": ["root", "parent"],
 			"properties": {
-				"root": { "type": "ref", "ref": "com.atproto.repo.strongRef" },
-				"parent": { "type": "ref", "ref": "com.atproto.repo.strongRef" }
+				"root": {
+					"type": "ref",
+					"ref": "com.atproto.repo.strongRef"
+				},
+				"parent": {
+					"type": "ref",
+					"ref": "com.atproto.repo.strongRef"
+				}
 			}
 		},
 		"entity": {
···
 			"description": "Deprecated: use facets instead.",
 			"required": ["index", "type", "value"],
 			"properties": {
-				"index": { "type": "ref", "ref": "#textSlice" },
+				"index": {
+					"type": "ref",
+					"ref": "#textSlice"
+				},
 				"type": {
 					"type": "string",
 					"description": "Expected values are 'mention' and 'link'."
 				},
-				"value": { "type": "string" }
+				"value": {
+					"type": "string"
+				}
 			}
 		},
 		"textSlice": {
···
 			"description": "Deprecated. Use app.bsky.richtext instead -- A text segment. Start is inclusive, end is exclusive. Indices are for utf16-encoded strings.",
 			"required": ["start", "end"],
 			"properties": {
-				"start": { "type": "integer", "minimum": 0 },
-				"end": { "type": "integer", "minimum": 0 }
+				"start": {
+					"type": "integer",
+					"minimum": 0
+				},
+				"end": {
+					"type": "integer",
+					"minimum": 0
+				}
 			}
 		}
 	}

lexdocs/bluesky/app/bsky/feed/postgate.json packages/definitions/bluesky/lexicons/app/bsky/feed/postgate.json

···
 				"type": "object",
 				"required": ["post", "createdAt"],
 				"properties": {
-					"createdAt": { "type": "string", "format": "datetime" },
+					"createdAt": {
+						"type": "string",
+						"format": "datetime"
+					},
 					"post": {
 						"type": "string",
 						"format": "at-uri",

lexdocs/bluesky/app/bsky/feed/repost.json

···
-{
-	"lexicon": 1,
-	"id": "app.bsky.feed.repost",
-	"defs": {
-		"main": {
-			"description": "Record representing a 'repost' of an existing Bluesky post.",
-			"type": "record",
-			"key": "tid",
-			"record": {
-				"type": "object",
-				"required": ["subject", "createdAt"],
-				"properties": {
-					"subject": { "type": "ref", "ref": "com.atproto.repo.strongRef" },
-					"createdAt": { "type": "string", "format": "datetime" },
-					"via": { "type": "ref", "ref": "com.atproto.repo.strongRef" }
-				}
-			}
-		}
-	}
-}

lexdocs/bluesky/app/bsky/feed/searchPosts.json packages/definitions/bluesky/lexicons/app/bsky/feed/searchPosts.json

···
 					"type": "object",
 					"required": ["posts"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"hitsTotal": {
 							"type": "integer",
 							"description": "Count of search hits. Optional, may be rounded/truncated, and may not be possible to paginate through all hits."
···
 					}
 				}
 			},
-			"errors": [{ "name": "BadQueryString" }]
+			"errors": [
+				{
+					"name": "BadQueryString"
+				}
+			]
 		}
 	}
 }

lexdocs/bluesky/app/bsky/feed/threadgate.json packages/definitions/bluesky/lexicons/app/bsky/feed/threadgate.json

···
 							"refs": ["#mentionRule", "#followerRule", "#followingRule", "#listRule"]
 						}
 					},
-					"createdAt": { "type": "string", "format": "datetime" },
+					"createdAt": {
+						"type": "string",
+						"format": "datetime"
+					},
 					"hiddenReplies": {
 						"type": "array",
 						"maxLength": 300,
···
 			"description": "Allow replies from actors on a list.",
 			"required": ["list"],
 			"properties": {
-				"list": { "type": "string", "format": "at-uri" }
+				"list": {
+					"type": "string",
+					"format": "at-uri"
+				}
 			}
 		}
 	}

lexdocs/bluesky/app/bsky/graph/block.json packages/definitions/bluesky/lexicons/app/bsky/graph/block.json

···
 						"format": "did",
 						"description": "DID of the account to be blocked."
 					},
-					"createdAt": { "type": "string", "format": "datetime" }
+					"createdAt": {
+						"type": "string",
+						"format": "datetime"
+					}
 				}
 			}
 		}

lexdocs/bluesky/app/bsky/graph/defs.json

···
-{
-	"lexicon": 1,
-	"id": "app.bsky.graph.defs",
-	"defs": {
-		"listViewBasic": {
-			"type": "object",
-			"required": ["uri", "cid", "name", "purpose"],
-			"properties": {
-				"uri": { "type": "string", "format": "at-uri" },
-				"cid": { "type": "string", "format": "cid" },
-				"name": { "type": "string", "maxLength": 64, "minLength": 1 },
-				"purpose": { "type": "ref", "ref": "#listPurpose" },
-				"avatar": { "type": "string", "format": "uri" },
-				"listItemCount": { "type": "integer", "minimum": 0 },
-				"labels": {
-					"type": "array",
-					"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
-				},
-				"viewer": { "type": "ref", "ref": "#listViewerState" },
-				"indexedAt": { "type": "string", "format": "datetime" }
-			}
-		},
-		"listView": {
-			"type": "object",
-			"required": ["uri", "cid", "creator", "name", "purpose", "indexedAt"],
-			"properties": {
-				"uri": { "type": "string", "format": "at-uri" },
-				"cid": { "type": "string", "format": "cid" },
-				"creator": { "type": "ref", "ref": "app.bsky.actor.defs#profileView" },
-				"name": { "type": "string", "maxLength": 64, "minLength": 1 },
-				"purpose": { "type": "ref", "ref": "#listPurpose" },
-				"description": {
-					"type": "string",
-					"maxGraphemes": 300,
-					"maxLength": 3000
-				},
-				"descriptionFacets": {
-					"type": "array",
-					"items": { "type": "ref", "ref": "app.bsky.richtext.facet" }
-				},
-				"avatar": { "type": "string", "format": "uri" },
-				"listItemCount": { "type": "integer", "minimum": 0 },
-				"labels": {
-					"type": "array",
-					"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
-				},
-				"viewer": { "type": "ref", "ref": "#listViewerState" },
-				"indexedAt": { "type": "string", "format": "datetime" }
-			}
-		},
-		"listItemView": {
-			"type": "object",
-			"required": ["uri", "subject"],
-			"properties": {
-				"uri": { "type": "string", "format": "at-uri" },
-				"subject": { "type": "ref", "ref": "app.bsky.actor.defs#profileView" }
-			}
-		},
-		"starterPackView": {
-			"type": "object",
-			"required": ["uri", "cid", "record", "creator", "indexedAt"],
-			"properties": {
-				"uri": { "type": "string", "format": "at-uri" },
-				"cid": { "type": "string", "format": "cid" },
-				"record": { "type": "unknown" },
-				"creator": {
-					"type": "ref",
-					"ref": "app.bsky.actor.defs#profileViewBasic"
-				},
-				"list": { "type": "ref", "ref": "#listViewBasic" },
-				"listItemsSample": {
-					"type": "array",
-					"maxLength": 12,
-					"items": { "type": "ref", "ref": "#listItemView" }
-				},
-				"feeds": {
-					"type": "array",
-					"maxLength": 3,
-					"items": { "type": "ref", "ref": "app.bsky.feed.defs#generatorView" }
-				},
-				"joinedWeekCount": { "type": "integer", "minimum": 0 },
-				"joinedAllTimeCount": { "type": "integer", "minimum": 0 },
-				"labels": {
-					"type": "array",
-					"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
-				},
-				"indexedAt": { "type": "string", "format": "datetime" }
-			}
-		},
-		"starterPackViewBasic": {
-			"type": "object",
-			"required": ["uri", "cid", "record", "creator", "indexedAt"],
-			"properties": {
-				"uri": { "type": "string", "format": "at-uri" },
-				"cid": { "type": "string", "format": "cid" },
-				"record": { "type": "unknown" },
-				"creator": {
-					"type": "ref",
-					"ref": "app.bsky.actor.defs#profileViewBasic"
-				},
-				"listItemCount": { "type": "integer", "minimum": 0 },
-				"joinedWeekCount": { "type": "integer", "minimum": 0 },
-				"joinedAllTimeCount": { "type": "integer", "minimum": 0 },
-				"labels": {
-					"type": "array",
-					"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
-				},
-				"indexedAt": { "type": "string", "format": "datetime" }
-			}
-		},
-		"listPurpose": {
-			"type": "string",
-			"knownValues": [
-				"app.bsky.graph.defs#modlist",
-				"app.bsky.graph.defs#curatelist",
-				"app.bsky.graph.defs#referencelist"
-			]
-		},
-		"modlist": {
-			"type": "token",
-			"description": "A list of actors to apply an aggregate moderation action (mute/block) on."
-		},
-		"curatelist": {
-			"type": "token",
-			"description": "A list of actors used for curation purposes such as list feeds or interaction gating."
-		},
-		"referencelist": {
-			"type": "token",
-			"description": "A list of actors used for only for reference purposes such as within a starter pack."
-		},
-		"listViewerState": {
-			"type": "object",
-			"properties": {
-				"muted": { "type": "boolean" },
-				"blocked": { "type": "string", "format": "at-uri" }
-			}
-		},
-		"notFoundActor": {
-			"type": "object",
-			"description": "indicates that a handle or DID could not be resolved",
-			"required": ["actor", "notFound"],
-			"properties": {
-				"actor": { "type": "string", "format": "at-identifier" },
-				"notFound": { "type": "boolean", "const": true }
-			}
-		},
-		"relationship": {
-			"type": "object",
-			"description": "lists the bi-directional graph relationships between one actor (not indicated in the object), and the target actors (the DID included in the object)",
-			"required": ["did"],
-			"properties": {
-				"did": { "type": "string", "format": "did" },
-				"following": {
-					"type": "string",
-					"format": "at-uri",
-					"description": "if the actor follows this DID, this is the AT-URI of the follow record"
-				},
-				"followedBy": {
-					"type": "string",
-					"format": "at-uri",
-					"description": "if the actor is followed by this DID, contains the AT-URI of the follow record"
-				}
-			}
-		}
-	}
-}

lexdocs/bluesky/app/bsky/graph/follow.json packages/definitions/bluesky/lexicons/app/bsky/graph/follow.json

···
 				"type": "object",
 				"required": ["subject", "createdAt"],
 				"properties": {
-					"subject": { "type": "string", "format": "did" },
-					"createdAt": { "type": "string", "format": "datetime" },
-					"via": { "type": "ref", "ref": "com.atproto.repo.strongRef" }
+					"subject": {
+						"type": "string",
+						"format": "did"
+					},
+					"createdAt": {
+						"type": "string",
+						"format": "datetime"
+					},
+					"via": {
+						"type": "ref",
+						"ref": "com.atproto.repo.strongRef"
+					}
 				}
 			}
 		}

lexdocs/bluesky/app/bsky/graph/getActorStarterPacks.json packages/definitions/bluesky/lexicons/app/bsky/graph/getActorStarterPacks.json

···
 				"type": "params",
 				"required": ["actor"],
 				"properties": {
-					"actor": { "type": "string", "format": "at-identifier" },
+					"actor": {
+						"type": "string",
+						"format": "at-identifier"
+					},
 					"limit": {
 						"type": "integer",
 						"minimum": 1,
 						"maximum": 100,
 						"default": 50
 					},
-					"cursor": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 					"type": "object",
 					"required": ["starterPacks"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"starterPacks": {
 							"type": "array",
 							"items": {

lexdocs/bluesky/app/bsky/graph/getBlocks.json packages/definitions/bluesky/lexicons/app/bsky/graph/getBlocks.json

···
 						"maximum": 100,
 						"default": 50
 					},
-					"cursor": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 					"type": "object",
 					"required": ["blocks"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"blocks": {
 							"type": "array",
 							"items": {

lexdocs/bluesky/app/bsky/graph/getFollowers.json packages/definitions/bluesky/lexicons/app/bsky/graph/getFollowers.json

···
 				"type": "params",
 				"required": ["actor"],
 				"properties": {
-					"actor": { "type": "string", "format": "at-identifier" },
+					"actor": {
+						"type": "string",
+						"format": "at-identifier"
+					},
 					"limit": {
 						"type": "integer",
 						"minimum": 1,
 						"maximum": 100,
 						"default": 50
 					},
-					"cursor": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 							"type": "ref",
 							"ref": "app.bsky.actor.defs#profileView"
 						},
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"followers": {
 							"type": "array",
 							"items": {

lexdocs/bluesky/app/bsky/graph/getFollows.json packages/definitions/bluesky/lexicons/app/bsky/graph/getFollows.json

···
 				"type": "params",
 				"required": ["actor"],
 				"properties": {
-					"actor": { "type": "string", "format": "at-identifier" },
+					"actor": {
+						"type": "string",
+						"format": "at-identifier"
+					},
 					"limit": {
 						"type": "integer",
 						"minimum": 1,
 						"maximum": 100,
 						"default": 50
 					},
-					"cursor": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 							"type": "ref",
 							"ref": "app.bsky.actor.defs#profileView"
 						},
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"follows": {
 							"type": "array",
 							"items": {

lexdocs/bluesky/app/bsky/graph/getKnownFollowers.json packages/definitions/bluesky/lexicons/app/bsky/graph/getKnownFollowers.json

···
 				"type": "params",
 				"required": ["actor"],
 				"properties": {
-					"actor": { "type": "string", "format": "at-identifier" },
+					"actor": {
+						"type": "string",
+						"format": "at-identifier"
+					},
 					"limit": {
 						"type": "integer",
 						"minimum": 1,
 						"maximum": 100,
 						"default": 50
 					},
-					"cursor": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 							"type": "ref",
 							"ref": "app.bsky.actor.defs#profileView"
 						},
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"followers": {
 							"type": "array",
 							"items": {

lexdocs/bluesky/app/bsky/graph/getList.json packages/definitions/bluesky/lexicons/app/bsky/graph/getList.json

···
 						"maximum": 100,
 						"default": 50
 					},
-					"cursor": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 					"type": "object",
 					"required": ["list", "items"],
 					"properties": {
-						"cursor": { "type": "string" },
-						"list": { "type": "ref", "ref": "app.bsky.graph.defs#listView" },
+						"cursor": {
+							"type": "string"
+						},
+						"list": {
+							"type": "ref",
+							"ref": "app.bsky.graph.defs#listView"
+						},
 						"items": {
 							"type": "array",
 							"items": {

lexdocs/bluesky/app/bsky/graph/getListBlocks.json packages/definitions/bluesky/lexicons/app/bsky/graph/getListBlocks.json

···
 						"maximum": 100,
 						"default": 50
 					},
-					"cursor": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 					"type": "object",
 					"required": ["lists"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"lists": {
 							"type": "array",
-							"items": { "type": "ref", "ref": "app.bsky.graph.defs#listView" }
+							"items": {
+								"type": "ref",
+								"ref": "app.bsky.graph.defs#listView"
+							}
 						}
 					}
 				}

lexdocs/bluesky/app/bsky/graph/getListMutes.json packages/definitions/bluesky/lexicons/app/bsky/graph/getListMutes.json

···
 						"maximum": 100,
 						"default": 50
 					},
-					"cursor": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 					"type": "object",
 					"required": ["lists"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"lists": {
 							"type": "array",
-							"items": { "type": "ref", "ref": "app.bsky.graph.defs#listView" }
+							"items": {
+								"type": "ref",
+								"ref": "app.bsky.graph.defs#listView"
+							}
 						}
 					}
 				}

lexdocs/bluesky/app/bsky/graph/getLists.json packages/definitions/bluesky/lexicons/app/bsky/graph/getLists.json

···
 						"maximum": 100,
 						"default": 50
 					},
-					"cursor": { "type": "string" },
+					"cursor": {
+						"type": "string"
+					},
 					"purposes": {
 						"type": "array",
 						"description": "Optional filter by list purpose. If not specified, all supported types are returned.",
···
 					"type": "object",
 					"required": ["lists"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"lists": {
 							"type": "array",
-							"items": { "type": "ref", "ref": "app.bsky.graph.defs#listView" }
+							"items": {
+								"type": "ref",
+								"ref": "app.bsky.graph.defs#listView"
+							}
 						}
 					}
 				}

lexdocs/bluesky/app/bsky/graph/getListsWithMembership.json packages/definitions/bluesky/lexicons/app/bsky/graph/getListsWithMembership.json

···
 						"maximum": 100,
 						"default": 50
 					},
-					"cursor": { "type": "string" },
+					"cursor": {
+						"type": "string"
+					},
 					"purposes": {
 						"type": "array",
 						"description": "Optional filter by list purpose. If not specified, all supported types are returned.",
···
 					"type": "object",
 					"required": ["listsWithMembership"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"listsWithMembership": {
 							"type": "array",
-							"items": { "type": "ref", "ref": "#listWithMembership" }
+							"items": {
+								"type": "ref",
+								"ref": "#listWithMembership"
+							}
 						}
 					}
 				}

lexdocs/bluesky/app/bsky/graph/getMutes.json packages/definitions/bluesky/lexicons/app/bsky/graph/getMutes.json

···
 						"maximum": 100,
 						"default": 50
 					},
-					"cursor": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 					"type": "object",
 					"required": ["mutes"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"mutes": {
 							"type": "array",
 							"items": {

lexdocs/bluesky/app/bsky/graph/getRelationships.json packages/definitions/bluesky/lexicons/app/bsky/graph/getRelationships.json

···
 					"type": "object",
 					"required": ["relationships"],
 					"properties": {
-						"actor": { "type": "string", "format": "did" },
+						"actor": {
+							"type": "string",
+							"format": "did"
+						},
 						"relationships": {
 							"type": "array",
 							"items": {

lexdocs/bluesky/app/bsky/graph/getStarterPacks.json packages/definitions/bluesky/lexicons/app/bsky/graph/getStarterPacks.json

···
 				"properties": {
 					"uris": {
 						"type": "array",
-						"items": { "type": "string", "format": "at-uri" },
+						"items": {
+							"type": "string",
+							"format": "at-uri"
+						},
 						"maxLength": 25
 					}
 				}

lexdocs/bluesky/app/bsky/graph/getStarterPacksWithMembership.json packages/definitions/bluesky/lexicons/app/bsky/graph/getStarterPacksWithMembership.json

···
 						"maximum": 100,
 						"default": 50
 					},
-					"cursor": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 					"type": "object",
 					"required": ["starterPacksWithMembership"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"starterPacksWithMembership": {
 							"type": "array",
-							"items": { "type": "ref", "ref": "#starterPackWithMembership" }
+							"items": {
+								"type": "ref",
+								"ref": "#starterPackWithMembership"
+							}
 						}
 					}
 				}

lexdocs/bluesky/app/bsky/graph/getSuggestedFollowsByActor.json packages/definitions/bluesky/lexicons/app/bsky/graph/getSuggestedFollowsByActor.json

···
 				"type": "params",
 				"required": ["actor"],
 				"properties": {
-					"actor": { "type": "string", "format": "at-identifier" }
+					"actor": {
+						"type": "string",
+						"format": "at-identifier"
+					}
 				}
 			},
 			"output": {

lexdocs/bluesky/app/bsky/graph/list.json packages/definitions/bluesky/lexicons/app/bsky/graph/list.json

···
 					},
 					"descriptionFacets": {
 						"type": "array",
-						"items": { "type": "ref", "ref": "app.bsky.richtext.facet" }
+						"items": {
+							"type": "ref",
+							"ref": "app.bsky.richtext.facet"
+						}
 					},
 					"avatar": {
 						"type": "blob",
···
 						"type": "union",
 						"refs": ["com.atproto.label.defs#selfLabels"]
 					},
-					"createdAt": { "type": "string", "format": "datetime" }
+					"createdAt": {
+						"type": "string",
+						"format": "datetime"
+					}
 				}
 			}
 		}

lexdocs/bluesky/app/bsky/graph/listblock.json packages/definitions/bluesky/lexicons/app/bsky/graph/listblock.json

···
 						"format": "at-uri",
 						"description": "Reference (AT-URI) to the mod list record."
 					},
-					"createdAt": { "type": "string", "format": "datetime" }
+					"createdAt": {
+						"type": "string",
+						"format": "datetime"
+					}
 				}
 			}
 		}

lexdocs/bluesky/app/bsky/graph/listitem.json packages/definitions/bluesky/lexicons/app/bsky/graph/listitem.json

···
 						"format": "at-uri",
 						"description": "Reference (AT-URI) to the list record (app.bsky.graph.list)."
 					},
-					"createdAt": { "type": "string", "format": "datetime" }
+					"createdAt": {
+						"type": "string",
+						"format": "datetime"
+					}
 				}
 			}
 		}

lexdocs/bluesky/app/bsky/graph/muteActor.json packages/definitions/bluesky/lexicons/app/bsky/graph/muteActor.json

···
 					"type": "object",
 					"required": ["actor"],
 					"properties": {
-						"actor": { "type": "string", "format": "at-identifier" }
+						"actor": {
+							"type": "string",
+							"format": "at-identifier"
+						}
 					}
 				}
 			}

lexdocs/bluesky/app/bsky/graph/muteActorList.json packages/definitions/bluesky/lexicons/app/bsky/graph/muteActorList.json

···
 					"type": "object",
 					"required": ["list"],
 					"properties": {
-						"list": { "type": "string", "format": "at-uri" }
+						"list": {
+							"type": "string",
+							"format": "at-uri"
+						}
 					}
 				}
 			}

lexdocs/bluesky/app/bsky/graph/muteThread.json packages/definitions/bluesky/lexicons/app/bsky/graph/muteThread.json

···
 					"type": "object",
 					"required": ["root"],
 					"properties": {
-						"root": { "type": "string", "format": "at-uri" }
+						"root": {
+							"type": "string",
+							"format": "at-uri"
+						}
 					}
 				}
 			}

lexdocs/bluesky/app/bsky/graph/starterpack.json packages/definitions/bluesky/lexicons/app/bsky/graph/starterpack.json

···
 					},
 					"descriptionFacets": {
 						"type": "array",
-						"items": { "type": "ref", "ref": "app.bsky.richtext.facet" }
+						"items": {
+							"type": "ref",
+							"ref": "app.bsky.richtext.facet"
+						}
 					},
 					"list": {
 						"type": "string",
···
 					"feeds": {
 						"type": "array",
 						"maxLength": 3,
-						"items": { "type": "ref", "ref": "#feedItem" }
+						"items": {
+							"type": "ref",
+							"ref": "#feedItem"
+						}
 					},
-					"createdAt": { "type": "string", "format": "datetime" }
+					"createdAt": {
+						"type": "string",
+						"format": "datetime"
+					}
 				}
 			}
 		},
···
 			"type": "object",
 			"required": ["uri"],
 			"properties": {
-				"uri": { "type": "string", "format": "at-uri" }
+				"uri": {
+					"type": "string",
+					"format": "at-uri"
+				}
 			}
 		}
 	}

lexdocs/bluesky/app/bsky/graph/unmuteActor.json packages/definitions/bluesky/lexicons/app/bsky/graph/unmuteActor.json

···
 					"type": "object",
 					"required": ["actor"],
 					"properties": {
-						"actor": { "type": "string", "format": "at-identifier" }
+						"actor": {
+							"type": "string",
+							"format": "at-identifier"
+						}
 					}
 				}
 			}

lexdocs/bluesky/app/bsky/graph/unmuteActorList.json packages/definitions/bluesky/lexicons/app/bsky/graph/unmuteActorList.json

···
 					"type": "object",
 					"required": ["list"],
 					"properties": {
-						"list": { "type": "string", "format": "at-uri" }
+						"list": {
+							"type": "string",
+							"format": "at-uri"
+						}
 					}
 				}
 			}

lexdocs/bluesky/app/bsky/graph/unmuteThread.json packages/definitions/bluesky/lexicons/app/bsky/graph/unmuteThread.json

···
 					"type": "object",
 					"required": ["root"],
 					"properties": {
-						"root": { "type": "string", "format": "at-uri" }
+						"root": {
+							"type": "string",
+							"format": "at-uri"
+						}
 					}
 				}
 			}

lexdocs/bluesky/app/bsky/labeler/defs.json packages/definitions/bluesky/lexicons/app/bsky/labeler/defs.json

···
 			"type": "object",
 			"required": ["uri", "cid", "creator", "indexedAt"],
 			"properties": {
-				"uri": { "type": "string", "format": "at-uri" },
-				"cid": { "type": "string", "format": "cid" },
-				"creator": { "type": "ref", "ref": "app.bsky.actor.defs#profileView" },
-				"likeCount": { "type": "integer", "minimum": 0 },
-				"viewer": { "type": "ref", "ref": "#labelerViewerState" },
-				"indexedAt": { "type": "string", "format": "datetime" },
+				"uri": {
+					"type": "string",
+					"format": "at-uri"
+				},
+				"cid": {
+					"type": "string",
+					"format": "cid"
+				},
+				"creator": {
+					"type": "ref",
+					"ref": "app.bsky.actor.defs#profileView"
+				},
+				"likeCount": {
+					"type": "integer",
+					"minimum": 0
+				},
+				"viewer": {
+					"type": "ref",
+					"ref": "#labelerViewerState"
+				},
+				"indexedAt": {
+					"type": "string",
+					"format": "datetime"
+				},
 				"labels": {
 					"type": "array",
-					"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+					"items": {
+						"type": "ref",
+						"ref": "com.atproto.label.defs#label"
+					}
 				}
 			}
 		},
···
 			"type": "object",
 			"required": ["uri", "cid", "creator", "policies", "indexedAt"],
 			"properties": {
-				"uri": { "type": "string", "format": "at-uri" },
-				"cid": { "type": "string", "format": "cid" },
-				"creator": { "type": "ref", "ref": "app.bsky.actor.defs#profileView" },
+				"uri": {
+					"type": "string",
+					"format": "at-uri"
+				},
+				"cid": {
+					"type": "string",
+					"format": "cid"
+				},
+				"creator": {
+					"type": "ref",
+					"ref": "app.bsky.actor.defs#profileView"
+				},
 				"policies": {
 					"type": "ref",
 					"ref": "app.bsky.labeler.defs#labelerPolicies"
 				},
-				"likeCount": { "type": "integer", "minimum": 0 },
-				"viewer": { "type": "ref", "ref": "#labelerViewerState" },
-				"indexedAt": { "type": "string", "format": "datetime" },
+				"likeCount": {
+					"type": "integer",
+					"minimum": 0
+				},
+				"viewer": {
+					"type": "ref",
+					"ref": "#labelerViewerState"
+				},
+				"indexedAt": {
+					"type": "string",
+					"format": "datetime"
+				},
 				"labels": {
 					"type": "array",
-					"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+					"items": {
+						"type": "ref",
+						"ref": "com.atproto.label.defs#label"
+					}
 				},
 				"reasonTypes": {
 					"description": "The set of report reason 'codes' which are in-scope for this service to review and action. These usually align to policy categories. If not defined (distinct from empty array), all reason types are allowed.",
···
 				"subjectCollections": {
 					"type": "array",
 					"description": "Set of record types (collection NSIDs) which can be reported to this service. If not defined (distinct from empty array), default is any record type.",
-					"items": { "type": "string", "format": "nsid" }
+					"items": {
+						"type": "string",
+						"format": "nsid"
+					}
 				}
 			}
 		},
 		"labelerViewerState": {
 			"type": "object",
 			"properties": {
-				"like": { "type": "string", "format": "at-uri" }
+				"like": {
+					"type": "string",
+					"format": "at-uri"
+				}
 			}
 		},
 		"labelerPolicies": {

lexdocs/bluesky/app/bsky/labeler/getServices.json packages/definitions/bluesky/lexicons/app/bsky/labeler/getServices.json

···
 				"properties": {
 					"dids": {
 						"type": "array",
-						"items": { "type": "string", "format": "did" }
+						"items": {
+							"type": "string",
+							"format": "did"
+						}
 					},
 					"detailed": {
 						"type": "boolean",

lexdocs/bluesky/app/bsky/labeler/service.json packages/definitions/bluesky/lexicons/app/bsky/labeler/service.json

···
 						"type": "union",
 						"refs": ["com.atproto.label.defs#selfLabels"]
 					},
-					"createdAt": { "type": "string", "format": "datetime" },
+					"createdAt": {
+						"type": "string",
+						"format": "datetime"
+					},
 					"reasonTypes": {
 						"description": "The set of report reason 'codes' which are in-scope for this service to review and action. These usually align to policy categories. If not defined (distinct from empty array), all reason types are allowed.",
 						"type": "array",
···
 					"subjectCollections": {
 						"type": "array",
 						"description": "Set of record types (collection NSIDs) which can be reported to this service. If not defined (distinct from empty array), default is any record type.",
-						"items": { "type": "string", "format": "nsid" }
+						"items": {
+							"type": "string",
+							"format": "nsid"
+						}
 					}
 				}
 			}

lexdocs/bluesky/app/bsky/notification/defs.json

···
-{
-	"lexicon": 1,
-	"id": "app.bsky.notification.defs",
-	"defs": {
-		"recordDeleted": {
-			"type": "object",
-			"properties": {}
-		},
-		"chatPreference": {
-			"type": "object",
-			"required": ["include", "push"],
-			"properties": {
-				"include": { "type": "string", "knownValues": ["all", "accepted"] },
-				"push": { "type": "boolean" }
-			}
-		},
-		"filterablePreference": {
-			"type": "object",
-			"required": ["include", "list", "push"],
-			"properties": {
-				"include": { "type": "string", "knownValues": ["all", "follows"] },
-				"list": { "type": "boolean" },
-				"push": { "type": "boolean" }
-			}
-		},
-		"preference": {
-			"type": "object",
-			"required": ["list", "push"],
-			"properties": {
-				"list": { "type": "boolean" },
-				"push": { "type": "boolean" }
-			}
-		},
-		"preferences": {
-			"type": "object",
-			"required": [
-				"chat",
-				"follow",
-				"like",
-				"likeViaRepost",
-				"mention",
-				"quote",
-				"reply",
-				"repost",
-				"repostViaRepost",
-				"starterpackJoined",
-				"subscribedPost",
-				"unverified",
-				"verified"
-			],
-			"properties": {
-				"chat": { "type": "ref", "ref": "#chatPreference" },
-				"follow": { "type": "ref", "ref": "#filterablePreference" },
-				"like": { "type": "ref", "ref": "#filterablePreference" },
-				"likeViaRepost": { "type": "ref", "ref": "#filterablePreference" },
-				"mention": { "type": "ref", "ref": "#filterablePreference" },
-				"quote": { "type": "ref", "ref": "#filterablePreference" },
-				"reply": { "type": "ref", "ref": "#filterablePreference" },
-				"repost": { "type": "ref", "ref": "#filterablePreference" },
-				"repostViaRepost": { "type": "ref", "ref": "#filterablePreference" },
-				"starterpackJoined": { "type": "ref", "ref": "#preference" },
-				"subscribedPost": { "type": "ref", "ref": "#preference" },
-				"unverified": { "type": "ref", "ref": "#preference" },
-				"verified": { "type": "ref", "ref": "#preference" }
-			}
-		},
-		"activitySubscription": {
-			"type": "object",
-			"required": ["post", "reply"],
-			"properties": {
-				"post": { "type": "boolean" },
-				"reply": { "type": "boolean" }
-			}
-		},
-		"subjectActivitySubscription": {
-			"description": "Object used to store activity subscription data in stash.",
-			"type": "object",
-			"required": ["subject", "activitySubscription"],
-			"properties": {
-				"subject": { "type": "string", "format": "did" },
-				"activitySubscription": {
-					"type": "ref",
-					"ref": "#activitySubscription"
-				}
-			}
-		}
-	}
-}

lexdocs/bluesky/app/bsky/notification/getUnreadCount.json packages/definitions/bluesky/lexicons/app/bsky/notification/getUnreadCount.json

···
 			"parameters": {
 				"type": "params",
 				"properties": {
-					"priority": { "type": "boolean" },
-					"seenAt": { "type": "string", "format": "datetime" }
+					"priority": {
+						"type": "boolean"
+					},
+					"seenAt": {
+						"type": "string",
+						"format": "datetime"
+					}
 				}
 			},
 			"output": {
···
 					"type": "object",
 					"required": ["count"],
 					"properties": {
-						"count": { "type": "integer" }
+						"count": {
+							"type": "integer"
+						}
 					}
 				}
 			}

lexdocs/bluesky/app/bsky/notification/listActivitySubscriptions.json packages/definitions/bluesky/lexicons/app/bsky/notification/listActivitySubscriptions.json

···
 						"maximum": 100,
 						"default": 50
 					},
-					"cursor": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 					"type": "object",
 					"required": ["subscriptions"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"subscriptions": {
 							"type": "array",
 							"items": {

lexdocs/bluesky/app/bsky/notification/listNotifications.json packages/definitions/bluesky/lexicons/app/bsky/notification/listNotifications.json

···
 						"maximum": 100,
 						"default": 50
 					},
-					"priority": { "type": "boolean" },
-					"cursor": { "type": "string" },
-					"seenAt": { "type": "string", "format": "datetime" }
+					"priority": {
+						"type": "boolean"
+					},
+					"cursor": {
+						"type": "string"
+					},
+					"seenAt": {
+						"type": "string",
+						"format": "datetime"
+					}
 				}
 			},
 			"output": {
···
 					"type": "object",
 					"required": ["notifications"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"notifications": {
 							"type": "array",
-							"items": { "type": "ref", "ref": "#notification" }
+							"items": {
+								"type": "ref",
+								"ref": "#notification"
+							}
+						},
+						"priority": {
+							"type": "boolean"
 						},
-						"priority": { "type": "boolean" },
-						"seenAt": { "type": "string", "format": "datetime" }
+						"seenAt": {
+							"type": "string",
+							"format": "datetime"
+						}
 					}
 				}
 			}
···
 			"type": "object",
 			"required": ["uri", "cid", "author", "reason", "record", "isRead", "indexedAt"],
 			"properties": {
-				"uri": { "type": "string", "format": "at-uri" },
-				"cid": { "type": "string", "format": "cid" },
-				"author": { "type": "ref", "ref": "app.bsky.actor.defs#profileView" },
+				"uri": {
+					"type": "string",
+					"format": "at-uri"
+				},
+				"cid": {
+					"type": "string",
+					"format": "cid"
+				},
+				"author": {
+					"type": "ref",
+					"ref": "app.bsky.actor.defs#profileView"
+				},
 				"reason": {
 					"type": "string",
 					"description": "The reason why this notification was delivered - e.g. your post was liked, or you received a new follower.",
···
 						"subscribed-post"
 					]
 				},
-				"reasonSubject": { "type": "string", "format": "at-uri" },
-				"record": { "type": "unknown" },
-				"isRead": { "type": "boolean" },
-				"indexedAt": { "type": "string", "format": "datetime" },
+				"reasonSubject": {
+					"type": "string",
+					"format": "at-uri"
+				},
+				"record": {
+					"type": "unknown"
+				},
+				"isRead": {
+					"type": "boolean"
+				},
+				"indexedAt": {
+					"type": "string",
+					"format": "datetime"
+				},
 				"labels": {
 					"type": "array",
-					"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+					"items": {
+						"type": "ref",
+						"ref": "com.atproto.label.defs#label"
+					}
 				}
 			}
 		}

lexdocs/bluesky/app/bsky/notification/putActivitySubscription.json packages/definitions/bluesky/lexicons/app/bsky/notification/putActivitySubscription.json

···
 					"type": "object",
 					"required": ["subject", "activitySubscription"],
 					"properties": {
-						"subject": { "type": "string", "format": "did" },
+						"subject": {
+							"type": "string",
+							"format": "did"
+						},
 						"activitySubscription": {
 							"type": "ref",
 							"ref": "app.bsky.notification.defs#activitySubscription"
···
 					"type": "object",
 					"required": ["subject"],
 					"properties": {
-						"subject": { "type": "string", "format": "did" },
+						"subject": {
+							"type": "string",
+							"format": "did"
+						},
 						"activitySubscription": {
 							"type": "ref",
 							"ref": "app.bsky.notification.defs#activitySubscription"

lexdocs/bluesky/app/bsky/notification/putPreferences.json packages/definitions/bluesky/lexicons/app/bsky/notification/putPreferences.json

···
 					"type": "object",
 					"required": ["priority"],
 					"properties": {
-						"priority": { "type": "boolean" }
+						"priority": {
+							"type": "boolean"
+						}
 					}
 				}
 			}

lexdocs/bluesky/app/bsky/notification/registerPush.json packages/definitions/bluesky/lexicons/app/bsky/notification/registerPush.json

···
 					"type": "object",
 					"required": ["serviceDid", "token", "platform", "appId"],
 					"properties": {
-						"serviceDid": { "type": "string", "format": "did" },
-						"token": { "type": "string" },
+						"serviceDid": {
+							"type": "string",
+							"format": "did"
+						},
+						"token": {
+							"type": "string"
+						},
 						"platform": {
 							"type": "string",
 							"knownValues": ["ios", "android", "web"]
 						},
-						"appId": { "type": "string" },
+						"appId": {
+							"type": "string"
+						},
 						"ageRestricted": {
 							"type": "boolean",
 							"description": "Set to true when the actor is age restricted"

lexdocs/bluesky/app/bsky/notification/unregisterPush.json packages/definitions/bluesky/lexicons/app/bsky/notification/unregisterPush.json

···
 					"type": "object",
 					"required": ["serviceDid", "token", "platform", "appId"],
 					"properties": {
-						"serviceDid": { "type": "string", "format": "did" },
-						"token": { "type": "string" },
+						"serviceDid": {
+							"type": "string",
+							"format": "did"
+						},
+						"token": {
+							"type": "string"
+						},
 						"platform": {
 							"type": "string",
 							"knownValues": ["ios", "android", "web"]
 						},
-						"appId": { "type": "string" }
+						"appId": {
+							"type": "string"
+						}
 					}
 				}
 			}

lexdocs/bluesky/app/bsky/notification/updateSeen.json packages/definitions/bluesky/lexicons/app/bsky/notification/updateSeen.json

···
 					"type": "object",
 					"required": ["seenAt"],
 					"properties": {
-						"seenAt": { "type": "string", "format": "datetime" }
+						"seenAt": {
+							"type": "string",
+							"format": "datetime"
+						}
 					}
 				}
 			}

lexdocs/bluesky/app/bsky/richtext/facet.json packages/definitions/bluesky/lexicons/app/bsky/richtext/facet.json

···
 			"description": "Annotation of a sub-string within rich text.",
 			"required": ["index", "features"],
 			"properties": {
-				"index": { "type": "ref", "ref": "#byteSlice" },
+				"index": {
+					"type": "ref",
+					"ref": "#byteSlice"
+				},
 				"features": {
 					"type": "array",
-					"items": { "type": "union", "refs": ["#mention", "#link", "#tag"] }
+					"items": {
+						"type": "union",
+						"refs": ["#mention", "#link", "#tag"]
+					}
 				}
 			}
 		},
···
 			"description": "Facet feature for mention of another account. The text is usually a handle, including a '@' prefix, but the facet reference is a DID.",
 			"required": ["did"],
 			"properties": {
-				"did": { "type": "string", "format": "did" }
+				"did": {
+					"type": "string",
+					"format": "did"
+				}
 			}
 		},
 		"link": {
···
 			"description": "Facet feature for a URL. The text URL may have been simplified or truncated, but the facet reference should be a complete URL.",
 			"required": ["uri"],
 			"properties": {
-				"uri": { "type": "string", "format": "uri" }
+				"uri": {
+					"type": "string",
+					"format": "uri"
+				}
 			}
 		},
 		"tag": {
···
 			"description": "Facet feature for a hashtag. The text usually includes a '#' prefix, but the facet reference should not (except in the case of 'double hash tags').",
 			"required": ["tag"],
 			"properties": {
-				"tag": { "type": "string", "maxLength": 640, "maxGraphemes": 64 }
+				"tag": {
+					"type": "string",
+					"maxLength": 640,
+					"maxGraphemes": 64
+				}
 			}
 		},
 		"byteSlice": {
···
 			"description": "Specifies the sub-string range a facet feature applies to. Start index is inclusive, end index is exclusive. Indices are zero-indexed, counting bytes of the UTF-8 encoded text. NOTE: some languages, like Javascript, use UTF-16 or Unicode codepoints for string slice indexing; in these languages, convert to byte arrays before working with facets.",
 			"required": ["byteStart", "byteEnd"],
 			"properties": {
-				"byteStart": { "type": "integer", "minimum": 0 },
-				"byteEnd": { "type": "integer", "minimum": 0 }
+				"byteStart": {
+					"type": "integer",
+					"minimum": 0
+				},
+				"byteEnd": {
+					"type": "integer",
+					"minimum": 0
+				}
 			}
 		}
 	}

lexdocs/bluesky/app/bsky/unspecced/defs.json packages/definitions/bluesky/lexicons/app/bsky/unspecced/defs.json

···
 			"type": "object",
 			"required": ["uri"],
 			"properties": {
-				"uri": { "type": "string", "format": "at-uri" }
+				"uri": {
+					"type": "string",
+					"format": "at-uri"
+				}
 			}
 		},
 		"skeletonSearchActor": {
 			"type": "object",
 			"required": ["did"],
 			"properties": {
-				"did": { "type": "string", "format": "did" }
+				"did": {
+					"type": "string",
+					"format": "did"
+				}
 			}
 		},
 		"skeletonSearchStarterPack": {
 			"type": "object",
 			"required": ["uri"],
 			"properties": {
-				"uri": { "type": "string", "format": "at-uri" }
+				"uri": {
+					"type": "string",
+					"format": "at-uri"
+				}
 			}
 		},
 		"trendingTopic": {
 			"type": "object",
 			"required": ["topic", "link"],
 			"properties": {
-				"topic": { "type": "string" },
-				"displayName": { "type": "string" },
-				"description": { "type": "string" },
-				"link": { "type": "string" }
+				"topic": {
+					"type": "string"
+				},
+				"displayName": {
+					"type": "string"
+				},
+				"description": {
+					"type": "string"
+				},
+				"link": {
+					"type": "string"
+				}
 			}
 		},
 		"skeletonTrend": {
 			"type": "object",
 			"required": ["topic", "displayName", "link", "startedAt", "postCount", "dids"],
 			"properties": {
-				"topic": { "type": "string" },
-				"displayName": { "type": "string" },
-				"link": { "type": "string" },
-				"startedAt": { "type": "string", "format": "datetime" },
-				"postCount": { "type": "integer" },
-				"status": { "type": "string", "knownValues": ["hot"] },
-				"category": { "type": "string" },
+				"topic": {
+					"type": "string"
+				},
+				"displayName": {
+					"type": "string"
+				},
+				"link": {
+					"type": "string"
+				},
+				"startedAt": {
+					"type": "string",
+					"format": "datetime"
+				},
+				"postCount": {
+					"type": "integer"
+				},
+				"status": {
+					"type": "string",
+					"knownValues": ["hot"]
+				},
+				"category": {
+					"type": "string"
+				},
 				"dids": {
 					"type": "array",
 					"items": {
···
 			"type": "object",
 			"required": ["topic", "displayName", "link", "startedAt", "postCount", "actors"],
 			"properties": {
-				"topic": { "type": "string" },
-				"displayName": { "type": "string" },
-				"link": { "type": "string" },
-				"startedAt": { "type": "string", "format": "datetime" },
-				"postCount": { "type": "integer" },
-				"status": { "type": "string", "knownValues": ["hot"] },
-				"category": { "type": "string" },
+				"topic": {
+					"type": "string"
+				},
+				"displayName": {
+					"type": "string"
+				},
+				"link": {
+					"type": "string"
+				},
+				"startedAt": {
+					"type": "string",
+					"format": "datetime"
+				},
+				"postCount": {
+					"type": "integer"
+				},
+				"status": {
+					"type": "string",
+					"knownValues": ["hot"]
+				},
+				"category": {
+					"type": "string"
+				},
 				"actors": {
 					"type": "array",
 					"items": {
···
 			"type": "object",
 			"required": ["post", "moreParents", "moreReplies", "opThread", "hiddenByThreadgate", "mutedByViewer"],
 			"properties": {
-				"post": { "type": "ref", "ref": "app.bsky.feed.defs#postView" },
+				"post": {
+					"type": "ref",
+					"ref": "app.bsky.feed.defs#postView"
+				},
 				"moreParents": {
 					"type": "boolean",
 					"description": "This post has more parents that were not present in the response. This is just a boolean, without the number of parents."
···
 			"type": "object",
 			"required": ["author"],
 			"properties": {
-				"author": { "type": "ref", "ref": "app.bsky.feed.defs#blockedAuthor" }
+				"author": {
+					"type": "ref",
+					"ref": "app.bsky.feed.defs#blockedAuthor"
+				}
 			}
 		},
 		"ageAssuranceState": {

lexdocs/bluesky/app/bsky/unspecced/getConfig.json packages/definitions/bluesky/lexicons/app/bsky/unspecced/getConfig.json

···
 					"type": "object",
 					"required": [],
 					"properties": {
-						"checkEmailConfirmed": { "type": "boolean" },
+						"checkEmailConfirmed": {
+							"type": "boolean"
+						},
 						"liveNow": {
 							"type": "array",
-							"items": { "type": "ref", "ref": "#liveNowConfig" }
+							"items": {
+								"type": "ref",
+								"ref": "#liveNowConfig"
+							}
 						}
 					}
 				}
···
 			"type": "object",
 			"required": ["did", "domains"],
 			"properties": {
-				"did": { "type": "string", "format": "did" },
+				"did": {
+					"type": "string",
+					"format": "did"
+				},
 				"domains": {
 					"type": "array",
 					"items": {

lexdocs/bluesky/app/bsky/unspecced/getPopularFeedGenerators.json packages/definitions/bluesky/lexicons/app/bsky/unspecced/getPopularFeedGenerators.json

···
 						"maximum": 100,
 						"default": 50
 					},
-					"cursor": { "type": "string" },
-					"query": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					},
+					"query": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 					"type": "object",
 					"required": ["feeds"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"feeds": {
 							"type": "array",
 							"items": {

lexdocs/bluesky/app/bsky/unspecced/getSuggestionsSkeleton.json packages/definitions/bluesky/lexicons/app/bsky/unspecced/getSuggestionsSkeleton.json

···
 						"maximum": 100,
 						"default": 50
 					},
-					"cursor": { "type": "string" },
+					"cursor": {
+						"type": "string"
+					},
 					"relativeToDid": {
 						"type": "string",
 						"format": "did",
···
 					"type": "object",
 					"required": ["actors"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"actors": {
 							"type": "array",
 							"items": {

lexdocs/bluesky/app/bsky/unspecced/getTaggedSuggestions.json packages/definitions/bluesky/lexicons/app/bsky/unspecced/getTaggedSuggestions.json

···
 			"type": "object",
 			"required": ["tag", "subjectType", "subject"],
 			"properties": {
-				"tag": { "type": "string" },
+				"tag": {
+					"type": "string"
+				},
 				"subjectType": {
 					"type": "string",
 					"knownValues": ["actor", "feed"]
 				},
-				"subject": { "type": "string", "format": "uri" }
+				"subject": {
+					"type": "string",
+					"format": "uri"
+				}
 			}
 		}
 	}

lexdocs/bluesky/app/bsky/unspecced/initAgeAssurance.json packages/definitions/bluesky/lexicons/app/bsky/unspecced/initAgeAssurance.json

···
 					"ref": "app.bsky.unspecced.defs#ageAssuranceState"
 				}
 			},
-			"errors": [{ "name": "InvalidEmail" }, { "name": "DidTooLong" }, { "name": "InvalidInitiation" }]
+			"errors": [
+				{
+					"name": "InvalidEmail"
+				},
+				{
+					"name": "DidTooLong"
+				},
+				{
+					"name": "InvalidInitiation"
+				}
+			]
 		}
 	}
 }

lexdocs/bluesky/app/bsky/unspecced/searchActorsSkeleton.json packages/definitions/bluesky/lexicons/app/bsky/unspecced/searchActorsSkeleton.json

···
 					"type": "object",
 					"required": ["actors"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"hitsTotal": {
 							"type": "integer",
 							"description": "Count of search hits. Optional, may be rounded/truncated, and may not be possible to paginate through all hits."
···
 					}
 				}
 			},
-			"errors": [{ "name": "BadQueryString" }]
+			"errors": [
+				{
+					"name": "BadQueryString"
+				}
+			]
 		}
 	}
 }

lexdocs/bluesky/app/bsky/unspecced/searchPostsSkeleton.json packages/definitions/bluesky/lexicons/app/bsky/unspecced/searchPostsSkeleton.json

···
 					"type": "object",
 					"required": ["posts"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"hitsTotal": {
 							"type": "integer",
 							"description": "Count of search hits. Optional, may be rounded/truncated, and may not be possible to paginate through all hits."
···
 					}
 				}
 			},
-			"errors": [{ "name": "BadQueryString" }]
+			"errors": [
+				{
+					"name": "BadQueryString"
+				}
+			]
 		}
 	}
 }

lexdocs/bluesky/app/bsky/video/defs.json packages/definitions/bluesky/lexicons/app/bsky/video/defs.json

···
 			"type": "object",
 			"required": ["jobId", "did", "state"],
 			"properties": {
-				"jobId": { "type": "string" },
-				"did": { "type": "string", "format": "did" },
+				"jobId": {
+					"type": "string"
+				},
+				"did": {
+					"type": "string",
+					"format": "did"
+				},
 				"state": {
 					"type": "string",
 					"description": "The state of the video processing job. All values not listed as a known value indicate that the job is in process.",
···
 					"maximum": 100,
 					"description": "Progress within the current processing state."
 				},
-				"blob": { "type": "blob" },
-				"error": { "type": "string" },
-				"message": { "type": "string" }
+				"blob": {
+					"type": "blob"
+				},
+				"error": {
+					"type": "string"
+				},
+				"message": {
+					"type": "string"
+				}
 			}
 		}
 	}

lexdocs/bluesky/app/bsky/video/getUploadLimits.json

···
-{
-	"lexicon": 1,
-	"id": "app.bsky.video.getUploadLimits",
-	"defs": {
-		"main": {
-			"type": "query",
-			"description": "Get video upload limits for the authenticated user.",
-			"output": {
-				"encoding": "application/json",
-				"schema": {
-					"type": "object",
-					"required": ["canUpload"],
-					"properties": {
-						"canUpload": { "type": "boolean" },
-						"remainingDailyVideos": { "type": "integer" },
-						"remainingDailyBytes": { "type": "integer" },
-						"message": { "type": "string" },
-						"error": { "type": "string" }
-					}
-				}
-			}
-		}
-	}
-}

lexdocs/bluesky/chat/bsky/actor/defs.json packages/definitions/bluesky/lexicons/chat/bsky/actor/defs.json

···
 			"type": "object",
 			"required": ["did", "handle"],
 			"properties": {
-				"did": { "type": "string", "format": "did" },
-				"handle": { "type": "string", "format": "handle" },
+				"did": {
+					"type": "string",
+					"format": "did"
+				},
+				"handle": {
+					"type": "string",
+					"format": "handle"
+				},
 				"displayName": {
 					"type": "string",
 					"maxGraphemes": 64,
 					"maxLength": 640
 				},
-				"avatar": { "type": "string", "format": "uri" },
+				"avatar": {
+					"type": "string",
+					"format": "uri"
+				},
 				"associated": {
 					"type": "ref",
 					"ref": "app.bsky.actor.defs#profileAssociated"
 				},
-				"viewer": { "type": "ref", "ref": "app.bsky.actor.defs#viewerState" },
+				"viewer": {
+					"type": "ref",
+					"ref": "app.bsky.actor.defs#viewerState"
+				},
 				"labels": {
 					"type": "array",
-					"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+					"items": {
+						"type": "ref",
+						"ref": "com.atproto.label.defs#label"
+					}
 				},
 				"chatDisabled": {
 					"type": "boolean",

lexdocs/bluesky/chat/bsky/convo/acceptConvo.json packages/definitions/bluesky/lexicons/chat/bsky/convo/acceptConvo.json

···
 					"type": "object",
 					"required": ["convoId"],
 					"properties": {
-						"convoId": { "type": "string" }
+						"convoId": {
+							"type": "string"
+						}
 					}
 				}
 			},

lexdocs/bluesky/chat/bsky/convo/addReaction.json packages/definitions/bluesky/lexicons/chat/bsky/convo/addReaction.json

···
 					"type": "object",
 					"required": ["convoId", "messageId", "value"],
 					"properties": {
-						"convoId": { "type": "string" },
-						"messageId": { "type": "string" },
+						"convoId": {
+							"type": "string"
+						},
+						"messageId": {
+							"type": "string"
+						},
 						"value": {
 							"type": "string",
 							"minLength": 1,

lexdocs/bluesky/chat/bsky/convo/defs.json packages/definitions/bluesky/lexicons/chat/bsky/convo/defs.json

···
 			"type": "object",
 			"required": ["did", "messageId", "convoId"],
 			"properties": {
-				"did": { "type": "string", "format": "did" },
-				"convoId": { "type": "string" },
-				"messageId": { "type": "string" }
+				"did": {
+					"type": "string",
+					"format": "did"
+				},
+				"convoId": {
+					"type": "string"
+				},
+				"messageId": {
+					"type": "string"
+				}
 			}
 		},
 		"messageInput": {
···
 				"facets": {
 					"type": "array",
 					"description": "Annotations of text (mentions, URLs, hashtags, etc)",
-					"items": { "type": "ref", "ref": "app.bsky.richtext.facet" }
+					"items": {
+						"type": "ref",
+						"ref": "app.bsky.richtext.facet"
+					}
 				},
 				"embed": {
 					"type": "union",
···
 			"type": "object",
 			"required": ["id", "rev", "text", "sender", "sentAt"],
 			"properties": {
-				"id": { "type": "string" },
-				"rev": { "type": "string" },
+				"id": {
+					"type": "string"
+				},
+				"rev": {
+					"type": "string"
+				},
 				"text": {
 					"type": "string",
 					"maxLength": 10000,
···
 				"facets": {
 					"type": "array",
 					"description": "Annotations of text (mentions, URLs, hashtags, etc)",
-					"items": { "type": "ref", "ref": "app.bsky.richtext.facet" }
+					"items": {
+						"type": "ref",
+						"ref": "app.bsky.richtext.facet"
+					}
 				},
 				"embed": {
 					"type": "union",
···
 				"reactions": {
 					"type": "array",
 					"description": "Reactions to this message, in ascending order of creation time.",
-					"items": { "type": "ref", "ref": "#reactionView" }
+					"items": {
+						"type": "ref",
+						"ref": "#reactionView"
+					}
+				},
+				"sender": {
+					"type": "ref",
+					"ref": "#messageViewSender"
 				},
-				"sender": { "type": "ref", "ref": "#messageViewSender" },
-				"sentAt": { "type": "string", "format": "datetime" }
+				"sentAt": {
+					"type": "string",
+					"format": "datetime"
+				}
 			}
 		},
 		"deletedMessageView": {
 			"type": "object",
 			"required": ["id", "rev", "sender", "sentAt"],
 			"properties": {
-				"id": { "type": "string" },
-				"rev": { "type": "string" },
-				"sender": { "type": "ref", "ref": "#messageViewSender" },
-				"sentAt": { "type": "string", "format": "datetime" }
+				"id": {
+					"type": "string"
+				},
+				"rev": {
+					"type": "string"
+				},
+				"sender": {
+					"type": "ref",
+					"ref": "#messageViewSender"
+				},
+				"sentAt": {
+					"type": "string",
+					"format": "datetime"
+				}
 			}
 		},
 		"messageViewSender": {
 			"type": "object",
 			"required": ["did"],
 			"properties": {
-				"did": { "type": "string", "format": "did" }
+				"did": {
+					"type": "string",
+					"format": "did"
+				}
 			}
 		},
 		"reactionView": {
 			"type": "object",
 			"required": ["value", "sender", "createdAt"],
 			"properties": {
-				"value": { "type": "string" },
-				"sender": { "type": "ref", "ref": "#reactionViewSender" },
-				"createdAt": { "type": "string", "format": "datetime" }
+				"value": {
+					"type": "string"
+				},
+				"sender": {
+					"type": "ref",
+					"ref": "#reactionViewSender"
+				},
+				"createdAt": {
+					"type": "string",
+					"format": "datetime"
+				}
 			}
 		},
 		"reactionViewSender": {
 			"type": "object",
 			"required": ["did"],
 			"properties": {
-				"did": { "type": "string", "format": "did" }
+				"did": {
+					"type": "string",
+					"format": "did"
+				}
 			}
 		},
 		"messageAndReactionView": {
 			"type": "object",
 			"required": ["message", "reaction"],
 			"properties": {
-				"message": { "type": "ref", "ref": "#messageView" },
-				"reaction": { "type": "ref", "ref": "#reactionView" }
+				"message": {
+					"type": "ref",
+					"ref": "#messageView"
+				},
+				"reaction": {
+					"type": "ref",
+					"ref": "#reactionView"
+				}
 			}
 		},
 		"convoView": {
 			"type": "object",
 			"required": ["id", "rev", "members", "muted", "unreadCount"],
 			"properties": {
-				"id": { "type": "string" },
-				"rev": { "type": "string" },
+				"id": {
+					"type": "string"
+				},
+				"rev": {
+					"type": "string"
+				},
 				"members": {
 					"type": "array",
 					"items": {
···
 					"type": "union",
 					"refs": ["#messageAndReactionView"]
 				},
-				"muted": { "type": "boolean" },
+				"muted": {
+					"type": "boolean"
+				},
 				"status": {
 					"type": "string",
 					"knownValues": ["request", "accepted"]
 				},
-				"unreadCount": { "type": "integer" }
+				"unreadCount": {
+					"type": "integer"
+				}
 			}
 		},
 		"logBeginConvo": {
 			"type": "object",
 			"required": ["rev", "convoId"],
 			"properties": {
-				"rev": { "type": "string" },
-				"convoId": { "type": "string" }
+				"rev": {
+					"type": "string"
+				},
+				"convoId": {
+					"type": "string"
+				}
 			}
 		},
 		"logAcceptConvo": {
 			"type": "object",
 			"required": ["rev", "convoId"],
 			"properties": {
-				"rev": { "type": "string" },
-				"convoId": { "type": "string" }
+				"rev": {
+					"type": "string"
+				},
+				"convoId": {
+					"type": "string"
+				}
 			}
 		},
 		"logLeaveConvo": {
 			"type": "object",
 			"required": ["rev", "convoId"],
 			"properties": {
-				"rev": { "type": "string" },
-				"convoId": { "type": "string" }
+				"rev": {
+					"type": "string"
+				},
+				"convoId": {
+					"type": "string"
+				}
 			}
 		},
 		"logMuteConvo": {
 			"type": "object",
 			"required": ["rev", "convoId"],
 			"properties": {
-				"rev": { "type": "string" },
-				"convoId": { "type": "string" }
+				"rev": {
+					"type": "string"
+				},
+				"convoId": {
+					"type": "string"
+				}
 			}
 		},
 		"logUnmuteConvo": {
 			"type": "object",
 			"required": ["rev", "convoId"],
 			"properties": {
-				"rev": { "type": "string" },
-				"convoId": { "type": "string" }
+				"rev": {
+					"type": "string"
+				},
+				"convoId": {
+					"type": "string"
+				}
 			}
 		},
 		"logCreateMessage": {
 			"type": "object",
 			"required": ["rev", "convoId", "message"],
 			"properties": {
-				"rev": { "type": "string" },
-				"convoId": { "type": "string" },
+				"rev": {
+					"type": "string"
+				},
+				"convoId": {
+					"type": "string"
+				},
 				"message": {
 					"type": "union",
 					"refs": ["#messageView", "#deletedMessageView"]
···
 			"type": "object",
 			"required": ["rev", "convoId", "message"],
 			"properties": {
-				"rev": { "type": "string" },
-				"convoId": { "type": "string" },
+				"rev": {
+					"type": "string"
+				},
+				"convoId": {
+					"type": "string"
+				},
 				"message": {
 					"type": "union",
 					"refs": ["#messageView", "#deletedMessageView"]
···
 			"type": "object",
 			"required": ["rev", "convoId", "message"],
 			"properties": {
-				"rev": { "type": "string" },
-				"convoId": { "type": "string" },
+				"rev": {
+					"type": "string"
+				},
+				"convoId": {
+					"type": "string"
+				},
 				"message": {
 					"type": "union",
 					"refs": ["#messageView", "#deletedMessageView"]
···
 			"type": "object",
 			"required": ["rev", "convoId", "message", "reaction"],
 			"properties": {
-				"rev": { "type": "string" },
-				"convoId": { "type": "string" },
+				"rev": {
+					"type": "string"
+				},
+				"convoId": {
+					"type": "string"
+				},
 				"message": {
 					"type": "union",
 					"refs": ["#messageView", "#deletedMessageView"]
 				},
-				"reaction": { "type": "ref", "ref": "#reactionView" }
+				"reaction": {
+					"type": "ref",
+					"ref": "#reactionView"
+				}
 			}
 		},
 		"logRemoveReaction": {
 			"type": "object",
 			"required": ["rev", "convoId", "message", "reaction"],
 			"properties": {
-				"rev": { "type": "string" },
-				"convoId": { "type": "string" },
+				"rev": {
+					"type": "string"
+				},
+				"convoId": {
+					"type": "string"
+				},
 				"message": {
 					"type": "union",
 					"refs": ["#messageView", "#deletedMessageView"]
 				},
-				"reaction": { "type": "ref", "ref": "#reactionView" }
+				"reaction": {
+					"type": "ref",
+					"ref": "#reactionView"
+				}
 			}
 		}
 	}

lexdocs/bluesky/chat/bsky/convo/deleteMessageForSelf.json packages/definitions/bluesky/lexicons/chat/bsky/convo/deleteMessageForSelf.json

···
 					"type": "object",
 					"required": ["convoId", "messageId"],
 					"properties": {
-						"convoId": { "type": "string" },
-						"messageId": { "type": "string" }
+						"convoId": {
+							"type": "string"
+						},
+						"messageId": {
+							"type": "string"
+						}
 					}
 				}
 			},

lexdocs/bluesky/chat/bsky/convo/getConvo.json packages/definitions/bluesky/lexicons/chat/bsky/convo/getConvo.json

···
 				"type": "params",
 				"required": ["convoId"],
 				"properties": {
-					"convoId": { "type": "string" }
+					"convoId": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {

lexdocs/bluesky/chat/bsky/convo/getLog.json packages/definitions/bluesky/lexicons/chat/bsky/convo/getLog.json

···
 				"type": "params",
 				"required": [],
 				"properties": {
-					"cursor": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 					"type": "object",
 					"required": ["logs"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"logs": {
 							"type": "array",
 							"items": {

lexdocs/bluesky/chat/bsky/convo/getMessages.json packages/definitions/bluesky/lexicons/chat/bsky/convo/getMessages.json

···
 				"type": "params",
 				"required": ["convoId"],
 				"properties": {
-					"convoId": { "type": "string" },
+					"convoId": {
+						"type": "string"
+					},
 					"limit": {
 						"type": "integer",
 						"minimum": 1,
 						"maximum": 100,
 						"default": 50
 					},
-					"cursor": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 					"type": "object",
 					"required": ["messages"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"messages": {
 							"type": "array",
 							"items": {

lexdocs/bluesky/chat/bsky/convo/leaveConvo.json packages/definitions/bluesky/lexicons/chat/bsky/convo/leaveConvo.json

···
 					"type": "object",
 					"required": ["convoId"],
 					"properties": {
-						"convoId": { "type": "string" }
+						"convoId": {
+							"type": "string"
+						}
 					}
 				}
 			},
···
 					"type": "object",
 					"required": ["convoId", "rev"],
 					"properties": {
-						"convoId": { "type": "string" },
-						"rev": { "type": "string" }
+						"convoId": {
+							"type": "string"
+						},
+						"rev": {
+							"type": "string"
+						}
 					}
 				}
 			}

lexdocs/bluesky/chat/bsky/convo/listConvos.json packages/definitions/bluesky/lexicons/chat/bsky/convo/listConvos.json

···
 						"maximum": 100,
 						"default": 50
 					},
-					"cursor": { "type": "string" },
+					"cursor": {
+						"type": "string"
+					},
 					"readState": {
 						"type": "string",
 						"knownValues": ["unread"]
···
 					"type": "object",
 					"required": ["convos"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"convos": {
 							"type": "array",
 							"items": {

lexdocs/bluesky/chat/bsky/convo/muteConvo.json packages/definitions/bluesky/lexicons/chat/bsky/convo/muteConvo.json

···
 					"type": "object",
 					"required": ["convoId"],
 					"properties": {
-						"convoId": { "type": "string" }
+						"convoId": {
+							"type": "string"
+						}
 					}
 				}
 			},

lexdocs/bluesky/chat/bsky/convo/removeReaction.json packages/definitions/bluesky/lexicons/chat/bsky/convo/removeReaction.json

···
 					"type": "object",
 					"required": ["convoId", "messageId", "value"],
 					"properties": {
-						"convoId": { "type": "string" },
-						"messageId": { "type": "string" },
+						"convoId": {
+							"type": "string"
+						},
+						"messageId": {
+							"type": "string"
+						},
 						"value": {
 							"type": "string",
 							"minLength": 1,

lexdocs/bluesky/chat/bsky/convo/sendMessage.json packages/definitions/bluesky/lexicons/chat/bsky/convo/sendMessage.json

···
 					"type": "object",
 					"required": ["convoId", "message"],
 					"properties": {
-						"convoId": { "type": "string" },
+						"convoId": {
+							"type": "string"
+						},
 						"message": {
 							"type": "ref",
 							"ref": "chat.bsky.convo.defs#messageInput"

lexdocs/bluesky/chat/bsky/convo/sendMessageBatch.json packages/definitions/bluesky/lexicons/chat/bsky/convo/sendMessageBatch.json

···
 			"type": "object",
 			"required": ["convoId", "message"],
 			"properties": {
-				"convoId": { "type": "string" },
+				"convoId": {
+					"type": "string"
+				},
 				"message": {
 					"type": "ref",
 					"ref": "chat.bsky.convo.defs#messageInput"

lexdocs/bluesky/chat/bsky/convo/unmuteConvo.json packages/definitions/bluesky/lexicons/chat/bsky/convo/unmuteConvo.json

···
 					"type": "object",
 					"required": ["convoId"],
 					"properties": {
-						"convoId": { "type": "string" }
+						"convoId": {
+							"type": "string"
+						}
 					}
 				}
 			},

lexdocs/bluesky/chat/bsky/convo/updateRead.json packages/definitions/bluesky/lexicons/chat/bsky/convo/updateRead.json

···
 					"type": "object",
 					"required": ["convoId"],
 					"properties": {
-						"convoId": { "type": "string" },
-						"messageId": { "type": "string" }
+						"convoId": {
+							"type": "string"
+						},
+						"messageId": {
+							"type": "string"
+						}
 					}
 				}
 			},

lexdocs/bluesky/chat/bsky/moderation/getActorMetadata.json

···
-{
-	"lexicon": 1,
-	"id": "chat.bsky.moderation.getActorMetadata",
-	"defs": {
-		"main": {
-			"type": "query",
-			"parameters": {
-				"type": "params",
-				"required": ["actor"],
-				"properties": {
-					"actor": { "type": "string", "format": "did" }
-				}
-			},
-			"output": {
-				"encoding": "application/json",
-				"schema": {
-					"type": "object",
-					"required": ["day", "month", "all"],
-					"properties": {
-						"day": { "type": "ref", "ref": "#metadata" },
-						"month": { "type": "ref", "ref": "#metadata" },
-						"all": { "type": "ref", "ref": "#metadata" }
-					}
-				}
-			}
-		},
-		"metadata": {
-			"type": "object",
-			"required": ["messagesSent", "messagesReceived", "convos", "convosStarted"],
-			"properties": {
-				"messagesSent": { "type": "integer" },
-				"messagesReceived": { "type": "integer" },
-				"convos": { "type": "integer" },
-				"convosStarted": { "type": "integer" }
-			}
-		}
-	}
-}

lexdocs/bluesky/chat/bsky/moderation/getMessageContext.json packages/definitions/bluesky/lexicons/chat/bsky/moderation/getMessageContext.json

···
 						"type": "string",
 						"description": "Conversation that the message is from. NOTE: this field will eventually be required."
 					},
-					"messageId": { "type": "string" },
-					"before": { "type": "integer", "default": 5 },
-					"after": { "type": "integer", "default": 5 }
+					"messageId": {
+						"type": "string"
+					},
+					"before": {
+						"type": "integer",
+						"default": 5
+					},
+					"after": {
+						"type": "integer",
+						"default": 5
+					}
 				}
 			},
 			"output": {

lexdocs/bluesky/chat/bsky/moderation/updateActorAccess.json packages/definitions/bluesky/lexicons/chat/bsky/moderation/updateActorAccess.json

···
 					"type": "object",
 					"required": ["actor", "allowAccess"],
 					"properties": {
-						"actor": { "type": "string", "format": "did" },
-						"allowAccess": { "type": "boolean" },
-						"ref": { "type": "string" }
+						"actor": {
+							"type": "string",
+							"format": "did"
+						},
+						"allowAccess": {
+							"type": "boolean"
+						},
+						"ref": {
+							"type": "string"
+						}
 					}
 				}
 			}

lexdocs/bluesky/com/atproto/admin/defs.json

···
-{
-	"lexicon": 1,
-	"id": "com.atproto.admin.defs",
-	"defs": {
-		"statusAttr": {
-			"type": "object",
-			"required": ["applied"],
-			"properties": {
-				"applied": { "type": "boolean" },
-				"ref": { "type": "string" }
-			}
-		},
-		"accountView": {
-			"type": "object",
-			"required": ["did", "handle", "indexedAt"],
-			"properties": {
-				"did": { "type": "string", "format": "did" },
-				"handle": { "type": "string", "format": "handle" },
-				"email": { "type": "string" },
-				"relatedRecords": { "type": "array", "items": { "type": "unknown" } },
-				"indexedAt": { "type": "string", "format": "datetime" },
-				"invitedBy": {
-					"type": "ref",
-					"ref": "com.atproto.server.defs#inviteCode"
-				},
-				"invites": {
-					"type": "array",
-					"items": {
-						"type": "ref",
-						"ref": "com.atproto.server.defs#inviteCode"
-					}
-				},
-				"invitesDisabled": { "type": "boolean" },
-				"emailConfirmedAt": { "type": "string", "format": "datetime" },
-				"inviteNote": { "type": "string" },
-				"deactivatedAt": { "type": "string", "format": "datetime" },
-				"threatSignatures": {
-					"type": "array",
-					"items": {
-						"type": "ref",
-						"ref": "#threatSignature"
-					}
-				}
-			}
-		},
-		"repoRef": {
-			"type": "object",
-			"required": ["did"],
-			"properties": {
-				"did": { "type": "string", "format": "did" }
-			}
-		},
-		"repoBlobRef": {
-			"type": "object",
-			"required": ["did", "cid"],
-			"properties": {
-				"did": { "type": "string", "format": "did" },
-				"cid": { "type": "string", "format": "cid" },
-				"recordUri": { "type": "string", "format": "at-uri" }
-			}
-		},
-		"threatSignature": {
-			"type": "object",
-			"required": ["property", "value"],
-			"properties": {
-				"property": { "type": "string" },
-				"value": { "type": "string" }
-			}
-		}
-	}
-}

lexdocs/bluesky/com/atproto/admin/deleteAccount.json packages/definitions/atproto/lexicons/com/atproto/admin/deleteAccount.json

···
 					"type": "object",
 					"required": ["did"],
 					"properties": {
-						"did": { "type": "string", "format": "did" }
+						"did": {
+							"type": "string",
+							"format": "did"
+						}
 					}
 				}
 			}

lexdocs/bluesky/com/atproto/admin/disableAccountInvites.json packages/definitions/atproto/lexicons/com/atproto/admin/disableAccountInvites.json

···
 					"type": "object",
 					"required": ["account"],
 					"properties": {
-						"account": { "type": "string", "format": "did" },
+						"account": {
+							"type": "string",
+							"format": "did"
+						},
 						"note": {
 							"type": "string",
 							"description": "Optional reason for disabled invites."

lexdocs/bluesky/com/atproto/admin/disableInviteCodes.json packages/definitions/atproto/lexicons/com/atproto/admin/disableInviteCodes.json

···
 					"properties": {
 						"codes": {
 							"type": "array",
-							"items": { "type": "string" }
+							"items": {
+								"type": "string"
+							}
 						},
 						"accounts": {
 							"type": "array",
-							"items": { "type": "string" }
+							"items": {
+								"type": "string"
+							}
 						}
 					}
 				}

lexdocs/bluesky/com/atproto/admin/enableAccountInvites.json packages/definitions/atproto/lexicons/com/atproto/admin/enableAccountInvites.json

···
 					"type": "object",
 					"required": ["account"],
 					"properties": {
-						"account": { "type": "string", "format": "did" },
+						"account": {
+							"type": "string",
+							"format": "did"
+						},
 						"note": {
 							"type": "string",
 							"description": "Optional reason for enabled invites."

lexdocs/bluesky/com/atproto/admin/getAccountInfo.json packages/definitions/atproto/lexicons/com/atproto/admin/getAccountInfo.json

···
 				"type": "params",
 				"required": ["did"],
 				"properties": {
-					"did": { "type": "string", "format": "did" }
+					"did": {
+						"type": "string",
+						"format": "did"
+					}
 				}
 			},
 			"output": {

lexdocs/bluesky/com/atproto/admin/getAccountInfos.json packages/definitions/atproto/lexicons/com/atproto/admin/getAccountInfos.json

···
 				"properties": {
 					"dids": {
 						"type": "array",
-						"items": { "type": "string", "format": "did" }
+						"items": {
+							"type": "string",
+							"format": "did"
+						}
 					}
 				}
 			},

lexdocs/bluesky/com/atproto/admin/getInviteCodes.json packages/definitions/atproto/lexicons/com/atproto/admin/getInviteCodes.json

···
 						"maximum": 500,
 						"default": 100
 					},
-					"cursor": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 					"type": "object",
 					"required": ["codes"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"codes": {
 							"type": "array",
 							"items": {

lexdocs/bluesky/com/atproto/admin/getSubjectStatus.json packages/definitions/atproto/lexicons/com/atproto/admin/getSubjectStatus.json

···
 			"parameters": {
 				"type": "params",
 				"properties": {
-					"did": { "type": "string", "format": "did" },
-					"uri": { "type": "string", "format": "at-uri" },
-					"blob": { "type": "string", "format": "cid" }
+					"did": {
+						"type": "string",
+						"format": "did"
+					},
+					"uri": {
+						"type": "string",
+						"format": "at-uri"
+					},
+					"blob": {
+						"type": "string",
+						"format": "cid"
+					}
 				}
 			},
 			"output": {

lexdocs/bluesky/com/atproto/admin/searchAccounts.json packages/definitions/atproto/lexicons/com/atproto/admin/searchAccounts.json

···
 			"parameters": {
 				"type": "params",
 				"properties": {
-					"email": { "type": "string" },
-					"cursor": { "type": "string" },
+					"email": {
+						"type": "string"
+					},
+					"cursor": {
+						"type": "string"
+					},
 					"limit": {
 						"type": "integer",
 						"minimum": 1,
···
 					"type": "object",
 					"required": ["accounts"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"accounts": {
 							"type": "array",
 							"items": {

lexdocs/bluesky/com/atproto/admin/sendEmail.json packages/definitions/atproto/lexicons/com/atproto/admin/sendEmail.json

···
 					"type": "object",
 					"required": ["recipientDid", "content", "senderDid"],
 					"properties": {
-						"recipientDid": { "type": "string", "format": "did" },
-						"content": { "type": "string" },
-						"subject": { "type": "string" },
-						"senderDid": { "type": "string", "format": "did" },
+						"recipientDid": {
+							"type": "string",
+							"format": "did"
+						},
+						"content": {
+							"type": "string"
+						},
+						"subject": {
+							"type": "string"
+						},
+						"senderDid": {
+							"type": "string",
+							"format": "did"
+						},
 						"comment": {
 							"type": "string",
 							"description": "Additional comment by the sender that won't be used in the email itself but helpful to provide more context for moderators/reviewers"
···
 					"type": "object",
 					"required": ["sent"],
 					"properties": {
-						"sent": { "type": "boolean" }
+						"sent": {
+							"type": "boolean"
+						}
 					}
 				}
 			}

lexdocs/bluesky/com/atproto/admin/updateAccountEmail.json packages/definitions/atproto/lexicons/com/atproto/admin/updateAccountEmail.json

···
 							"format": "at-identifier",
 							"description": "The handle or DID of the repo."
 						},
-						"email": { "type": "string" }
+						"email": {
+							"type": "string"
+						}
 					}
 				}
 			}

lexdocs/bluesky/com/atproto/admin/updateAccountHandle.json packages/definitions/atproto/lexicons/com/atproto/admin/updateAccountHandle.json

···
 					"type": "object",
 					"required": ["did", "handle"],
 					"properties": {
-						"did": { "type": "string", "format": "did" },
-						"handle": { "type": "string", "format": "handle" }
+						"did": {
+							"type": "string",
+							"format": "did"
+						},
+						"handle": {
+							"type": "string",
+							"format": "handle"
+						}
 					}
 				}
 			}

lexdocs/bluesky/com/atproto/admin/updateAccountPassword.json packages/definitions/atproto/lexicons/com/atproto/admin/updateAccountPassword.json

···
 					"type": "object",
 					"required": ["did", "password"],
 					"properties": {
-						"did": { "type": "string", "format": "did" },
-						"password": { "type": "string" }
+						"did": {
+							"type": "string",
+							"format": "did"
+						},
+						"password": {
+							"type": "string"
+						}
 					}
 				}
 			}

lexdocs/bluesky/com/atproto/admin/updateAccountSigningKey.json packages/definitions/atproto/lexicons/com/atproto/admin/updateAccountSigningKey.json

···
 					"type": "object",
 					"required": ["did", "signingKey"],
 					"properties": {
-						"did": { "type": "string", "format": "did" },
+						"did": {
+							"type": "string",
+							"format": "did"
+						},
 						"signingKey": {
 							"type": "string",
 							"format": "did",

lexdocs/bluesky/com/atproto/identity/defs.json packages/definitions/atproto/lexicons/com/atproto/identity/defs.json

···
 			"type": "object",
 			"required": ["did", "handle", "didDoc"],
 			"properties": {
-				"did": { "type": "string", "format": "did" },
+				"did": {
+					"type": "string",
+					"format": "did"
+				},
 				"handle": {
 					"type": "string",
 					"format": "handle",

lexdocs/bluesky/com/atproto/identity/getRecommendedDidCredentials.json packages/definitions/atproto/lexicons/com/atproto/identity/getRecommendedDidCredentials.json

···
 						"rotationKeys": {
 							"description": "Recommended rotation keys for PLC dids. Should be undefined (or ignored) for did:webs.",
 							"type": "array",
-							"items": { "type": "string" }
+							"items": {
+								"type": "string"
+							}
 						},
 						"alsoKnownAs": {
 							"type": "array",
-							"items": { "type": "string" }
+							"items": {
+								"type": "string"
+							}
 						},
-						"verificationMethods": { "type": "unknown" },
-						"services": { "type": "unknown" }
+						"verificationMethods": {
+							"type": "unknown"
+						},
+						"services": {
+							"type": "unknown"
+						}
 					}
 				}
 			}

lexdocs/bluesky/com/atproto/identity/resolveHandle.json packages/definitions/atproto/lexicons/com/atproto/identity/resolveHandle.json

···
 					"type": "object",
 					"required": ["did"],
 					"properties": {
-						"did": { "type": "string", "format": "did" }
+						"did": {
+							"type": "string",
+							"format": "did"
+						}
 					}
 				}
 			},

lexdocs/bluesky/com/atproto/identity/signPlcOperation.json packages/definitions/atproto/lexicons/com/atproto/identity/signPlcOperation.json

···
 						},
 						"rotationKeys": {
 							"type": "array",
-							"items": { "type": "string" }
+							"items": {
+								"type": "string"
+							}
 						},
 						"alsoKnownAs": {
 							"type": "array",
-							"items": { "type": "string" }
+							"items": {
+								"type": "string"
+							}
 						},
-						"verificationMethods": { "type": "unknown" },
-						"services": { "type": "unknown" }
+						"verificationMethods": {
+							"type": "unknown"
+						},
+						"services": {
+							"type": "unknown"
+						}
 					}
 				}
 			},

lexdocs/bluesky/com/atproto/identity/submitPlcOperation.json packages/definitions/atproto/lexicons/com/atproto/identity/submitPlcOperation.json

···
 					"type": "object",
 					"required": ["operation"],
 					"properties": {
-						"operation": { "type": "unknown" }
+						"operation": {
+							"type": "unknown"
+						}
 					}
 				}
 			}

lexdocs/bluesky/com/atproto/label/defs.json packages/definitions/atproto/lexicons/com/atproto/label/defs.json

···
 			"properties": {
 				"values": {
 					"type": "array",
-					"items": { "type": "ref", "ref": "#selfLabel" },
+					"items": {
+						"type": "ref",
+						"ref": "#selfLabel"
+					},
 					"maxLength": 10
 				}
 			}
···
 				},
 				"locales": {
 					"type": "array",
-					"items": { "type": "ref", "ref": "#labelValueDefinitionStrings" }
+					"items": {
+						"type": "ref",
+						"ref": "#labelValueDefinitionStrings"
+					}
 				}
 			}
 		},

lexdocs/bluesky/com/atproto/label/queryLabels.json packages/definitions/atproto/lexicons/com/atproto/label/queryLabels.json

···
 				"properties": {
 					"uriPatterns": {
 						"type": "array",
-						"items": { "type": "string" },
+						"items": {
+							"type": "string"
+						},
 						"description": "List of AT URI patterns to match (boolean 'OR'). Each may be a prefix (ending with '*'; will match inclusive of the string leading to '*'), or a full URI."
 					},
 					"sources": {
 						"type": "array",
-						"items": { "type": "string", "format": "did" },
+						"items": {
+							"type": "string",
+							"format": "did"
+						},
 						"description": "Optional list of label sources (DIDs) to filter on."
 					},
 					"limit": {
···
 						"maximum": 250,
 						"default": 50
 					},
-					"cursor": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 					"type": "object",
 					"required": ["labels"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"labels": {
 							"type": "array",
-							"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+							"items": {
+								"type": "ref",
+								"ref": "com.atproto.label.defs#label"
+							}
 						}
 					}
 				}

lexdocs/bluesky/com/atproto/label/subscribeLabels.json packages/definitions/atproto/lexicons/com/atproto/label/subscribeLabels.json

···
 					"refs": ["#labels", "#info"]
 				}
 			},
-			"errors": [{ "name": "FutureCursor" }]
+			"errors": [
+				{
+					"name": "FutureCursor"
+				}
+			]
 		},
 		"labels": {
 			"type": "object",
 			"required": ["seq", "labels"],
 			"properties": {
-				"seq": { "type": "integer" },
+				"seq": {
+					"type": "integer"
+				},
 				"labels": {
 					"type": "array",
-					"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+					"items": {
+						"type": "ref",
+						"ref": "com.atproto.label.defs#label"
+					}
 				}
 			}
 		},

lexdocs/bluesky/com/atproto/moderation/createReport.json packages/definitions/atproto/lexicons/com/atproto/moderation/createReport.json

···
 					"type": "object",
 					"required": ["id", "reasonType", "subject", "reportedBy", "createdAt"],
 					"properties": {
-						"id": { "type": "integer" },
+						"id": {
+							"type": "integer"
+						},
 						"reasonType": {
 							"type": "ref",
 							"ref": "com.atproto.moderation.defs#reasonType"
···
 							"type": "union",
 							"refs": ["com.atproto.admin.defs#repoRef", "com.atproto.repo.strongRef"]
 						},
-						"reportedBy": { "type": "string", "format": "did" },
-						"createdAt": { "type": "string", "format": "datetime" }
+						"reportedBy": {
+							"type": "string",
+							"format": "did"
+						},
+						"createdAt": {
+							"type": "string",
+							"format": "datetime"
+						}
 					}
 				}
 			}

lexdocs/bluesky/com/atproto/moderation/defs.json packages/definitions/atproto/lexicons/com/atproto/moderation/defs.json

···
 				"com.atproto.moderation.defs#reasonRude",
 				"com.atproto.moderation.defs#reasonOther",
 				"com.atproto.moderation.defs#reasonAppeal",
-
 				"tools.ozone.report.defs#reasonAppeal",
 				"tools.ozone.report.defs#reasonOther",
-
 				"tools.ozone.report.defs#reasonViolenceAnimal",
 				"tools.ozone.report.defs#reasonViolenceThreats",
 				"tools.ozone.report.defs#reasonViolenceGraphicContent",
···
 				"tools.ozone.report.defs#reasonViolenceExtremistContent",
 				"tools.ozone.report.defs#reasonViolenceTrafficking",
 				"tools.ozone.report.defs#reasonViolenceOther",
-
 				"tools.ozone.report.defs#reasonSexualAbuseContent",
 				"tools.ozone.report.defs#reasonSexualNCII",
 				"tools.ozone.report.defs#reasonSexualDeepfake",
 				"tools.ozone.report.defs#reasonSexualAnimal",
 				"tools.ozone.report.defs#reasonSexualUnlabeled",
 				"tools.ozone.report.defs#reasonSexualOther",
-
 				"tools.ozone.report.defs#reasonChildSafetyCSAM",
 				"tools.ozone.report.defs#reasonChildSafetyGroom",
 				"tools.ozone.report.defs#reasonChildSafetyPrivacy",
 				"tools.ozone.report.defs#reasonChildSafetyHarassment",
 				"tools.ozone.report.defs#reasonChildSafetyOther",
-
 				"tools.ozone.report.defs#reasonHarassmentTroll",
 				"tools.ozone.report.defs#reasonHarassmentTargeted",
 				"tools.ozone.report.defs#reasonHarassmentHateSpeech",
 				"tools.ozone.report.defs#reasonHarassmentDoxxing",
 				"tools.ozone.report.defs#reasonHarassmentOther",
-
 				"tools.ozone.report.defs#reasonMisleadingBot",
 				"tools.ozone.report.defs#reasonMisleadingImpersonation",
 				"tools.ozone.report.defs#reasonMisleadingSpam",
 				"tools.ozone.report.defs#reasonMisleadingScam",
 				"tools.ozone.report.defs#reasonMisleadingElections",
 				"tools.ozone.report.defs#reasonMisleadingOther",
-
 				"tools.ozone.report.defs#reasonRuleSiteSecurity",
 				"tools.ozone.report.defs#reasonRuleProhibitedSales",
 				"tools.ozone.report.defs#reasonRuleBanEvasion",
 				"tools.ozone.report.defs#reasonRuleOther",
-
 				"tools.ozone.report.defs#reasonSelfHarmContent",
 				"tools.ozone.report.defs#reasonSelfHarmED",
 				"tools.ozone.report.defs#reasonSelfHarmStunts",

lexdocs/bluesky/com/atproto/repo/applyWrites.json packages/definitions/atproto/lexicons/com/atproto/repo/applyWrites.json

···
 			"description": "Operation which creates a new record.",
 			"required": ["collection", "value"],
 			"properties": {
-				"collection": { "type": "string", "format": "nsid" },
+				"collection": {
+					"type": "string",
+					"format": "nsid"
+				},
 				"rkey": {
 					"type": "string",
 					"maxLength": 512,
 					"format": "record-key",
 					"description": "NOTE: maxLength is redundant with record-key format. Keeping it temporarily to ensure backwards compatibility."
 				},
-				"value": { "type": "unknown" }
+				"value": {
+					"type": "unknown"
+				}
 			}
 		},
 		"update": {
···
 			"description": "Operation which updates an existing record.",
 			"required": ["collection", "rkey", "value"],
 			"properties": {
-				"collection": { "type": "string", "format": "nsid" },
-				"rkey": { "type": "string", "format": "record-key" },
-				"value": { "type": "unknown" }
+				"collection": {
+					"type": "string",
+					"format": "nsid"
+				},
+				"rkey": {
+					"type": "string",
+					"format": "record-key"
+				},
+				"value": {
+					"type": "unknown"
+				}
 			}
 		},
 		"delete": {
···
 			"description": "Operation which deletes an existing record.",
 			"required": ["collection", "rkey"],
 			"properties": {
-				"collection": { "type": "string", "format": "nsid" },
-				"rkey": { "type": "string", "format": "record-key" }
+				"collection": {
+					"type": "string",
+					"format": "nsid"
+				},
+				"rkey": {
+					"type": "string",
+					"format": "record-key"
+				}
 			}
 		},
 		"createResult": {
 			"type": "object",
 			"required": ["uri", "cid"],
 			"properties": {
-				"uri": { "type": "string", "format": "at-uri" },
-				"cid": { "type": "string", "format": "cid" },
+				"uri": {
+					"type": "string",
+					"format": "at-uri"
+				},
+				"cid": {
+					"type": "string",
+					"format": "cid"
+				},
 				"validationStatus": {
 					"type": "string",
 					"knownValues": ["valid", "unknown"]
···
 			"type": "object",
 			"required": ["uri", "cid"],
 			"properties": {
-				"uri": { "type": "string", "format": "at-uri" },
-				"cid": { "type": "string", "format": "cid" },
+				"uri": {
+					"type": "string",
+					"format": "at-uri"
+				},
+				"cid": {
+					"type": "string",
+					"format": "cid"
+				},
 				"validationStatus": {
 					"type": "string",
 					"knownValues": ["valid", "unknown"]

lexdocs/bluesky/com/atproto/repo/createRecord.json packages/definitions/atproto/lexicons/com/atproto/repo/createRecord.json

···
 					"type": "object",
 					"required": ["uri", "cid"],
 					"properties": {
-						"uri": { "type": "string", "format": "at-uri" },
-						"cid": { "type": "string", "format": "cid" },
+						"uri": {
+							"type": "string",
+							"format": "at-uri"
+						},
+						"cid": {
+							"type": "string",
+							"format": "cid"
+						},
 						"commit": {
 							"type": "ref",
 							"ref": "com.atproto.repo.defs#commitMeta"

lexdocs/bluesky/com/atproto/repo/defs.json

···
-{
-	"lexicon": 1,
-	"id": "com.atproto.repo.defs",
-	"defs": {
-		"commitMeta": {
-			"type": "object",
-			"required": ["cid", "rev"],
-			"properties": {
-				"cid": { "type": "string", "format": "cid" },
-				"rev": { "type": "string", "format": "tid" }
-			}
-		}
-	}
-}

lexdocs/bluesky/com/atproto/repo/deleteRecord.json packages/definitions/atproto/lexicons/com/atproto/repo/deleteRecord.json

···
 					}
 				}
 			},
-			"errors": [{ "name": "InvalidSwap" }]
+			"errors": [
+				{
+					"name": "InvalidSwap"
+				}
+			]
 		}
 	}
 }

lexdocs/bluesky/com/atproto/repo/describeRepo.json packages/definitions/atproto/lexicons/com/atproto/repo/describeRepo.json

···
 					"type": "object",
 					"required": ["handle", "did", "didDoc", "collections", "handleIsCorrect"],
 					"properties": {
-						"handle": { "type": "string", "format": "handle" },
-						"did": { "type": "string", "format": "did" },
+						"handle": {
+							"type": "string",
+							"format": "handle"
+						},
+						"did": {
+							"type": "string",
+							"format": "did"
+						},
 						"didDoc": {
 							"type": "unknown",
 							"description": "The complete DID document for this account."
···
 						"collections": {
 							"type": "array",
 							"description": "List of all the collections (NSIDs) for which this repo contains at least one record.",
-							"items": { "type": "string", "format": "nsid" }
+							"items": {
+								"type": "string",
+								"format": "nsid"
+							}
 						},
 						"handleIsCorrect": {
 							"type": "boolean",

lexdocs/bluesky/com/atproto/repo/getRecord.json packages/definitions/atproto/lexicons/com/atproto/repo/getRecord.json

···
 					"type": "object",
 					"required": ["uri", "value"],
 					"properties": {
-						"uri": { "type": "string", "format": "at-uri" },
-						"cid": { "type": "string", "format": "cid" },
-						"value": { "type": "unknown" }
+						"uri": {
+							"type": "string",
+							"format": "at-uri"
+						},
+						"cid": {
+							"type": "string",
+							"format": "cid"
+						},
+						"value": {
+							"type": "unknown"
+						}
 					}
 				}
 			},
-			"errors": [{ "name": "RecordNotFound" }]
+			"errors": [
+				{
+					"name": "RecordNotFound"
+				}
+			]
 		}
 	}
 }

lexdocs/bluesky/com/atproto/repo/listMissingBlobs.json packages/definitions/atproto/lexicons/com/atproto/repo/listMissingBlobs.json

···
 						"maximum": 1000,
 						"default": 500
 					},
-					"cursor": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 					"type": "object",
 					"required": ["blobs"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"blobs": {
 							"type": "array",
-							"items": { "type": "ref", "ref": "#recordBlob" }
+							"items": {
+								"type": "ref",
+								"ref": "#recordBlob"
+							}
 						}
 					}
 				}
···
 			"type": "object",
 			"required": ["cid", "recordUri"],
 			"properties": {
-				"cid": { "type": "string", "format": "cid" },
-				"recordUri": { "type": "string", "format": "at-uri" }
+				"cid": {
+					"type": "string",
+					"format": "cid"
+				},
+				"recordUri": {
+					"type": "string",
+					"format": "at-uri"
+				}
 			}
 		}
 	}

lexdocs/bluesky/com/atproto/repo/listRecords.json packages/definitions/atproto/lexicons/com/atproto/repo/listRecords.json

···
 						"default": 50,
 						"description": "The number of records to return."
 					},
-					"cursor": { "type": "string" },
+					"cursor": {
+						"type": "string"
+					},
 					"reverse": {
 						"type": "boolean",
 						"description": "Flag to reverse the order of the returned records."
···
 					"type": "object",
 					"required": ["records"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"records": {
 							"type": "array",
-							"items": { "type": "ref", "ref": "#record" }
+							"items": {
+								"type": "ref",
+								"ref": "#record"
+							}
 						}
 					}
 				}
···
 			"type": "object",
 			"required": ["uri", "cid", "value"],
 			"properties": {
-				"uri": { "type": "string", "format": "at-uri" },
-				"cid": { "type": "string", "format": "cid" },
-				"value": { "type": "unknown" }
+				"uri": {
+					"type": "string",
+					"format": "at-uri"
+				},
+				"cid": {
+					"type": "string",
+					"format": "cid"
+				},
+				"value": {
+					"type": "unknown"
+				}
 			}
 		}
 	}

lexdocs/bluesky/com/atproto/repo/putRecord.json packages/definitions/atproto/lexicons/com/atproto/repo/putRecord.json

···
 					"type": "object",
 					"required": ["uri", "cid"],
 					"properties": {
-						"uri": { "type": "string", "format": "at-uri" },
-						"cid": { "type": "string", "format": "cid" },
+						"uri": {
+							"type": "string",
+							"format": "at-uri"
+						},
+						"cid": {
+							"type": "string",
+							"format": "cid"
+						},
 						"commit": {
 							"type": "ref",
 							"ref": "com.atproto.repo.defs#commitMeta"
···
 					}
 				}
 			},
-			"errors": [{ "name": "InvalidSwap" }]
+			"errors": [
+				{
+					"name": "InvalidSwap"
+				}
+			]
 		}
 	}
 }

lexdocs/bluesky/com/atproto/repo/strongRef.json packages/definitions/atproto/lexicons/com/atproto/repo/strongRef.json

···
 			"type": "object",
 			"required": ["uri", "cid"],
 			"properties": {
-				"uri": { "type": "string", "format": "at-uri" },
-				"cid": { "type": "string", "format": "cid" }
+				"uri": {
+					"type": "string",
+					"format": "at-uri"
+				},
+				"cid": {
+					"type": "string",
+					"format": "cid"
+				}
 			}
 		}
 	}

lexdocs/bluesky/com/atproto/repo/uploadBlob.json packages/definitions/atproto/lexicons/com/atproto/repo/uploadBlob.json

···
 					"type": "object",
 					"required": ["blob"],
 					"properties": {
-						"blob": { "type": "blob" }
+						"blob": {
+							"type": "blob"
+						}
 					}
 				}
 			}

lexdocs/bluesky/com/atproto/server/checkAccountStatus.json

···
-{
-	"lexicon": 1,
-	"id": "com.atproto.server.checkAccountStatus",
-	"defs": {
-		"main": {
-			"type": "query",
-			"description": "Returns the status of an account, especially as pertaining to import or recovery. Can be called many times over the course of an account migration. Requires auth and can only be called pertaining to oneself.",
-			"output": {
-				"encoding": "application/json",
-				"schema": {
-					"type": "object",
-					"required": [
-						"activated",
-						"validDid",
-						"repoCommit",
-						"repoRev",
-						"repoBlocks",
-						"indexedRecords",
-						"privateStateValues",
-						"expectedBlobs",
-						"importedBlobs"
-					],
-					"properties": {
-						"activated": { "type": "boolean" },
-						"validDid": { "type": "boolean" },
-						"repoCommit": { "type": "string", "format": "cid" },
-						"repoRev": { "type": "string" },
-						"repoBlocks": { "type": "integer" },
-						"indexedRecords": { "type": "integer" },
-						"privateStateValues": { "type": "integer" },
-						"expectedBlobs": { "type": "integer" },
-						"importedBlobs": { "type": "integer" }
-					}
-				}
-			}
-		}
-	}
-}

lexdocs/bluesky/com/atproto/server/confirmEmail.json packages/definitions/atproto/lexicons/com/atproto/server/confirmEmail.json

···
 					"type": "object",
 					"required": ["email", "token"],
 					"properties": {
-						"email": { "type": "string" },
-						"token": { "type": "string" }
+						"email": {
+							"type": "string"
+						},
+						"token": {
+							"type": "string"
+						}
 					}
 				}
 			},
 			"errors": [
-				{ "name": "AccountNotFound" },
-				{ "name": "ExpiredToken" },
-				{ "name": "InvalidToken" },
-				{ "name": "InvalidEmail" }
+				{
+					"name": "AccountNotFound"
+				},
+				{
+					"name": "ExpiredToken"
+				},
+				{
+					"name": "InvalidToken"
+				},
+				{
+					"name": "InvalidEmail"
+				}
 			]
 		}
 	}

lexdocs/bluesky/com/atproto/server/createAccount.json packages/definitions/atproto/lexicons/com/atproto/server/createAccount.json

···
 					"type": "object",
 					"required": ["handle"],
 					"properties": {
-						"email": { "type": "string" },
+						"email": {
+							"type": "string"
+						},
 						"handle": {
 							"type": "string",
 							"format": "handle",
···
 							"format": "did",
 							"description": "Pre-existing atproto DID, being imported to a new account."
 						},
-						"inviteCode": { "type": "string" },
-						"verificationCode": { "type": "string" },
-						"verificationPhone": { "type": "string" },
+						"inviteCode": {
+							"type": "string"
+						},
+						"verificationCode": {
+							"type": "string"
+						},
+						"verificationPhone": {
+							"type": "string"
+						},
 						"password": {
 							"type": "string",
 							"description": "Initial account password. May need to meet instance-specific password strength requirements."
···
 					"description": "Account login session returned on successful account creation.",
 					"required": ["accessJwt", "refreshJwt", "handle", "did"],
 					"properties": {
-						"accessJwt": { "type": "string" },
-						"refreshJwt": { "type": "string" },
-						"handle": { "type": "string", "format": "handle" },
+						"accessJwt": {
+							"type": "string"
+						},
+						"refreshJwt": {
+							"type": "string"
+						},
+						"handle": {
+							"type": "string",
+							"format": "handle"
+						},
 						"did": {
 							"type": "string",
 							"format": "did",
···
 				}
 			},
 			"errors": [
-				{ "name": "InvalidHandle" },
-				{ "name": "InvalidPassword" },
-				{ "name": "InvalidInviteCode" },
-				{ "name": "HandleNotAvailable" },
-				{ "name": "UnsupportedDomain" },
-				{ "name": "UnresolvableDid" },
-				{ "name": "IncompatibleDidDoc" }
+				{
+					"name": "InvalidHandle"
+				},
+				{
+					"name": "InvalidPassword"
+				},
+				{
+					"name": "InvalidInviteCode"
+				},
+				{
+					"name": "HandleNotAvailable"
+				},
+				{
+					"name": "UnsupportedDomain"
+				},
+				{
+					"name": "UnresolvableDid"
+				},
+				{
+					"name": "IncompatibleDidDoc"
+				}
 			]
 		}
 	}

lexdocs/bluesky/com/atproto/server/createAppPassword.json packages/definitions/atproto/lexicons/com/atproto/server/createAppPassword.json

···
 					"ref": "#appPassword"
 				}
 			},
-			"errors": [{ "name": "AccountTakedown" }]
+			"errors": [
+				{
+					"name": "AccountTakedown"
+				}
+			]
 		},
 		"appPassword": {
 			"type": "object",
 			"required": ["name", "password", "createdAt"],
 			"properties": {
-				"name": { "type": "string" },
-				"password": { "type": "string" },
-				"createdAt": { "type": "string", "format": "datetime" },
-				"privileged": { "type": "boolean" }
+				"name": {
+					"type": "string"
+				},
+				"password": {
+					"type": "string"
+				},
+				"createdAt": {
+					"type": "string",
+					"format": "datetime"
+				},
+				"privileged": {
+					"type": "boolean"
+				}
 			}
 		}
 	}

lexdocs/bluesky/com/atproto/server/createInviteCode.json packages/definitions/atproto/lexicons/com/atproto/server/createInviteCode.json

···
 					"type": "object",
 					"required": ["useCount"],
 					"properties": {
-						"useCount": { "type": "integer" },
-						"forAccount": { "type": "string", "format": "did" }
+						"useCount": {
+							"type": "integer"
+						},
+						"forAccount": {
+							"type": "string",
+							"format": "did"
+						}
 					}
 				}
 			},
···
 					"type": "object",
 					"required": ["code"],
 					"properties": {
-						"code": { "type": "string" }
+						"code": {
+							"type": "string"
+						}
 					}
 				}
 			}

lexdocs/bluesky/com/atproto/server/createInviteCodes.json packages/definitions/atproto/lexicons/com/atproto/server/createInviteCodes.json

···
 					"type": "object",
 					"required": ["codeCount", "useCount"],
 					"properties": {
-						"codeCount": { "type": "integer", "default": 1 },
-						"useCount": { "type": "integer" },
+						"codeCount": {
+							"type": "integer",
+							"default": 1
+						},
+						"useCount": {
+							"type": "integer"
+						},
 						"forAccounts": {
 							"type": "array",
-							"items": { "type": "string", "format": "did" }
+							"items": {
+								"type": "string",
+								"format": "did"
+							}
 						}
 					}
 				}
···
 					"properties": {
 						"codes": {
 							"type": "array",
-							"items": { "type": "ref", "ref": "#accountCodes" }
+							"items": {
+								"type": "ref",
+								"ref": "#accountCodes"
+							}
 						}
 					}
 				}
···
 			"type": "object",
 			"required": ["account", "codes"],
 			"properties": {
-				"account": { "type": "string" },
+				"account": {
+					"type": "string"
+				},
 				"codes": {
 					"type": "array",
-					"items": { "type": "string" }
+					"items": {
+						"type": "string"
+					}
 				}
 			}
 		}

lexdocs/bluesky/com/atproto/server/createSession.json packages/definitions/atproto/lexicons/com/atproto/server/createSession.json

···
 							"type": "string",
 							"description": "Handle or other identifier supported by the server for the authenticating user."
 						},
-						"password": { "type": "string" },
-						"authFactorToken": { "type": "string" },
+						"password": {
+							"type": "string"
+						},
+						"authFactorToken": {
+							"type": "string"
+						},
 						"allowTakendown": {
 							"type": "boolean",
 							"description": "When true, instead of throwing error for takendown accounts, a valid response with a narrow scoped token will be returned"
···
 					"type": "object",
 					"required": ["accessJwt", "refreshJwt", "handle", "did"],
 					"properties": {
-						"accessJwt": { "type": "string" },
-						"refreshJwt": { "type": "string" },
-						"handle": { "type": "string", "format": "handle" },
-						"did": { "type": "string", "format": "did" },
-						"didDoc": { "type": "unknown" },
-						"email": { "type": "string" },
-						"emailConfirmed": { "type": "boolean" },
-						"emailAuthFactor": { "type": "boolean" },
-						"active": { "type": "boolean" },
+						"accessJwt": {
+							"type": "string"
+						},
+						"refreshJwt": {
+							"type": "string"
+						},
+						"handle": {
+							"type": "string",
+							"format": "handle"
+						},
+						"did": {
+							"type": "string",
+							"format": "did"
+						},
+						"didDoc": {
+							"type": "unknown"
+						},
+						"email": {
+							"type": "string"
+						},
+						"emailConfirmed": {
+							"type": "boolean"
+						},
+						"emailAuthFactor": {
+							"type": "boolean"
+						},
+						"active": {
+							"type": "boolean"
+						},
 						"status": {
 							"type": "string",
 							"description": "If active=false, this optional field indicates a possible reason for why the account is not active. If active=false and no status is supplied, then the host makes no claim for why the repository is no longer being hosted.",
···
 					}
 				}
 			},
-			"errors": [{ "name": "AccountTakedown" }, { "name": "AuthFactorTokenRequired" }]
+			"errors": [
+				{
+					"name": "AccountTakedown"
+				},
+				{
+					"name": "AuthFactorTokenRequired"
+				}
+			]
 		}
 	}
 }

lexdocs/bluesky/com/atproto/server/defs.json

···
-{
-	"lexicon": 1,
-	"id": "com.atproto.server.defs",
-	"defs": {
-		"inviteCode": {
-			"type": "object",
-			"required": ["code", "available", "disabled", "forAccount", "createdBy", "createdAt", "uses"],
-			"properties": {
-				"code": { "type": "string" },
-				"available": { "type": "integer" },
-				"disabled": { "type": "boolean" },
-				"forAccount": { "type": "string" },
-				"createdBy": { "type": "string" },
-				"createdAt": { "type": "string", "format": "datetime" },
-				"uses": {
-					"type": "array",
-					"items": { "type": "ref", "ref": "#inviteCodeUse" }
-				}
-			}
-		},
-		"inviteCodeUse": {
-			"type": "object",
-			"required": ["usedBy", "usedAt"],
-			"properties": {
-				"usedBy": { "type": "string", "format": "did" },
-				"usedAt": { "type": "string", "format": "datetime" }
-			}
-		}
-	}
-}

lexdocs/bluesky/com/atproto/server/deleteAccount.json packages/definitions/atproto/lexicons/com/atproto/server/deleteAccount.json

···
 					"type": "object",
 					"required": ["did", "password", "token"],
 					"properties": {
-						"did": { "type": "string", "format": "did" },
-						"password": { "type": "string" },
-						"token": { "type": "string" }
+						"did": {
+							"type": "string",
+							"format": "did"
+						},
+						"password": {
+							"type": "string"
+						},
+						"token": {
+							"type": "string"
+						}
 					}
 				}
 			},
-			"errors": [{ "name": "ExpiredToken" }, { "name": "InvalidToken" }]
+			"errors": [
+				{
+					"name": "ExpiredToken"
+				},
+				{
+					"name": "InvalidToken"
+				}
+			]
 		}
 	}
 }

lexdocs/bluesky/com/atproto/server/describeServer.json packages/definitions/atproto/lexicons/com/atproto/server/describeServer.json

···
 						"availableUserDomains": {
 							"type": "array",
 							"description": "List of domain suffixes that can be used in account handles.",
-							"items": { "type": "string" }
+							"items": {
+								"type": "string"
+							}
 						},
 						"links": {
 							"type": "ref",
···
 		"links": {
 			"type": "object",
 			"properties": {
-				"privacyPolicy": { "type": "string", "format": "uri" },
-				"termsOfService": { "type": "string", "format": "uri" }
+				"privacyPolicy": {
+					"type": "string",
+					"format": "uri"
+				},
+				"termsOfService": {
+					"type": "string",
+					"format": "uri"
+				}
 			}
 		},
 		"contact": {
 			"type": "object",
 			"properties": {
-				"email": { "type": "string" }
+				"email": {
+					"type": "string"
+				}
 			}
 		}
 	}

lexdocs/bluesky/com/atproto/server/getAccountInviteCodes.json packages/definitions/atproto/lexicons/com/atproto/server/getAccountInviteCodes.json

···
 			"parameters": {
 				"type": "params",
 				"properties": {
-					"includeUsed": { "type": "boolean", "default": true },
+					"includeUsed": {
+						"type": "boolean",
+						"default": true
+					},
 					"createAvailable": {
 						"type": "boolean",
 						"default": true,
···
 					}
 				}
 			},
-			"errors": [{ "name": "DuplicateCreate" }]
+			"errors": [
+				{
+					"name": "DuplicateCreate"
+				}
+			]
 		}
 	}
 }

lexdocs/bluesky/com/atproto/server/getSession.json packages/definitions/atproto/lexicons/com/atproto/server/getSession.json

···
 					"type": "object",
 					"required": ["handle", "did"],
 					"properties": {
-						"handle": { "type": "string", "format": "handle" },
-						"did": { "type": "string", "format": "did" },
-						"email": { "type": "string" },
-						"emailConfirmed": { "type": "boolean" },
-						"emailAuthFactor": { "type": "boolean" },
-						"didDoc": { "type": "unknown" },
-						"active": { "type": "boolean" },
+						"handle": {
+							"type": "string",
+							"format": "handle"
+						},
+						"did": {
+							"type": "string",
+							"format": "did"
+						},
+						"email": {
+							"type": "string"
+						},
+						"emailConfirmed": {
+							"type": "boolean"
+						},
+						"emailAuthFactor": {
+							"type": "boolean"
+						},
+						"didDoc": {
+							"type": "unknown"
+						},
+						"active": {
+							"type": "boolean"
+						},
 						"status": {
 							"type": "string",
 							"description": "If active=false, this optional field indicates a possible reason for why the account is not active. If active=false and no status is supplied, then the host makes no claim for why the repository is no longer being hosted.",

lexdocs/bluesky/com/atproto/server/listAppPasswords.json packages/definitions/atproto/lexicons/com/atproto/server/listAppPasswords.json

···
 					"properties": {
 						"passwords": {
 							"type": "array",
-							"items": { "type": "ref", "ref": "#appPassword" }
+							"items": {
+								"type": "ref",
+								"ref": "#appPassword"
+							}
 						}
 					}
 				}
 			},
-			"errors": [{ "name": "AccountTakedown" }]
+			"errors": [
+				{
+					"name": "AccountTakedown"
+				}
+			]
 		},
 		"appPassword": {
 			"type": "object",
 			"required": ["name", "createdAt"],
 			"properties": {
-				"name": { "type": "string" },
-				"createdAt": { "type": "string", "format": "datetime" },
-				"privileged": { "type": "boolean" }
+				"name": {
+					"type": "string"
+				},
+				"createdAt": {
+					"type": "string",
+					"format": "datetime"
+				},
+				"privileged": {
+					"type": "boolean"
+				}
 			}
 		}
 	}

lexdocs/bluesky/com/atproto/server/refreshSession.json

···
-{
-	"lexicon": 1,
-	"id": "com.atproto.server.refreshSession",
-	"defs": {
-		"main": {
-			"type": "procedure",
-			"description": "Refresh an authentication session. Requires auth using the 'refreshJwt' (not the 'accessJwt').",
-			"output": {
-				"encoding": "application/json",
-				"schema": {
-					"type": "object",
-					"required": ["accessJwt", "refreshJwt", "handle", "did"],
-					"properties": {
-						"accessJwt": { "type": "string" },
-						"refreshJwt": { "type": "string" },
-						"handle": { "type": "string", "format": "handle" },
-						"did": { "type": "string", "format": "did" },
-						"didDoc": { "type": "unknown" },
-						"active": { "type": "boolean" },
-						"status": {
-							"type": "string",
-							"description": "Hosting status of the account. If not specified, then assume 'active'.",
-							"knownValues": ["takendown", "suspended", "deactivated"]
-						}
-					}
-				}
-			},
-			"errors": [{ "name": "AccountTakedown" }]
-		}
-	}
-}

lexdocs/bluesky/com/atproto/server/requestEmailUpdate.json packages/definitions/atproto/lexicons/com/atproto/server/requestEmailUpdate.json

···
 					"type": "object",
 					"required": ["tokenRequired"],
 					"properties": {
-						"tokenRequired": { "type": "boolean" }
+						"tokenRequired": {
+							"type": "boolean"
+						}
 					}
 				}
 			}

lexdocs/bluesky/com/atproto/server/requestPasswordReset.json packages/definitions/atproto/lexicons/com/atproto/server/requestPasswordReset.json

···
 					"type": "object",
 					"required": ["email"],
 					"properties": {
-						"email": { "type": "string" }
+						"email": {
+							"type": "string"
+						}
 					}
 				}
 			}

lexdocs/bluesky/com/atproto/server/resetPassword.json packages/definitions/atproto/lexicons/com/atproto/server/resetPassword.json

···
 					"type": "object",
 					"required": ["token", "password"],
 					"properties": {
-						"token": { "type": "string" },
-						"password": { "type": "string" }
+						"token": {
+							"type": "string"
+						},
+						"password": {
+							"type": "string"
+						}
 					}
 				}
 			},
-			"errors": [{ "name": "ExpiredToken" }, { "name": "InvalidToken" }]
+			"errors": [
+				{
+					"name": "ExpiredToken"
+				},
+				{
+					"name": "InvalidToken"
+				}
+			]
 		}
 	}
 }

lexdocs/bluesky/com/atproto/server/revokeAppPassword.json packages/definitions/atproto/lexicons/com/atproto/server/revokeAppPassword.json

···
 					"type": "object",
 					"required": ["name"],
 					"properties": {
-						"name": { "type": "string" }
+						"name": {
+							"type": "string"
+						}
 					}
 				}
 			}

lexdocs/bluesky/com/atproto/server/updateEmail.json packages/definitions/atproto/lexicons/com/atproto/server/updateEmail.json

···
 					"type": "object",
 					"required": ["email"],
 					"properties": {
-						"email": { "type": "string" },
-						"emailAuthFactor": { "type": "boolean" },
+						"email": {
+							"type": "string"
+						},
+						"emailAuthFactor": {
+							"type": "boolean"
+						},
 						"token": {
 							"type": "string",
 							"description": "Requires a token from com.atproto.sever.requestEmailUpdate if the account's email has been confirmed."
···
 					}
 				}
 			},
-			"errors": [{ "name": "ExpiredToken" }, { "name": "InvalidToken" }, { "name": "TokenRequired" }]
+			"errors": [
+				{
+					"name": "ExpiredToken"
+				},
+				{
+					"name": "InvalidToken"
+				},
+				{
+					"name": "TokenRequired"
+				}
+			]
 		}
 	}
 }

lexdocs/bluesky/com/atproto/sync/getBlob.json packages/definitions/atproto/lexicons/com/atproto/sync/getBlob.json

···
 				"encoding": "*/*"
 			},
 			"errors": [
-				{ "name": "BlobNotFound" },
-				{ "name": "RepoNotFound" },
-				{ "name": "RepoTakendown" },
-				{ "name": "RepoSuspended" },
-				{ "name": "RepoDeactivated" }
+				{
+					"name": "BlobNotFound"
+				},
+				{
+					"name": "RepoNotFound"
+				},
+				{
+					"name": "RepoTakendown"
+				},
+				{
+					"name": "RepoSuspended"
+				},
+				{
+					"name": "RepoDeactivated"
+				}
 			]
 		}
 	}

lexdocs/bluesky/com/atproto/sync/getBlocks.json packages/definitions/atproto/lexicons/com/atproto/sync/getBlocks.json

···
 					},
 					"cids": {
 						"type": "array",
-						"items": { "type": "string", "format": "cid" }
+						"items": {
+							"type": "string",
+							"format": "cid"
+						}
 					}
 				}
 			},
···
 				"encoding": "application/vnd.ipld.car"
 			},
 			"errors": [
-				{ "name": "BlockNotFound" },
-				{ "name": "RepoNotFound" },
-				{ "name": "RepoTakendown" },
-				{ "name": "RepoSuspended" },
-				{ "name": "RepoDeactivated" }
+				{
+					"name": "BlockNotFound"
+				},
+				{
+					"name": "RepoNotFound"
+				},
+				{
+					"name": "RepoTakendown"
+				},
+				{
+					"name": "RepoSuspended"
+				},
+				{
+					"name": "RepoDeactivated"
+				}
 			]
 		}
 	}

lexdocs/bluesky/com/atproto/sync/getHead.json packages/definitions/atproto/lexicons/com/atproto/sync/getHead.json

···
 					"type": "object",
 					"required": ["root"],
 					"properties": {
-						"root": { "type": "string", "format": "cid" }
+						"root": {
+							"type": "string",
+							"format": "cid"
+						}
 					}
 				}
 			},
-			"errors": [{ "name": "HeadNotFound" }]
+			"errors": [
+				{
+					"name": "HeadNotFound"
+				}
+			]
 		}
 	}
 }

lexdocs/bluesky/com/atproto/sync/getHostStatus.json packages/definitions/atproto/lexicons/com/atproto/sync/getHostStatus.json

···
 					"type": "object",
 					"required": ["hostname"],
 					"properties": {
-						"hostname": { "type": "string" },
+						"hostname": {
+							"type": "string"
+						},
 						"seq": {
 							"type": "integer",
 							"description": "Recent repo stream event sequence number. May be delayed from actual stream processing (eg, persisted cursor not in-memory cursor)."
···
 					}
 				}
 			},
-			"errors": [{ "name": "HostNotFound" }]
+			"errors": [
+				{
+					"name": "HostNotFound"
+				}
+			]
 		}
 	}
 }

lexdocs/bluesky/com/atproto/sync/getLatestCommit.json packages/definitions/atproto/lexicons/com/atproto/sync/getLatestCommit.json

···
 					"type": "object",
 					"required": ["cid", "rev"],
 					"properties": {
-						"cid": { "type": "string", "format": "cid" },
-						"rev": { "type": "string", "format": "tid" }
+						"cid": {
+							"type": "string",
+							"format": "cid"
+						},
+						"rev": {
+							"type": "string",
+							"format": "tid"
+						}
 					}
 				}
 			},
 			"errors": [
-				{ "name": "RepoNotFound" },
-				{ "name": "RepoTakendown" },
-				{ "name": "RepoSuspended" },
-				{ "name": "RepoDeactivated" }
+				{
+					"name": "RepoNotFound"
+				},
+				{
+					"name": "RepoTakendown"
+				},
+				{
+					"name": "RepoSuspended"
+				},
+				{
+					"name": "RepoDeactivated"
+				}
 			]
 		}
 	}

lexdocs/bluesky/com/atproto/sync/getRecord.json packages/definitions/atproto/lexicons/com/atproto/sync/getRecord.json

···
 						"format": "did",
 						"description": "The DID of the repo."
 					},
-					"collection": { "type": "string", "format": "nsid" },
+					"collection": {
+						"type": "string",
+						"format": "nsid"
+					},
 					"rkey": {
 						"type": "string",
 						"description": "Record Key",
···
 				"encoding": "application/vnd.ipld.car"
 			},
 			"errors": [
-				{ "name": "RecordNotFound" },
-				{ "name": "RepoNotFound" },
-				{ "name": "RepoTakendown" },
-				{ "name": "RepoSuspended" },
-				{ "name": "RepoDeactivated" }
+				{
+					"name": "RecordNotFound"
+				},
+				{
+					"name": "RepoNotFound"
+				},
+				{
+					"name": "RepoTakendown"
+				},
+				{
+					"name": "RepoSuspended"
+				},
+				{
+					"name": "RepoDeactivated"
+				}
 			]
 		}
 	}

lexdocs/bluesky/com/atproto/sync/getRepo.json packages/definitions/atproto/lexicons/com/atproto/sync/getRepo.json

···
 				"encoding": "application/vnd.ipld.car"
 			},
 			"errors": [
-				{ "name": "RepoNotFound" },
-				{ "name": "RepoTakendown" },
-				{ "name": "RepoSuspended" },
-				{ "name": "RepoDeactivated" }
+				{
+					"name": "RepoNotFound"
+				},
+				{
+					"name": "RepoTakendown"
+				},
+				{
+					"name": "RepoSuspended"
+				},
+				{
+					"name": "RepoDeactivated"
+				}
 			]
 		}
 	}

lexdocs/bluesky/com/atproto/sync/getRepoStatus.json packages/definitions/atproto/lexicons/com/atproto/sync/getRepoStatus.json

···
 					"type": "object",
 					"required": ["did", "active"],
 					"properties": {
-						"did": { "type": "string", "format": "did" },
-						"active": { "type": "boolean" },
+						"did": {
+							"type": "string",
+							"format": "did"
+						},
+						"active": {
+							"type": "boolean"
+						},
 						"status": {
 							"type": "string",
 							"description": "If active=false, this optional field indicates a possible reason for why the account is not active. If active=false and no status is supplied, then the host makes no claim for why the repository is no longer being hosted.",
···
 					}
 				}
 			},
-			"errors": [{ "name": "RepoNotFound" }]
+			"errors": [
+				{
+					"name": "RepoNotFound"
+				}
+			]
 		}
 	}
 }

lexdocs/bluesky/com/atproto/sync/listBlobs.json packages/definitions/atproto/lexicons/com/atproto/sync/listBlobs.json

···
 						"maximum": 1000,
 						"default": 500
 					},
-					"cursor": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 					"type": "object",
 					"required": ["cids"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"cids": {
 							"type": "array",
-							"items": { "type": "string", "format": "cid" }
+							"items": {
+								"type": "string",
+								"format": "cid"
+							}
 						}
 					}
 				}
 			},
 			"errors": [
-				{ "name": "RepoNotFound" },
-				{ "name": "RepoTakendown" },
-				{ "name": "RepoSuspended" },
-				{ "name": "RepoDeactivated" }
+				{
+					"name": "RepoNotFound"
+				},
+				{
+					"name": "RepoTakendown"
+				},
+				{
+					"name": "RepoSuspended"
+				},
+				{
+					"name": "RepoDeactivated"
+				}
 			]
 		}
 	}

lexdocs/bluesky/com/atproto/sync/listHosts.json packages/definitions/atproto/lexicons/com/atproto/sync/listHosts.json

···
 						"maximum": 1000,
 						"default": 200
 					},
-					"cursor": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 					"type": "object",
 					"required": ["hosts"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"hosts": {
 							"type": "array",
-							"items": { "type": "ref", "ref": "#host" },
+							"items": {
+								"type": "ref",
+								"ref": "#host"
+							},
 							"description": "Sort order is not formally specified. Recommended order is by time host was first seen by the server, with oldest first."
 						}
 					}
···
 					"type": "integer",
 					"description": "Recent repo stream event sequence number. May be delayed from actual stream processing (eg, persisted cursor not in-memory cursor)."
 				},
-				"accountCount": { "type": "integer" },
+				"accountCount": {
+					"type": "integer"
+				},
 				"status": {
 					"type": "ref",
 					"ref": "com.atproto.sync.defs#hostStatus"

lexdocs/bluesky/com/atproto/sync/listRepos.json packages/definitions/atproto/lexicons/com/atproto/sync/listRepos.json

···
 						"maximum": 1000,
 						"default": 500
 					},
-					"cursor": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 					"type": "object",
 					"required": ["repos"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"repos": {
 							"type": "array",
-							"items": { "type": "ref", "ref": "#repo" }
+							"items": {
+								"type": "ref",
+								"ref": "#repo"
+							}
 						}
 					}
 				}
···
 			"type": "object",
 			"required": ["did", "head", "rev"],
 			"properties": {
-				"did": { "type": "string", "format": "did" },
+				"did": {
+					"type": "string",
+					"format": "did"
+				},
 				"head": {
 					"type": "string",
 					"format": "cid",
 					"description": "Current repo commit CID"
 				},
-				"rev": { "type": "string", "format": "tid" },
-				"active": { "type": "boolean" },
+				"rev": {
+					"type": "string",
+					"format": "tid"
+				},
+				"active": {
+					"type": "boolean"
+				},
 				"status": {
 					"type": "string",
 					"description": "If active=false, this optional field indicates a possible reason for why the account is not active. If active=false and no status is supplied, then the host makes no claim for why the repository is no longer being hosted.",

lexdocs/bluesky/com/atproto/sync/listReposByCollection.json packages/definitions/atproto/lexicons/com/atproto/sync/listReposByCollection.json

···
 				"type": "params",
 				"required": ["collection"],
 				"properties": {
-					"collection": { "type": "string", "format": "nsid" },
+					"collection": {
+						"type": "string",
+						"format": "nsid"
+					},
 					"limit": {
 						"type": "integer",
 						"description": "Maximum size of response set. Recommend setting a large maximum (1000+) when enumerating large DID lists.",
···
 						"maximum": 2000,
 						"default": 500
 					},
-					"cursor": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 					"type": "object",
 					"required": ["repos"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"repos": {
 							"type": "array",
-							"items": { "type": "ref", "ref": "#repo" }
+							"items": {
+								"type": "ref",
+								"ref": "#repo"
+							}
 						}
 					}
 				}
···
 			"type": "object",
 			"required": ["did"],
 			"properties": {
-				"did": { "type": "string", "format": "did" }
+				"did": {
+					"type": "string",
+					"format": "did"
+				}
 			}
 		}
 	}

lexdocs/bluesky/com/atproto/sync/requestCrawl.json packages/definitions/atproto/lexicons/com/atproto/sync/requestCrawl.json

···
 					}
 				}
 			},
-			"errors": [{ "name": "HostBanned" }]
+			"errors": [
+				{
+					"name": "HostBanned"
+				}
+			]
 		}
 	}
 }

lexdocs/bluesky/com/atproto/sync/subscribeRepos.json packages/definitions/atproto/lexicons/com/atproto/sync/subscribeRepos.json

···
 				}
 			},
 			"errors": [
-				{ "name": "FutureCursor" },
+				{
+					"name": "FutureCursor"
+				},
 				{
 					"name": "ConsumerTooSlow",
 					"description": "If the consumer of the stream can not keep up with events, and a backlog gets too large, the server will drop the connection."
···
 					"type": "integer",
 					"description": "The stream sequence number of this message."
 				},
-				"rebase": { "type": "boolean", "description": "DEPRECATED -- unused" },
+				"rebase": {
+					"type": "boolean",
+					"description": "DEPRECATED -- unused"
+				},
 				"tooBig": {
 					"type": "boolean",
 					"description": "DEPRECATED -- replaced by #sync event and data limits. Indicates that this commit contained too many ops, or data size was too large. Consumers will need to make a separate request to get missing data."
···
 			"description": "Represents a change to an account's identity. Could be an updated handle, signing key, or pds hosting endpoint. Serves as a prod to all downstream services to refresh their identity cache.",
 			"required": ["seq", "did", "time"],
 			"properties": {
-				"seq": { "type": "integer" },
-				"did": { "type": "string", "format": "did" },
-				"time": { "type": "string", "format": "datetime" },
+				"seq": {
+					"type": "integer"
+				},
+				"did": {
+					"type": "string",
+					"format": "did"
+				},
+				"time": {
+					"type": "string",
+					"format": "datetime"
+				},
 				"handle": {
 					"type": "string",
 					"format": "handle",
···
 			"description": "Represents a change to an account's status on a host (eg, PDS or Relay). The semantics of this event are that the status is at the host which emitted the event, not necessarily that at the currently active PDS. Eg, a Relay takedown would emit a takedown with active=false, even if the PDS is still active.",
 			"required": ["seq", "did", "time", "active"],
 			"properties": {
-				"seq": { "type": "integer" },
-				"did": { "type": "string", "format": "did" },
-				"time": { "type": "string", "format": "datetime" },
+				"seq": {
+					"type": "integer"
+				},
+				"did": {
+					"type": "string",
+					"format": "did"
+				},
+				"time": {
+					"type": "string",
+					"format": "datetime"
+				},
 				"active": {
 					"type": "boolean",
 					"description": "Indicates that the account has a repository which can be fetched from the host that emitted this event."
···
 					"type": "string",
 					"knownValues": ["create", "update", "delete"]
 				},
-				"path": { "type": "string" },
+				"path": {
+					"type": "string"
+				},
 				"cid": {
 					"type": "cid-link",
 					"description": "For creates and updates, the new record CID. For deletions, null."

lexdocs/bluesky/com/atproto/temp/addReservedHandle.json packages/definitions/atproto/lexicons/com/atproto/temp/addReservedHandle.json

···
 					"type": "object",
 					"required": ["handle"],
 					"properties": {
-						"handle": { "type": "string" }
+						"handle": {
+							"type": "string"
+						}
 					}
 				}
 			},

lexdocs/bluesky/com/atproto/temp/checkSignupQueue.json packages/definitions/atproto/lexicons/com/atproto/temp/checkSignupQueue.json

···
 					"type": "object",
 					"required": ["activated"],
 					"properties": {
-						"activated": { "type": "boolean" },
-						"placeInQueue": { "type": "integer" },
-						"estimatedTimeMs": { "type": "integer" }
+						"activated": {
+							"type": "boolean"
+						},
+						"placeInQueue": {
+							"type": "integer"
+						},
+						"estimatedTimeMs": {
+							"type": "integer"
+						}
 					}
 				}
 			}

lexdocs/bluesky/com/atproto/temp/fetchLabels.json packages/definitions/atproto/lexicons/com/atproto/temp/fetchLabels.json

···
 			"parameters": {
 				"type": "params",
 				"properties": {
-					"since": { "type": "integer" },
+					"since": {
+						"type": "integer"
+					},
 					"limit": {
 						"type": "integer",
 						"minimum": 1,
···
 					"properties": {
 						"labels": {
 							"type": "array",
-							"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+							"items": {
+								"type": "ref",
+								"ref": "com.atproto.label.defs#label"
+							}
 						}
 					}
 				}

lexdocs/bluesky/com/atproto/temp/requestPhoneVerification.json packages/definitions/atproto/lexicons/com/atproto/temp/requestPhoneVerification.json

···
 					"type": "object",
 					"required": ["phoneNumber"],
 					"properties": {
-						"phoneNumber": { "type": "string" }
+						"phoneNumber": {
+							"type": "string"
+						}
 					}
 				}
 			}

lexdocs/bluesky/tools/ozone/communication/createTemplate.json packages/definitions/ozone/lexicons/tools/ozone/communication/createTemplate.json

···
 					"ref": "tools.ozone.communication.defs#templateView"
 				}
 			},
-			"errors": [{ "name": "DuplicateTemplateName" }]
+			"errors": [
+				{
+					"name": "DuplicateTemplateName"
+				}
+			]
 		}
 	}
 }

lexdocs/bluesky/tools/ozone/communication/defs.json packages/definitions/ozone/lexicons/tools/ozone/communication/defs.json

···
 			"type": "object",
 			"required": ["id", "name", "contentMarkdown", "disabled", "lastUpdatedBy", "createdAt", "updatedAt"],
 			"properties": {
-				"id": { "type": "string" },
-				"name": { "type": "string", "description": "Name of the template." },
+				"id": {
+					"type": "string"
+				},
+				"name": {
+					"type": "string",
+					"description": "Name of the template."
+				},
 				"subject": {
 					"type": "string",
 					"description": "Content of the template, can contain markdown and variable placeholders."
···
 					"type": "string",
 					"description": "Subject of the message, used in emails."
 				},
-				"disabled": { "type": "boolean" },
+				"disabled": {
+					"type": "boolean"
+				},
 				"lang": {
 					"type": "string",
 					"format": "language",
···
 					"format": "did",
 					"description": "DID of the user who last updated the template."
 				},
-				"createdAt": { "type": "string", "format": "datetime" },
-				"updatedAt": { "type": "string", "format": "datetime" }
+				"createdAt": {
+					"type": "string",
+					"format": "datetime"
+				},
+				"updatedAt": {
+					"type": "string",
+					"format": "datetime"
+				}
 			}
 		}
 	}

lexdocs/bluesky/tools/ozone/communication/deleteTemplate.json packages/definitions/ozone/lexicons/tools/ozone/communication/deleteTemplate.json

···
 					"type": "object",
 					"required": ["id"],
 					"properties": {
-						"id": { "type": "string" }
+						"id": {
+							"type": "string"
+						}
 					}
 				}
 			}

lexdocs/bluesky/tools/ozone/communication/updateTemplate.json packages/definitions/ozone/lexicons/tools/ozone/communication/updateTemplate.json

···
 					"ref": "tools.ozone.communication.defs#templateView"
 				}
 			},
-			"errors": [{ "name": "DuplicateTemplateName" }]
+			"errors": [
+				{
+					"name": "DuplicateTemplateName"
+				}
+			]
 		}
 	}
 }

lexdocs/bluesky/tools/ozone/hosting/getAccountHistory.json packages/definitions/ozone/lexicons/tools/ozone/hosting/getAccountHistory.json

···
 				"type": "params",
 				"required": ["did"],
 				"properties": {
-					"did": { "type": "string", "format": "did" },
+					"did": {
+						"type": "string",
+						"format": "did"
+					},
 					"events": {
 						"type": "array",
 						"items": {
···
 							]
 						}
 					},
-					"cursor": { "type": "string" },
+					"cursor": {
+						"type": "string"
+					},
 					"limit": {
 						"type": "integer",
 						"minimum": 1,
···
 					"type": "object",
 					"required": ["events"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"events": {
 							"type": "array",
 							"items": {
···
 						"#handleUpdated"
 					]
 				},
-				"createdBy": { "type": "string" },
-				"createdAt": { "type": "string", "format": "datetime" }
+				"createdBy": {
+					"type": "string"
+				},
+				"createdAt": {
+					"type": "string",
+					"format": "datetime"
+				}
 			}
 		},
 		"accountCreated": {
 			"type": "object",
 			"required": [],
 			"properties": {
-				"email": { "type": "string" },
-				"handle": { "type": "string", "format": "handle" }
+				"email": {
+					"type": "string"
+				},
+				"handle": {
+					"type": "string",
+					"format": "handle"
+				}
 			}
 		},
 		"emailUpdated": {
 			"type": "object",
 			"required": ["email"],
 			"properties": {
-				"email": { "type": "string" }
+				"email": {
+					"type": "string"
+				}
 			}
 		},
 		"emailConfirmed": {
 			"type": "object",
 			"required": ["email"],
 			"properties": {
-				"email": { "type": "string" }
+				"email": {
+					"type": "string"
+				}
 			}
 		},
 		"passwordUpdated": {
···
 			"type": "object",
 			"required": ["handle"],
 			"properties": {
-				"handle": { "type": "string", "format": "handle" }
+				"handle": {
+					"type": "string",
+					"format": "handle"
+				}
 			}
 		}
 	}

lexdocs/bluesky/tools/ozone/moderation/cancelScheduledActions.json packages/definitions/ozone/lexicons/tools/ozone/moderation/cancelScheduledActions.json

···
 			"properties": {
 				"succeeded": {
 					"type": "array",
-					"items": { "type": "string", "format": "did" },
+					"items": {
+						"type": "string",
+						"format": "did"
+					},
 					"description": "DIDs for which all pending scheduled actions were successfully cancelled"
 				},
 				"failed": {
 					"type": "array",
-					"items": { "type": "ref", "ref": "#failedCancellation" },
+					"items": {
+						"type": "ref",
+						"ref": "#failedCancellation"
+					},
 					"description": "DIDs for which cancellation failed with error details"
 				}
 			}
···
 			"type": "object",
 			"required": ["did", "error"],
 			"properties": {
-				"did": { "type": "string", "format": "did" },
-				"error": { "type": "string" },
-				"errorCode": { "type": "string" }
+				"did": {
+					"type": "string",
+					"format": "did"
+				},
+				"error": {
+					"type": "string"
+				},
+				"errorCode": {
+					"type": "string"
+				}
 			}
 		}
 	}

lexdocs/bluesky/tools/ozone/moderation/defs.json packages/definitions/ozone/lexicons/tools/ozone/moderation/defs.json

···
 			"type": "object",
 			"required": ["id", "event", "subject", "subjectBlobCids", "createdBy", "createdAt"],
 			"properties": {
-				"id": { "type": "integer" },
+				"id": {
+					"type": "integer"
+				},
 				"event": {
 					"type": "union",
 					"refs": [
···
 						"chat.bsky.convo.defs#messageRef"
 					]
 				},
-				"subjectBlobCids": { "type": "array", "items": { "type": "string" } },
-				"createdBy": { "type": "string", "format": "did" },
-				"createdAt": { "type": "string", "format": "datetime" },
-				"creatorHandle": { "type": "string" },
-				"subjectHandle": { "type": "string" },
-				"modTool": { "type": "ref", "ref": "#modTool" }
+				"subjectBlobCids": {
+					"type": "array",
+					"items": {
+						"type": "string"
+					}
+				},
+				"createdBy": {
+					"type": "string",
+					"format": "did"
+				},
+				"createdAt": {
+					"type": "string",
+					"format": "datetime"
+				},
+				"creatorHandle": {
+					"type": "string"
+				},
+				"subjectHandle": {
+					"type": "string"
+				},
+				"modTool": {
+					"type": "ref",
+					"ref": "#modTool"
+				}
 			}
 		},
 		"modEventViewDetail": {
 			"type": "object",
 			"required": ["id", "event", "subject", "subjectBlobs", "createdBy", "createdAt"],
 			"properties": {
-				"id": { "type": "integer" },
+				"id": {
+					"type": "integer"
+				},
 				"event": {
 					"type": "union",
 					"refs": [
···
 				},
 				"subjectBlobs": {
 					"type": "array",
-					"items": { "type": "ref", "ref": "#blobView" }
+					"items": {
+						"type": "ref",
+						"ref": "#blobView"
+					}
+				},
+				"createdBy": {
+					"type": "string",
+					"format": "did"
 				},
-				"createdBy": { "type": "string", "format": "did" },
-				"createdAt": { "type": "string", "format": "datetime" },
-				"modTool": { "type": "ref", "ref": "#modTool" }
+				"createdAt": {
+					"type": "string",
+					"format": "datetime"
+				},
+				"modTool": {
+					"type": "ref",
+					"ref": "#modTool"
+				}
 			}
 		},
 		"subjectStatusView": {
 			"type": "object",
 			"required": ["id", "subject", "createdAt", "updatedAt", "reviewState"],
 			"properties": {
-				"id": { "type": "integer" },
+				"id": {
+					"type": "integer"
+				},
 				"subject": {
 					"type": "union",
 					"refs": [
···
 				},
 				"subjectBlobCids": {
 					"type": "array",
-					"items": { "type": "string", "format": "cid" }
+					"items": {
+						"type": "string",
+						"format": "cid"
+					}
+				},
+				"subjectRepoHandle": {
+					"type": "string"
 				},
-				"subjectRepoHandle": { "type": "string" },
 				"updatedAt": {
 					"type": "string",
 					"format": "datetime",
···
 				},
 				"tags": {
 					"type": "array",
-					"items": { "type": "string" }
+					"items": {
+						"type": "string"
+					}
 				},
 				"accountStats": {
 					"description": "Statistics related to the account subject",
···
 				"policies": {
 					"type": "array",
 					"maxLength": 5,
-					"items": { "type": "string" },
+					"items": {
+						"type": "string"
+					},
 					"description": "Names/Keywords of the policies that drove the decision."
 				},
 				"severityLevel": {
 					"type": "string",
 					"description": "Severity level of the violation (e.g., 'sev-0', 'sev-1', 'sev-2', etc.)."
 				},
+				"targetServices": {
+					"type": "array",
+					"items": {
+						"type": "string",
+						"knownValues": ["appview", "pds"]
+					},
+					"description": "List of services where the takedown should be applied. If empty or not provided, takedown is applied on all configured services."
+				},
 				"strikeCount": {
 					"type": "integer",
 					"description": "Number of strikes to assign to the user for this violation."
···
 				"policies": {
 					"type": "array",
 					"maxLength": 5,
-					"items": { "type": "string" },
+					"items": {
+						"type": "string"
+					},
 					"description": "Names/Keywords of the policy infraction for which takedown is being reversed."
 				},
 				"severityLevel": {
···
 				},
 				"createLabelVals": {
 					"type": "array",
-					"items": { "type": "string" }
+					"items": {
+						"type": "string"
+					}
 				},
 				"negateLabelVals": {
 					"type": "array",
-					"items": { "type": "string" }
+					"items": {
+						"type": "string"
+					}
 				},
 				"durationInHours": {
 					"type": "integer",
···
 		"modEventAcknowledge": {
 			"type": "object",
 			"properties": {
-				"comment": { "type": "string" },
+				"comment": {
+					"type": "string"
+				},
 				"acknowledgeAccountSubjects": {
 					"type": "boolean",
 					"description": "If true, all other reports on content authored by this account will be resolved (acknowledged)."
···
 		"modEventEscalate": {
 			"type": "object",
 			"properties": {
-				"comment": { "type": "string" }
+				"comment": {
+					"type": "string"
+				}
 			}
 		},
 		"modEventMute": {
···
 			"description": "Mute incoming reports on a subject",
 			"required": ["durationInHours"],
 			"properties": {
-				"comment": { "type": "string" },
+				"comment": {
+					"type": "string"
+				},
 				"durationInHours": {
 					"type": "integer",
 					"description": "Indicates how long the subject should remain muted."
···
 			"type": "object",
 			"description": "Mute incoming reports from an account",
 			"properties": {
-				"comment": { "type": "string" },
+				"comment": {
+					"type": "string"
+				},
 				"durationInHours": {
 					"type": "integer",
 					"description": "Indicates how long the account should remain muted. Falsy value here means a permanent mute."
···
 				"policies": {
 					"type": "array",
 					"maxLength": 5,
-					"items": { "type": "string" },
+					"items": {
+						"type": "string"
+					},
 					"description": "Names/Keywords of the policies that necessitated the email."
 				},
 				"severityLevel": {
···
 					"type": "string",
 					"format": "datetime",
 					"description": "When the strike should expire. If not provided, the strike never expires."
+				},
+				"isDelivered": {
+					"type": "boolean",
+					"description": "Indicates whether the email was successfully delivered to the user's inbox."
 				}
 			}
 		},
···
 			"type": "object",
 			"description": "Divert a record's blobs to a 3rd party service for further scanning/tagging",
 			"properties": {
-				"comment": { "type": "string" }
+				"comment": {
+					"type": "string"
+				}
 			}
 		},
 		"modEventTag": {
···
 			"properties": {
 				"add": {
 					"type": "array",
-					"items": { "type": "string" },
+					"items": {
+						"type": "string"
+					},
 					"description": "Tags to be added to the subject. If already exists, won't be duplicated."
 				},
 				"remove": {
 					"type": "array",
-					"items": { "type": "string" },
+					"items": {
+						"type": "string"
+					},
 					"description": "Tags to be removed to the subject. Ignores a tag If it doesn't exist, won't be duplicated."
 				},
 				"comment": {
···
 			"description": "Logs account status related events on a repo subject. Normally captured by automod from the firehose and emitted to ozone for historical tracking.",
 			"required": ["timestamp", "active"],
 			"properties": {
-				"comment": { "type": "string" },
+				"comment": {
+					"type": "string"
+				},
 				"active": {
 					"type": "boolean",
 					"description": "Indicates that the account has a repository which can be fetched from the host that emitted this event."
···
 			"description": "Logs identity related events on a repo subject. Normally captured by automod from the firehose and emitted to ozone for historical tracking.",
 			"required": ["timestamp"],
 			"properties": {
-				"comment": { "type": "string" },
-				"handle": { "type": "string", "format": "handle" },
-				"pdsHost": { "type": "string", "format": "uri" },
-				"tombstone": { "type": "boolean" },
+				"comment": {
+					"type": "string"
+				},
+				"handle": {
+					"type": "string",
+					"format": "handle"
+				},
+				"pdsHost": {
+					"type": "string",
+					"format": "uri"
+				},
+				"tombstone": {
+					"type": "boolean"
+				},
 				"timestamp": {
 					"type": "string",
 					"format": "datetime"
···
 			"description": "Logs lifecycle event on a record subject. Normally captured by automod from the firehose and emitted to ozone for historical tracking.",
 			"required": ["timestamp", "op"],
 			"properties": {
-				"comment": { "type": "string" },
+				"comment": {
+					"type": "string"
+				},
 				"op": {
 					"type": "string",
 					"knownValues": ["create", "update", "delete"]
 				},
-				"cid": { "type": "string", "format": "cid" },
-				"timestamp": { "type": "string", "format": "datetime" }
+				"cid": {
+					"type": "string",
+					"format": "cid"
+				},
+				"timestamp": {
+					"type": "string",
+					"format": "datetime"
+				}
 			}
 		},
 		"scheduleTakedownEvent": {
 			"type": "object",
 			"description": "Logs a scheduled takedown action for an account.",
 			"properties": {
-				"comment": { "type": "string" },
-				"executeAt": { "type": "string", "format": "datetime" },
-				"executeAfter": { "type": "string", "format": "datetime" },
-				"executeUntil": { "type": "string", "format": "datetime" }
+				"comment": {
+					"type": "string"
+				},
+				"executeAt": {
+					"type": "string",
+					"format": "datetime"
+				},
+				"executeAfter": {
+					"type": "string",
+					"format": "datetime"
+				},
+				"executeUntil": {
+					"type": "string",
+					"format": "datetime"
+				}
 			}
 		},
 		"cancelScheduledTakedownEvent": {
 			"type": "object",
 			"description": "Logs cancellation of a scheduled takedown action for an account.",
 			"properties": {
-				"comment": { "type": "string" }
+				"comment": {
+					"type": "string"
+				}
 			}
 		},
 		"repoView": {
 			"type": "object",
 			"required": ["did", "handle", "relatedRecords", "indexedAt", "moderation"],
 			"properties": {
-				"did": { "type": "string", "format": "did" },
-				"handle": { "type": "string", "format": "handle" },
-				"email": { "type": "string" },
-				"relatedRecords": { "type": "array", "items": { "type": "unknown" } },
-				"indexedAt": { "type": "string", "format": "datetime" },
-				"moderation": { "type": "ref", "ref": "#moderation" },
+				"did": {
+					"type": "string",
+					"format": "did"
+				},
+				"handle": {
+					"type": "string",
+					"format": "handle"
+				},
+				"email": {
+					"type": "string"
+				},
+				"relatedRecords": {
+					"type": "array",
+					"items": {
+						"type": "unknown"
+					}
+				},
+				"indexedAt": {
+					"type": "string",
+					"format": "datetime"
+				},
+				"moderation": {
+					"type": "ref",
+					"ref": "#moderation"
+				},
 				"invitedBy": {
 					"type": "ref",
 					"ref": "com.atproto.server.defs#inviteCode"
 				},
-				"invitesDisabled": { "type": "boolean" },
-				"inviteNote": { "type": "string" },
-				"deactivatedAt": { "type": "string", "format": "datetime" },
+				"invitesDisabled": {
+					"type": "boolean"
+				},
+				"inviteNote": {
+					"type": "string"
+				},
+				"deactivatedAt": {
+					"type": "string",
+					"format": "datetime"
+				},
 				"threatSignatures": {
 					"type": "array",
 					"items": {
···
 			"type": "object",
 			"required": ["did", "handle", "relatedRecords", "indexedAt", "moderation"],
 			"properties": {
-				"did": { "type": "string", "format": "did" },
-				"handle": { "type": "string", "format": "handle" },
-				"email": { "type": "string" },
-				"relatedRecords": { "type": "array", "items": { "type": "unknown" } },
-				"indexedAt": { "type": "string", "format": "datetime" },
-				"moderation": { "type": "ref", "ref": "#moderationDetail" },
+				"did": {
+					"type": "string",
+					"format": "did"
+				},
+				"handle": {
+					"type": "string",
+					"format": "handle"
+				},
+				"email": {
+					"type": "string"
+				},
+				"relatedRecords": {
+					"type": "array",
+					"items": {
+						"type": "unknown"
+					}
+				},
+				"indexedAt": {
+					"type": "string",
+					"format": "datetime"
+				},
+				"moderation": {
+					"type": "ref",
+					"ref": "#moderationDetail"
+				},
 				"labels": {
 					"type": "array",
-					"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+					"items": {
+						"type": "ref",
+						"ref": "com.atproto.label.defs#label"
+					}
 				},
 				"invitedBy": {
 					"type": "ref",
···
 						"ref": "com.atproto.server.defs#inviteCode"
 					}
 				},
-				"invitesDisabled": { "type": "boolean" },
-				"inviteNote": { "type": "string" },
-				"emailConfirmedAt": { "type": "string", "format": "datetime" },
-				"deactivatedAt": { "type": "string", "format": "datetime" },
+				"invitesDisabled": {
+					"type": "boolean"
+				},
+				"inviteNote": {
+					"type": "string"
+				},
+				"emailConfirmedAt": {
+					"type": "string",
+					"format": "datetime"
+				},
+				"deactivatedAt": {
+					"type": "string",
+					"format": "datetime"
+				},
 				"threatSignatures": {
 					"type": "array",
 					"items": {
···
 			"type": "object",
 			"required": ["did"],
 			"properties": {
-				"did": { "type": "string", "format": "did" }
+				"did": {
+					"type": "string",
+					"format": "did"
+				}
 			}
 		},
 		"recordView": {
 			"type": "object",
 			"required": ["uri", "cid", "value", "blobCids", "indexedAt", "moderation", "repo"],
 			"properties": {
-				"uri": { "type": "string", "format": "at-uri" },
-				"cid": { "type": "string", "format": "cid" },
-				"value": { "type": "unknown" },
+				"uri": {
+					"type": "string",
+					"format": "at-uri"
+				},
+				"cid": {
+					"type": "string",
+					"format": "cid"
+				},
+				"value": {
+					"type": "unknown"
+				},
 				"blobCids": {
 					"type": "array",
-					"items": { "type": "string", "format": "cid" }
+					"items": {
+						"type": "string",
+						"format": "cid"
+					}
+				},
+				"indexedAt": {
+					"type": "string",
+					"format": "datetime"
 				},
-				"indexedAt": { "type": "string", "format": "datetime" },
-				"moderation": { "type": "ref", "ref": "#moderation" },
-				"repo": { "type": "ref", "ref": "#repoView" }
+				"moderation": {
+					"type": "ref",
+					"ref": "#moderation"
+				},
+				"repo": {
+					"type": "ref",
+					"ref": "#repoView"
+				}
 			}
 		},
 		"recordViewDetail": {
 			"type": "object",
 			"required": ["uri", "cid", "value", "blobs", "indexedAt", "moderation", "repo"],
 			"properties": {
-				"uri": { "type": "string", "format": "at-uri" },
-				"cid": { "type": "string", "format": "cid" },
-				"value": { "type": "unknown" },
+				"uri": {
+					"type": "string",
+					"format": "at-uri"
+				},
+				"cid": {
+					"type": "string",
+					"format": "cid"
+				},
+				"value": {
+					"type": "unknown"
+				},
 				"blobs": {
 					"type": "array",
-					"items": { "type": "ref", "ref": "#blobView" }
+					"items": {
+						"type": "ref",
+						"ref": "#blobView"
+					}
 				},
 				"labels": {
 					"type": "array",
-					"items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+					"items": {
+						"type": "ref",
+						"ref": "com.atproto.label.defs#label"
+					}
 				},
-				"indexedAt": { "type": "string", "format": "datetime" },
-				"moderation": { "type": "ref", "ref": "#moderationDetail" },
-				"repo": { "type": "ref", "ref": "#repoView" }
+				"indexedAt": {
+					"type": "string",
+					"format": "datetime"
+				},
+				"moderation": {
+					"type": "ref",
+					"ref": "#moderationDetail"
+				},
+				"repo": {
+					"type": "ref",
+					"ref": "#repoView"
+				}
 			}
 		},
 		"recordViewNotFound": {
 			"type": "object",
 			"required": ["uri"],
 			"properties": {
-				"uri": { "type": "string", "format": "at-uri" }
+				"uri": {
+					"type": "string",
+					"format": "at-uri"
+				}
 			}
 		},
 		"moderation": {
 			"type": "object",
 			"properties": {
-				"subjectStatus": { "type": "ref", "ref": "#subjectStatusView" }
+				"subjectStatus": {
+					"type": "ref",
+					"ref": "#subjectStatusView"
+				}
 			}
 		},
 		"moderationDetail": {
···
 			"type": "object",
 			"required": ["cid", "mimeType", "size", "createdAt"],
 			"properties": {
-				"cid": { "type": "string", "format": "cid" },
-				"mimeType": { "type": "string" },
-				"size": { "type": "integer" },
-				"createdAt": { "type": "string", "format": "datetime" },
+				"cid": {
+					"type": "string",
+					"format": "cid"
+				},
+				"mimeType": {
+					"type": "string"
+				},
+				"size": {
+					"type": "integer"
+				},
+				"createdAt": {
+					"type": "string",
+					"format": "datetime"
+				},
 				"details": {
 					"type": "union",
 					"refs": ["#imageDetails", "#videoDetails"]
 				},
-				"moderation": { "type": "ref", "ref": "#moderation" }
+				"moderation": {
+					"type": "ref",
+					"ref": "#moderation"
+				}
 			}
 		},
 		"imageDetails": {
 			"type": "object",
 			"required": ["width", "height"],
 			"properties": {
-				"width": { "type": "integer" },
-				"height": { "type": "integer" }
+				"width": {
+					"type": "integer"
+				},
+				"height": {
+					"type": "integer"
+				}
 			}
 		},
 		"videoDetails": {
 			"type": "object",
 			"required": ["width", "height", "length"],
 			"properties": {
-				"width": { "type": "integer" },
-				"height": { "type": "integer" },
-				"length": { "type": "integer" }
+				"width": {
+					"type": "integer"
+				},
+				"height": {
+					"type": "integer"
+				},
+				"length": {
+					"type": "integer"
+				}
 			}
 		},
 		"accountHosting": {

lexdocs/bluesky/tools/ozone/moderation/getEvent.json packages/definitions/ozone/lexicons/tools/ozone/moderation/getEvent.json

···
 				"type": "params",
 				"required": ["id"],
 				"properties": {
-					"id": { "type": "integer" }
+					"id": {
+						"type": "integer"
+					}
 				}
 			},
 			"output": {

lexdocs/bluesky/tools/ozone/moderation/getRecord.json packages/definitions/ozone/lexicons/tools/ozone/moderation/getRecord.json

···
 				"type": "params",
 				"required": ["uri"],
 				"properties": {
-					"uri": { "type": "string", "format": "at-uri" },
-					"cid": { "type": "string", "format": "cid" }
+					"uri": {
+						"type": "string",
+						"format": "at-uri"
+					},
+					"cid": {
+						"type": "string",
+						"format": "cid"
+					}
 				}
 			},
 			"output": {
···
 					"ref": "tools.ozone.moderation.defs#recordViewDetail"
 				}
 			},
-			"errors": [{ "name": "RecordNotFound" }]
+			"errors": [
+				{
+					"name": "RecordNotFound"
+				}
+			]
 		}
 	}
 }

lexdocs/bluesky/tools/ozone/moderation/getRepo.json packages/definitions/ozone/lexicons/tools/ozone/moderation/getRepo.json

···
 				"type": "params",
 				"required": ["did"],
 				"properties": {
-					"did": { "type": "string", "format": "did" }
+					"did": {
+						"type": "string",
+						"format": "did"
+					}
 				}
 			},
 			"output": {
···
 					"ref": "tools.ozone.moderation.defs#repoViewDetail"
 				}
 			},
-			"errors": [{ "name": "RepoNotFound" }]
+			"errors": [
+				{
+					"name": "RepoNotFound"
+				}
+			]
 		}
 	}
 }

lexdocs/bluesky/tools/ozone/moderation/queryStatuses.json packages/definitions/ozone/lexicons/tools/ozone/moderation/queryStatuses.json

···
 					},
 					"reviewState": {
 						"type": "string",
-						"description": "Specify when fetching subjects in a certain state"
+						"description": "Specify when fetching subjects in a certain state",
+						"knownValues": [
+							"tools.ozone.moderation.defs#reviewOpen",
+							"tools.ozone.moderation.defs#reviewClosed",
+							"tools.ozone.moderation.defs#reviewEscalated",
+							"tools.ozone.moderation.defs#reviewNone"
+						]
 					},
 					"ignoreSubjects": {
 						"type": "array",

lexdocs/bluesky/tools/ozone/moderation/scheduleAction.json packages/definitions/ozone/lexicons/tools/ozone/moderation/scheduleAction.json

···
 						"type": "string"
 					},
 					"description": "Names/Keywords of the policies that drove the decision."
+				},
+				"severityLevel": {
+					"type": "string",
+					"description": "Severity level of the violation (e.g., 'sev-0', 'sev-1', 'sev-2', etc.)."
+				},
+				"strikeCount": {
+					"type": "integer",
+					"description": "Number of strikes to assign to the user when takedown is applied."
+				},
+				"strikeExpiresAt": {
+					"type": "string",
+					"format": "datetime",
+					"description": "When the strike should expire. If not provided, the strike never expires."
+				},
+				"emailContent": {
+					"type": "string",
+					"description": "Email content to be sent to the user upon takedown."
+				},
+				"emailSubject": {
+					"type": "string",
+					"description": "Subject of the email to be sent to the user upon takedown."
 				}
 			}
 		},

lexdocs/bluesky/tools/ozone/moderation/searchRepos.json packages/definitions/ozone/lexicons/tools/ozone/moderation/searchRepos.json

···
 						"type": "string",
 						"description": "DEPRECATED: use 'q' instead"
 					},
-					"q": { "type": "string" },
+					"q": {
+						"type": "string"
+					},
 					"limit": {
 						"type": "integer",
 						"minimum": 1,
 						"maximum": 100,
 						"default": 50
 					},
-					"cursor": { "type": "string" }
+					"cursor": {
+						"type": "string"
+					}
 				}
 			},
 			"output": {
···
 					"type": "object",
 					"required": ["repos"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"repos": {
 							"type": "array",
 							"items": {

lexdocs/bluesky/tools/ozone/report/defs.json packages/definitions/ozone/lexicons/tools/ozone/report/defs.json

···
 			"knownValues": [
 				"tools.ozone.report.defs#reasonAppeal",
 				"tools.ozone.report.defs#reasonOther",
-
 				"tools.ozone.report.defs#reasonViolenceAnimal",
 				"tools.ozone.report.defs#reasonViolenceThreats",
 				"tools.ozone.report.defs#reasonViolenceGraphicContent",
···
 				"tools.ozone.report.defs#reasonViolenceExtremistContent",
 				"tools.ozone.report.defs#reasonViolenceTrafficking",
 				"tools.ozone.report.defs#reasonViolenceOther",
-
 				"tools.ozone.report.defs#reasonSexualAbuseContent",
 				"tools.ozone.report.defs#reasonSexualNCII",
 				"tools.ozone.report.defs#reasonSexualDeepfake",
 				"tools.ozone.report.defs#reasonSexualAnimal",
 				"tools.ozone.report.defs#reasonSexualUnlabeled",
 				"tools.ozone.report.defs#reasonSexualOther",
-
 				"tools.ozone.report.defs#reasonChildSafetyCSAM",
 				"tools.ozone.report.defs#reasonChildSafetyGroom",
 				"tools.ozone.report.defs#reasonChildSafetyPrivacy",
 				"tools.ozone.report.defs#reasonChildSafetyHarassment",
 				"tools.ozone.report.defs#reasonChildSafetyOther",
-
 				"tools.ozone.report.defs#reasonHarassmentTroll",
 				"tools.ozone.report.defs#reasonHarassmentTargeted",
 				"tools.ozone.report.defs#reasonHarassmentHateSpeech",
 				"tools.ozone.report.defs#reasonHarassmentDoxxing",
 				"tools.ozone.report.defs#reasonHarassmentOther",
-
 				"tools.ozone.report.defs#reasonMisleadingBot",
 				"tools.ozone.report.defs#reasonMisleadingImpersonation",
 				"tools.ozone.report.defs#reasonMisleadingSpam",
 				"tools.ozone.report.defs#reasonMisleadingScam",
 				"tools.ozone.report.defs#reasonMisleadingElections",
 				"tools.ozone.report.defs#reasonMisleadingOther",
-
 				"tools.ozone.report.defs#reasonRuleSiteSecurity",
 				"tools.ozone.report.defs#reasonRuleProhibitedSales",
 				"tools.ozone.report.defs#reasonRuleBanEvasion",
 				"tools.ozone.report.defs#reasonRuleOther",
-
 				"tools.ozone.report.defs#reasonSelfHarmContent",
 				"tools.ozone.report.defs#reasonSelfHarmED",
 				"tools.ozone.report.defs#reasonSelfHarmStunts",
···
 			"type": "token",
 			"description": "Other violent content"
 		},
-
 		"reasonSexualAbuseContent": {
 			"type": "token",
 			"description": "Adult sexual abuse content"
···
 			"type": "token",
 			"description": "Other sexual violence content"
 		},
-
 		"reasonChildSafetyCSAM": {
 			"type": "token",
 			"description": "Child sexual abuse material (CSAM). These reports will be sent only be sent to the application's Moderation Authority."
···
 			"type": "token",
 			"description": "Other child safety. These reports will be sent only be sent to the application's Moderation Authority."
 		},
-
 		"reasonHarassmentTroll": {
 			"type": "token",
 			"description": "Trolling"
···
 			"type": "token",
 			"description": "Other harassing or hateful content"
 		},
-
 		"reasonMisleadingBot": {
 			"type": "token",
 			"description": "Fake account or bot"
···
 			"type": "token",
 			"description": "Other misleading content"
 		},
-
 		"reasonRuleSiteSecurity": {
 			"type": "token",
 			"description": "Hacking or system attacks"

lexdocs/bluesky/tools/ozone/signature/defs.json packages/definitions/ozone/lexicons/tools/ozone/signature/defs.json

···
 			"type": "object",
 			"required": ["property", "value"],
 			"properties": {
-				"property": { "type": "string" },
-				"value": { "type": "string" }
+				"property": {
+					"type": "string"
+				},
+				"value": {
+					"type": "string"
+				}
 			}
 		}
 	}

lexdocs/bluesky/tools/ozone/signature/findRelatedAccounts.json packages/definitions/ozone/lexicons/tools/ozone/signature/findRelatedAccounts.json

···
 						"type": "string",
 						"format": "did"
 					},
-					"cursor": { "type": "string" },
+					"cursor": {
+						"type": "string"
+					},
 					"limit": {
 						"type": "integer",
 						"minimum": 1,
···
 					"type": "object",
 					"required": ["accounts"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"accounts": {
 							"type": "array",
 							"items": {

lexdocs/bluesky/tools/ozone/signature/searchAccounts.json packages/definitions/ozone/lexicons/tools/ozone/signature/searchAccounts.json

···
 							"type": "string"
 						}
 					},
-					"cursor": { "type": "string" },
+					"cursor": {
+						"type": "string"
+					},
 					"limit": {
 						"type": "integer",
 						"minimum": 1,
···
 					"type": "object",
 					"required": ["accounts"],
 					"properties": {
-						"cursor": { "type": "string" },
+						"cursor": {
+							"type": "string"
+						},
 						"accounts": {
 							"type": "array",
 							"items": {

lexdocs/bluesky/tools/ozone/team/addMember.json packages/definitions/ozone/lexicons/tools/ozone/team/addMember.json

···
 					"type": "object",
 					"required": ["did", "role"],
 					"properties": {
-						"did": { "type": "string", "format": "did" },
+						"did": {
+							"type": "string",
+							"format": "did"
+						},
 						"role": {
 							"type": "string",
 							"knownValues": [

lexdocs/bluesky/tools/ozone/team/defs.json packages/definitions/ozone/lexicons/tools/ozone/team/defs.json

···
 			"type": "object",
 			"required": ["did", "role"],
 			"properties": {
-				"did": { "type": "string", "format": "did" },
-				"disabled": { "type": "boolean" },
+				"did": {
+					"type": "string",
+					"format": "did"
+				},
+				"disabled": {
+					"type": "boolean"
+				},
 				"profile": {
 					"type": "ref",
 					"ref": "app.bsky.actor.defs#profileViewDetailed"
 				},
-				"createdAt": { "type": "string", "format": "datetime" },
-				"updatedAt": { "type": "string", "format": "datetime" },
-				"lastUpdatedBy": { "type": "string" },
+				"createdAt": {
+					"type": "string",
+					"format": "datetime"
+				},
+				"updatedAt": {
+					"type": "string",
+					"format": "datetime"
+				},
+				"lastUpdatedBy": {
+					"type": "string"
+				},
 				"role": {
 					"type": "string",
 					"knownValues": ["#roleAdmin", "#roleModerator", "#roleTriage", "#roleVerifier"]

lexdocs/bluesky/tools/ozone/team/deleteMember.json packages/definitions/ozone/lexicons/tools/ozone/team/deleteMember.json

···
 					"type": "object",
 					"required": ["did"],
 					"properties": {
-						"did": { "type": "string", "format": "did" }
+						"did": {
+							"type": "string",
+							"format": "did"
+						}
 					}
 				}
 			},

lexdocs/bluesky/tools/ozone/team/updateMember.json packages/definitions/ozone/lexicons/tools/ozone/team/updateMember.json

···
 					"type": "object",
 					"required": ["did"],
 					"properties": {
-						"did": { "type": "string", "format": "did" },
-						"disabled": { "type": "boolean" },
+						"did": {
+							"type": "string",
+							"format": "did"
+						},
+						"disabled": {
+							"type": "boolean"
+						},
 						"role": {
 							"type": "string",
 							"knownValues": [

lexdocs/frontpage/README.md

···
-https://github.com/likeandscribe/frontpage/tree/ad5d8e1a76ed8353afb3ccc0ef83a64ecd67c676/lexicons/fyi/unravel/frontpage/

lexdocs/frontpage/comment.json packages/definitions/frontpage/lexicons/fyi/unravel/frontpage/comment.json

···
 						"format": "datetime",
 						"description": "Client-declared timestamp when this comment was originally created."
 					},
-					"parent": { "type": "ref", "ref": "com.atproto.repo.strongRef" },
-					"post": { "type": "ref", "ref": "com.atproto.repo.strongRef" }
+					"parent": {
+						"type": "ref",
+						"ref": "com.atproto.repo.strongRef"
+					},
+					"post": {
+						"type": "ref",
+						"ref": "com.atproto.repo.strongRef"
+					}
 				}
 			}
 		}

lexdocs/frontpage/vote.json packages/definitions/frontpage/lexicons/fyi/unravel/frontpage/vote.json

···
 				"type": "object",
 				"required": ["subject", "createdAt"],
 				"properties": {
-					"subject": { "type": "ref", "ref": "com.atproto.repo.strongRef" },
+					"subject": {
+						"type": "ref",
+						"ref": "com.atproto.repo.strongRef"
+					},
 					"createdAt": {
 						"type": "string",
 						"format": "datetime",

lexdocs/leaflet/README.md

···
-https://github.com/hyperlink-academy/leaflet/tree/fb3fe27c3b8f8c0146899add899cc49a76673029/lexicons/pub/leaflet/

lexdocs/lexcom/README.md

···
-https://github.com/lexicon-community/lexicon/tree/2bf2cbbfd3058d710f8c468307ef7e003bc22383/community/lexicon/

lexdocs/tangled/README.md

···
-https://github.com/mary-ext/tangled.sh-mirror/tree/7ed8a10067d69edc97679e0f42eeb51e646dd893/lexicons/

lexdocs/whtwnd/README.md

···
-https://github.com/whtwnd/whitewind-blog/tree/dc4b802154250b982191a52af1d1c9913c3b62e7/lexicons/com/whtwnd/

package.json

···
 	"private": true,
 	"type": "module",
 	"scripts": {
-		"pull": "node ./scripts/pull-lexicons.js",
-		"pull:bluemoji": "node ./scripts/pull-bluemoji-lexicons.js",
-		"pull:frontpage": "node ./scripts/pull-frontpage-lexicons.js",
-		"pull:leaflet": "node ./scripts/pull-leaflet-lexicons.js",
-		"pull:lexcom": "node ./scripts/pull-lexcom-lexicons.js",
-		"pull:tangled": "node ./scripts/pull-tangled-lexicons.js",
-		"pull:whtwnd": "node ./scripts/pull-whtwnd-lexicons.js",
 		"fmt": "PRETTIER_EXPERIMENTAL_CLI=1 prettier --cache --write ."
 	},
 	"devDependencies": {

packages/definitions/atproto/lex.config.js

···
 import { defineLexiconConfig } from '@atcute/lex-cli';
 
 export default defineLexiconConfig({
-	files: ['../../../lexdocs/bluesky/com/atproto/**/*.json'],
+	files: ['lexicons/**/*.json'],
 	outdir: 'lib/lexicons/',
+
+	pull: {
+		outdir: 'lexicons/',
+		clean: true,
+		sources: [
+			{
+				type: 'git',
+				remote: 'https://github.com/bluesky-social/atproto.git',
+				pattern: ['lexicons/com/atproto/**/*.json'],
+			},
+		],
+	},
 });

packages/definitions/atproto/lexicons/README.md

···
+# lexicon sources
+
+this directory contains lexicon documents pulled from the following sources:
+
+- https://github.com/bluesky-social/atproto.git
+  - commit: 0748d919d127d68ee8c8aeb130b477e3dd5a9be6

packages/definitions/atproto/lexicons/com/atproto/admin/defs.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.admin.defs",
+	"defs": {
+		"statusAttr": {
+			"type": "object",
+			"required": ["applied"],
+			"properties": {
+				"applied": {
+					"type": "boolean"
+				},
+				"ref": {
+					"type": "string"
+				}
+			}
+		},
+		"accountView": {
+			"type": "object",
+			"required": ["did", "handle", "indexedAt"],
+			"properties": {
+				"did": {
+					"type": "string",
+					"format": "did"
+				},
+				"handle": {
+					"type": "string",
+					"format": "handle"
+				},
+				"email": {
+					"type": "string"
+				},
+				"relatedRecords": {
+					"type": "array",
+					"items": {
+						"type": "unknown"
+					}
+				},
+				"indexedAt": {
+					"type": "string",
+					"format": "datetime"
+				},
+				"invitedBy": {
+					"type": "ref",
+					"ref": "com.atproto.server.defs#inviteCode"
+				},
+				"invites": {
+					"type": "array",
+					"items": {
+						"type": "ref",
+						"ref": "com.atproto.server.defs#inviteCode"
+					}
+				},
+				"invitesDisabled": {
+					"type": "boolean"
+				},
+				"emailConfirmedAt": {
+					"type": "string",
+					"format": "datetime"
+				},
+				"inviteNote": {
+					"type": "string"
+				},
+				"deactivatedAt": {
+					"type": "string",
+					"format": "datetime"
+				},
+				"threatSignatures": {
+					"type": "array",
+					"items": {
+						"type": "ref",
+						"ref": "#threatSignature"
+					}
+				}
+			}
+		},
+		"repoRef": {
+			"type": "object",
+			"required": ["did"],
+			"properties": {
+				"did": {
+					"type": "string",
+					"format": "did"
+				}
+			}
+		},
+		"repoBlobRef": {
+			"type": "object",
+			"required": ["did", "cid"],
+			"properties": {
+				"did": {
+					"type": "string",
+					"format": "did"
+				},
+				"cid": {
+					"type": "string",
+					"format": "cid"
+				},
+				"recordUri": {
+					"type": "string",
+					"format": "at-uri"
+				}
+			}
+		},
+		"threatSignature": {
+			"type": "object",
+			"required": ["property", "value"],
+			"properties": {
+				"property": {
+					"type": "string"
+				},
+				"value": {
+					"type": "string"
+				}
+			}
+		}
+	}
+}

packages/definitions/atproto/lexicons/com/atproto/repo/defs.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.repo.defs",
+	"defs": {
+		"commitMeta": {
+			"type": "object",
+			"required": ["cid", "rev"],
+			"properties": {
+				"cid": {
+					"type": "string",
+					"format": "cid"
+				},
+				"rev": {
+					"type": "string",
+					"format": "tid"
+				}
+			}
+		}
+	}
+}

packages/definitions/atproto/lexicons/com/atproto/server/checkAccountStatus.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.server.checkAccountStatus",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Returns the status of an account, especially as pertaining to import or recovery. Can be called many times over the course of an account migration. Requires auth and can only be called pertaining to oneself.",
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": [
+						"activated",
+						"validDid",
+						"repoCommit",
+						"repoRev",
+						"repoBlocks",
+						"indexedRecords",
+						"privateStateValues",
+						"expectedBlobs",
+						"importedBlobs"
+					],
+					"properties": {
+						"activated": {
+							"type": "boolean"
+						},
+						"validDid": {
+							"type": "boolean"
+						},
+						"repoCommit": {
+							"type": "string",
+							"format": "cid"
+						},
+						"repoRev": {
+							"type": "string"
+						},
+						"repoBlocks": {
+							"type": "integer"
+						},
+						"indexedRecords": {
+							"type": "integer"
+						},
+						"privateStateValues": {
+							"type": "integer"
+						},
+						"expectedBlobs": {
+							"type": "integer"
+						},
+						"importedBlobs": {
+							"type": "integer"
+						}
+					}
+				}
+			}
+		}
+	}
+}

packages/definitions/atproto/lexicons/com/atproto/server/defs.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.server.defs",
+	"defs": {
+		"inviteCode": {
+			"type": "object",
+			"required": ["code", "available", "disabled", "forAccount", "createdBy", "createdAt", "uses"],
+			"properties": {
+				"code": {
+					"type": "string"
+				},
+				"available": {
+					"type": "integer"
+				},
+				"disabled": {
+					"type": "boolean"
+				},
+				"forAccount": {
+					"type": "string"
+				},
+				"createdBy": {
+					"type": "string"
+				},
+				"createdAt": {
+					"type": "string",
+					"format": "datetime"
+				},
+				"uses": {
+					"type": "array",
+					"items": {
+						"type": "ref",
+						"ref": "#inviteCodeUse"
+					}
+				}
+			}
+		},
+		"inviteCodeUse": {
+			"type": "object",
+			"required": ["usedBy", "usedAt"],
+			"properties": {
+				"usedBy": {
+					"type": "string",
+					"format": "did"
+				},
+				"usedAt": {
+					"type": "string",
+					"format": "datetime"
+				}
+			}
+		}
+	}
+}

packages/definitions/atproto/lexicons/com/atproto/server/refreshSession.json

···
+{
+	"lexicon": 1,
+	"id": "com.atproto.server.refreshSession",
+	"defs": {
+		"main": {
+			"type": "procedure",
+			"description": "Refresh an authentication session. Requires auth using the 'refreshJwt' (not the 'accessJwt').",
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["accessJwt", "refreshJwt", "handle", "did"],
+					"properties": {
+						"accessJwt": {
+							"type": "string"
+						},
+						"refreshJwt": {
+							"type": "string"
+						},
+						"handle": {
+							"type": "string",
+							"format": "handle"
+						},
+						"did": {
+							"type": "string",
+							"format": "did"
+						},
+						"didDoc": {
+							"type": "unknown"
+						},
+						"active": {
+							"type": "boolean"
+						},
+						"status": {
+							"type": "string",
+							"description": "Hosting status of the account. If not specified, then assume 'active'.",
+							"knownValues": ["takendown", "suspended", "deactivated"]
+						}
+					}
+				}
+			},
+			"errors": [
+				{
+					"name": "AccountTakedown"
+				}
+			]
+		}
+	}
+}

packages/definitions/atproto/package.json

···
 	},
 	"scripts": {
 		"build": "tsc",
+		"pull": "lex-cli pull -c ./lex.config.js",
 		"generate": "rm -r ./lib/lexicons/; lex-cli generate -c ./lex.config.js",
 		"prepublish": "rm -rf dist; pnpm run build"
 	},

packages/definitions/bluemoji/lex.config.js

···
 import { defineLexiconConfig } from '@atcute/lex-cli';
 
 export default defineLexiconConfig({
-	files: ['../../../lexdocs/bluemoji/**/*.json'],
+	files: ['lexicons/**/*.json'],
 	outdir: 'lib/lexicons/',
 	imports: ['@atcute/atproto', '@atcute/bluesky'],
+
+	// pull: {
+	// 	outdir: 'lexicons/',
+	// 	clean: true,
+	// 	sources: [
+	// 		{
+	// 			type: 'git',
+	// 			remote: 'https://github.com/aendra-rininsland/bluemoji.git',
+	// 			pattern: ['schema/**/*.json'],
+	// 		},
+	// 	],
+	// },
 });

packages/definitions/bluesky/lex.config.js

···
 import { defineLexiconConfig } from '@atcute/lex-cli';
 
 export default defineLexiconConfig({
-	files: ['../../../lexdocs/bluesky/app/bsky/**/*.json', '../../../lexdocs/bluesky/chat/bsky/**/*.json'],
+	files: ['lexicons/**/*.json'],
 	outdir: 'lib/lexicons/',
 	imports: ['@atcute/atproto'],
+
+	pull: {
+		outdir: 'lexicons/',
+		clean: true,
+		sources: [
+			{
+				type: 'git',
+				remote: 'https://github.com/bluesky-social/atproto.git',
+				pattern: ['lexicons/app/bsky/**/*.json', 'lexicons/chat/bsky/**/*.json'],
+			},
+		],
+	},
 });

packages/definitions/bluesky/lexicons/README.md

···
+# lexicon sources
+
+this directory contains lexicon documents pulled from the following sources:
+
+- https://github.com/bluesky-social/atproto.git
+  - commit: 0748d919d127d68ee8c8aeb130b477e3dd5a9be6

packages/definitions/bluesky/lexicons/app/bsky/feed/like.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.feed.like",
+	"defs": {
+		"main": {
+			"type": "record",
+			"description": "Record declaring a 'like' of a piece of subject content.",
+			"key": "tid",
+			"record": {
+				"type": "object",
+				"required": ["subject", "createdAt"],
+				"properties": {
+					"subject": {
+						"type": "ref",
+						"ref": "com.atproto.repo.strongRef"
+					},
+					"createdAt": {
+						"type": "string",
+						"format": "datetime"
+					},
+					"via": {
+						"type": "ref",
+						"ref": "com.atproto.repo.strongRef"
+					}
+				}
+			}
+		}
+	}
+}

packages/definitions/bluesky/lexicons/app/bsky/feed/repost.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.feed.repost",
+	"defs": {
+		"main": {
+			"description": "Record representing a 'repost' of an existing Bluesky post.",
+			"type": "record",
+			"key": "tid",
+			"record": {
+				"type": "object",
+				"required": ["subject", "createdAt"],
+				"properties": {
+					"subject": {
+						"type": "ref",
+						"ref": "com.atproto.repo.strongRef"
+					},
+					"createdAt": {
+						"type": "string",
+						"format": "datetime"
+					},
+					"via": {
+						"type": "ref",
+						"ref": "com.atproto.repo.strongRef"
+					}
+				}
+			}
+		}
+	}
+}

packages/definitions/bluesky/lexicons/app/bsky/graph/defs.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.graph.defs",
+	"defs": {
+		"listViewBasic": {
+			"type": "object",
+			"required": ["uri", "cid", "name", "purpose"],
+			"properties": {
+				"uri": {
+					"type": "string",
+					"format": "at-uri"
+				},
+				"cid": {
+					"type": "string",
+					"format": "cid"
+				},
+				"name": {
+					"type": "string",
+					"maxLength": 64,
+					"minLength": 1
+				},
+				"purpose": {
+					"type": "ref",
+					"ref": "#listPurpose"
+				},
+				"avatar": {
+					"type": "string",
+					"format": "uri"
+				},
+				"listItemCount": {
+					"type": "integer",
+					"minimum": 0
+				},
+				"labels": {
+					"type": "array",
+					"items": {
+						"type": "ref",
+						"ref": "com.atproto.label.defs#label"
+					}
+				},
+				"viewer": {
+					"type": "ref",
+					"ref": "#listViewerState"
+				},
+				"indexedAt": {
+					"type": "string",
+					"format": "datetime"
+				}
+			}
+		},
+		"listView": {
+			"type": "object",
+			"required": ["uri", "cid", "creator", "name", "purpose", "indexedAt"],
+			"properties": {
+				"uri": {
+					"type": "string",
+					"format": "at-uri"
+				},
+				"cid": {
+					"type": "string",
+					"format": "cid"
+				},
+				"creator": {
+					"type": "ref",
+					"ref": "app.bsky.actor.defs#profileView"
+				},
+				"name": {
+					"type": "string",
+					"maxLength": 64,
+					"minLength": 1
+				},
+				"purpose": {
+					"type": "ref",
+					"ref": "#listPurpose"
+				},
+				"description": {
+					"type": "string",
+					"maxGraphemes": 300,
+					"maxLength": 3000
+				},
+				"descriptionFacets": {
+					"type": "array",
+					"items": {
+						"type": "ref",
+						"ref": "app.bsky.richtext.facet"
+					}
+				},
+				"avatar": {
+					"type": "string",
+					"format": "uri"
+				},
+				"listItemCount": {
+					"type": "integer",
+					"minimum": 0
+				},
+				"labels": {
+					"type": "array",
+					"items": {
+						"type": "ref",
+						"ref": "com.atproto.label.defs#label"
+					}
+				},
+				"viewer": {
+					"type": "ref",
+					"ref": "#listViewerState"
+				},
+				"indexedAt": {
+					"type": "string",
+					"format": "datetime"
+				}
+			}
+		},
+		"listItemView": {
+			"type": "object",
+			"required": ["uri", "subject"],
+			"properties": {
+				"uri": {
+					"type": "string",
+					"format": "at-uri"
+				},
+				"subject": {
+					"type": "ref",
+					"ref": "app.bsky.actor.defs#profileView"
+				}
+			}
+		},
+		"starterPackView": {
+			"type": "object",
+			"required": ["uri", "cid", "record", "creator", "indexedAt"],
+			"properties": {
+				"uri": {
+					"type": "string",
+					"format": "at-uri"
+				},
+				"cid": {
+					"type": "string",
+					"format": "cid"
+				},
+				"record": {
+					"type": "unknown"
+				},
+				"creator": {
+					"type": "ref",
+					"ref": "app.bsky.actor.defs#profileViewBasic"
+				},
+				"list": {
+					"type": "ref",
+					"ref": "#listViewBasic"
+				},
+				"listItemsSample": {
+					"type": "array",
+					"maxLength": 12,
+					"items": {
+						"type": "ref",
+						"ref": "#listItemView"
+					}
+				},
+				"feeds": {
+					"type": "array",
+					"maxLength": 3,
+					"items": {
+						"type": "ref",
+						"ref": "app.bsky.feed.defs#generatorView"
+					}
+				},
+				"joinedWeekCount": {
+					"type": "integer",
+					"minimum": 0
+				},
+				"joinedAllTimeCount": {
+					"type": "integer",
+					"minimum": 0
+				},
+				"labels": {
+					"type": "array",
+					"items": {
+						"type": "ref",
+						"ref": "com.atproto.label.defs#label"
+					}
+				},
+				"indexedAt": {
+					"type": "string",
+					"format": "datetime"
+				}
+			}
+		},
+		"starterPackViewBasic": {
+			"type": "object",
+			"required": ["uri", "cid", "record", "creator", "indexedAt"],
+			"properties": {
+				"uri": {
+					"type": "string",
+					"format": "at-uri"
+				},
+				"cid": {
+					"type": "string",
+					"format": "cid"
+				},
+				"record": {
+					"type": "unknown"
+				},
+				"creator": {
+					"type": "ref",
+					"ref": "app.bsky.actor.defs#profileViewBasic"
+				},
+				"listItemCount": {
+					"type": "integer",
+					"minimum": 0
+				},
+				"joinedWeekCount": {
+					"type": "integer",
+					"minimum": 0
+				},
+				"joinedAllTimeCount": {
+					"type": "integer",
+					"minimum": 0
+				},
+				"labels": {
+					"type": "array",
+					"items": {
+						"type": "ref",
+						"ref": "com.atproto.label.defs#label"
+					}
+				},
+				"indexedAt": {
+					"type": "string",
+					"format": "datetime"
+				}
+			}
+		},
+		"listPurpose": {
+			"type": "string",
+			"knownValues": [
+				"app.bsky.graph.defs#modlist",
+				"app.bsky.graph.defs#curatelist",
+				"app.bsky.graph.defs#referencelist"
+			]
+		},
+		"modlist": {
+			"type": "token",
+			"description": "A list of actors to apply an aggregate moderation action (mute/block) on."
+		},
+		"curatelist": {
+			"type": "token",
+			"description": "A list of actors used for curation purposes such as list feeds or interaction gating."
+		},
+		"referencelist": {
+			"type": "token",
+			"description": "A list of actors used for only for reference purposes such as within a starter pack."
+		},
+		"listViewerState": {
+			"type": "object",
+			"properties": {
+				"muted": {
+					"type": "boolean"
+				},
+				"blocked": {
+					"type": "string",
+					"format": "at-uri"
+				}
+			}
+		},
+		"notFoundActor": {
+			"type": "object",
+			"description": "indicates that a handle or DID could not be resolved",
+			"required": ["actor", "notFound"],
+			"properties": {
+				"actor": {
+					"type": "string",
+					"format": "at-identifier"
+				},
+				"notFound": {
+					"type": "boolean",
+					"const": true
+				}
+			}
+		},
+		"relationship": {
+			"type": "object",
+			"description": "lists the bi-directional graph relationships between one actor (not indicated in the object), and the target actors (the DID included in the object)",
+			"required": ["did"],
+			"properties": {
+				"did": {
+					"type": "string",
+					"format": "did"
+				},
+				"following": {
+					"type": "string",
+					"format": "at-uri",
+					"description": "if the actor follows this DID, this is the AT-URI of the follow record"
+				},
+				"followedBy": {
+					"type": "string",
+					"format": "at-uri",
+					"description": "if the actor is followed by this DID, contains the AT-URI of the follow record"
+				}
+			}
+		}
+	}
+}

packages/definitions/bluesky/lexicons/app/bsky/notification/defs.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.notification.defs",
+	"defs": {
+		"recordDeleted": {
+			"type": "object",
+			"properties": {}
+		},
+		"chatPreference": {
+			"type": "object",
+			"required": ["include", "push"],
+			"properties": {
+				"include": {
+					"type": "string",
+					"knownValues": ["all", "accepted"]
+				},
+				"push": {
+					"type": "boolean"
+				}
+			}
+		},
+		"filterablePreference": {
+			"type": "object",
+			"required": ["include", "list", "push"],
+			"properties": {
+				"include": {
+					"type": "string",
+					"knownValues": ["all", "follows"]
+				},
+				"list": {
+					"type": "boolean"
+				},
+				"push": {
+					"type": "boolean"
+				}
+			}
+		},
+		"preference": {
+			"type": "object",
+			"required": ["list", "push"],
+			"properties": {
+				"list": {
+					"type": "boolean"
+				},
+				"push": {
+					"type": "boolean"
+				}
+			}
+		},
+		"preferences": {
+			"type": "object",
+			"required": [
+				"chat",
+				"follow",
+				"like",
+				"likeViaRepost",
+				"mention",
+				"quote",
+				"reply",
+				"repost",
+				"repostViaRepost",
+				"starterpackJoined",
+				"subscribedPost",
+				"unverified",
+				"verified"
+			],
+			"properties": {
+				"chat": {
+					"type": "ref",
+					"ref": "#chatPreference"
+				},
+				"follow": {
+					"type": "ref",
+					"ref": "#filterablePreference"
+				},
+				"like": {
+					"type": "ref",
+					"ref": "#filterablePreference"
+				},
+				"likeViaRepost": {
+					"type": "ref",
+					"ref": "#filterablePreference"
+				},
+				"mention": {
+					"type": "ref",
+					"ref": "#filterablePreference"
+				},
+				"quote": {
+					"type": "ref",
+					"ref": "#filterablePreference"
+				},
+				"reply": {
+					"type": "ref",
+					"ref": "#filterablePreference"
+				},
+				"repost": {
+					"type": "ref",
+					"ref": "#filterablePreference"
+				},
+				"repostViaRepost": {
+					"type": "ref",
+					"ref": "#filterablePreference"
+				},
+				"starterpackJoined": {
+					"type": "ref",
+					"ref": "#preference"
+				},
+				"subscribedPost": {
+					"type": "ref",
+					"ref": "#preference"
+				},
+				"unverified": {
+					"type": "ref",
+					"ref": "#preference"
+				},
+				"verified": {
+					"type": "ref",
+					"ref": "#preference"
+				}
+			}
+		},
+		"activitySubscription": {
+			"type": "object",
+			"required": ["post", "reply"],
+			"properties": {
+				"post": {
+					"type": "boolean"
+				},
+				"reply": {
+					"type": "boolean"
+				}
+			}
+		},
+		"subjectActivitySubscription": {
+			"description": "Object used to store activity subscription data in stash.",
+			"type": "object",
+			"required": ["subject", "activitySubscription"],
+			"properties": {
+				"subject": {
+					"type": "string",
+					"format": "did"
+				},
+				"activitySubscription": {
+					"type": "ref",
+					"ref": "#activitySubscription"
+				}
+			}
+		}
+	}
+}

packages/definitions/bluesky/lexicons/app/bsky/video/getUploadLimits.json

···
+{
+	"lexicon": 1,
+	"id": "app.bsky.video.getUploadLimits",
+	"defs": {
+		"main": {
+			"type": "query",
+			"description": "Get video upload limits for the authenticated user.",
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["canUpload"],
+					"properties": {
+						"canUpload": {
+							"type": "boolean"
+						},
+						"remainingDailyVideos": {
+							"type": "integer"
+						},
+						"remainingDailyBytes": {
+							"type": "integer"
+						},
+						"message": {
+							"type": "string"
+						},
+						"error": {
+							"type": "string"
+						}
+					}
+				}
+			}
+		}
+	}
+}

packages/definitions/bluesky/lexicons/chat/bsky/moderation/getActorMetadata.json

···
+{
+	"lexicon": 1,
+	"id": "chat.bsky.moderation.getActorMetadata",
+	"defs": {
+		"main": {
+			"type": "query",
+			"parameters": {
+				"type": "params",
+				"required": ["actor"],
+				"properties": {
+					"actor": {
+						"type": "string",
+						"format": "did"
+					}
+				}
+			},
+			"output": {
+				"encoding": "application/json",
+				"schema": {
+					"type": "object",
+					"required": ["day", "month", "all"],
+					"properties": {
+						"day": {
+							"type": "ref",
+							"ref": "#metadata"
+						},
+						"month": {
+							"type": "ref",
+							"ref": "#metadata"
+						},
+						"all": {
+							"type": "ref",
+							"ref": "#metadata"
+						}
+					}
+				}
+			}
+		},
+		"metadata": {
+			"type": "object",
+			"required": ["messagesSent", "messagesReceived", "convos", "convosStarted"],
+			"properties": {
+				"messagesSent": {
+					"type": "integer"
+				},
+				"messagesReceived": {
+					"type": "integer"
+				},
+				"convos": {
+					"type": "integer"
+				},
+				"convosStarted": {
+					"type": "integer"
+				}
+			}
+		}
+	}
+}

packages/definitions/bluesky/package.json

···
 	},
 	"scripts": {
 		"build": "tsc --project tsconfig.build.json",
+		"pull": "lex-cli pull -c ./lex.config.js",
 		"test": "vitest",
 		"generate": "rm -r ./lib/lexicons/; lex-cli generate -c ./lex.config.js",
 		"prepublish": "rm -rf dist; pnpm run build"

packages/definitions/frontpage/lex.config.js

···
 import { defineLexiconConfig } from '@atcute/lex-cli';
 
 export default defineLexiconConfig({
-	files: ['../../../lexdocs/frontpage/**/*.json'],
+	files: ['lexicons/**/*.json'],
 	outdir: 'lib/lexicons/',
 	imports: ['@atcute/atproto'],
+
+	pull: {
+		outdir: 'lexicons/',
+		clean: true,
+		sources: [
+			{
+				type: 'git',
+				remote: 'https://github.com/frontpagefyi/frontpage.git',
+				pattern: ['lexicons/**/*.json', '!lexicons/com/atproto/**'],
+			},
+		],
+	},
 });

packages/definitions/frontpage/lexicons/README.md

···
+# lexicon sources
+
+this directory contains lexicon documents pulled from the following sources:
+
+- https://github.com/frontpagefyi/frontpage.git
+  - commit: b8c3431c11f009d381a89f89c254c34f9e0e342c

packages/definitions/frontpage/lexicons/fyi/frontpage/feed/comment.json

···
+{
+	"lexicon": 1,
+	"id": "fyi.frontpage.feed.comment",
+	"defs": {
+		"main": {
+			"type": "record",
+			"description": "Record containing a Frontpage comment.",
+			"key": "tid",
+			"record": {
+				"type": "object",
+				"required": ["createdAt", "post", "blocks"],
+				"properties": {
+					"blocks": {
+						"type": "array",
+						"maxLength": 200,
+						"description": "The content of the comment. Note, there are additional constraints placed on the total size of the content within the Frontpage AppView that are not possible to express in lexicon. Generally a comment can have a maximum length of 10,000 graphemes, the Frontpage AppView will enforce this limit.",
+						"items": {
+							"type": "ref",
+							"ref": "fyi.frontpage.richtext.block"
+						}
+					},
+					"createdAt": {
+						"type": "string",
+						"format": "datetime",
+						"description": "Client-declared timestamp when this comment was originally created."
+					},
+					"parent": {
+						"type": "ref",
+						"ref": "com.atproto.repo.strongRef"
+					},
+					"post": {
+						"type": "ref",
+						"ref": "com.atproto.repo.strongRef"
+					}
+				}
+			}
+		}
+	}
+}

packages/definitions/frontpage/lexicons/fyi/frontpage/feed/post.json

···
+{
+	"lexicon": 1,
+	"id": "fyi.frontpage.feed.post",
+	"defs": {
+		"main": {
+			"type": "record",
+			"description": "Record containing a Frontpage post.",
+			"key": "tid",
+			"record": {
+				"type": "object",
+				"required": ["title", "createdAt", "subject"],
+				"properties": {
+					"title": {
+						"type": "string",
+						"maxLength": 3000,
+						"maxGraphemes": 300,
+						"description": "The title of the post."
+					},
+					"subject": {
+						"type": "union",
+						"description": "The piece of content that this Frontpage post is about.",
+						"refs": ["#urlSubject"]
+					},
+					"createdAt": {
+						"type": "string",
+						"format": "datetime",
+						"description": "Client-declared timestamp when this post was originally created."
+					}
+				}
+			}
+		},
+		"urlSubject": {
+			"type": "object",
+			"required": ["url"],
+			"properties": {
+				"url": {
+					"type": "string",
+					"format": "uri"
+				}
+			}
+		}
+	}
+}

packages/definitions/frontpage/lexicons/fyi/frontpage/feed/vote.json

···
+{
+	"lexicon": 1,
+	"id": "fyi.frontpage.feed.vote",
+	"defs": {
+		"main": {
+			"type": "record",
+			"description": "Record containing a Frontpage vote.",
+			"key": "tid",
+			"record": {
+				"type": "object",
+				"required": ["subject", "createdAt"],
+				"properties": {
+					"subject": {
+						"type": "ref",
+						"description": "The post or comment that this Frontpage vote is for.",
+						"ref": "com.atproto.repo.strongRef"
+					},
+					"createdAt": {
+						"type": "string",
+						"format": "datetime",
+						"description": "Client-declared timestamp when this vote was originally created."
+					}
+				}
+			}
+		}
+	}
+}

packages/definitions/frontpage/lexicons/fyi/frontpage/richtext/block.json

···
+{
+	"lexicon": 1,
+	"id": "fyi.frontpage.richtext.block",
+	"defs": {
+		"main": {
+			"type": "object",
+			"required": ["content"],
+			"properties": {
+				"content": {
+					"type": "union",
+					"refs": ["#plaintextParagraph"]
+				}
+			}
+		},
+		"plaintextParagraph": {
+			"type": "object",
+			"required": ["text"],
+			"properties": {
+				"text": {
+					"type": "string",
+					"maxLength": 100000,
+					"maxGraphemes": 10000
+				}
+			}
+		}
+	}
+}

packages/definitions/frontpage/lib/lexicons/index.ts

···
+export * as FyiFrontpageFeedComment from './types/fyi/frontpage/feed/comment.js';
+export * as FyiFrontpageFeedPost from './types/fyi/frontpage/feed/post.js';
+export * as FyiFrontpageFeedVote from './types/fyi/frontpage/feed/vote.js';
+export * as FyiFrontpageRichtextBlock from './types/fyi/frontpage/richtext/block.js';
 export * as FyiUnravelFrontpageComment from './types/fyi/unravel/frontpage/comment.js';
 export * as FyiUnravelFrontpagePost from './types/fyi/unravel/frontpage/post.js';
 export * as FyiUnravelFrontpageVote from './types/fyi/unravel/frontpage/vote.js';

packages/definitions/frontpage/lib/lexicons/types/fyi/frontpage/feed/comment.ts

···
+import type {} from '@atcute/lexicons';
+import * as v from '@atcute/lexicons/validations';
+import type {} from '@atcute/lexicons/ambient';
+import * as ComAtprotoRepoStrongRef from '@atcute/atproto/types/repo/strongRef';
+import * as FyiFrontpageRichtextBlock from '../richtext/block.js';
+
+const _mainSchema = /*#__PURE__*/ v.record(
+	/*#__PURE__*/ v.tidString(),
+	/*#__PURE__*/ v.object({
+		$type: /*#__PURE__*/ v.literal('fyi.frontpage.feed.comment'),
+		/**
+		 * The content of the comment. Note, there are additional constraints placed on the total size of the content within the Frontpage AppView that are not possible to express in lexicon. Generally a comment can have a maximum length of 10,000 graphemes, the Frontpage AppView will enforce this limit.
+		 * @maxLength 200
+		 */
+		get blocks() {
+			return /*#__PURE__*/ v.constrain(/*#__PURE__*/ v.array(FyiFrontpageRichtextBlock.mainSchema), [
+				/*#__PURE__*/ v.arrayLength(0, 200),
+			]);
+		},
+		/**
+		 * Client-declared timestamp when this comment was originally created.
+		 */
+		createdAt: /*#__PURE__*/ v.datetimeString(),
+		get parent() {
+			return /*#__PURE__*/ v.optional(ComAtprotoRepoStrongRef.mainSchema);
+		},
+		get post() {
+			return ComAtprotoRepoStrongRef.mainSchema;
+		},
+	}),
+);
+
+type main$schematype = typeof _mainSchema;
+
+export interface mainSchema extends main$schematype {}
+
+export const mainSchema = _mainSchema as mainSchema;
+
+export interface Main extends v.InferInput<typeof mainSchema> {}
+
+declare module '@atcute/lexicons/ambient' {
+	interface Records {
+		'fyi.frontpage.feed.comment': mainSchema;
+	}
+}

packages/definitions/frontpage/lib/lexicons/types/fyi/frontpage/feed/post.ts

···
+import type {} from '@atcute/lexicons';
+import * as v from '@atcute/lexicons/validations';
+import type {} from '@atcute/lexicons/ambient';
+
+const _mainSchema = /*#__PURE__*/ v.record(
+	/*#__PURE__*/ v.tidString(),
+	/*#__PURE__*/ v.object({
+		$type: /*#__PURE__*/ v.literal('fyi.frontpage.feed.post'),
+		/**
+		 * Client-declared timestamp when this post was originally created.
+		 */
+		createdAt: /*#__PURE__*/ v.datetimeString(),
+		/**
+		 * The piece of content that this Frontpage post is about.
+		 */
+		get subject() {
+			return /*#__PURE__*/ v.variant([urlSubjectSchema]);
+		},
+		/**
+		 * The title of the post.
+		 * @maxLength 3000
+		 * @maxGraphemes 300
+		 */
+		title: /*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [
+			/*#__PURE__*/ v.stringLength(0, 3000),
+			/*#__PURE__*/ v.stringGraphemes(0, 300),
+		]),
+	}),
+);
+const _urlSubjectSchema = /*#__PURE__*/ v.object({
+	$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('fyi.frontpage.feed.post#urlSubject')),
+	url: /*#__PURE__*/ v.genericUriString(),
+});
+
+type main$schematype = typeof _mainSchema;
+type urlSubject$schematype = typeof _urlSubjectSchema;
+
+export interface mainSchema extends main$schematype {}
+export interface urlSubjectSchema extends urlSubject$schematype {}
+
+export const mainSchema = _mainSchema as mainSchema;
+export const urlSubjectSchema = _urlSubjectSchema as urlSubjectSchema;
+
+export interface Main extends v.InferInput<typeof mainSchema> {}
+export interface UrlSubject extends v.InferInput<typeof urlSubjectSchema> {}
+
+declare module '@atcute/lexicons/ambient' {
+	interface Records {
+		'fyi.frontpage.feed.post': mainSchema;
+	}
+}

packages/definitions/frontpage/lib/lexicons/types/fyi/frontpage/feed/vote.ts

···
+import type {} from '@atcute/lexicons';
+import * as v from '@atcute/lexicons/validations';
+import type {} from '@atcute/lexicons/ambient';
+import * as ComAtprotoRepoStrongRef from '@atcute/atproto/types/repo/strongRef';
+
+const _mainSchema = /*#__PURE__*/ v.record(
+	/*#__PURE__*/ v.tidString(),
+	/*#__PURE__*/ v.object({
+		$type: /*#__PURE__*/ v.literal('fyi.frontpage.feed.vote'),
+		/**
+		 * Client-declared timestamp when this vote was originally created.
+		 */
+		createdAt: /*#__PURE__*/ v.datetimeString(),
+		/**
+		 * The post or comment that this Frontpage vote is for.
+		 */
+		get subject() {
+			return ComAtprotoRepoStrongRef.mainSchema;
+		},
+	}),
+);
+
+type main$schematype = typeof _mainSchema;
+
+export interface mainSchema extends main$schematype {}
+
+export const mainSchema = _mainSchema as mainSchema;
+
+export interface Main extends v.InferInput<typeof mainSchema> {}
+
+declare module '@atcute/lexicons/ambient' {
+	interface Records {
+		'fyi.frontpage.feed.vote': mainSchema;
+	}
+}

packages/definitions/frontpage/lib/lexicons/types/fyi/frontpage/richtext/block.ts

···
+import type {} from '@atcute/lexicons';
+import * as v from '@atcute/lexicons/validations';
+
+const _mainSchema = /*#__PURE__*/ v.object({
+	$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('fyi.frontpage.richtext.block')),
+	get content() {
+		return /*#__PURE__*/ v.variant([plaintextParagraphSchema]);
+	},
+});
+const _plaintextParagraphSchema = /*#__PURE__*/ v.object({
+	$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('fyi.frontpage.richtext.block#plaintextParagraph')),
+	/**
+	 * @maxLength 100000
+	 * @maxGraphemes 10000
+	 */
+	text: /*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [
+		/*#__PURE__*/ v.stringLength(0, 100000),
+		/*#__PURE__*/ v.stringGraphemes(0, 10000),
+	]),
+});
+
+type main$schematype = typeof _mainSchema;
+type plaintextParagraph$schematype = typeof _plaintextParagraphSchema;
+
+export interface mainSchema extends main$schematype {}
+export interface plaintextParagraphSchema extends plaintextParagraph$schematype {}
+
+export const mainSchema = _mainSchema as mainSchema;
+export const plaintextParagraphSchema = _plaintextParagraphSchema as plaintextParagraphSchema;
+
+export interface Main extends v.InferInput<typeof mainSchema> {}
+export interface PlaintextParagraph extends v.InferInput<typeof plaintextParagraphSchema> {}

packages/definitions/frontpage/package.json

···
 	],
 	"exports": {
 		".": "./dist/index.js",
-		"./types/*": "./dist/lexicons/types/fyi/unravel/frontpage/*.js"
+		"./types/*": "./dist/lexicons/types/*.js"
 	},
 	"scripts": {
 		"build": "tsc",
+		"pull": "lex-cli pull -c ./lex.config.js",
 		"generate": "rm -r ./lib/lexicons/; lex-cli generate -c ./lex.config.js",
 		"prepublish": "rm -rf dist; pnpm run build"
 	},
···
 		"mappings": {
 			"fyi.unravel.frontpage.*": {
 				"type": "namespace",
-				"path": "./types/{{nsid_remainder}}"
+				"path": "./types/{{nsid}}"
+			},
+			"fyi.frontpage.*": {
+				"type": "namespace",
+				"path": "./types/{{nsid}}"
 			}
 		}
 	}

packages/definitions/leaflet/lex.config.js

···
 import { defineLexiconConfig } from '@atcute/lex-cli';
 
 export default defineLexiconConfig({
-	files: ['../../../lexdocs/leaflet/**/*.json'],
+	files: ['lexicons/**/*.json'],
 	outdir: 'lib/lexicons/',
 	imports: ['@atcute/atproto'],
+
+	pull: {
+		outdir: 'lexicons/',
+		clean: true,
+		sources: [
+			{
+				type: 'git',
+				remote: 'https://github.com/hyperlink-academy/leaflet.git',
+				pattern: ['lexicons/pub/leaflet/**/*.json'],
+			},
+		],
+	},
 });

packages/definitions/leaflet/lexicons/README.md

···
+# lexicon sources
+
+this directory contains lexicon documents pulled from the following sources:
+
+- https://github.com/hyperlink-academy/leaflet.git
+  - commit: 695201ca99bf5cae29a770d22aaf627d2165d2b8

packages/definitions/leaflet/package.json

···
 	},
 	"scripts": {
 		"build": "tsc",
+		"pull": "lex-cli pull -c ./lex.config.js",
 		"generate": "rm -r ./lib/lexicons/; lex-cli generate -c ./lex.config.js",
 		"prepublish": "rm -rf dist; pnpm run build"
 	},

packages/definitions/lexicon-community/lex.config.js

···
 import { defineLexiconConfig } from '@atcute/lex-cli';
 
 export default defineLexiconConfig({
-	files: ['../../../lexdocs/lexcom/**/*.json'],
+	files: ['lexicons/**/*.json'],
 	outdir: 'lib/lexicons/',
 	imports: ['@atcute/atproto'],
+
+	pull: {
+		outdir: 'lexicons/',
+		clean: true,
+		sources: [
+			{
+				type: 'git',
+				remote: 'https://github.com/lexicon-community/lexicon.git',
+				pattern: ['**/*.json'],
+			},
+		],
+	},
 });

packages/definitions/lexicon-community/lexicons/README.md

···
+# lexicon sources
+
+this directory contains lexicon documents pulled from the following sources:
+
+- https://github.com/lexicon-community/lexicon.git
+  - commit: 2bf2cbbfd3058d710f8c468307ef7e003bc22383

packages/definitions/lexicon-community/package.json

···
 	},
 	"scripts": {
 		"build": "tsc",
+		"pull": "lex-cli pull -c ./lex.config.js",
 		"generate": "rm -r ./lib/lexicons/; lex-cli generate -c ./lex.config.js",
 		"prepublish": "rm -rf dist; pnpm run build"
 	},

packages/definitions/microcosm/lex.config.js

···
 import { defineLexiconConfig } from '@atcute/lex-cli';
 
 export default defineLexiconConfig({
-	files: ['../../../lexdocs/microcosm/**/*.json'],
+	files: ['lexicons/**/*.json'],
 	outdir: 'lib/lexicons/',
 });

packages/definitions/ozone/lex.config.js

···
 import { defineLexiconConfig } from '@atcute/lex-cli';
 
 export default defineLexiconConfig({
-	files: ['../../../lexdocs/bluesky/tools/ozone/**/*.json'],
+	files: ['lexicons/**/*.json'],
 	outdir: 'lib/lexicons/',
 	imports: ['@atcute/atproto', '@atcute/bluesky'],
+
+	pull: {
+		outdir: 'lexicons/',
+		clean: true,
+		sources: [
+			{
+				type: 'git',
+				remote: 'https://github.com/bluesky-social/atproto.git',
+				pattern: ['lexicons/tools/ozone/**/*.json'],
+			},
+		],
+	},
 });

packages/definitions/ozone/lexicons/README.md

···
+# lexicon sources
+
+this directory contains lexicon documents pulled from the following sources:
+
+- https://github.com/bluesky-social/atproto.git
+  - commit: 0748d919d127d68ee8c8aeb130b477e3dd5a9be6

packages/definitions/ozone/lib/lexicons/types/tools/ozone/moderation/defs.ts

···
 	 */
 	content: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.string()),
 	/**
+	 * Indicates whether the email was successfully delivered to the user's inbox.
+	 */
+	isDelivered: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.boolean()),
+	/**
 	 * Names/Keywords of the policies that necessitated the email.
 	 * @maxLength 5
 	 */
···
 	 * When the strike should expire. If not provided, the strike never expires.
 	 */
 	strikeExpiresAt: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.datetimeString()),
+	/**
+	 * List of services where the takedown should be applied. If empty or not provided, takedown is applied on all configured services.
+	 */
+	targetServices: /*#__PURE__*/ v.optional(
+		/*#__PURE__*/ v.array(/*#__PURE__*/ v.string<'appview' | 'pds' | (string & {})>()),
+	),
 });
 const _modEventUnmuteSchema = /*#__PURE__*/ v.object({
 	$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('tools.ozone.moderation.defs#modEventUnmute')),

packages/definitions/ozone/lib/lexicons/types/tools/ozone/moderation/queryStatuses.ts

···
 		/**
 		 * Specify when fetching subjects in a certain state
 		 */
-		reviewState: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.string()),
+		reviewState: /*#__PURE__*/ v.optional(
+			/*#__PURE__*/ v.string<
+				| 'tools.ozone.moderation.defs#reviewClosed'
+				| 'tools.ozone.moderation.defs#reviewEscalated'
+				| 'tools.ozone.moderation.defs#reviewNone'
+				| 'tools.ozone.moderation.defs#reviewOpen'
+				| (string & {})
+			>(),
+		),
 		/**
 		 * Search subjects reviewed after a given timestamp
 		 */

packages/definitions/ozone/lib/lexicons/types/tools/ozone/moderation/scheduleAction.ts

···
 	 */
 	durationInHours: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.integer()),
 	/**
+	 * Email content to be sent to the user upon takedown.
+	 */
+	emailContent: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.string()),
+	/**
+	 * Subject of the email to be sent to the user upon takedown.
+	 */
+	emailSubject: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.string()),
+	/**
 	 * Names/Keywords of the policies that drove the decision.
 	 * @maxLength 5
 	 */
···
 			/*#__PURE__*/ v.arrayLength(0, 5),
 		]),
 	),
+	/**
+	 * Severity level of the violation (e.g., 'sev-0', 'sev-1', 'sev-2', etc.).
+	 */
+	severityLevel: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.string()),
+	/**
+	 * Number of strikes to assign to the user when takedown is applied.
+	 */
+	strikeCount: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.integer()),
+	/**
+	 * When the strike should expire. If not provided, the strike never expires.
+	 */
+	strikeExpiresAt: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.datetimeString()),
 });
 
 type failedScheduling$schematype = typeof _failedSchedulingSchema;

packages/definitions/ozone/package.json

···
 	},
 	"scripts": {
 		"build": "tsc",
+		"pull": "lex-cli pull -c ./lex.config.js",
 		"generate": "rm -r ./lib/lexicons/; lex-cli generate -c ./lex.config.js",
 		"prepublish": "rm -rf dist; pnpm run build"
 	},

packages/definitions/tangled/lex.config.js

···
 import { defineLexiconConfig } from '@atcute/lex-cli';
 
 export default defineLexiconConfig({
-	files: ['../../../lexdocs/tangled/**/*.json'],
+	files: ['lexicons/**/*.json'],
 	outdir: 'lib/lexicons/',
 	imports: ['@atcute/atproto'],
+
+	pull: {
+		outdir: 'lexicons/',
+		clean: true,
+		sources: [
+			{
+				type: 'git',
+				remote: 'https://github.com/mary-ext/tangled.sh-mirror.git',
+				pattern: ['lexicons/**/*.json'],
+			},
+		],
+	},
 });

packages/definitions/tangled/lexicons/README.md

···
+# lexicon sources
+
+this directory contains lexicon documents pulled from the following sources:
+
+- https://github.com/mary-ext/tangled.sh-mirror.git
+  - commit: affc138f70d4ff01a7ede27c35b3022a0a8c811c

packages/definitions/tangled/package.json

···
 	},
 	"scripts": {
 		"build": "tsc",
+		"pull": "lex-cli pull -c ./lex.config.js",
 		"generate": "rm -r ./lib/lexicons/; lex-cli generate -c ./lex.config.js",
 		"prepublish": "rm -rf dist; pnpm run build"
 	},

packages/definitions/whitewind/lex.config.js

···
 import { defineLexiconConfig } from '@atcute/lex-cli';
 
 export default defineLexiconConfig({
-	files: ['../../../lexdocs/whtwnd/**/*.json'],
+	files: ['lexicons/com/whtwnd/**/*.json'],
 	outdir: 'lib/lexicons/',
+
+	pull: {
+		outdir: 'lexicons/',
+		clean: true,
+		sources: [
+			{
+				type: 'git',
+				remote: 'https://github.com/whtwnd/whitewind-blog.git',
+				pattern: ['lexicons/com/whtwnd/**/*.json'],
+			},
+		],
+	},
 });

packages/definitions/whitewind/lexicons/README.md

···
+# lexicon sources
+
+this directory contains lexicon documents pulled from the following sources:
+
+- https://github.com/whtwnd/whitewind-blog.git
+  - commit: 047c8d44b5a13e5b8518823982c486e9e3df50c0

packages/definitions/whitewind/package.json

···
 	},
 	"scripts": {
 		"build": "tsc",
+		"pull": "lex-cli pull -c ./lex.config.js",
 		"generate": "rm -r ./lib/lexicons/; lex-cli generate -c ./lex.config.js",
 		"prepublish": "rm -rf dist; pnpm run build"
 	},

packages/lexicons/lex-cli/README.md

···
 npm exec lex-cli generate -c ./lex.config.js
 ```
 
+## pulling lexicons
+
+configure sources to be pulled locally before code generation. pulled files are written using their
+nsids (e.g., `app.bsky.feed.post` becomes `app/bsky/feed/post.json`).
+
+```ts
+// file: lex.config.js
+import { defineLexiconConfig } from '@atcute/lex-cli';
+
+export default defineLexiconConfig({
+	pull: {
+		outdir: 'lexicons/',
+		clean: true,
+		sources: [
+			{
+				type: 'git',
+				remote: 'https://github.com/bluesky-social/atproto.git',
+				ref: 'main',
+				pattern: ['lexicons/**/*.json'],
+			},
+		],
+	},
+	files: ['lexicons/**/*.json'],
+	outdir: 'src/lexicons/',
+});
+```
+
+pull the lexicons to disk, then generate types from them:
+
+```
+npm exec lex-cli pull -c ./lex.config.js
+npm exec lex-cli generate -c ./lex.config.js
+```
+
 ## publishing your schemas
 
 if you're packaging your generated schemas as a publishable library, add the `atcute:lexicons`

packages/lexicons/lex-cli/src/cli.ts

···
 
 import { object } from '@optique/core/constructs';
 import { command, constant, option } from '@optique/core/primitives';
+import { or } from '@optique/core/constructs';
 import { run } from '@optique/run';
 import { path as pathParser } from '@optique/run/valueparser';
 import pc from 'picocolors';
···
 import { generateLexiconApi, type ImportMapping } from './codegen.js';
 import { loadConfig } from './config.js';
 import { packageJsonSchema } from './lexicon-metadata.js';
+import { runPull } from './pull.js';
 
 /**
  * Resolves package imports to ImportMapping[]
···
 	return mappings;
 };
 
-const parser = command(
-	'generate',
-	object({
-		type: constant('generate'),
-		config: option('-c', '--config', pathParser({ metavar: 'CONFIG' })),
-	}),
+const parser = or(
+	command(
+		'generate',
+		object({
+			type: constant('generate'),
+			config: option('-c', '--config', pathParser({ metavar: 'CONFIG' })),
+		}),
+	),
+	command(
+		'pull',
+		object({
+			type: constant('pull'),
+			config: option('-c', '--config', pathParser({ metavar: 'CONFIG' })),
+		}),
+	),
 );
 
 const result = run(parser, { programName: 'lex-cli' });
···
 		await fs.mkdir(dirname, { recursive: true });
 		await fs.writeFile(filename, file.code);
 	}
+} else if (result.type === 'pull') {
+	const config = await loadConfig(result.config);
+	await runPull(config);
 }

packages/lexicons/lex-cli/src/config.ts

···
 
 import type { ImportMapping } from './codegen.js';
 
+const gitSourceConfigSchema = v.object({
+	type: v.literal('git'),
+	remote: v.string().assert((value) => value.length > 0, `must not be empty`),
+	ref: v
+		.string()
+		.assert((value) => value.length > 0, `must not be empty`)
+		.optional(),
+	pattern: v
+		.array(v.string().assert((value) => value.length > 0, `must not be empty`))
+		.assert((value) => value.length > 0, `must include at least one glob pattern`),
+});
+
+const sourceConfigSchema = v.union(gitSourceConfigSchema);
+
+const pullConfigSchema = v.object({
+	outdir: v.string().assert((value) => value.length > 0, `must not be empty`),
+	clean: v.boolean().optional(),
+	sources: v
+		.array(sourceConfigSchema)
+		.assert((value) => value.length > 0, `must include at least one source`),
+});
+
+export type GitSourceConfig = v.Infer<typeof gitSourceConfigSchema>;
+export type SourceConfig = v.Infer<typeof sourceConfigSchema>;
+export type PullConfig = v.Infer<typeof pullConfigSchema>;
+
 const isValidLexiconPattern = (pattern: string): boolean => {
 	if (pattern.endsWith('.*')) {
 		return isNsid(`${pattern.slice(0, -2)}.x`);
···
 const mappingImports: v.Type<ImportMapping['imports']> = v.unknown().chain((value) => {
 	if (typeof value === 'string') {
 		if (value.length === 0) {
-			return v.err({ message: 'imports must not be empty' });
+			return v.err('imports must not be empty');
 		}
 
 		return v.ok(value);
···
 		return v.ok(value as ImportMapping['imports']);
 	}
 
-	return v.err({ message: 'imports must be a string or function' });
+	return v.err('imports must be a string or function');
 });
 
 const importMappingSchema: v.Type<ImportMapping> = v.object({
···
 		.array(
 			v.string().chain((value) => {
 				if (!isValidLexiconPattern(value)) {
-					return v.err({
-						message: 'invalid NSID pattern (must be valid NSID or end with .*)',
-					});
+					return v.err(`invalid NSID pattern (must be valid NSID or end with .*)`);
 				}
 
 				return v.ok(value);
 			}),
 		)
-		.assert((patterns) => patterns.length > 0, {
-			message: 'nsid requires at least one pattern',
-		}),
+		.assert((patterns) => patterns.length > 0, `nsid requires at least one pattern`),
 	imports: mappingImports,
 });
 
 export const lexiconConfigSchema = v.object({
-	outdir: v.string().assert((value) => value.length > 0, {
-		message: 'outdir must not be empty',
-	}),
+	outdir: v.string().assert((value) => value.length > 0, `must not be empty`),
 	files: v
-		.array(
-			v.string().assert((value) => value.length > 0, {
-				message: 'files entries must not be empty',
-			}),
-		)
-		.assert((value) => value.length > 0, {
-			message: 'files must include at least one pattern',
-		}),
-	imports: v
-		.array(
-			v.string().assert((value) => value.length > 0, {
-				message: 'imports entries must not be empty',
-			}),
-		)
-		.optional(),
+		.array(v.string().assert((value) => value.length > 0, `must not be empty`))
+		.assert((value) => value.length > 0, `must include at least one glob pattern`),
+	imports: v.array(v.string().assert((value) => value.length > 0, `must not be empty`)).optional(),
 	mappings: v.array(importMappingSchema).optional(),
 	modules: v
 		.object({
 			importSuffix: v
 				.string()
-				.assert((value) => value.length > 0, { message: 'importSuffix must not be empty' })
+				.assert((value) => value.length > 0, `must not be empty`)
 				.optional(),
 		})
 		.partial()
 		.optional(),
+	pull: pullConfigSchema.optional(),
 });
 
 export type LexiconConfig = v.Infer<typeof lexiconConfigSchema>;

packages/lexicons/lex-cli/src/git.ts

···
+import { spawn } from 'node:child_process';
+
+export interface GitCommandOptions {
+	cwd?: string;
+	env?: NodeJS.ProcessEnv;
+	stdin?: string;
+	timeoutMs?: number;
+}
+
+export interface GitResult {
+	stdout: string;
+	stderr: string;
+}
+
+export class GitError extends Error {
+	readonly args: readonly string[];
+	readonly code: number | null;
+	readonly signal: NodeJS.Signals | null;
+	readonly stdout: string;
+	readonly stderr: string;
+
+	constructor(
+		args: readonly string[],
+		stdout: string,
+		stderr: string,
+		code: number | null,
+		signal: NodeJS.Signals | null,
+	) {
+		const reason = code !== null ? `code ${code}` : `signal ${signal ?? 'unknown'}`;
+		super(`git ${args.join(' ')} failed with ${reason}`);
+
+		this.name = 'GitError';
+		this.args = args;
+		this.code = code;
+		this.signal = signal;
+		this.stdout = stdout;
+		this.stderr = stderr;
+	}
+}
+
+/**
+ * runs git with the provided arguments and throws when the command fails.
+ * @param args positional arguments for git
+ * @param options execution options
+ * @returns stdout and stderr from git
+ * @throws GitError when git exits with a non-zero status or is terminated
+ */
+export const runGit = (args: readonly string[], options: GitCommandOptions = {}): Promise<GitResult> => {
+	return new Promise((resolve, reject) => {
+		const child = spawn('git', args, {
+			cwd: options.cwd,
+			env: options.env,
+			stdio: ['pipe', 'pipe', 'pipe'],
+		});
+
+		let stdout = '';
+		let stderr = '';
+
+		child.stdout?.setEncoding('utf8');
+		child.stderr?.setEncoding('utf8');
+
+		child.stdout?.on('data', (chunk) => {
+			stdout += chunk;
+		});
+
+		child.stderr?.on('data', (chunk) => {
+			stderr += chunk;
+		});
+
+		let timer: NodeJS.Timeout | undefined;
+		if (options.timeoutMs !== undefined) {
+			timer = setTimeout(() => {
+				child.kill('SIGKILL');
+			}, options.timeoutMs);
+		}
+
+		child.on('error', (err) => {
+			if (timer) {
+				clearTimeout(timer);
+			}
+
+			reject(err);
+		});
+
+		child.on('close', (code, signal) => {
+			if (timer) {
+				clearTimeout(timer);
+			}
+
+			if (code === 0) {
+				resolve({ stdout, stderr });
+				return;
+			}
+
+			reject(new GitError(args, stdout, stderr, code, signal));
+		});
+
+		if (options.stdin !== undefined) {
+			child.stdin?.end(options.stdin);
+		} else {
+			child.stdin?.end();
+		}
+	});
+};

packages/lexicons/lex-cli/src/pull.ts

···
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+
+import { lexiconDoc, refineLexiconDoc, type LexiconDoc } from '@atcute/lexicon-doc';
+import prettier from 'prettier';
+import pc from 'picocolors';
+
+import { runGit, GitError } from './git.js';
+import type { NormalizedConfig, PullConfig, SourceConfig } from './config.js';
+
+interface SourceRevision {
+	source: SourceConfig;
+	rev: string;
+}
+
+interface SourceLocation {
+	absolutePath: string;
+	relativePath: string;
+	sourceDescription: string;
+}
+
+interface PulledLexicon {
+	nsid: string;
+	doc: LexiconDoc;
+	location: SourceLocation;
+}
+
+interface PullResult {
+	pulled: Map<string, PulledLexicon>;
+	rev: string;
+}
+
+const ensurePullConfig = (config: NormalizedConfig): PullConfig => {
+	if (!config.pull) {
+		console.error(pc.bold(pc.red(`pull configuration missing`)));
+		process.exit(1);
+	}
+
+	return config.pull;
+};
+
+const parseLexiconFile = async (loc: SourceLocation): Promise<LexiconDoc> => {
+	let source: string;
+
+	try {
+		source = await fs.readFile(loc.absolutePath, 'utf8');
+	} catch (err) {
+		console.error(
+			pc.bold(pc.red(`file read error for ${loc.relativePath} when pulling ${loc.sourceDescription}`)),
+		);
+		console.error(`found in ${loc.absolutePath}`);
+		console.error(err);
+		process.exit(1);
+	}
+
+	let json: unknown;
+	try {
+		json = JSON.parse(source);
+	} catch (err) {
+		console.error(
+			pc.bold(pc.red(`json parse error in ${loc.relativePath} when pulling ${loc.sourceDescription}`)),
+		);
+		console.error(`found in ${loc.absolutePath}`);
+		console.error(err);
+		process.exit(1);
+	}
+
+	const result = lexiconDoc.try(json, { mode: 'passthrough' });
+	if (!result.ok) {
+		console.error(
+			pc.bold(
+				pc.red(`schema validation failed for ${loc.relativePath} when pulling ${loc.sourceDescription}`),
+			),
+		);
+		console.error(`found in ${loc.absolutePath}`);
+		console.error(result.message);
+
+		for (const issue of result.issues) {
+			console.log(`- ${issue.code} at .${issue.path.join('.')}`);
+		}
+
+		process.exit(1);
+	}
+
+	const issues = refineLexiconDoc(result.value, true);
+	if (issues.length > 0) {
+		console.error(
+			pc.bold(pc.red(`lint validation failed for ${loc.relativePath} when pulling ${loc.sourceDescription}`)),
+		);
+		console.error(`found in ${loc.absolutePath}`);
+
+		for (const issue of issues) {
+			console.log(`- ${issue.message} at .${issue.path.join('.')}`);
+		}
+
+		process.exit(1);
+	}
+
+	return result.value;
+};
+
+const writeLexicon = async (
+	outdir: string,
+	nsid: string,
+	doc: LexiconDoc,
+	prettierConfig: prettier.Options | null,
+): Promise<void> => {
+	const nsidPath = nsid.replaceAll('.', '/');
+	const target = path.join(outdir, `${nsidPath}.json`);
+	const dirname = path.dirname(target);
+
+	const code = await prettier.format(JSON.stringify(doc, null, 2), {
+		...(prettierConfig ?? {}),
+		parser: 'json',
+	});
+
+	await fs.mkdir(dirname, { recursive: true });
+	await fs.writeFile(target, code);
+};
+
+/**
+ * pulls lexicon documents from a git repository source
+ * @param source git source configuration
+ * @returns pulled lexicons and commit hash
+ */
+const pullGitSource = async (source: SourceConfig & { type: 'git' }): Promise<PullResult> => {
+	const tempParent = await fs.mkdtemp(path.join(os.tmpdir(), 'lex-cli-pull-'));
+
+	const cloneDir = path.join(tempParent, 'repo');
+
+	try {
+		await runGit(
+			[
+				'clone',
+				'--filter=blob:none',
+				'--depth',
+				'1',
+				'--sparse',
+				...(source.ref ? ['--branch', source.ref, '--single-branch'] : []),
+				source.remote,
+				cloneDir,
+			],
+			{ timeoutMs: 60_000 },
+		);
+	} catch (err) {
+		if (err instanceof GitError) {
+			console.error(pc.bold(pc.red(`git clone failed for ${source.remote}:`)));
+			console.error(err.stderr || err.message);
+			process.exit(1);
+		}
+
+		throw err;
+	}
+
+	try {
+		await runGit(['-C', cloneDir, 'sparse-checkout', 'set', '--no-cone', ...source.pattern], {
+			timeoutMs: 30_000,
+		});
+	} catch (err) {
+		if (err instanceof GitError) {
+			console.error(pc.bold(pc.red(`git sparse-checkout failed for ${source.remote}:`)));
+			console.error(err.stderr || err.message);
+			process.exit(1);
+		}
+
+		throw err;
+	}
+
+	const pulled = new Map<string, PulledLexicon>();
+
+	for await (const filename of fs.glob(source.pattern, { cwd: cloneDir })) {
+		const absolute = path.join(cloneDir, filename);
+		const stat = await fs.stat(absolute);
+
+		if (!stat.isFile()) {
+			continue;
+		}
+
+		const location: SourceLocation = {
+			absolutePath: absolute,
+			relativePath: filename,
+			sourceDescription: source.remote,
+		};
+
+		const doc = await parseLexiconFile(location);
+
+		pulled.set(doc.id, { nsid: doc.id, doc, location });
+	}
+
+	// get the commit hash
+	let rev: string;
+	try {
+		const result = await runGit(['-C', cloneDir, 'rev-parse', 'HEAD'], { timeoutMs: 10_000 });
+		rev = result.stdout.trim();
+	} catch (err) {
+		if (err instanceof GitError) {
+			console.error(pc.bold(pc.red(`git rev-parse failed for ${source.remote}:`)));
+			console.error(err.stderr || err.message);
+			process.exit(1);
+		}
+
+		throw err;
+	}
+
+	await fs.rm(tempParent, { recursive: true, force: true });
+
+	return { pulled, rev };
+};
+
+const pullSource = async (source: SourceConfig): Promise<PullResult> => {
+	switch (source.type) {
+		case 'git': {
+			return pullGitSource(source);
+		}
+	}
+};
+
+const writeSourceReadme = async (
+	outdir: string,
+	revisions: SourceRevision[],
+	prettierConfig: prettier.Options | null,
+): Promise<void> => {
+	const lines = [
+		'# lexicon sources',
+		'',
+		'this directory contains lexicon documents pulled from the following sources:',
+		'',
+	];
+
+	for (const { source, rev } of revisions) {
+		switch (source.type) {
+			case 'git': {
+				lines.push(`- ${source.remote}${source.ref ? ` (ref: ${source.ref})` : ``}`);
+				lines.push(`  - commit: ${rev}`);
+				break;
+			}
+		}
+	}
+
+	lines.push('');
+
+	const content = lines.join('\n');
+	const formatted = await prettier.format(content, {
+		...(prettierConfig ?? {}),
+		parser: 'markdown',
+	});
+
+	await fs.writeFile(path.join(outdir, 'README.md'), formatted);
+};
+
+/**
+ * pulls lexicon documents from configured sources and writes them to disk using nsid-based paths.
+ * @param config normalized lex-cli configuration
+ */
+export const runPull = async (config: NormalizedConfig): Promise<void> => {
+	const pullConfig = ensurePullConfig(config);
+	const outdir = path.resolve(config.root, pullConfig.outdir);
+	const prettierConfig = await prettier.resolveConfig(config.root, { editorconfig: true });
+
+	const seen = new Map<string, SourceLocation>();
+	const collected: PulledLexicon[] = [];
+	const sourceRevisions: SourceRevision[] = [];
+
+	for (const source of pullConfig.sources) {
+		const result = await pullSource(source);
+
+		sourceRevisions.push({ source, rev: result.rev });
+
+		for (const [nsid, entry] of result.pulled) {
+			const existing = seen.get(nsid);
+
+			if (existing) {
+				console.error(pc.bold(pc.red(`duplicate lexicon "${nsid}"`)));
+				console.error(`- found ${entry.location.relativePath} from ${entry.location.sourceDescription}`);
+				console.error(`  at ${entry.location.absolutePath}`);
+				console.error(`- already found ${existing.relativePath} from ${existing.sourceDescription}`);
+				console.error(`  at ${existing.absolutePath}`);
+				process.exit(1);
+			}
+
+			seen.set(nsid, entry.location);
+			collected.push(entry);
+		}
+	}
+
+	if (pullConfig.clean) {
+		await fs.rm(outdir, { recursive: true, force: true });
+	}
+
+	await fs.mkdir(outdir, { recursive: true });
+
+	for (const entry of collected) {
+		await writeLexicon(outdir, entry.nsid, entry.doc, prettierConfig);
+	}
+
+	await writeSourceReadme(outdir, sourceRevisions, prettierConfig);
+};

scripts/pull-bluemoji-lexicons.js

···
-import * as path from 'node:path';
-import * as fs from 'node:fs/promises';
-
-import { untar } from '@mary/tar';
-import prettier from 'prettier';
-
-const config = {
-	repo: `aendra-rininsland/bluemoji`,
-	path: `schema/`,
-	out: `lexdocs/bluemoji/`,
-};
-
-async function main() {
-	const prettierConfig = await prettier.resolveConfig(process.cwd() + '/foo', { editorconfig: true });
-
-	let sha;
-	{
-		console.log(`retrieving latest commit`);
-		const response = await fetch(`https://api.github.com/repos/${config.repo}/commits?path=${config.path}/`);
-
-		if (!response.ok) {
-			console.log(`  response error ${response.status}`);
-			return;
-		}
-
-		const json = await response.json();
-		const latest = json[0];
-
-		if (!latest) {
-			console.log(`  latest commit missing?`);
-			return;
-		}
-
-		sha = latest.sha;
-		console.log(`  got ${sha}`);
-	}
-
-	const tmpdir = `lexicons-tmp/`;
-
-	{
-		console.log(`retrieving zip file`);
-		const response = await fetch(`https://github.com/${config.repo}/archive/${sha}.tar.gz`);
-
-		if (!response.ok) {
-			console.log(`  response error ${response.status}`);
-			return;
-		}
-
-		const reponame = config.repo.replace(/^.*?\//, '');
-		const basename = `${reponame}-${sha}/${config.path}`;
-
-		const ds = new DecompressionStream('gzip');
-		const stream = response.body.pipeThrough(ds);
-
-		const promises = [];
-
-		console.log(`  reading`);
-		for await (const entry of untar(stream)) {
-			if (entry.type === 'file' && entry.name.startsWith(basename) && entry.name.endsWith('.json')) {
-				const name = entry.name.slice(basename.length);
-				const basedir = tmpdir + path.dirname(name);
-
-				const code = await entry.text();
-
-				const promise = (async () => {
-					const formatted = await prettier.format(code, { ...prettierConfig, parser: 'json' });
-
-					await fs.mkdir(basedir, { recursive: true });
-					await fs.writeFile(tmpdir + name, formatted);
-				})();
-
-				promises.push(promise);
-			}
-		}
-
-		console.log(`  flushing writes`);
-		await Promise.all(promises);
-	}
-
-	{
-		const source = `https://github.com/${config.repo}/tree/${sha}/${config.path}\n`;
-
-		console.log(`writing readme file`);
-
-		await fs.writeFile(tmpdir + `README.md`, source);
-	}
-
-	{
-		console.log(`moving folder`);
-
-		await fs.rm(config.out, { recursive: true, force: true });
-		await fs.rename(tmpdir, config.out);
-	}
-}
-
-await main();

scripts/pull-frontpage-lexicons.js

···
-import * as path from 'node:path';
-import * as fs from 'node:fs/promises';
-
-import { untar } from '@mary/tar';
-import prettier from 'prettier';
-
-const config = {
-	repo: `likeandscribe/frontpage`,
-	path: `lexicons/fyi/unravel/frontpage/`,
-	out: `lexdocs/frontpage/`,
-};
-
-async function main() {
-	const prettierConfig = await prettier.resolveConfig(process.cwd() + '/foo', { editorconfig: true });
-
-	let sha;
-	{
-		console.log(`retrieving latest commit`);
-		const response = await fetch(`https://api.github.com/repos/${config.repo}/commits?path=${config.path}/`);
-
-		if (!response.ok) {
-			console.log(`  response error ${response.status}`);
-			return;
-		}
-
-		const json = await response.json();
-		const latest = json[0];
-
-		if (!latest) {
-			console.log(`  latest commit missing?`);
-			return;
-		}
-
-		sha = latest.sha;
-		console.log(`  got ${sha}`);
-	}
-
-	const tmpdir = `lexicons-tmp/`;
-
-	{
-		console.log(`retrieving zip file`);
-		const response = await fetch(`https://github.com/${config.repo}/archive/${sha}.tar.gz`);
-
-		if (!response.ok) {
-			console.log(`  response error ${response.status}`);
-			return;
-		}
-
-		const reponame = config.repo.replace(/^.*?\//, '');
-		const basename = `${reponame}-${sha}/${config.path}`;
-
-		const ds = new DecompressionStream('gzip');
-		const stream = response.body.pipeThrough(ds);
-
-		const promises = [];
-
-		console.log(`  reading`);
-		for await (const entry of untar(stream)) {
-			if (entry.type === 'file' && entry.name.startsWith(basename) && entry.name.endsWith('.json')) {
-				const name = entry.name.slice(basename.length);
-				const basedir = tmpdir + path.dirname(name);
-
-				const code = await entry.text();
-
-				const promise = (async () => {
-					const formatted = await prettier.format(code, { ...prettierConfig, parser: 'json' });
-
-					await fs.mkdir(basedir, { recursive: true });
-					await fs.writeFile(tmpdir + name, formatted);
-				})();
-
-				promises.push(promise);
-			}
-		}
-
-		console.log(`  flushing writes`);
-		await Promise.all(promises);
-	}
-
-	{
-		const source = `https://github.com/${config.repo}/tree/${sha}/${config.path}\n`;
-
-		console.log(`writing readme file`);
-
-		await fs.writeFile(tmpdir + `README.md`, source);
-	}
-
-	{
-		console.log(`moving folder`);
-
-		await fs.rm(config.out, { recursive: true, force: true });
-		await fs.rename(tmpdir, config.out);
-	}
-}
-
-await main();

scripts/pull-leaflet-lexicons.js

···
-import * as path from 'node:path';
-import * as fs from 'node:fs/promises';
-
-import { untar } from '@mary/tar';
-import prettier from 'prettier';
-
-const config = {
-	repo: `hyperlink-academy/leaflet`,
-	path: `lexicons/pub/leaflet/`,
-	out: `lexdocs/leaflet/`,
-};
-
-async function main() {
-	const prettierConfig = await prettier.resolveConfig(process.cwd() + '/foo', { editorconfig: true });
-
-	let sha;
-	{
-		console.log(`retrieving latest commit`);
-		const response = await fetch(`https://api.github.com/repos/${config.repo}/commits?path=${config.path}/`);
-
-		if (!response.ok) {
-			console.log(`  response error ${response.status}`);
-			return;
-		}
-
-		const json = await response.json();
-		const latest = json[0];
-
-		if (!latest) {
-			console.log(`  latest commit missing?`);
-			return;
-		}
-
-		sha = latest.sha;
-		console.log(`  got ${sha}`);
-	}
-
-	const tmpdir = `lexicons-tmp/`;
-
-	{
-		console.log(`retrieving zip file`);
-		const response = await fetch(`https://github.com/${config.repo}/archive/${sha}.tar.gz`);
-
-		if (!response.ok) {
-			console.log(`  response error ${response.status}`);
-			return;
-		}
-
-		const reponame = config.repo.replace(/^.*?\//, '');
-		const basename = `${reponame}-${sha}/${config.path}`;
-
-		const ds = new DecompressionStream('gzip');
-		const stream = response.body.pipeThrough(ds);
-
-		const promises = [];
-
-		console.log(`  reading`);
-		for await (const entry of untar(stream)) {
-			if (entry.type === 'file' && entry.name.startsWith(basename) && entry.name.endsWith('.json')) {
-				const name = entry.name.slice(basename.length);
-				const basedir = tmpdir + path.dirname(name);
-
-				const code = await entry.text();
-
-				const promise = (async () => {
-					const formatted = await prettier.format(code, { ...prettierConfig, parser: 'json' });
-
-					await fs.mkdir(basedir, { recursive: true });
-					await fs.writeFile(tmpdir + name, formatted);
-				})();
-
-				promises.push(promise);
-			}
-		}
-
-		console.log(`  flushing writes`);
-		await Promise.all(promises);
-	}
-
-	{
-		const source = `https://github.com/${config.repo}/tree/${sha}/${config.path}\n`;
-
-		console.log(`writing readme file`);
-
-		await fs.writeFile(tmpdir + `README.md`, source);
-	}
-
-	{
-		console.log(`moving folder`);
-
-		await fs.rm(config.out, { recursive: true, force: true });
-		await fs.rename(tmpdir, config.out);
-	}
-}
-
-await main();

scripts/pull-lexcom-lexicons.js

···
-import * as path from 'node:path';
-import * as fs from 'node:fs/promises';
-
-import { untar } from '@mary/tar';
-import prettier from 'prettier';
-
-const config = {
-	repo: `lexicon-community/lexicon`,
-	path: `community/lexicon/`,
-	out: `lexdocs/lexcom/`,
-};
-
-async function main() {
-	const prettierConfig = await prettier.resolveConfig(process.cwd() + '/foo', { editorconfig: true });
-
-	let sha;
-	{
-		console.log(`retrieving latest commit`);
-		const response = await fetch(`https://api.github.com/repos/${config.repo}/commits?path=${config.path}/`);
-
-		if (!response.ok) {
-			console.log(`  response error ${response.status}`);
-			return;
-		}
-
-		const json = await response.json();
-		const latest = json[0];
-
-		if (!latest) {
-			console.log(`  latest commit missing?`);
-			return;
-		}
-
-		sha = latest.sha;
-		console.log(`  got ${sha}`);
-	}
-
-	const tmpdir = `lexicons-tmp/`;
-
-	{
-		console.log(`retrieving zip file`);
-		const response = await fetch(`https://github.com/${config.repo}/archive/${sha}.tar.gz`);
-
-		if (!response.ok) {
-			console.log(`  response error ${response.status}`);
-			return;
-		}
-
-		const reponame = config.repo.replace(/^.*?\//, '');
-		const basename = `${reponame}-${sha}/${config.path}`;
-
-		const ds = new DecompressionStream('gzip');
-		const stream = response.body.pipeThrough(ds);
-
-		const promises = [];
-
-		console.log(`  reading`);
-		for await (const entry of untar(stream)) {
-			if (entry.type === 'file' && entry.name.startsWith(basename) && entry.name.endsWith('.json')) {
-				const name = entry.name.slice(basename.length);
-				const basedir = tmpdir + path.dirname(name);
-
-				const code = await entry.text();
-
-				const promise = (async () => {
-					const formatted = await prettier.format(code, { ...prettierConfig, parser: 'json' });
-
-					await fs.mkdir(basedir, { recursive: true });
-					await fs.writeFile(tmpdir + name, formatted);
-				})();
-
-				promises.push(promise);
-			}
-		}
-
-		console.log(`  flushing writes`);
-		await Promise.all(promises);
-	}
-
-	{
-		const source = `https://github.com/${config.repo}/tree/${sha}/${config.path}\n`;
-
-		console.log(`writing readme file`);
-
-		await fs.writeFile(tmpdir + `README.md`, source);
-	}
-
-	{
-		console.log(`moving folder`);
-
-		await fs.rm(config.out, { recursive: true, force: true });
-		await fs.rename(tmpdir, config.out);
-	}
-}
-
-await main();

scripts/pull-lexicons.js

···
-import * as path from 'node:path';
-import * as fs from 'node:fs/promises';
-
-import { untar } from '@mary/tar';
-import prettier from 'prettier';
-
-const config = {
-	repo: `bluesky-social/atproto`,
-	path: `lexicons/`,
-	out: `lexdocs/bluesky/`,
-};
-
-async function main() {
-	const prettierConfig = await prettier.resolveConfig(process.cwd() + '/foo', { editorconfig: true });
-
-	let sha;
-	{
-		console.log(`retrieving latest commit`);
-		const response = await fetch(`https://api.github.com/repos/${config.repo}/commits?path=${config.path}/`);
-
-		if (!response.ok) {
-			console.log(`  response error ${response.status}`);
-			return;
-		}
-
-		const json = await response.json();
-		const latest = json[0];
-
-		if (!latest) {
-			console.log(`  latest commit missing?`);
-			return;
-		}
-
-		sha = latest.sha;
-		console.log(`  got ${sha}`);
-	}
-
-	const tmpdir = `lexicons-tmp/`;
-
-	{
-		console.log(`retrieving zip file`);
-		const response = await fetch(`https://github.com/${config.repo}/archive/${sha}.tar.gz`);
-
-		if (!response.ok) {
-			console.log(`  response error ${response.status}`);
-			return;
-		}
-
-		const reponame = config.repo.replace(/^.*?\//, '');
-		const basename = `${reponame}-${sha}/${config.path}`;
-
-		const ds = new DecompressionStream('gzip');
-		const stream = response.body.pipeThrough(ds);
-
-		const promises = [];
-
-		console.log(`  reading`);
-		for await (const entry of untar(stream)) {
-			if (entry.type === 'file' && entry.name.startsWith(basename) && entry.name.endsWith('.json')) {
-				const name = entry.name.slice(basename.length);
-				const basedir = tmpdir + path.dirname(name);
-
-				const code = await entry.text();
-
-				const promise = (async () => {
-					const formatted = await prettier.format(code, { ...prettierConfig, parser: 'json' });
-
-					await fs.mkdir(basedir, { recursive: true });
-					await fs.writeFile(tmpdir + name, formatted);
-				})();
-
-				promises.push(promise);
-			}
-		}
-
-		console.log(`  flushing writes`);
-		await Promise.all(promises);
-	}
-
-	{
-		const source = `https://github.com/${config.repo}/tree/${sha}/${config.path}\n`;
-
-		console.log(`writing readme file`);
-
-		await fs.writeFile(tmpdir + `README.md`, source);
-	}
-
-	{
-		console.log(`moving folder`);
-
-		await fs.rm(config.out, { recursive: true, force: true });
-		await fs.rename(tmpdir, config.out);
-	}
-}
-
-await main();

scripts/pull-tangled-lexicons.js

···
-import * as path from 'node:path';
-import * as fs from 'node:fs/promises';
-
-import { untar } from '@mary/tar';
-import prettier from 'prettier';
-
-const config = {
-	repo: `mary-ext/tangled.sh-mirror`,
-	path: `lexicons/`,
-	out: `lexdocs/tangled/`,
-};
-
-async function main() {
-	const prettierConfig = await prettier.resolveConfig(process.cwd() + '/foo', { editorconfig: true });
-
-	let sha;
-	{
-		console.log(`retrieving latest commit`);
-		const response = await fetch(`https://api.github.com/repos/${config.repo}/commits?path=${config.path}/`);
-
-		if (!response.ok) {
-			console.log(`  response error ${response.status}`);
-			return;
-		}
-
-		const json = await response.json();
-		const latest = json[0];
-
-		if (!latest) {
-			console.log(`  latest commit missing?`);
-			return;
-		}
-
-		sha = latest.sha;
-		console.log(`  got ${sha}`);
-	}
-
-	const tmpdir = `lexicons-tmp/`;
-
-	{
-		console.log(`retrieving zip file`);
-		const response = await fetch(`https://github.com/${config.repo}/archive/${sha}.tar.gz`);
-
-		if (!response.ok) {
-			console.log(`  response error ${response.status}`);
-			return;
-		}
-
-		const reponame = config.repo.replace(/^.*?\//, '');
-		const basename = `${reponame}-${sha}/${config.path}`;
-
-		const ds = new DecompressionStream('gzip');
-		const stream = response.body.pipeThrough(ds);
-
-		const promises = [];
-
-		console.log(`  reading`);
-		for await (const entry of untar(stream)) {
-			if (entry.type === 'file' && entry.name.startsWith(basename) && entry.name.endsWith('.json')) {
-				const name = entry.name.slice(basename.length);
-				const basedir = tmpdir + path.dirname(name);
-
-				const code = await entry.text();
-
-				const promise = (async () => {
-					const formatted = await prettier.format(code, { ...prettierConfig, parser: 'json' });
-
-					await fs.mkdir(basedir, { recursive: true });
-					await fs.writeFile(tmpdir + name, formatted);
-				})();
-
-				promises.push(promise);
-			}
-		}
-
-		console.log(`  flushing writes`);
-		await Promise.all(promises);
-	}
-
-	{
-		const source = `https://github.com/${config.repo}/tree/${sha}/${config.path}\n`;
-
-		console.log(`writing readme file`);
-
-		await fs.writeFile(tmpdir + `README.md`, source);
-	}
-
-	{
-		console.log(`moving folder`);
-
-		await fs.rm(config.out, { recursive: true, force: true });
-		await fs.rename(tmpdir, config.out);
-	}
-}
-
-await main();

scripts/pull-whtwnd-lexicons.js

···
-import * as path from 'node:path';
-import * as fs from 'node:fs/promises';
-
-import { untar } from '@mary/tar';
-import prettier from 'prettier';
-
-const config = {
-	repo: `whtwnd/whitewind-blog`,
-	path: `lexicons/com/whtwnd/`,
-	out: `lexdocs/whtwnd/`,
-};
-
-async function main() {
-	const prettierConfig = await prettier.resolveConfig(process.cwd() + '/foo', { editorconfig: true });
-
-	let sha;
-	{
-		console.log(`retrieving latest commit`);
-		const response = await fetch(`https://api.github.com/repos/${config.repo}/commits?path=${config.path}/`);
-
-		if (!response.ok) {
-			console.log(`  response error ${response.status}`);
-			return;
-		}
-
-		const json = await response.json();
-		const latest = json[0];
-
-		if (!latest) {
-			console.log(`  latest commit missing?`);
-			return;
-		}
-
-		sha = latest.sha;
-		console.log(`  got ${sha}`);
-	}
-
-	const tmpdir = `lexicons-tmp/`;
-
-	{
-		console.log(`retrieving zip file`);
-		const response = await fetch(`https://github.com/${config.repo}/archive/${sha}.tar.gz`);
-
-		if (!response.ok) {
-			console.log(`  response error ${response.status}`);
-			return;
-		}
-
-		const reponame = config.repo.replace(/^.*?\//, '');
-		const basename = `${reponame}-${sha}/${config.path}`;
-
-		const ds = new DecompressionStream('gzip');
-		const stream = response.body.pipeThrough(ds);
-
-		const promises = [];
-
-		console.log(`  reading`);
-		for await (const entry of untar(stream)) {
-			if (entry.type === 'file' && entry.name.startsWith(basename) && entry.name.endsWith('.json')) {
-				const name = entry.name.slice(basename.length);
-				const basedir = tmpdir + path.dirname(name);
-
-				const code = await entry.text();
-
-				const promise = (async () => {
-					const formatted = await prettier.format(code, { ...prettierConfig, parser: 'json' });
-
-					await fs.mkdir(basedir, { recursive: true });
-					await fs.writeFile(tmpdir + name, formatted);
-				})();
-
-				promises.push(promise);
-			}
-		}
-
-		console.log(`  flushing writes`);
-		await Promise.all(promises);
-	}
-
-	{
-		const source = `https://github.com/${config.repo}/tree/${sha}/${config.path}\n`;
-
-		console.log(`writing readme file`);
-
-		await fs.writeFile(tmpdir + `README.md`, source);
-	}
-
-	{
-		console.log(`moving folder`);
-
-		await fs.rm(config.out, { recursive: true, force: true });
-		await fs.rename(tmpdir, config.out);
-	}
-}
-
-await main();