waitlists!

api/scripts/generate_typescript.ts

···
 interface LexiconDefinition {
   type: string;
   record?: LexiconRecord;
+  properties?: Record<string, LexiconProperty>;
 }
 
 interface Lexicon {
···
 // Convert lexicon type to TypeScript type
 function convertLexiconTypeToTypeScript(
   def: any,
-  currentLexicon: string
+  currentLexicon: string,
+  propertyName?: string
 ): string {
   const type = def.type;
   switch (type) {
     case "string":
+      // For knownValues, return the type alias name
+      if (def.knownValues && Array.isArray(def.knownValues) && def.knownValues.length > 0 && propertyName) {
+        // Reference the generated type alias with namespace
+        const namespace = nsidToNamespace(currentLexicon);
+        return `${namespace}${defNameToPascalCase(propertyName)}`;
+      }
       return "string";
     case "integer":
       return "number";
···
 
   if (defValue.properties) {
     for (const [propName, propDef] of Object.entries(defValue.properties)) {
-      const tsType = convertLexiconTypeToTypeScript(propDef as any, lexicon.id);
+      const tsType = convertLexiconTypeToTypeScript(propDef as any, lexicon.id, propName);
       const required =
         defValue.required && defValue.required.includes(propName);
 
···
 
   if (recordDef.properties) {
     for (const [propName, propDef] of Object.entries(recordDef.properties)) {
-      const tsType = convertLexiconTypeToTypeScript(propDef as any, lexicon.id);
+      const tsType = convertLexiconTypeToTypeScript(propDef as any, lexicon.id, propName);
       const required = isPropertyRequired(recordDef, propName);
 
       properties.push({
···
   });
 }
 
+// Generate type aliases for string fields with knownValues
+function generateKnownValuesTypes(): void {
+  for (const lexicon of lexicons) {
+    if (lexicon.definitions && typeof lexicon.definitions === "object") {
+      for (const [defKey, defValue] of Object.entries(lexicon.definitions)) {
+        if (defValue.type === "record" && defValue.record?.properties) {
+          for (const [propName, propDef] of Object.entries(defValue.record.properties)) {
+            const prop = propDef as any;
+            if (prop.type === "string" && prop.knownValues && Array.isArray(prop.knownValues) && prop.knownValues.length > 0) {
+              // Generate a type alias for this property, namespaced by lexicon
+              const namespace = nsidToNamespace(lexicon.id);
+              const pascalPropName = defNameToPascalCase(propName);
+              const typeName = `${namespace}${pascalPropName}`;
+
+              const knownValueTypes = prop.knownValues.map((value: string) => `'${value}'`).join('\n  | ');
+              const typeDefinition = `${knownValueTypes}\n  | (string & {})`;
+
+              sourceFile.addTypeAlias({
+                name: typeName,
+                isExported: true,
+                type: typeDefinition,
+                leadingTrivia: "\n",
+              });
+            }
+          }
+        } else if (defValue.type === "object" && defValue.properties) {
+          for (const [propName, propDef] of Object.entries(defValue.properties)) {
+            const prop = propDef as any;
+            if (prop.type === "string" && prop.knownValues && Array.isArray(prop.knownValues) && prop.knownValues.length > 0) {
+              // Generate a type alias for this property, namespaced by lexicon
+              const namespace = nsidToNamespace(lexicon.id);
+              const pascalPropName = defNameToPascalCase(propName);
+              const typeName = `${namespace}${pascalPropName}`;
+
+              const knownValueTypes = prop.knownValues.map((value: string) => `'${value}'`).join('\n  | ');
+              const typeDefinition = `${knownValueTypes}\n  | (string & {})`;
+
+              sourceFile.addTypeAlias({
+                name: typeName,
+                isExported: true,
+                type: typeDefinition,
+                leadingTrivia: "\n",
+              });
+            }
+          }
+        } else if (defValue.type === "string") {
+          // Handle standalone string definitions with knownValues (like labelValue)
+          const stringDef = defValue as any;
+          if (stringDef.knownValues && Array.isArray(stringDef.knownValues) && stringDef.knownValues.length > 0) {
+            // Generate a type alias for this definition, namespaced by lexicon
+            const namespace = nsidToNamespace(lexicon.id);
+            const typeName = `${namespace}${defNameToPascalCase(defKey)}`;
+
+            const knownValueTypes = stringDef.knownValues.map((value: string) => `'${value}'`).join('\n  | ');
+            const typeDefinition = `${knownValueTypes}\n  | (string & {})`;
+
+            sourceFile.addTypeAlias({
+              name: typeName,
+              isExported: true,
+              type: typeDefinition,
+              leadingTrivia: "\n",
+            });
+          }
+        }
+      }
+    }
+  }
+}
+
 // Add lexicon-specific interfaces and types
 function addLexiconInterfaces(): void {
   // First pass: Generate all individual definition interfaces/types
···
             isReadonly: true,
           });
           break;
+        case "string":
+          // Check if this is a string type with knownValues
+          const stringDef = defValue as any;
+          if (stringDef.knownValues && Array.isArray(stringDef.knownValues) && stringDef.knownValues.length > 0) {
+            // This generates a type alias, reference it in the namespace with full name
+            namespaceProperties.push({
+              name: defName,
+              type: `${namespace}${defNameToPascalCase(defKey)}`,
+              isReadonly: true,
+            });
+          }
+          break;
         case "union":
         case "array":
         case "token":
···
                 {
                   name: "client",
                   type: "SlicesClient",
-                  scope: "private",
+                  scope: "private" as any,
                   isReadonly: true,
                 },
               ]),
···
 
 // Generate the TypeScript
 addBaseInterfaces();
+generateKnownValuesTypes();
 addLexiconInterfaces();
 addClientClass();
 

api/src/handler_xrpc_dynamic.rs

···
 
     match LexiconValidator::for_slice(&state.database, validation_slice_uri).await {
         Ok(validator) => {
-            // Debug: Get lexicons from the system slice to see what's there
-            if collection == "network.slices.lexicon" {}
 
             if let Err(e) = validator.validate_record(&collection, &record_data) {
                 return Err((
···
                 ));
             }
         }
-        Err(e) => {
+        Err(_e) => {
             // If no lexicon found, continue without validation (backwards compatibility)
-            eprintln!("Could not load lexicon validator: {:?}", e);
         }
     }
 
···
                 ));
             }
         }
-        Err(e) => {
+        Err(_e) => {
             // If no lexicon found, continue without validation (backwards compatibility)
-            eprintln!("Could not load lexicon validator: {:?}", e);
         }
     }
 

docker-compose.yml

···
       HTTP_PORT: "8081"
       DATABASE_URL: "sqlite:///data/aip.db"
       HTTP_CLIENT_TIMEOUT: "30"
-      OAUTH_SUPPORTED_SCOPES: "openid email profile atproto transition:generic account:email blob:image/* repo:network.slices.slice repo:network.slices.lexicon repo:network.slices.actor.profile repo:network.slices.waiting"
+      OAUTH_SUPPORTED_SCOPES: "openid email profile atproto transition:generic account:email blob:image/* repo:network.slices.slice repo:network.slices.lexicon repo:network.slices.actor.profile repo:network.slices.waitlist.request"
       ENABLE_CLIENT_API: "true"
       ADMIN_DIDS: "did:plc:bcgltzqazw5tb6k2g3ttenbj"
       DPOP_NONCE_SEED: "local-dev-nonce-seed"

docs/sdk-usage.md

···
   where: {
     releaseDate: {
       gte: "1990-01-01",
-      lte: "1999-12-31"
+      lte: "1999-12-31",
     },
   },
 });
···
 // Filter by exact handle
 const exactHandle = await client.network.slices.slice.getActors({
   where: {
-    handle: { eq: "alice.bsky.social" },
+    handle: { eq: "user.bsky.social" },
   },
 });
 
···
 // Limit to specific collections
 const specificSearch = await client.network.slices.slice.getSliceRecords({
   where: {
-    collection: { in: ["com.recordcollector.album", "com.recordcollector.review"] },
+    collection: {
+      in: ["com.recordcollector.album", "com.recordcollector.review"],
+    },
     json: { contains: "grunge" },
   },
 });

frontend/deno.json

···
     "jsxImportSource": "preact"
   },
   "imports": {
-    "@slices/client": "jsr:@slices/client@^0.1.0-alpha.2",
+    "@slices/client": "jsr:@slices/client@^0.1.0-alpha.3",
     "@slices/oauth": "jsr:@slices/oauth@^0.4.1",
     "@slices/session": "jsr:@slices/session@^0.2.1",
     "@std/assert": "jsr:@std/assert@^1.0.14",

frontend/deno.lock

···
   "version": "5",
   "specifiers": {
     "jsr:@shikijs/shiki@*": "3.7.0",
-    "jsr:@slices/client@~0.1.0-alpha.2": "0.1.0-alpha.2",
+    "jsr:@slices/client@~0.1.0-alpha.3": "0.1.0-alpha.3",
     "jsr:@slices/oauth@~0.4.1": "0.4.1",
     "jsr:@slices/session@~0.2.1": "0.2.1",
     "jsr:@std/assert@^1.0.14": "1.0.14",
···
         "npm:shiki"
       ]
     },
-    "@slices/client@0.1.0-alpha.2": {
-      "integrity": "d3c591e89ab5b7ed7988faf9428bb7b3539484c6b90005a7c66f2188cc60fe19",
-      "dependencies": [
-        "jsr:@slices/oauth"
-      ]
+    "@slices/client@0.1.0-alpha.3": {
+      "integrity": "c18d6ad2dbe1043bbeb7da7c5a11724fa0fa388c3e6e96089bb033f518c4b23c"
     },
     "@slices/oauth@0.4.1": {
       "integrity": "15f20df2ba81e9d1764291c8b4f6e3eb38cfc953750eeb3815872b7e22475492"
···
   },
   "workspace": {
     "dependencies": [
-      "jsr:@slices/client@~0.1.0-alpha.2",
+      "jsr:@slices/client@~0.1.0-alpha.3",
       "jsr:@slices/oauth@~0.4.1",
       "jsr:@slices/session@~0.2.1",
       "jsr:@std/assert@^1.0.14",

frontend/scripts/register-oauth-client.sh

···
 {
     "client_name": "$CLIENT_NAME",
     "redirect_uris": ["$REDIRECT_URI"],
-    "scope": "openid email profile atproto transition:generic account:email blob:image/* repo:network.slices.slice repo:network.slices.lexicon repo:network.slices.actor.profile repo:network.slices.waiting",
+    "scope": "openid email profile atproto transition:generic account:email blob:image/* repo:network.slices.slice repo:network.slices.lexicon repo:network.slices.actor.profile repo:network.slices.waitlist.request",
     "grant_types": ["authorization_code", "refresh_token"],
     "response_types": ["code"],
     "token_endpoint_auth_method": "client_secret_basic"
···
 echo "  - Client ID: $CLIENT_ID"
 echo "  - Client Name: $CLIENT_NAME"
 echo "  - Redirect URI: $REDIRECT_URI"
-echo "  - Scopes: openid email profile atproto transition:generic account:email blob:image/* repo:network.slices.slice repo:network.slices.lexicon repo:network.slices.actor.profile repo:network.slices.waiting"
+echo "  - Scopes: openid email profile atproto transition:generic account:email blob:image/* repo:network.slices.slice repo:network.slices.lexicon repo:network.slices.actor.profile repo:network.slices.waitlist.request"
 echo "  - Config saved to: $CONFIG_FILE"
 echo
 echo "🔧 Environment variables saved to $CONFIG_FILE:"

frontend/src/client.ts

···
 // Generated TypeScript client for AT Protocol records
-// Generated at: 2025-09-16 21:02:30 UTC
-// Lexicons: 9
+// Generated at: 2025-09-17 17:42:43 UTC
+// Lexicons: 25
 
 /**
  * @example Usage
···
  *   'at://did:plc:bcgltzqazw5tb6k2g3ttenbj/network.slices.slice/3lymhd4jhrd2z'
  * );
  *
- * // Get records from the app.bsky.actor.profile collection
- * const records = await client.app.bsky.actor.profile.getRecords();
+ * // Get records from the app.bsky.graph.follow collection
+ * const records = await client.app.bsky.graph.follow.getRecords();
  *
  * // Get a specific record
- * const record = await client.app.bsky.actor.profile.getRecord({
- *   uri: 'at://did:plc:example/app.bsky.actor.profile/3abc123'
+ * const record = await client.app.bsky.graph.follow.getRecord({
+ *   uri: 'at://did:plc:example/app.bsky.graph.follow/3abc123'
  * });
  *
  * // Get records with filtering and search
- * const filteredRecords = await client.app.bsky.actor.profile.getRecords({
+ * const filteredRecords = await client.app.bsky.graph.follow.getRecords({
  *   where: {
  *     text: { contains: "example search term" }
  *   }
  * });
  *
  * // Use slice-level methods for cross-collection queries with type safety
- * const sliceRecords = await client.network.slices.slice.getSliceRecords<AppBskyActorProfile>({
+ * const sliceRecords = await client.network.slices.slice.getSliceRecords<AppBskyGraphFollow>({
  *   where: {
- *     collection: { eq: 'app.bsky.actor.profile' }
+ *     collection: { eq: 'app.bsky.graph.follow' }
  *   }
  * });
  *
  * // Search across multiple collections using union types
- * const multiCollectionRecords = await client.network.slices.slice.getSliceRecords<AppBskyActorProfile | AppBskyActorProfile>({
+ * const multiCollectionRecords = await client.network.slices.slice.getSliceRecords<AppBskyGraphFollow | AppBskyActorProfile>({
  *   where: {
- *     collection: { in: ['app.bsky.actor.profile', 'app.bsky.actor.profile'] },
+ *     collection: { in: ['app.bsky.graph.follow', 'app.bsky.actor.profile'] },
  *     text: { contains: 'example search term' },
  *     did: { in: ['did:plc:user1', 'did:plc:user2'] }
  *   },
···
   message: string;
 }
 
+export type AppBskyGraphDefsListPurpose =
+  | "app.bsky.graph.defs#modlist"
+  | "app.bsky.graph.defs#curatelist"
+  | "app.bsky.graph.defs#referencelist"
+  | (string & {});
+
+export type AppBskyFeedDefsEvent =
+  | "app.bsky.feed.defs#requestLess"
+  | "app.bsky.feed.defs#requestMore"
+  | "app.bsky.feed.defs#clickthroughItem"
+  | "app.bsky.feed.defs#clickthroughAuthor"
+  | "app.bsky.feed.defs#clickthroughReposter"
+  | "app.bsky.feed.defs#clickthroughEmbed"
+  | "app.bsky.feed.defs#interactionSeen"
+  | "app.bsky.feed.defs#interactionLike"
+  | "app.bsky.feed.defs#interactionRepost"
+  | "app.bsky.feed.defs#interactionReply"
+  | "app.bsky.feed.defs#interactionQuote"
+  | "app.bsky.feed.defs#interactionShare"
+  | (string & {});
+
+export type AppBskyFeedDefsContentMode =
+  | "app.bsky.feed.defs#contentModeUnspecified"
+  | "app.bsky.feed.defs#contentModeVideo"
+  | (string & {});
+
+export type AppBskyActorDefsActorTarget =
+  | "all"
+  | "exclude-following"
+  | (string & {});
+
+export type AppBskyActorDefsType = "feed" | "list" | "timeline" | (string & {});
+
+export type AppBskyActorDefsSort =
+  | "oldest"
+  | "newest"
+  | "most-likes"
+  | "random"
+  | "hotness"
+  | (string & {});
+
+export type AppBskyActorDefsMutedWordTarget = "content" | "tag" | (string & {});
+
+export type AppBskyActorDefsVisibility =
+  | "ignore"
+  | "show"
+  | "warn"
+  | "hide"
+  | (string & {});
+
+export type AppBskyActorDefsAllowIncoming =
+  | "all"
+  | "none"
+  | "following"
+  | (string & {});
+
+export type ComAtprotoLabelDefsLabelValue =
+  | "!hide"
+  | "!no-promote"
+  | "!warn"
+  | "!no-unauthenticated"
+  | "dmca-violation"
+  | "doxxing"
+  | "porn"
+  | "sexual"
+  | "nudity"
+  | "nsfl"
+  | "gore"
+  | (string & {});
+
+export type ComAtprotoLabelDefsBlurs =
+  | "content"
+  | "media"
+  | "none"
+  | (string & {});
+
+export type ComAtprotoLabelDefsSeverity =
+  | "inform"
+  | "alert"
+  | "none"
+  | (string & {});
+
+export type ComAtprotoLabelDefsDefaultSetting =
+  | "ignore"
+  | "warn"
+  | "hide"
+  | (string & {});
+
+export interface AppBskyEmbedDefsAspectRatio {
+  width: number;
+  height: number;
+}
+
+export interface AppBskyEmbedRecordMain {
+  record: ComAtprotoRepoStrongRef;
+}
+
+export interface AppBskyEmbedRecordView {
+  record:
+    | AppBskyEmbedRecord["ViewRecord"]
+    | AppBskyEmbedRecord["ViewNotFound"]
+    | AppBskyEmbedRecord["ViewBlocked"]
+    | AppBskyEmbedRecord["ViewDetached"]
+    | AppBskyFeedDefs["GeneratorView"]
+    | AppBskyGraphDefs["ListView"]
+    | AppBskyLabelerDefs["LabelerView"]
+    | AppBskyGraphDefs["StarterPackViewBasic"]
+    | { $type: string; [key: string]: unknown };
+}
+
+export interface AppBskyEmbedRecordViewRecord {
+  cid: string;
+  uri: string;
+  /** The record data itself. */
+  value: unknown;
+  author: AppBskyActorDefs["ProfileViewBasic"];
+  embeds?:
+    | AppBskyEmbedImages["View"]
+    | AppBskyEmbedVideo["View"]
+    | AppBskyEmbedExternal["View"]
+    | AppBskyEmbedRecord["View"]
+    | AppBskyEmbedRecordWithMedia["View"]
+    | { $type: string; [key: string]: unknown }[];
+  labels?: ComAtprotoLabelDefs["Label"][];
+  indexedAt: string;
+  likeCount?: number;
+  quoteCount?: number;
+  replyCount?: number;
+  repostCount?: number;
+}
+
+export interface AppBskyEmbedRecordViewBlocked {
+  uri: string;
+  author: AppBskyFeedDefs["BlockedAuthor"];
+  blocked: boolean;
+}
+
+export interface AppBskyEmbedRecordViewDetached {
+  uri: string;
+  detached: boolean;
+}
+
+export interface AppBskyEmbedRecordViewNotFound {
+  uri: string;
+  notFound: boolean;
+}
+
+export interface AppBskyEmbedImagesMain {
+  images: AppBskyEmbedImages["Image"][];
+}
+
+export interface AppBskyEmbedImagesView {
+  images: AppBskyEmbedImages["ViewImage"][];
+}
+
+export interface AppBskyEmbedImagesImage {
+  /** Alt text description of the image, for accessibility. */
+  alt: string;
+  image: BlobRef;
+  aspectRatio?: AppBskyEmbedDefs["AspectRatio"];
+}
+
+export interface AppBskyEmbedImagesViewImage {
+  /** Alt text description of the image, for accessibility. */
+  alt: string;
+  /** Fully-qualified URL where a thumbnail of the image can be fetched. For example, CDN location provided by the App View. */
+  thumb: string;
+  /** Fully-qualified URL where a large version of the image can be fetched. May or may not be the exact original blob. For example, CDN location provided by the App View. */
+  fullsize: string;
+  aspectRatio?: AppBskyEmbedDefs["AspectRatio"];
+}
+
+export interface AppBskyEmbedRecordWithMediaMain {
+  media:
+    | AppBskyEmbedImages["Main"]
+    | AppBskyEmbedVideo["Main"]
+    | AppBskyEmbedExternal["Main"]
+    | { $type: string; [key: string]: unknown };
+  record: AppBskyEmbedRecord["Main"];
+}
+
+export interface AppBskyEmbedRecordWithMediaView {
+  media:
+    | AppBskyEmbedImages["View"]
+    | AppBskyEmbedVideo["View"]
+    | AppBskyEmbedExternal["View"]
+    | { $type: string; [key: string]: unknown };
+  record: AppBskyEmbedRecord["View"];
+}
+
+export interface AppBskyEmbedVideoMain {
+  /** Alt text description of the video, for accessibility. */
+  alt?: string;
+  video: BlobRef;
+  captions?: AppBskyEmbedVideo["Caption"][];
+  aspectRatio?: AppBskyEmbedDefs["AspectRatio"];
+}
+
+export interface AppBskyEmbedVideoView {
+  alt?: string;
+  cid: string;
+  playlist: string;
+  thumbnail?: string;
+  aspectRatio?: AppBskyEmbedDefs["AspectRatio"];
+}
+
+export interface AppBskyEmbedVideoCaption {
+  file: BlobRef;
+  lang: string;
+}
+
+export interface AppBskyEmbedExternalMain {
+  external: AppBskyEmbedExternal["External"];
+}
+
+export interface AppBskyEmbedExternalView {
+  external: AppBskyEmbedExternal["ViewExternal"];
+}
+
+export interface AppBskyEmbedExternalExternal {
+  uri: string;
+  thumb?: BlobRef;
+  title: string;
+  description: string;
+}
+
+export interface AppBskyEmbedExternalViewExternal {
+  uri: string;
+  thumb?: string;
+  title: string;
+  description: string;
+}
+
+export interface AppBskyGraphFollow {
+  subject: string;
+  createdAt: string;
+}
+
+export type AppBskyGraphFollowSortFields = "subject" | "createdAt";
+export type AppBskyGraphDefsModlist = "app.bsky.graph.defs#modlist";
+
+export interface AppBskyGraphDefsListView {
+  cid: string;
+  uri: string;
+  name: string;
+  avatar?: string;
+  labels?: ComAtprotoLabelDefs["Label"][];
+  viewer?: AppBskyGraphDefs["ListViewerState"];
+  creator: AppBskyActorDefs["ProfileView"];
+  purpose: AppBskyGraphDefs["ListPurpose"];
+  indexedAt: string;
+  description?: string;
+  listItemCount?: number;
+  descriptionFacets?: AppBskyRichtextFacet["Main"][];
+}
+
+export type AppBskyGraphDefsCuratelist = "app.bsky.graph.defs#curatelist";
+
+export interface AppBskyGraphDefsListItemView {
+  uri: string;
+  subject: AppBskyActorDefs["ProfileView"];
+}
+
+export interface AppBskyGraphDefsRelationship {
+  did: string;
+  /** if the actor follows this DID, this is the AT-URI of the follow record */
+  following?: string;
+  /** if the actor is followed by this DID, contains the AT-URI of the follow record */
+  followedBy?: string;
+}
+
+export interface AppBskyGraphDefsListViewBasic {
+  cid: string;
+  uri: string;
+  name: string;
+  avatar?: string;
+  labels?: ComAtprotoLabelDefs["Label"][];
+  viewer?: AppBskyGraphDefs["ListViewerState"];
+  purpose: AppBskyGraphDefs["ListPurpose"];
+  indexedAt?: string;
+  listItemCount?: number;
+}
+
+export interface AppBskyGraphDefsNotFoundActor {
+  actor: string;
+  notFound: boolean;
+}
+
+export type AppBskyGraphDefsReferencelist = "app.bsky.graph.defs#referencelist";
+
+export interface AppBskyGraphDefsListViewerState {
+  muted?: boolean;
+  blocked?: string;
+}
+
+export interface AppBskyGraphDefsStarterPackView {
+  cid: string;
+  uri: string;
+  list?: AppBskyGraphDefs["ListViewBasic"];
+  feeds?: AppBskyFeedDefs["GeneratorView"][];
+  labels?: ComAtprotoLabelDefs["Label"][];
+  record: unknown;
+  creator: AppBskyActorDefs["ProfileViewBasic"];
+  indexedAt: string;
+  joinedWeekCount?: number;
+  listItemsSample?: AppBskyGraphDefs["ListItemView"][];
+  joinedAllTimeCount?: number;
+}
+
+export interface AppBskyGraphDefsStarterPackViewBasic {
+  cid: string;
+  uri: string;
+  labels?: ComAtprotoLabelDefs["Label"][];
+  record: unknown;
+  creator: AppBskyActorDefs["ProfileViewBasic"];
+  indexedAt: string;
+  listItemCount?: number;
+  joinedWeekCount?: number;
+  joinedAllTimeCount?: number;
+}
+
+export interface AppBskyFeedDefsPostView {
+  cid: string;
+  uri: string;
+  embed?:
+    | AppBskyEmbedImages["View"]
+    | AppBskyEmbedVideo["View"]
+    | AppBskyEmbedExternal["View"]
+    | AppBskyEmbedRecord["View"]
+    | AppBskyEmbedRecordWithMedia["View"]
+    | { $type: string; [key: string]: unknown };
+  author: AppBskyActorDefs["ProfileViewBasic"];
+  labels?: ComAtprotoLabelDefs["Label"][];
+  record: unknown;
+  viewer?: AppBskyFeedDefs["ViewerState"];
+  indexedAt: string;
+  likeCount?: number;
+  quoteCount?: number;
+  replyCount?: number;
+  threadgate?: AppBskyFeedDefs["ThreadgateView"];
+  repostCount?: number;
+}
+
+export interface AppBskyFeedDefsReplyRef {
+  root:
+    | AppBskyFeedDefs["PostView"]
+    | AppBskyFeedDefs["NotFoundPost"]
+    | AppBskyFeedDefs["BlockedPost"]
+    | { $type: string; [key: string]: unknown };
+  parent:
+    | AppBskyFeedDefs["PostView"]
+    | AppBskyFeedDefs["NotFoundPost"]
+    | AppBskyFeedDefs["BlockedPost"]
+    | { $type: string; [key: string]: unknown };
+  /** When parent is a reply to another post, this is the author of that post. */
+  grandparentAuthor?: AppBskyActorDefs["ProfileViewBasic"];
+}
+
+export interface AppBskyFeedDefsReasonPin {}
+
+export interface AppBskyFeedDefsBlockedPost {
+  uri: string;
+  author: AppBskyFeedDefs["BlockedAuthor"];
+  blocked: boolean;
+}
+
+export interface AppBskyFeedDefsInteraction {
+  item?: string;
+  event?: AppBskyFeedDefsEvent;
+  /** Context on a feed item that was originally supplied by the feed generator on getFeedSkeleton. */
+  feedContext?: string;
+}
+
+export type AppBskyFeedDefsRequestLess = "app.bsky.feed.defs#requestLess";
+export type AppBskyFeedDefsRequestMore = "app.bsky.feed.defs#requestMore";
+
+export interface AppBskyFeedDefsViewerState {
+  like?: string;
+  pinned?: boolean;
+  repost?: string;
+  threadMuted?: boolean;
+  replyDisabled?: boolean;
+  embeddingDisabled?: boolean;
+}
+
+export interface AppBskyFeedDefsFeedViewPost {
+  post: AppBskyFeedDefs["PostView"];
+  reply?: AppBskyFeedDefs["ReplyRef"];
+  reason?:
+    | AppBskyFeedDefs["ReasonRepost"]
+    | AppBskyFeedDefs["ReasonPin"]
+    | {
+        $type: string;
+        [key: string]: unknown;
+      };
+  /** Context provided by feed generator that may be passed back alongside interactions. */
+  feedContext?: string;
+}
+
+export interface AppBskyFeedDefsNotFoundPost {
+  uri: string;
+  notFound: boolean;
+}
+
+export interface AppBskyFeedDefsReasonRepost {
+  by: AppBskyActorDefs["ProfileViewBasic"];
+  indexedAt: string;
+}
+
+export interface AppBskyFeedDefsBlockedAuthor {
+  did: string;
+  viewer?: AppBskyActorDefs["ViewerState"];
+}
+
+export interface AppBskyFeedDefsGeneratorView {
+  cid: string;
+  did: string;
+  uri: string;
+  avatar?: string;
+  labels?: ComAtprotoLabelDefs["Label"][];
+  viewer?: AppBskyFeedDefs["GeneratorViewerState"];
+  creator: AppBskyActorDefs["ProfileView"];
+  indexedAt: string;
+  likeCount?: number;
+  contentMode?: AppBskyFeedDefsContentMode;
+  description?: string;
+  displayName: string;
+  descriptionFacets?: AppBskyRichtextFacet["Main"][];
+  acceptsInteractions?: boolean;
+}
+
+export interface AppBskyFeedDefsThreadContext {
+  rootAuthorLike?: string;
+}
+
+export interface AppBskyFeedDefsThreadViewPost {
+  post: AppBskyFeedDefs["PostView"];
+  parent?:
+    | AppBskyFeedDefs["ThreadViewPost"]
+    | AppBskyFeedDefs["NotFoundPost"]
+    | AppBskyFeedDefs["BlockedPost"]
+    | { $type: string; [key: string]: unknown };
+  replies?:
+    | AppBskyFeedDefs["ThreadViewPost"]
+    | AppBskyFeedDefs["NotFoundPost"]
+    | AppBskyFeedDefs["BlockedPost"]
+    | { $type: string; [key: string]: unknown }[];
+  threadContext?: AppBskyFeedDefs["ThreadContext"];
+}
+
+export interface AppBskyFeedDefsThreadgateView {
+  cid?: string;
+  uri?: string;
+  lists?: AppBskyGraphDefs["ListViewBasic"][];
+  record?: unknown;
+}
+
+export type AppBskyFeedDefsInteractionLike =
+  "app.bsky.feed.defs#interactionLike";
+export type AppBskyFeedDefsInteractionSeen =
+  "app.bsky.feed.defs#interactionSeen";
+export type AppBskyFeedDefsClickthroughItem =
+  "app.bsky.feed.defs#clickthroughItem";
+export type AppBskyFeedDefsContentModeVideo =
+  "app.bsky.feed.defs#contentModeVideo";
+export type AppBskyFeedDefsInteractionQuote =
+  "app.bsky.feed.defs#interactionQuote";
+export type AppBskyFeedDefsInteractionReply =
+  "app.bsky.feed.defs#interactionReply";
+export type AppBskyFeedDefsInteractionShare =
+  "app.bsky.feed.defs#interactionShare";
+
+export interface AppBskyFeedDefsSkeletonFeedPost {
+  post: string;
+  reason?:
+    | AppBskyFeedDefs["SkeletonReasonRepost"]
+    | AppBskyFeedDefs["SkeletonReasonPin"]
+    | { $type: string; [key: string]: unknown };
+  /** Context that will be passed through to client and may be passed to feed generator back alongside interactions. */
+  feedContext?: string;
+}
+
+export type AppBskyFeedDefsClickthroughEmbed =
+  "app.bsky.feed.defs#clickthroughEmbed";
+export type AppBskyFeedDefsInteractionRepost =
+  "app.bsky.feed.defs#interactionRepost";
+
+export interface AppBskyFeedDefsSkeletonReasonPin {}
+
+export type AppBskyFeedDefsClickthroughAuthor =
+  "app.bsky.feed.defs#clickthroughAuthor";
+export type AppBskyFeedDefsClickthroughReposter =
+  "app.bsky.feed.defs#clickthroughReposter";
+
+export interface AppBskyFeedDefsGeneratorViewerState {
+  like?: string;
+}
+
+export interface AppBskyFeedDefsSkeletonReasonRepost {
+  repost: string;
+}
+
+export type AppBskyFeedDefsContentModeUnspecified =
+  "app.bsky.feed.defs#contentModeUnspecified";
+
+export interface AppBskyFeedPostgate {
+  /** Reference (AT-URI) to the post record. */
+  post: string;
+  createdAt: string;
+  /** List of rules defining who can embed this post. If value is an empty array or is undefined, no particular rules apply and anyone can embed. */
+  embeddingRules?:
+    | AppBskyFeedPostgate["DisableRule"]
+    | {
+        $type: string;
+        [key: string]: unknown;
+      }[];
+  /** List of AT-URIs embedding this post that the author has detached from. */
+  detachedEmbeddingUris?: string[];
+}
+
+export type AppBskyFeedPostgateSortFields = "post" | "createdAt";
+
+export interface AppBskyFeedPostgateDisableRule {}
+
+export interface AppBskyFeedThreadgate {
+  /** Reference (AT-URI) to the post record. */
+  post: string;
+  /** List of rules defining who can reply to this post. If value is an empty array, no one can reply. If value is undefined, anyone can reply. */
+  allow?:
+    | AppBskyFeedThreadgate["MentionRule"]
+    | AppBskyFeedThreadgate["FollowerRule"]
+    | AppBskyFeedThreadgate["FollowingRule"]
+    | AppBskyFeedThreadgate["ListRule"]
+    | { $type: string; [key: string]: unknown }[];
+  createdAt: string;
+  /** List of hidden reply URIs. */
+  hiddenReplies?: string[];
+}
+
+export type AppBskyFeedThreadgateSortFields = "post" | "createdAt";
+
+export interface AppBskyFeedThreadgateListRule {
+  list: string;
+}
+
+export interface AppBskyFeedThreadgateMentionRule {}
+
+export interface AppBskyFeedThreadgateFollowerRule {}
+
+export interface AppBskyFeedThreadgateFollowingRule {}
+
+export interface AppBskyRichtextFacetTag {
+  tag: string;
+}
+
+export interface AppBskyRichtextFacetLink {
+  uri: string;
+}
+
+export interface AppBskyRichtextFacetMain {
+  index: AppBskyRichtextFacet["ByteSlice"];
+  features:
+    | AppBskyRichtextFacet["Mention"]
+    | AppBskyRichtextFacet["Link"]
+    | AppBskyRichtextFacet["Tag"]
+    | { $type: string; [key: string]: unknown }[];
+}
+
+export interface AppBskyRichtextFacetMention {
+  did: string;
+}
+
+export interface AppBskyRichtextFacetByteSlice {
+  byteEnd: number;
+  byteStart: number;
+}
+
+export interface AppBskyActorDefsNux {
+  id: string;
+  /** Arbitrary data for the NUX. The structure is defined by the NUX itself. Limited to 300 characters. */
+  data?: string;
+  completed: boolean;
+  /** The date and time at which the NUX will expire and should be considered completed. */
+  expiresAt?: string;
+}
+
+export interface AppBskyActorDefsMutedWord {
+  id?: string;
+  /** The muted word itself. */
+  value: string;
+  /** The intended targets of the muted word. */
+  targets: AppBskyActorDefs["MutedWordTarget"][];
+  /** The date and time at which the muted word will expire and no longer be applied. */
+  expiresAt?: string;
+  /** Groups of users to apply the muted word to. If undefined, applies to all users. */
+  actorTarget?: AppBskyActorDefsActorTarget;
+}
+
+export interface AppBskyActorDefsSavedFeed {
+  id: string;
+  type: AppBskyActorDefsType;
+  value: string;
+  pinned: boolean;
+}
+
+export type AppBskyActorDefsPreferences =
+  | AppBskyActorDefs["AdultContentPref"]
+  | AppBskyActorDefs["ContentLabelPref"]
+  | AppBskyActorDefs["SavedFeedsPref"]
+  | AppBskyActorDefs["SavedFeedsPrefV2"]
+  | AppBskyActorDefs["PersonalDetailsPref"]
+  | AppBskyActorDefs["FeedViewPref"]
+  | AppBskyActorDefs["ThreadViewPref"]
+  | AppBskyActorDefs["InterestsPref"]
+  | AppBskyActorDefs["MutedWordsPref"]
+  | AppBskyActorDefs["HiddenPostsPref"]
+  | AppBskyActorDefs["BskyAppStatePref"]
+  | AppBskyActorDefs["LabelersPref"]
+  | AppBskyActorDefs["PostInteractionSettingsPref"]
+  | { $type: string; [key: string]: unknown }[];
+
+export interface AppBskyActorDefsProfileView {
+  did: string;
+  avatar?: string;
+  handle: string;
+  labels?: ComAtprotoLabelDefs["Label"][];
+  viewer?: AppBskyActorDefs["ViewerState"];
+  createdAt?: string;
+  indexedAt?: string;
+  associated?: AppBskyActorDefs["ProfileAssociated"];
+  description?: string;
+  displayName?: string;
+}
+
+export interface AppBskyActorDefsViewerState {
+  muted?: boolean;
+  blocking?: string;
+  blockedBy?: boolean;
+  following?: string;
+  followedBy?: string;
+  mutedByList?: AppBskyGraphDefs["ListViewBasic"];
+  blockingByList?: AppBskyGraphDefs["ListViewBasic"];
+  knownFollowers?: AppBskyActorDefs["KnownFollowers"];
+}
+
+export interface AppBskyActorDefsFeedViewPref {
+  /** The URI of the feed, or an identifier which describes the feed. */
+  feed: string;
+  /** Hide replies in the feed. */
+  hideReplies?: boolean;
+  /** Hide reposts in the feed. */
+  hideReposts?: boolean;
+  /** Hide quote posts in the feed. */
+  hideQuotePosts?: boolean;
+  /** Hide replies in the feed if they do not have this number of likes. */
+  hideRepliesByLikeCount?: number;
+  /** Hide replies in the feed if they are not by followed users. */
+  hideRepliesByUnfollowed?: boolean;
+}
+
+export interface AppBskyActorDefsLabelersPref {
+  labelers: AppBskyActorDefs["LabelerPrefItem"][];
+}
+
+export interface AppBskyActorDefsInterestsPref {
+  /** A list of tags which describe the account owner's interests gathered during onboarding. */
+  tags: string[];
+}
+
+export interface AppBskyActorDefsKnownFollowers {
+  count: number;
+  followers: AppBskyActorDefs["ProfileViewBasic"][];
+}
+
+export interface AppBskyActorDefsMutedWordsPref {
+  /** A list of words the account owner has muted. */
+  items: AppBskyActorDefs["MutedWord"][];
+}
+
+export interface AppBskyActorDefsSavedFeedsPref {
+  saved: string[];
+  pinned: string[];
+  timelineIndex?: number;
+}
+
+export interface AppBskyActorDefsThreadViewPref {
+  /** Sorting mode for threads. */
+  sort?: AppBskyActorDefsSort;
+  /** Show followed users at the top of all replies. */
+  prioritizeFollowedUsers?: boolean;
+}
+
+export interface AppBskyActorDefsHiddenPostsPref {
+  /** A list of URIs of posts the account owner has hidden. */
+  items: string[];
+}
+
+export interface AppBskyActorDefsLabelerPrefItem {
+  did: string;
+}
+
+export interface AppBskyActorDefsAdultContentPref {
+  enabled: boolean;
+}
+
+export interface AppBskyActorDefsBskyAppStatePref {
+  /** Storage for NUXs the user has encountered. */
+  nuxs?: AppBskyActorDefs["Nux"][];
+  /** An array of tokens which identify nudges (modals, popups, tours, highlight dots) that should be shown to the user. */
+  queuedNudges?: string[];
+  activeProgressGuide?: AppBskyActorDefs["BskyAppProgressGuide"];
+}
+
+export interface AppBskyActorDefsContentLabelPref {
+  label: string;
+  /** Which labeler does this preference apply to? If undefined, applies globally. */
+  labelerDid?: string;
+  visibility: AppBskyActorDefsVisibility;
+}
+
+export interface AppBskyActorDefsProfileViewBasic {
+  did: string;
+  avatar?: string;
+  handle: string;
+  labels?: ComAtprotoLabelDefs["Label"][];
+  viewer?: AppBskyActorDefs["ViewerState"];
+  createdAt?: string;
+  associated?: AppBskyActorDefs["ProfileAssociated"];
+  displayName?: string;
+}
+
+export interface AppBskyActorDefsSavedFeedsPrefV2 {
+  items: AppBskyActorDefs["SavedFeed"][];
+}
+
+export interface AppBskyActorDefsProfileAssociated {
+  chat?: AppBskyActorDefs["ProfileAssociatedChat"];
+  lists?: number;
+  labeler?: boolean;
+  feedgens?: number;
+  starterPacks?: number;
+}
+
+export interface AppBskyActorDefsPersonalDetailsPref {
+  /** The birth date of account owner. */
+  birthDate?: string;
+}
+
+export interface AppBskyActorDefsProfileViewDetailed {
+  did: string;
+  avatar?: string;
+  banner?: string;
+  handle: string;
+  labels?: ComAtprotoLabelDefs["Label"][];
+  viewer?: AppBskyActorDefs["ViewerState"];
+  createdAt?: string;
+  indexedAt?: string;
+  associated?: AppBskyActorDefs["ProfileAssociated"];
+  pinnedPost?: ComAtprotoRepoStrongRef;
+  postsCount?: number;
+  description?: string;
+  displayName?: string;
+  followsCount?: number;
+  followersCount?: number;
+  joinedViaStarterPack?: AppBskyGraphDefs["StarterPackViewBasic"];
+}
+
+export interface AppBskyActorDefsBskyAppProgressGuide {
+  guide: string;
+}
+
+export interface AppBskyActorDefsProfileAssociatedChat {
+  allowIncoming: AppBskyActorDefsAllowIncoming;
+}
+
+export interface AppBskyActorDefsPostInteractionSettingsPref {
+  /** Matches threadgate record. List of rules defining who can reply to this users posts. If value is an empty array, no one can reply. If value is undefined, anyone can reply. */
+  threadgateAllowRules?:
+    | AppBskyFeedThreadgate["MentionRule"]
+    | AppBskyFeedThreadgate["FollowerRule"]
+    | AppBskyFeedThreadgate["FollowingRule"]
+    | AppBskyFeedThreadgate["ListRule"]
+    | { $type: string; [key: string]: unknown }[];
+  /** Matches postgate record. List of rules defining who can embed this users posts. If value is an empty array or is undefined, no particular rules apply and anyone can embed. */
+  postgateEmbeddingRules?:
+    | AppBskyFeedPostgate["DisableRule"]
+    | {
+        $type: string;
+        [key: string]: unknown;
+      }[];
+}
+
 export interface AppBskyActorProfile {
   /** Small image to be displayed next to posts from account. AKA, 'profile picture' */
   avatar?: BlobRef;
···
   | "description"
   | "displayName";
 
+export interface AppBskyLabelerDefsLabelerView {
+  cid: string;
+  uri: string;
+  labels?: ComAtprotoLabelDefs["Label"][];
+  viewer?: AppBskyLabelerDefs["LabelerViewerState"];
+  creator: AppBskyActorDefs["ProfileView"];
+  indexedAt: string;
+  likeCount?: number;
+}
+
+export interface AppBskyLabelerDefsLabelerPolicies {
+  /** The label values which this labeler publishes. May include global or custom labels. */
+  labelValues: ComAtprotoLabelDefs["LabelValue"][];
+  /** Label values created by this labeler and scoped exclusively to it. Labels defined here will override global label definitions for this labeler. */
+  labelValueDefinitions?: ComAtprotoLabelDefs["LabelValueDefinition"][];
+}
+
+export interface AppBskyLabelerDefsLabelerViewerState {
+  like?: string;
+}
+
+export interface AppBskyLabelerDefsLabelerViewDetailed {
+  cid: string;
+  uri: string;
+  labels?: ComAtprotoLabelDefs["Label"][];
+  viewer?: AppBskyLabelerDefs["LabelerViewerState"];
+  creator: AppBskyActorDefs["ProfileView"];
+  policies: AppBskyLabelerDefs["LabelerPolicies"];
+  indexedAt: string;
+  likeCount?: number;
+}
+
+export interface NetworkSlicesWaitlistRequest {
+  /** The AT URI of the slice being requested access to */
+  slice: string;
+  /** When the user joined the waitlist */
+  createdAt: string;
+}
+
+export type NetworkSlicesWaitlistRequestSortFields = "slice" | "createdAt";
+
+export interface NetworkSlicesWaitlistDefsRequestView {
+  /** The AT URI of the slice being requested access to */
+  slice: string;
+  /** When the user joined the waitlist */
+  createdAt: string;
+  /** Profile of the requester */
+  profile?: AppBskyActorDefs["ProfileViewBasic"];
+}
+
+export interface NetworkSlicesWaitlistDefsInviteView {
+  /** The DID being invited */
+  did: string;
+  /** The AT URI of the slice this invite is for */
+  slice: string;
+  /** When this invitation was created */
+  createdAt: string;
+  /** Optional expiration date for this invitation */
+  expiresAt?: string;
+  /** The AT URI of this invite record */
+  uri?: string;
+  /** Profile of the invitee */
+  profile?: AppBskyActorDefs["ProfileViewBasic"];
+}
+
+export interface NetworkSlicesWaitlistInvite {
+  /** The DID being invited */
+  did: string;
+  /** The AT URI of the slice this invite is for */
+  slice: string;
+  /** When this invitation was created */
+  createdAt: string;
+  /** Optional expiration date for this invitation */
+  expiresAt?: string;
+}
+
+export type NetworkSlicesWaitlistInviteSortFields =
+  | "did"
+  | "slice"
+  | "createdAt"
+  | "expiresAt";
+
 export interface NetworkSlicesSliceDefsSliceView {
   uri: string;
   cid: string;
···
 }
 
 export type NetworkSlicesSliceSortFields = "name" | "domain" | "createdAt";
-
-export interface NetworkSlicesWaiting {
-  /** When the user joined the waitlist */
-  createdAt: string;
-}
-
-export type NetworkSlicesWaitingSortFields = "createdAt";
 
 export interface NetworkSlicesLexicon {
   /** Namespaced identifier for the lexicon */
···
 
 export interface ComAtprotoLabelDefsLabelValueDefinition {
   /** What should this label hide in the UI, if applied? 'content' hides all of the target; 'media' hides the images/video/audio; 'none' hides nothing. */
-  blurs: string;
+  blurs: ComAtprotoLabelDefsBlurs;
   locales: ComAtprotoLabelDefs["LabelValueDefinitionStrings"][];
   /** How should a client visually convey this label? 'inform' means neutral and informational; 'alert' means negative and warning; 'none' means show nothing. */
-  severity: string;
+  severity: ComAtprotoLabelDefsSeverity;
   /** Does the user need to have adult content enabled in order to configure this label? */
   adultOnly?: boolean;
   /** The value of the label being defined. Must only include lowercase ascii and the '-' character ([a-z-]+). */
   identifier: string;
   /** The default setting for this label. */
-  defaultSetting?: string;
+  defaultSetting?: ComAtprotoLabelDefsDefaultSetting;
 }
 
 export interface ComAtprotoLabelDefsLabelValueDefinitionStrings {
···
   uri: string;
 }
 
+export interface AppBskyEmbedDefs {
+  readonly AspectRatio: AppBskyEmbedDefsAspectRatio;
+}
+
+export interface AppBskyEmbedRecord {
+  readonly Main: AppBskyEmbedRecordMain;
+  readonly View: AppBskyEmbedRecordView;
+  readonly ViewRecord: AppBskyEmbedRecordViewRecord;
+  readonly ViewBlocked: AppBskyEmbedRecordViewBlocked;
+  readonly ViewDetached: AppBskyEmbedRecordViewDetached;
+  readonly ViewNotFound: AppBskyEmbedRecordViewNotFound;
+}
+
+export interface AppBskyEmbedImages {
+  readonly Main: AppBskyEmbedImagesMain;
+  readonly View: AppBskyEmbedImagesView;
+  readonly Image: AppBskyEmbedImagesImage;
+  readonly ViewImage: AppBskyEmbedImagesViewImage;
+}
+
+export interface AppBskyEmbedRecordWithMedia {
+  readonly Main: AppBskyEmbedRecordWithMediaMain;
+  readonly View: AppBskyEmbedRecordWithMediaView;
+}
+
+export interface AppBskyEmbedVideo {
+  readonly Main: AppBskyEmbedVideoMain;
+  readonly View: AppBskyEmbedVideoView;
+  readonly Caption: AppBskyEmbedVideoCaption;
+}
+
+export interface AppBskyEmbedExternal {
+  readonly Main: AppBskyEmbedExternalMain;
+  readonly View: AppBskyEmbedExternalView;
+  readonly External: AppBskyEmbedExternalExternal;
+  readonly ViewExternal: AppBskyEmbedExternalViewExternal;
+}
+
+export interface AppBskyGraphDefs {
+  readonly Modlist: AppBskyGraphDefsModlist;
+  readonly ListView: AppBskyGraphDefsListView;
+  readonly Curatelist: AppBskyGraphDefsCuratelist;
+  readonly ListPurpose: AppBskyGraphDefsListPurpose;
+  readonly ListItemView: AppBskyGraphDefsListItemView;
+  readonly Relationship: AppBskyGraphDefsRelationship;
+  readonly ListViewBasic: AppBskyGraphDefsListViewBasic;
+  readonly NotFoundActor: AppBskyGraphDefsNotFoundActor;
+  readonly Referencelist: AppBskyGraphDefsReferencelist;
+  readonly ListViewerState: AppBskyGraphDefsListViewerState;
+  readonly StarterPackView: AppBskyGraphDefsStarterPackView;
+  readonly StarterPackViewBasic: AppBskyGraphDefsStarterPackViewBasic;
+}
+
+export interface AppBskyFeedDefs {
+  readonly PostView: AppBskyFeedDefsPostView;
+  readonly ReplyRef: AppBskyFeedDefsReplyRef;
+  readonly ReasonPin: AppBskyFeedDefsReasonPin;
+  readonly BlockedPost: AppBskyFeedDefsBlockedPost;
+  readonly Interaction: AppBskyFeedDefsInteraction;
+  readonly RequestLess: AppBskyFeedDefsRequestLess;
+  readonly RequestMore: AppBskyFeedDefsRequestMore;
+  readonly ViewerState: AppBskyFeedDefsViewerState;
+  readonly FeedViewPost: AppBskyFeedDefsFeedViewPost;
+  readonly NotFoundPost: AppBskyFeedDefsNotFoundPost;
+  readonly ReasonRepost: AppBskyFeedDefsReasonRepost;
+  readonly BlockedAuthor: AppBskyFeedDefsBlockedAuthor;
+  readonly GeneratorView: AppBskyFeedDefsGeneratorView;
+  readonly ThreadContext: AppBskyFeedDefsThreadContext;
+  readonly ThreadViewPost: AppBskyFeedDefsThreadViewPost;
+  readonly ThreadgateView: AppBskyFeedDefsThreadgateView;
+  readonly InteractionLike: AppBskyFeedDefsInteractionLike;
+  readonly InteractionSeen: AppBskyFeedDefsInteractionSeen;
+  readonly ClickthroughItem: AppBskyFeedDefsClickthroughItem;
+  readonly ContentModeVideo: AppBskyFeedDefsContentModeVideo;
+  readonly InteractionQuote: AppBskyFeedDefsInteractionQuote;
+  readonly InteractionReply: AppBskyFeedDefsInteractionReply;
+  readonly InteractionShare: AppBskyFeedDefsInteractionShare;
+  readonly SkeletonFeedPost: AppBskyFeedDefsSkeletonFeedPost;
+  readonly ClickthroughEmbed: AppBskyFeedDefsClickthroughEmbed;
+  readonly InteractionRepost: AppBskyFeedDefsInteractionRepost;
+  readonly SkeletonReasonPin: AppBskyFeedDefsSkeletonReasonPin;
+  readonly ClickthroughAuthor: AppBskyFeedDefsClickthroughAuthor;
+  readonly ClickthroughReposter: AppBskyFeedDefsClickthroughReposter;
+  readonly GeneratorViewerState: AppBskyFeedDefsGeneratorViewerState;
+  readonly SkeletonReasonRepost: AppBskyFeedDefsSkeletonReasonRepost;
+  readonly ContentModeUnspecified: AppBskyFeedDefsContentModeUnspecified;
+}
+
+export interface AppBskyFeedPostgate {
+  readonly Main: AppBskyFeedPostgate;
+  readonly DisableRule: AppBskyFeedPostgateDisableRule;
+}
+
+export interface AppBskyFeedThreadgate {
+  readonly Main: AppBskyFeedThreadgate;
+  readonly ListRule: AppBskyFeedThreadgateListRule;
+  readonly MentionRule: AppBskyFeedThreadgateMentionRule;
+  readonly FollowerRule: AppBskyFeedThreadgateFollowerRule;
+  readonly FollowingRule: AppBskyFeedThreadgateFollowingRule;
+}
+
+export interface AppBskyRichtextFacet {
+  readonly Tag: AppBskyRichtextFacetTag;
+  readonly Link: AppBskyRichtextFacetLink;
+  readonly Main: AppBskyRichtextFacetMain;
+  readonly Mention: AppBskyRichtextFacetMention;
+  readonly ByteSlice: AppBskyRichtextFacetByteSlice;
+}
+
+export interface AppBskyActorDefs {
+  readonly Nux: AppBskyActorDefsNux;
+  readonly MutedWord: AppBskyActorDefsMutedWord;
+  readonly SavedFeed: AppBskyActorDefsSavedFeed;
+  readonly Preferences: AppBskyActorDefsPreferences;
+  readonly ProfileView: AppBskyActorDefsProfileView;
+  readonly ViewerState: AppBskyActorDefsViewerState;
+  readonly FeedViewPref: AppBskyActorDefsFeedViewPref;
+  readonly LabelersPref: AppBskyActorDefsLabelersPref;
+  readonly InterestsPref: AppBskyActorDefsInterestsPref;
+  readonly KnownFollowers: AppBskyActorDefsKnownFollowers;
+  readonly MutedWordsPref: AppBskyActorDefsMutedWordsPref;
+  readonly SavedFeedsPref: AppBskyActorDefsSavedFeedsPref;
+  readonly ThreadViewPref: AppBskyActorDefsThreadViewPref;
+  readonly HiddenPostsPref: AppBskyActorDefsHiddenPostsPref;
+  readonly LabelerPrefItem: AppBskyActorDefsLabelerPrefItem;
+  readonly MutedWordTarget: AppBskyActorDefsMutedWordTarget;
+  readonly AdultContentPref: AppBskyActorDefsAdultContentPref;
+  readonly BskyAppStatePref: AppBskyActorDefsBskyAppStatePref;
+  readonly ContentLabelPref: AppBskyActorDefsContentLabelPref;
+  readonly ProfileViewBasic: AppBskyActorDefsProfileViewBasic;
+  readonly SavedFeedsPrefV2: AppBskyActorDefsSavedFeedsPrefV2;
+  readonly ProfileAssociated: AppBskyActorDefsProfileAssociated;
+  readonly PersonalDetailsPref: AppBskyActorDefsPersonalDetailsPref;
+  readonly ProfileViewDetailed: AppBskyActorDefsProfileViewDetailed;
+  readonly BskyAppProgressGuide: AppBskyActorDefsBskyAppProgressGuide;
+  readonly ProfileAssociatedChat: AppBskyActorDefsProfileAssociatedChat;
+  readonly PostInteractionSettingsPref: AppBskyActorDefsPostInteractionSettingsPref;
+}
+
+export interface AppBskyLabelerDefs {
+  readonly LabelerView: AppBskyLabelerDefsLabelerView;
+  readonly LabelerPolicies: AppBskyLabelerDefsLabelerPolicies;
+  readonly LabelerViewerState: AppBskyLabelerDefsLabelerViewerState;
+  readonly LabelerViewDetailed: AppBskyLabelerDefsLabelerViewDetailed;
+}
+
+export interface NetworkSlicesWaitlistDefs {
+  readonly RequestView: NetworkSlicesWaitlistDefsRequestView;
+  readonly InviteView: NetworkSlicesWaitlistDefsInviteView;
+}
+
 export interface NetworkSlicesSliceDefs {
   readonly SliceView: NetworkSlicesSliceDefsSliceView;
   readonly SparklinePoint: NetworkSlicesSliceDefsSparklinePoint;
···
 export interface ComAtprotoLabelDefs {
   readonly Label: ComAtprotoLabelDefsLabel;
   readonly SelfLabel: ComAtprotoLabelDefsSelfLabel;
+  readonly LabelValue: ComAtprotoLabelDefsLabelValue;
   readonly SelfLabels: ComAtprotoLabelDefsSelfLabels;
   readonly LabelValueDefinition: ComAtprotoLabelDefsLabelValueDefinition;
   readonly LabelValueDefinitionStrings: ComAtprotoLabelDefsLabelValueDefinitionStrings;
 }
 
+class FollowGraphBskyAppClient {
+  private readonly client: SlicesClient;
+
+  constructor(client: SlicesClient) {
+    this.client = client;
+  }
+
+  async getRecords(params?: {
+    limit?: number;
+    cursor?: string;
+    where?: {
+      [K in
+        | AppBskyGraphFollowSortFields
+        | IndexedRecordFields]?: WhereCondition;
+    };
+    orWhere?: {
+      [K in
+        | AppBskyGraphFollowSortFields
+        | IndexedRecordFields]?: WhereCondition;
+    };
+    sortBy?: SortField<AppBskyGraphFollowSortFields>[];
+  }): Promise<GetRecordsResponse<AppBskyGraphFollow>> {
+    return await this.client.getRecords("app.bsky.graph.follow", params);
+  }
+
+  async getRecord(
+    params: GetRecordParams
+  ): Promise<RecordResponse<AppBskyGraphFollow>> {
+    return await this.client.getRecord("app.bsky.graph.follow", params);
+  }
+
+  async countRecords(params?: {
+    limit?: number;
+    cursor?: string;
+    where?: {
+      [K in
+        | AppBskyGraphFollowSortFields
+        | IndexedRecordFields]?: WhereCondition;
+    };
+    orWhere?: {
+      [K in
+        | AppBskyGraphFollowSortFields
+        | IndexedRecordFields]?: WhereCondition;
+    };
+    sortBy?: SortField<AppBskyGraphFollowSortFields>[];
+  }): Promise<CountRecordsResponse> {
+    return await this.client.countRecords("app.bsky.graph.follow", params);
+  }
+
+  async createRecord(
+    record: AppBskyGraphFollow,
+    useSelfRkey?: boolean
+  ): Promise<{ uri: string; cid: string }> {
+    return await this.client.createRecord(
+      "app.bsky.graph.follow",
+      record,
+      useSelfRkey
+    );
+  }
+
+  async updateRecord(
+    rkey: string,
+    record: AppBskyGraphFollow
+  ): Promise<{ uri: string; cid: string }> {
+    return await this.client.updateRecord(
+      "app.bsky.graph.follow",
+      rkey,
+      record
+    );
+  }
+
+  async deleteRecord(rkey: string): Promise<void> {
+    return await this.client.deleteRecord("app.bsky.graph.follow", rkey);
+  }
+}
+
+class GraphBskyAppClient {
+  readonly follow: FollowGraphBskyAppClient;
+  private readonly client: SlicesClient;
+
+  constructor(client: SlicesClient) {
+    this.client = client;
+    this.follow = new FollowGraphBskyAppClient(client);
+  }
+}
+
+class PostgateFeedBskyAppClient {
+  private readonly client: SlicesClient;
+
+  constructor(client: SlicesClient) {
+    this.client = client;
+  }
+
+  async getRecords(params?: {
+    limit?: number;
+    cursor?: string;
+    where?: {
+      [K in
+        | AppBskyFeedPostgateSortFields
+        | IndexedRecordFields]?: WhereCondition;
+    };
+    orWhere?: {
+      [K in
+        | AppBskyFeedPostgateSortFields
+        | IndexedRecordFields]?: WhereCondition;
+    };
+    sortBy?: SortField<AppBskyFeedPostgateSortFields>[];
+  }): Promise<GetRecordsResponse<AppBskyFeedPostgate>> {
+    return await this.client.getRecords("app.bsky.feed.postgate", params);
+  }
+
+  async getRecord(
+    params: GetRecordParams
+  ): Promise<RecordResponse<AppBskyFeedPostgate>> {
+    return await this.client.getRecord("app.bsky.feed.postgate", params);
+  }
+
+  async countRecords(params?: {
+    limit?: number;
+    cursor?: string;
+    where?: {
+      [K in
+        | AppBskyFeedPostgateSortFields
+        | IndexedRecordFields]?: WhereCondition;
+    };
+    orWhere?: {
+      [K in
+        | AppBskyFeedPostgateSortFields
+        | IndexedRecordFields]?: WhereCondition;
+    };
+    sortBy?: SortField<AppBskyFeedPostgateSortFields>[];
+  }): Promise<CountRecordsResponse> {
+    return await this.client.countRecords("app.bsky.feed.postgate", params);
+  }
+
+  async createRecord(
+    record: AppBskyFeedPostgate,
+    useSelfRkey?: boolean
+  ): Promise<{ uri: string; cid: string }> {
+    return await this.client.createRecord(
+      "app.bsky.feed.postgate",
+      record,
+      useSelfRkey
+    );
+  }
+
+  async updateRecord(
+    rkey: string,
+    record: AppBskyFeedPostgate
+  ): Promise<{ uri: string; cid: string }> {
+    return await this.client.updateRecord(
+      "app.bsky.feed.postgate",
+      rkey,
+      record
+    );
+  }
+
+  async deleteRecord(rkey: string): Promise<void> {
+    return await this.client.deleteRecord("app.bsky.feed.postgate", rkey);
+  }
+}
+
+class ThreadgateFeedBskyAppClient {
+  private readonly client: SlicesClient;
+
+  constructor(client: SlicesClient) {
+    this.client = client;
+  }
+
+  async getRecords(params?: {
+    limit?: number;
+    cursor?: string;
+    where?: {
+      [K in
+        | AppBskyFeedThreadgateSortFields
+        | IndexedRecordFields]?: WhereCondition;
+    };
+    orWhere?: {
+      [K in
+        | AppBskyFeedThreadgateSortFields
+        | IndexedRecordFields]?: WhereCondition;
+    };
+    sortBy?: SortField<AppBskyFeedThreadgateSortFields>[];
+  }): Promise<GetRecordsResponse<AppBskyFeedThreadgate>> {
+    return await this.client.getRecords("app.bsky.feed.threadgate", params);
+  }
+
+  async getRecord(
+    params: GetRecordParams
+  ): Promise<RecordResponse<AppBskyFeedThreadgate>> {
+    return await this.client.getRecord("app.bsky.feed.threadgate", params);
+  }
+
+  async countRecords(params?: {
+    limit?: number;
+    cursor?: string;
+    where?: {
+      [K in
+        | AppBskyFeedThreadgateSortFields
+        | IndexedRecordFields]?: WhereCondition;
+    };
+    orWhere?: {
+      [K in
+        | AppBskyFeedThreadgateSortFields
+        | IndexedRecordFields]?: WhereCondition;
+    };
+    sortBy?: SortField<AppBskyFeedThreadgateSortFields>[];
+  }): Promise<CountRecordsResponse> {
+    return await this.client.countRecords("app.bsky.feed.threadgate", params);
+  }
+
+  async createRecord(
+    record: AppBskyFeedThreadgate,
+    useSelfRkey?: boolean
+  ): Promise<{ uri: string; cid: string }> {
+    return await this.client.createRecord(
+      "app.bsky.feed.threadgate",
+      record,
+      useSelfRkey
+    );
+  }
+
+  async updateRecord(
+    rkey: string,
+    record: AppBskyFeedThreadgate
+  ): Promise<{ uri: string; cid: string }> {
+    return await this.client.updateRecord(
+      "app.bsky.feed.threadgate",
+      rkey,
+      record
+    );
+  }
+
+  async deleteRecord(rkey: string): Promise<void> {
+    return await this.client.deleteRecord("app.bsky.feed.threadgate", rkey);
+  }
+}
+
+class FeedBskyAppClient {
+  readonly postgate: PostgateFeedBskyAppClient;
+  readonly threadgate: ThreadgateFeedBskyAppClient;
+  private readonly client: SlicesClient;
+
+  constructor(client: SlicesClient) {
+    this.client = client;
+    this.postgate = new PostgateFeedBskyAppClient(client);
+    this.threadgate = new ThreadgateFeedBskyAppClient(client);
+  }
+}
+
 class ProfileActorBskyAppClient {
   private readonly client: SlicesClient;
 
···
 }
 
 class BskyAppClient {
+  readonly graph: GraphBskyAppClient;
+  readonly feed: FeedBskyAppClient;
   readonly actor: ActorBskyAppClient;
   private readonly client: SlicesClient;
 
   constructor(client: SlicesClient) {
     this.client = client;
+    this.graph = new GraphBskyAppClient(client);
+    this.feed = new FeedBskyAppClient(client);
     this.actor = new ActorBskyAppClient(client);
   }
 }
···
   }
 }
 
+class RequestWaitlistSlicesNetworkClient {
+  private readonly client: SlicesClient;
+
+  constructor(client: SlicesClient) {
+    this.client = client;
+  }
+
+  async getRecords(params?: {
+    limit?: number;
+    cursor?: string;
+    where?: {
+      [K in
+        | NetworkSlicesWaitlistRequestSortFields
+        | IndexedRecordFields]?: WhereCondition;
+    };
+    orWhere?: {
+      [K in
+        | NetworkSlicesWaitlistRequestSortFields
+        | IndexedRecordFields]?: WhereCondition;
+    };
+    sortBy?: SortField<NetworkSlicesWaitlistRequestSortFields>[];
+  }): Promise<GetRecordsResponse<NetworkSlicesWaitlistRequest>> {
+    return await this.client.getRecords(
+      "network.slices.waitlist.request",
+      params
+    );
+  }
+
+  async getRecord(
+    params: GetRecordParams
+  ): Promise<RecordResponse<NetworkSlicesWaitlistRequest>> {
+    return await this.client.getRecord(
+      "network.slices.waitlist.request",
+      params
+    );
+  }
+
+  async countRecords(params?: {
+    limit?: number;
+    cursor?: string;
+    where?: {
+      [K in
+        | NetworkSlicesWaitlistRequestSortFields
+        | IndexedRecordFields]?: WhereCondition;
+    };
+    orWhere?: {
+      [K in
+        | NetworkSlicesWaitlistRequestSortFields
+        | IndexedRecordFields]?: WhereCondition;
+    };
+    sortBy?: SortField<NetworkSlicesWaitlistRequestSortFields>[];
+  }): Promise<CountRecordsResponse> {
+    return await this.client.countRecords(
+      "network.slices.waitlist.request",
+      params
+    );
+  }
+
+  async createRecord(
+    record: NetworkSlicesWaitlistRequest,
+    useSelfRkey?: boolean
+  ): Promise<{ uri: string; cid: string }> {
+    return await this.client.createRecord(
+      "network.slices.waitlist.request",
+      record,
+      useSelfRkey
+    );
+  }
+
+  async updateRecord(
+    rkey: string,
+    record: NetworkSlicesWaitlistRequest
+  ): Promise<{ uri: string; cid: string }> {
+    return await this.client.updateRecord(
+      "network.slices.waitlist.request",
+      rkey,
+      record
+    );
+  }
+
+  async deleteRecord(rkey: string): Promise<void> {
+    return await this.client.deleteRecord(
+      "network.slices.waitlist.request",
+      rkey
+    );
+  }
+}
+
+class InviteWaitlistSlicesNetworkClient {
+  private readonly client: SlicesClient;
+
+  constructor(client: SlicesClient) {
+    this.client = client;
+  }
+
+  async getRecords(params?: {
+    limit?: number;
+    cursor?: string;
+    where?: {
+      [K in
+        | NetworkSlicesWaitlistInviteSortFields
+        | IndexedRecordFields]?: WhereCondition;
+    };
+    orWhere?: {
+      [K in
+        | NetworkSlicesWaitlistInviteSortFields
+        | IndexedRecordFields]?: WhereCondition;
+    };
+    sortBy?: SortField<NetworkSlicesWaitlistInviteSortFields>[];
+  }): Promise<GetRecordsResponse<NetworkSlicesWaitlistInvite>> {
+    return await this.client.getRecords(
+      "network.slices.waitlist.invite",
+      params
+    );
+  }
+
+  async getRecord(
+    params: GetRecordParams
+  ): Promise<RecordResponse<NetworkSlicesWaitlistInvite>> {
+    return await this.client.getRecord(
+      "network.slices.waitlist.invite",
+      params
+    );
+  }
+
+  async countRecords(params?: {
+    limit?: number;
+    cursor?: string;
+    where?: {
+      [K in
+        | NetworkSlicesWaitlistInviteSortFields
+        | IndexedRecordFields]?: WhereCondition;
+    };
+    orWhere?: {
+      [K in
+        | NetworkSlicesWaitlistInviteSortFields
+        | IndexedRecordFields]?: WhereCondition;
+    };
+    sortBy?: SortField<NetworkSlicesWaitlistInviteSortFields>[];
+  }): Promise<CountRecordsResponse> {
+    return await this.client.countRecords(
+      "network.slices.waitlist.invite",
+      params
+    );
+  }
+
+  async createRecord(
+    record: NetworkSlicesWaitlistInvite,
+    useSelfRkey?: boolean
+  ): Promise<{ uri: string; cid: string }> {
+    return await this.client.createRecord(
+      "network.slices.waitlist.invite",
+      record,
+      useSelfRkey
+    );
+  }
+
+  async updateRecord(
+    rkey: string,
+    record: NetworkSlicesWaitlistInvite
+  ): Promise<{ uri: string; cid: string }> {
+    return await this.client.updateRecord(
+      "network.slices.waitlist.invite",
+      rkey,
+      record
+    );
+  }
+
+  async deleteRecord(rkey: string): Promise<void> {
+    return await this.client.deleteRecord(
+      "network.slices.waitlist.invite",
+      rkey
+    );
+  }
+}
+
+class WaitlistSlicesNetworkClient {
+  readonly request: RequestWaitlistSlicesNetworkClient;
+  readonly invite: InviteWaitlistSlicesNetworkClient;
+  private readonly client: SlicesClient;
+
+  constructor(client: SlicesClient) {
+    this.client = client;
+    this.request = new RequestWaitlistSlicesNetworkClient(client);
+    this.invite = new InviteWaitlistSlicesNetworkClient(client);
+  }
+}
+
 class SliceSlicesNetworkClient {
   private readonly client: SlicesClient;
 
···
   }
 }
 
-class WaitingSlicesNetworkClient {
-  private readonly client: SlicesClient;
-
-  constructor(client: SlicesClient) {
-    this.client = client;
-  }
-
-  async getRecords(params?: {
-    limit?: number;
-    cursor?: string;
-    where?: {
-      [K in
-        | NetworkSlicesWaitingSortFields
-        | IndexedRecordFields]?: WhereCondition;
-    };
-    orWhere?: {
-      [K in
-        | NetworkSlicesWaitingSortFields
-        | IndexedRecordFields]?: WhereCondition;
-    };
-    sortBy?: SortField<NetworkSlicesWaitingSortFields>[];
-  }): Promise<GetRecordsResponse<NetworkSlicesWaiting>> {
-    return await this.client.getRecords("network.slices.waiting", params);
-  }
-
-  async getRecord(
-    params: GetRecordParams
-  ): Promise<RecordResponse<NetworkSlicesWaiting>> {
-    return await this.client.getRecord("network.slices.waiting", params);
-  }
-
-  async countRecords(params?: {
-    limit?: number;
-    cursor?: string;
-    where?: {
-      [K in
-        | NetworkSlicesWaitingSortFields
-        | IndexedRecordFields]?: WhereCondition;
-    };
-    orWhere?: {
-      [K in
-        | NetworkSlicesWaitingSortFields
-        | IndexedRecordFields]?: WhereCondition;
-    };
-    sortBy?: SortField<NetworkSlicesWaitingSortFields>[];
-  }): Promise<CountRecordsResponse> {
-    return await this.client.countRecords("network.slices.waiting", params);
-  }
-
-  async createRecord(
-    record: NetworkSlicesWaiting,
-    useSelfRkey?: boolean
-  ): Promise<{ uri: string; cid: string }> {
-    return await this.client.createRecord(
-      "network.slices.waiting",
-      record,
-      useSelfRkey
-    );
-  }
-
-  async updateRecord(
-    rkey: string,
-    record: NetworkSlicesWaiting
-  ): Promise<{ uri: string; cid: string }> {
-    return await this.client.updateRecord(
-      "network.slices.waiting",
-      rkey,
-      record
-    );
-  }
-
-  async deleteRecord(rkey: string): Promise<void> {
-    return await this.client.deleteRecord("network.slices.waiting", rkey);
-  }
-}
-
 class LexiconSlicesNetworkClient {
   private readonly client: SlicesClient;
 
···
 }
 
 class SlicesNetworkClient {
+  readonly waitlist: WaitlistSlicesNetworkClient;
   readonly slice: SliceSlicesNetworkClient;
-  readonly waiting: WaitingSlicesNetworkClient;
   readonly lexicon: LexiconSlicesNetworkClient;
   readonly actor: ActorSlicesNetworkClient;
   private readonly client: SlicesClient;
 
   constructor(client: SlicesClient) {
     this.client = client;
+    this.waitlist = new WaitlistSlicesNetworkClient(client);
     this.slice = new SliceSlicesNetworkClient(client);
-    this.waiting = new WaitingSlicesNetworkClient(client);
     this.lexicon = new LexiconSlicesNetworkClient(client);
     this.actor = new ActorSlicesNetworkClient(client);
   }

frontend/src/config.ts

···
 const OAUTH_REDIRECT_URI = Deno.env.get("OAUTH_REDIRECT_URI");
 const OAUTH_AIP_BASE_URL = Deno.env.get("OAUTH_AIP_BASE_URL");
 const API_URL = Deno.env.get("API_URL");
-const SLICE_URI = Deno.env.get("SLICE_URI");
+export const SLICE_URI = Deno.env.get("SLICE_URI");
 
 if (
   !OAUTH_CLIENT_ID ||
···
 ) {
   throw new Error(
     "Missing OAuth configuration. Please ensure .env file contains:\n" +
-      "OAUTH_CLIENT_ID, OAUTH_CLIENT_SECRET, OAUTH_REDIRECT_URI, OAUTH_AIP_BASE_URL, API_URL, SLICE_URI",
+      "OAUTH_CLIENT_ID, OAUTH_CLIENT_SECRET, OAUTH_REDIRECT_URI, OAUTH_AIP_BASE_URL, API_URL, SLICE_URI"
   );
 }
 
···
       // "repo:network.slices.waiting",
     ],
   },
-  oauthStorage,
+  oauthStorage
 );
 
 // Session setup (shared database)

frontend/src/features/auth/handlers.tsx

···
 import { atprotoClient, oauthSessions, sessionStore } from "../../config.ts";
 import { renderHTML } from "../../utils/render.tsx";
 import { LoginPage } from "./templates/LoginPage.tsx";
+import { SLICE_URI } from "../../config.ts";
+import type { NetworkSlicesActorProfile } from "../../client.ts";
+
+// ============================================================================
+// WAITLIST GATING UTILITIES
+// ============================================================================
+
+async function checkUserAccess(
+  userDid: string
+): Promise<{ hasAccess: boolean; isOnWaitlist: boolean }> {
+  try {
+    // Build the slice URI to query invites for
+    const sliceUri = SLICE_URI!;
+
+    // Query for invites for this DID - using json field to query the record content
+    const invitesResult =
+      await atprotoClient.network.slices.waitlist.invite.getRecords({
+        where: {
+          slice: { eq: sliceUri },
+          json: { contains: userDid },
+        },
+        limit: 1,
+      });
+
+    // Check if user has a valid invite
+    if (invitesResult.records && invitesResult.records.length > 0) {
+      const invite = invitesResult.records[0];
+
+      // Check if invite has expired
+      if (invite.value.expiresAt) {
+        const expiresAt = new Date(invite.value.expiresAt);
+        const now = new Date();
+        if (expiresAt < now) {
+          return { hasAccess: false, isOnWaitlist: false }; // Invite has expired
+        }
+      }
+
+      return { hasAccess: true, isOnWaitlist: false }; // Valid invite found
+    }
+
+    // Check if user is already on the waitlist - requests are created by the user so record.did is correct
+    const requestsResult =
+      await atprotoClient.network.slices.waitlist.request.getRecords({
+        where: {
+          slice: { eq: sliceUri },
+          json: { eq: userDid },
+        },
+        limit: 1,
+      });
+
+    const isOnWaitlist =
+      requestsResult.records && requestsResult.records.length > 0;
+
+    return { hasAccess: false, isOnWaitlist };
+  } catch (error) {
+    console.error("Error checking user access:", error);
+    return { hasAccess: false, isOnWaitlist: false }; // Default to blocking access on error
+  }
+}
 
 // ============================================================================
 // LOGIN PAGE HANDLER
···
 
   const error = url.searchParams.get("error");
   return renderHTML(
-    <LoginPage error={error || undefined} currentUser={context.currentUser} />,
+    <LoginPage error={error || undefined} currentUser={context.currentUser} />
   );
 }
 
···
     return Response.redirect(
       new URL(
         "/login?error=" + encodeURIComponent("OAuth initialization failed"),
-        req.url,
+        req.url
       ),
-      302,
+      302
     );
   }
 }
···
       return Response.redirect(
         new URL(
           "/login?error=" + encodeURIComponent("Invalid OAuth callback"),
-          req.url,
+          req.url
         ),
-        302,
+        302
       );
     }
 
···
       return Response.redirect(
         new URL(
           "/login?error=" + encodeURIComponent("OAuth client not configured"),
-          req.url,
+          req.url
         ),
-        302,
+        302
       );
     }
 
···
       return Response.redirect(
         new URL(
           "/login?error=" + encodeURIComponent("Failed to create session"),
-          req.url,
+          req.url
         ),
-        302,
+        302
       );
     }
 
···
     try {
       userInfo = await atprotoClient.oauth?.getUserInfo();
     } catch (error) {
-      console.log("Failed to get user info:", error);
+      console.error("Failed to get user info:", error);
+    }
+
+    // Check waitlist access if user info is available
+    if (userInfo?.sub) {
+      const { hasAccess, isOnWaitlist } = await checkUserAccess(userInfo.sub);
+      if (!hasAccess) {
+        // Clear OAuth session and redirect to waitlist page
+        await atprotoClient.oauth?.logout();
+
+        const errorCode = isOnWaitlist
+          ? "already_on_waitlist"
+          : "invite_required";
+        return Response.redirect(
+          new URL(`/waitlist?error=${errorCode}`, req.url),
+          302
+        );
+      }
     }
 
-    // Sync external collections if user doesn't have them yet
+    // Sync external collections first to ensure actor records are populated
     try {
-      if (!userInfo?.sub) {
-        console.log(
-          "No user DID available, skipping external collections sync",
-        );
-      } else {
-        // Check if user already has bsky profile synced
-        try {
-          const profileCheck = await atprotoClient.app.bsky.actor.profile
-            .getRecords({
-              where: {
-                did: { eq: userInfo.sub },
-              },
-              limit: 1,
-            });
+      if (userInfo?.sub) {
+        await atprotoClient.network.slices.slice.syncUserCollections();
+      }
+    } catch (error) {
+      console.error("Error during external collections sync:", error);
+    }
+
+    // Create network.slices.actor.profile record for first-time users
+    if (userInfo?.sub && userInfo?.name) {
+      try {
+        // Check if user already has a profile record in our slice
+        const existingProfile =
+          await atprotoClient.network.slices.actor.profile.getRecords({
+            where: {
+              did: { eq: userInfo.sub },
+            },
+            limit: 1,
+          });
+
+        // If no profile exists, create one
+        if (!existingProfile.records || existingProfile.records.length === 0) {
+          // Fetch their bsky profile to copy avatar and other data
+          const profileData: NetworkSlicesActorProfile = {
+            displayName: userInfo.name || userInfo.sub,
+            createdAt: new Date().toISOString(),
+          };
+
+          try {
+            // Get their bsky profile data
+            const bskyProfile =
+              await atprotoClient.app.bsky.actor.profile.getRecords({
+                where: {
+                  did: { eq: userInfo.sub },
+                },
+                limit: 1,
+              });
+
+            if (bskyProfile.records && bskyProfile.records.length > 0) {
+              const bskyData = bskyProfile.records[0].value;
 
-          // If we can't find existing records, sync them
-          if (!profileCheck.records || profileCheck.records.length === 0) {
-            console.log("No existing external collections found, syncing...");
-            await atprotoClient.network.slices.slice.syncUserCollections();
-          } else {
-            console.log("External collections already synced, skipping sync");
+              // Copy over relevant fields from bsky profile
+              if (bskyData.displayName) {
+                profileData.displayName = bskyData.displayName;
+              }
+              if (bskyData.description) {
+                profileData.description = bskyData.description;
+              }
+              if (bskyData.avatar) {
+                profileData.avatar = bskyData.avatar;
+              }
+            }
+          } catch (_bskyError) {
+            // Could not fetch bsky profile, using basic data
           }
-        } catch (_profileError) {
-          // If we can't check existing records, skip sync to be safe
-          console.log(
-            "Could not check existing external collections, skipping sync",
+
+          // Create the profile record with the data using "self" as the rkey
+          await atprotoClient.network.slices.actor.profile.createRecord(
+            profileData,
+            true
           );
         }
+      } catch (error) {
+        console.error(
+          "Error creating network.slices.actor.profile record:",
+          error
+        );
+        // Don't fail the login process if profile creation fails
       }
-    } catch (error) {
-      console.log(
-        "Error during sync check, skipping external collections sync:",
-        error,
-      );
     }
 
     // Redirect to user's profile page if handle is available
···
     return Response.redirect(
       new URL(
         "/login?error=" + encodeURIComponent("Authentication failed"),
-        req.url,
+        req.url
       ),
-      302,
+      302
     );
   }
 }
···
         isWaitlistFlow: true,
         handle,
         redirectUri: "/auth/waitlist/callback",
-      }),
+      })
     );
 
     // Initiate OAuth with minimal scope for waitlist, passing state directly
     const authResult = await atprotoClient.oauth.authorize({
       loginHint: handle,
-      scope: "atproto repo:network.slices.waiting",
+      scope: "atproto repo:network.slices.waitlist.request",
       state: waitlistState,
     });
 
···
     if (!code || !state) {
       return Response.redirect(
         new URL("/waitlist?error=invalid_callback", req.url),
-        302,
+        302
       );
     }
 
···
     if (!atprotoClient.oauth) {
       return Response.redirect(
         new URL("/waitlist?error=oauth_not_configured", req.url),
-        302,
+        302
       );
     }
 
···
     const userInfo = await atprotoClient.oauth.getUserInfo();
 
     if (!userInfo) {
-      return Response.redirect(new URL("/waitlist?error=no_user_info", req.url), 302);
+      return Response.redirect(
+        new URL("/waitlist?error=no_user_info", req.url),
+        302
+      );
     }
 
     // Create waitlist record
     try {
-      // For now, just log the waitlist join
-      console.log("User joined waitlist:", {
-        did: userInfo.sub,
-        handle: userInfo.name || waitlistData.handle || "unknown",
-        joinedAt: new Date().toISOString(),
-      });
-
-      await atprotoClient.network.slices.waiting.createRecord(
+      await atprotoClient.network.slices.waitlist.request.createRecord(
         {
+          slice: SLICE_URI!,
           createdAt: new Date().toISOString(),
         },
-        true,
+        true
       );
+
+      // Sync user collections to populate their Bluesky profile data
+      try {
+        await atprotoClient.network.slices.slice.syncUserCollections();
+      } catch (syncError) {
+        console.error(
+          "Failed to sync user collections for waitlist user:",
+          syncError
+        );
+        // Don't fail the waitlist process if sync fails
+      }
     } catch (error) {
       console.error("Failed to create waitlist record:", error);
     }
···
     return Response.redirect(redirectUrl.toString(), 302);
   } catch (error) {
     console.error("Waitlist callback error:", error);
-    return Response.redirect(new URL("/waitlist?error=waitlist_failed", req.url), 302);
+    return Response.redirect(
+      new URL("/waitlist?error=waitlist_failed", req.url),
+      302
+    );
   }
 }
 

frontend/src/features/dashboard/handlers.tsx

···
 
 async function handleProfilePage(
   req: Request,
-  params?: URLPatternResult,
+  params?: URLPatternResult
 ): Promise<Response> {
   const context = await withAuth(req);
 
···
       slices={slices}
       currentUser={context.currentUser}
       profile={profile}
-    />,
+    />
   );
 }
 
···
   const authInfo = await atprotoClient.oauth?.getAuthenticationInfo();
   if (!authInfo?.isAuthenticated) {
     return renderHTML(
-      <CreateSliceDialog error="Session expired. Please log in again." />,
+      <CreateSliceDialog error="Session expired. Please log in again." />
     );
   }
 
···
           error="Slice name is required"
           name={name}
           domain={domain}
-        />,
+        />
       );
     }
 
···
           error="Primary domain is required"
           name={name}
           domain={domain}
-        />,
+        />
       );
     }
 
···
       };
 
       const result = await atprotoClient.network.slices.slice.createRecord(
-        recordData,
+        recordData
       );
 
       const uriParts = result.uri.split("/");
···
           error="Failed to create slice record. Please try again."
           name={name}
           domain={domain}
-        />,
+        />
       );
     }
   } catch (_error) {

frontend/src/features/docs/templates/DocsIndexPage.tsx

···
               href={`/docs/${doc.slug}`}
               className="block"
             >
-              <Card variant="hover">
+              <Card padding="md" variant="hover">
                 <Text as="h2" size="xl" className="font-semibold mb-2">
                   {doc.title}
                 </Text>

frontend/src/features/landing/templates/fragments/WaitlistFormModal.tsx

···
         <h2 class="font-mono text-xl font-bold text-gray-800 mb-4">
           Join the Waitlist
         </h2>
-        <form
-          action="/auth/waitlist/initiate"
-          method="POST"
-          class="space-y-4"
-        >
+        <form action="/auth/waitlist/initiate" method="POST" class="space-y-4">
           <div>
             <label
               for="handle-input"
···
               type="text"
               id="handle-input"
               name="handle"
-              placeholder="alice.bsky.social"
+              placeholder="user.bsky.social"
               class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-gray-800 font-mono text-sm"
               required
             />

frontend/src/features/settings/templates/fragments/SettingsForm.tsx

···
 
 export function SettingsForm({ profile }: SettingsFormProps) {
   return (
-    <Card>
+    <Card padding="md">
       <Text as="h2" size="xl" className="font-semibold mb-4">
         Profile Settings
       </Text>

frontend/src/features/slices/codegen/templates/SliceCodegenPage.tsx

···
       hasSliceAccess={hasSliceAccess}
       title={`${slice.name} - Code Generation`}
     >
-      <Card padding="none">
+      <Card>
         <Card.Header
           title="TypeScript Client"
           action={
···
         <Card.Content>
           {error ? (
             <div className="p-6">
-              <Card variant="danger">
+              <Card padding="md" variant="danger">
                 <Text as="h3" size="lg" className="font-semibold mb-2">
                   ❌ Generation Failed
                 </Text>

frontend/src/features/slices/lexicon/templates/LexiconDetailPage.tsx

···
           </Button>
         </div>
 
-        <Card padding="none">
+        <Card>
           <Card.Header title="Lexicon Definitions" />
           <Card.Content className="text-sm overflow-x-auto [&_pre]:p-4 [&_pre]:m-0">
             <div dangerouslySetInnerHTML={{ __html: highlightedCode }} />

frontend/src/features/slices/lexicon/templates/SliceLexiconPage.tsx

···
             </Button>
           </div>
         )}
-        <Card padding="none">
+        <Card>
           <Card.Header
             title={`${lexicons.length} ${
               lexicons.length === 1 ? "Lexicon" : "Lexicons"

frontend/src/features/slices/mod.ts

···
 import { syncRoutes } from "./sync/handlers.tsx";
 import { syncLogsRoutes } from "./sync-logs/handlers.tsx";
 import { jetstreamRoutes } from "./jetstream/handlers.tsx";
+import { waitlistRoutes } from "./waitlist/handlers.tsx";
 
 // Export individual route groups
 export {
···
   settingsRoutes,
   syncLogsRoutes,
   syncRoutes,
+  waitlistRoutes,
 };
 
 // Export consolidated routes array for easy import
···
   ...syncRoutes,
   ...syncLogsRoutes,
   ...jetstreamRoutes,
+  ...waitlistRoutes,
 ];

frontend/src/features/slices/oauth/templates/SliceOAuthPage.tsx

···
         </Button>
       </div>
 
-      <Card padding="none">
+      <Card>
         <Card.Header title="OAuth Clients" />
         <Card.Content>
           {clients.length === 0

frontend/src/features/slices/overview/templates/SliceOverview.tsx

···
       </div>
 
       {(slice.indexedRecordCount ?? 0) > 0 && (
-        <Card className="mb-8">
+        <Card padding="md" className="mb-8">
           <Text as="h2" size="xl" className="font-semibold mb-4">
             📊 Database Status
           </Text>
···
       )}
 
       <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-6">
-        <Card>
+        <Card padding="md">
           <Text as="h2" size="xl" className="font-semibold mb-4 block">
             📚 Lexicon Definitions
           </Text>
···
           </Button>
         </Card>
 
-        <Card>
+        <Card padding="md">
           <Text as="h2" size="xl" className="font-semibold mb-4 block">
             📝 View Records
           </Text>
···
           )}
         </Card>
 
-        <Card>
+        <Card padding="md">
           <Text as="h2" size="xl" className="font-semibold mb-4 block">
             ⚡ Code Generation
           </Text>
···
           </Button>
         </Card>
 
-        <Card>
+        <Card padding="md">
           <Text as="h2" size="xl" className="font-semibold mb-4 block">
             📖 API Documentation
           </Text>
···
         </Card>
 
         {hasSliceAccess && (
-          <Card>
+          <Card padding="md">
             <Text as="h2" size="xl" className="font-semibold mb-4 block">
               🔄 Sync
             </Text>
···
         )}
 
         {collections.length > 0 && (
-          <Card>
+          <Card padding="md">
             <Text as="h2" size="xl" className="font-semibold mb-4 block">
               📊 Synced Collections
             </Text>

frontend/src/features/slices/records/templates/fragments/RecordsList.tsx

···
-import type { IndexedRecord } from "../../../../../client.ts";
+import { IndexedRecord } from "@slices/client";
 import { Card } from "../../../../../shared/fragments/Card.tsx";
 import { Text } from "../../../../../shared/fragments/Text.tsx";
 
···
 
 export function RecordsList({ records }: RecordsListProps) {
   return (
-    <Card padding="none">
-      <Card.Header
-        title={`Records (${records.length})`}
-      />
+    <Card>
+      <Card.Header title={`Records (${records.length})`} />
       <Card.Content className="divide-y divide-zinc-200 dark:divide-zinc-700">
         {records.map((record) => (
           <div key={record.uri} className="p-6">
···
                 </Text>
                 <dl className="grid grid-cols-1 gap-x-4 gap-y-2 text-sm">
                   <div className="grid grid-cols-3 gap-4">
-                    <Text as="dt" size="sm" variant="muted" className="font-medium">URI:</Text>
+                    <Text
+                      as="dt"
+                      size="sm"
+                      variant="muted"
+                      className="font-medium"
+                    >
+                      URI:
+                    </Text>
                     <Text as="dd" size="sm" className="col-span-2 break-all">
                       {record.uri}
                     </Text>
                   </div>
                   <div className="grid grid-cols-3 gap-4">
-                    <Text as="dt" size="sm" variant="muted" className="font-medium">
+                    <Text
+                      as="dt"
+                      size="sm"
+                      variant="muted"
+                      className="font-medium"
+                    >
                       Collection:
                     </Text>
                     <Text as="dd" size="sm" className="col-span-2">
···
                     </Text>
                   </div>
                   <div className="grid grid-cols-3 gap-4">
-                    <Text as="dt" size="sm" variant="muted" className="font-medium">DID:</Text>
+                    <Text
+                      as="dt"
+                      size="sm"
+                      variant="muted"
+                      className="font-medium"
+                    >
+                      DID:
+                    </Text>
                     <Text as="dd" size="sm" className="col-span-2 break-all">
                       {record.did}
                     </Text>
                   </div>
                   <div className="grid grid-cols-3 gap-4">
-                    <Text as="dt" size="sm" variant="muted" className="font-medium">CID:</Text>
+                    <Text
+                      as="dt"
+                      size="sm"
+                      variant="muted"
+                      className="font-medium"
+                    >
+                      CID:
+                    </Text>
                     <Text as="dd" size="sm" className="col-span-2 break-all">
                       {record.cid}
                     </Text>
                   </div>
                   <div className="grid grid-cols-3 gap-4">
-                    <Text as="dt" size="sm" variant="muted" className="font-medium">
+                    <Text
+                      as="dt"
+                      size="sm"
+                      variant="muted"
+                      className="font-medium"
+                    >
                       Indexed:
                     </Text>
                     <Text as="dd" size="sm" className="col-span-2">
···
                   Record Data
                 </Text>
                 <pre className="bg-zinc-50 dark:bg-zinc-800 border border-zinc-200 dark:border-zinc-700 p-3 text-xs overflow-auto max-h-64">
-                  <Text as="span" size="xs">{record.pretty_value ||
-                    JSON.stringify(record.value, null, 2)}</Text>
+                  <Text as="span" size="xs">
+                    {record.pretty_value ||
+                      JSON.stringify(record.value, null, 2)}
+                  </Text>
                 </pre>
               </div>
             </div>

frontend/src/features/slices/settings/templates/SliceSettings.tsx

···
       {/* Settings Content */}
       <div className="space-y-8">
         {/* Edit Slice Settings */}
-        <Card>
+        <Card padding="md">
           <Text as="h2" size="xl" className="font-semibold mb-4">
             Edit Slice Settings
           </Text>
···
         </Card>
 
         {/* Danger Zone */}
-        <Card className="border-l-4 border-l-red-500">
+        <Card padding="md" className="border-l-4 border-l-red-500">
           <Text
             as="h2"
             size="xl"

frontend/src/features/slices/shared/fragments/SliceTabs.tsx

···
     }
   );
 
-  // Add oauth and settings tabs only if user owns the slice
+  // Add oauth, waitlist and settings tabs only if user owns the slice
   if (hasSliceAccess) {
     tabs.push(
       {
         id: "oauth",
         name: "OAuth Clients",
         href: buildSliceUrlFromView(slice, sliceId, "oauth"),
+      },
+      {
+        id: "waitlist",
+        name: "Waitlist",
+        href: buildSliceUrlFromView(slice, sliceId, "waitlist"),
       },
       {
         id: "settings",

frontend/src/features/slices/sync/templates/SliceSyncPage.tsx

···
             <span className="flex items-center gap-2">Start Sync</span>
           </Button>
         </div>
-        <Card padding="none">
+        <Card>
           <Card.Header title="Recent Sync History" />
           <Card.Content
             hx-get={`/api/slices/${sliceId}/job-history?handle=${slice.creator?.handle}`}

frontend/src/features/slices/waitlist/api.ts

···
+import type {
+  NetworkSlicesWaitlistDefsRequestView,
+  NetworkSlicesWaitlistDefsInviteView,
+  NetworkSlicesWaitlistRequest,
+  NetworkSlicesWaitlistInvite,
+  AppBskyActorDefsProfileViewBasic,
+  AppBskyActorProfile,
+  AtProtoClient,
+} from "../../../client.ts";
+import type { RecordResponse } from "@slices/client";
+import { recordBlobToCdnUrl } from "@slices/client";
+
+/**
+ * Converts a profile record to ProfileViewBasic format
+ */
+function profileToView(
+  record: RecordResponse<AppBskyActorProfile>,
+  did: string,
+  handle?: string
+): AppBskyActorDefsProfileViewBasic {
+  return {
+    did,
+    handle: handle || did, // Use provided handle or fall back to DID
+    displayName: record.value.displayName,
+    avatar: record.value.avatar
+      ? recordBlobToCdnUrl(record, record.value.avatar, "avatar")
+      : undefined,
+  };
+}
+
+/**
+ * Converts a waitlist request record to RequestView format
+ */
+function requestToView(
+  record: RecordResponse<NetworkSlicesWaitlistRequest>,
+  profile?: AppBskyActorDefsProfileViewBasic
+): NetworkSlicesWaitlistDefsRequestView {
+  return {
+    slice: record.value.slice,
+    createdAt: record.value.createdAt,
+    profile,
+  };
+}
+
+/**
+ * Converts a waitlist invite record to InviteView format
+ */
+function inviteToView(
+  record: RecordResponse<NetworkSlicesWaitlistInvite>,
+  profile?: AppBskyActorDefsProfileViewBasic
+): NetworkSlicesWaitlistDefsInviteView {
+  return {
+    did: record.value.did,
+    slice: record.value.slice,
+    createdAt: record.value.createdAt,
+    expiresAt: record.value.expiresAt,
+    uri: record.uri,
+    profile,
+  };
+}
+
+export async function getHydratedWaitlistRequests(
+  client: AtProtoClient,
+  sliceUri: string
+): Promise<NetworkSlicesWaitlistDefsRequestView[]> {
+  // Fetch waitlist requests
+  const requestsResponse =
+    await client.network.slices.waitlist.request.getRecords({
+      where: {
+        slice: { eq: sliceUri },
+      },
+      sortBy: [{ field: "createdAt", direction: "desc" }],
+    });
+
+  if (!requestsResponse.records || requestsResponse.records.length === 0) {
+    return [];
+  }
+
+  // Get unique DIDs from requests
+  const dids = [...new Set(requestsResponse.records.map((r) => r.did))];
+
+  // Fetch profiles and actors for all DIDs
+  const profilesMap = new Map<string, AppBskyActorDefsProfileViewBasic>();
+
+  try {
+    // Fetch actors to get handles
+    const actorsResponse = await client.network.slices.slice.getActors({
+      where: {
+        did: { in: dids }
+      }
+    });
+
+    // Create a map of DIDs to handles
+    const handleMap = new Map<string, string>();
+    actorsResponse.actors?.forEach((actor) => {
+      if (actor.handle) {
+        handleMap.set(actor.did, actor.handle);
+      }
+    });
+
+    // Fetch Bluesky profiles
+    const profileResponses = await Promise.all(
+      dids.map((did) =>
+        client.app.bsky.actor.profile
+          .getRecords({
+            where: { did: { eq: did } },
+            limit: 1,
+          })
+          .catch(() => null)
+      )
+    );
+
+    profileResponses.forEach((response, index) => {
+      if (response?.records?.[0]) {
+        const record = response.records[0];
+        const did = dids[index];
+        const handle = handleMap.get(did);
+        profilesMap.set(did, profileToView(record, did, handle));
+      }
+    });
+  } catch (error) {
+    console.error("Error fetching profiles:", error);
+  }
+
+  // Transform to RequestView format with profiles
+  return requestsResponse.records.map((record) =>
+    requestToView(record, profilesMap.get(record.did))
+  );
+}
+
+export async function getHydratedWaitlistInvites(
+  client: AtProtoClient,
+  sliceUri: string
+): Promise<NetworkSlicesWaitlistDefsInviteView[]> {
+  // Fetch waitlist invites
+  const invitesResponse =
+    await client.network.slices.waitlist.invite.getRecords({
+      where: {
+        slice: { eq: sliceUri },
+      },
+      sortBy: [{ field: "createdAt", direction: "desc" }],
+    });
+
+  if (!invitesResponse.records || invitesResponse.records.length === 0) {
+    return [];
+  }
+
+  // Get unique DIDs from invites
+  const dids = [...new Set(invitesResponse.records.map((r) => r.value.did))];
+
+  // Fetch profiles and actors for all DIDs
+  const profilesMap = new Map<string, AppBskyActorDefsProfileViewBasic>();
+
+  try {
+    // Fetch actors to get handles
+    const actorsResponse = await client.network.slices.slice.getActors({
+      where: {
+        did: { in: dids }
+      }
+    });
+
+    // Create a map of DIDs to handles
+    const handleMap = new Map<string, string>();
+    actorsResponse.actors?.forEach((actor) => {
+      if (actor.handle) {
+        handleMap.set(actor.did, actor.handle);
+      }
+    });
+
+    // Fetch Bluesky profiles
+    const profileResponses = await Promise.all(
+      dids.map((did) =>
+        client.app.bsky.actor.profile
+          .getRecords({
+            where: { did: { eq: did } },
+            limit: 1,
+          })
+          .catch(() => null)
+      )
+    );
+
+    profileResponses.forEach((response, index) => {
+      if (response?.records?.[0]) {
+        const record = response.records[0];
+        const did = dids[index];
+        const handle = handleMap.get(did);
+        profilesMap.set(did, profileToView(record, did, handle));
+      }
+    });
+  } catch (error) {
+    console.error("Error fetching profiles:", error);
+  }
+
+  // Transform to InviteView format with profiles
+  return invitesResponse.records.map((record) =>
+    inviteToView(record, profilesMap.get(record.value.did))
+  );
+}
+
+export async function createInviteFromRequest(
+  client: AtProtoClient,
+  requestUri: string,
+  requestDid: string,
+  sliceUri: string
+): Promise<{ uri: string; cid: string }> {
+  // Create the invite record
+  const result = await client.network.slices.waitlist.invite.createRecord({
+    did: requestDid,
+    slice: sliceUri,
+    createdAt: new Date().toISOString(),
+  });
+
+  // Delete the request record
+  try {
+    const rkey = requestUri.split("/").pop();
+    if (rkey) {
+      await client.network.slices.waitlist.request.deleteRecord(rkey);
+    }
+  } catch (error) {
+    console.error("Failed to delete request after creating invite:", error);
+  }
+
+  return result;
+}
+
+export async function removeInvite(
+  client: AtProtoClient,
+  inviteUri: string
+): Promise<void> {
+  const rkey = inviteUri.split("/").pop();
+  if (rkey) {
+    await client.network.slices.waitlist.invite.deleteRecord(rkey);
+  }
+}

frontend/src/features/slices/waitlist/handlers.tsx

···
+import type { Route } from "@std/http/unstable-route";
+import { withAuth } from "../../../routes/middleware.ts";
+import { withSliceAccess } from "../../../routes/slice-middleware.ts";
+import { extractSliceParams, buildSliceUrlFromView } from "../../../utils/slice-params.ts";
+import { getSliceClient } from "../../../utils/client.ts";
+import { getRkeyFromUri, buildSliceUri } from "../../../utils/at-uri.ts";
+import { renderHTML } from "../../../utils/render.tsx";
+import { hxRedirect } from "../../../utils/htmx.ts";
+import { SliceWaitlistPage } from "./templates/SliceWaitlistPage.tsx";
+import { CreateInviteModal } from "./templates/fragments/CreateInviteModal.tsx";
+import type {
+  NetworkSlicesWaitlistDefsRequestView,
+  NetworkSlicesWaitlistDefsInviteView,
+  NetworkSlicesWaitlistInvite,
+} from "../../../client.ts";
+import {
+  getHydratedWaitlistRequests,
+  getHydratedWaitlistInvites,
+} from "./api.ts";
+
+async function handleSliceWaitlistPage(
+  req: Request,
+  params?: URLPatternResult
+): Promise<Response> {
+  const authContext = await withAuth(req);
+  const sliceParams = extractSliceParams(params);
+
+  if (!sliceParams) {
+    return Response.redirect(new URL("/", req.url), 302);
+  }
+
+  const context = await withSliceAccess(
+    authContext,
+    sliceParams.handle,
+    sliceParams.sliceId
+  );
+
+  // Check if slice exists and user has access
+  if (!context.sliceContext?.slice || !context.sliceContext?.hasAccess) {
+    return new Response("Slice not found or access denied", { status: 404 });
+  }
+
+  // Get the active tab from query params
+  const url = new URL(req.url);
+  const activeTab = url.searchParams.get("tab") || "requests";
+
+  // Fetch waitlist requests and invites from the API
+  const sliceClient = getSliceClient(
+    authContext,
+    sliceParams.sliceId,
+    context.sliceContext.profileDid
+  );
+
+  // Build the slice URI to filter by
+  const sliceUri = buildSliceUri(
+    context.sliceContext.profileDid,
+    sliceParams.sliceId
+  );
+
+  let requests: NetworkSlicesWaitlistDefsRequestView[] = [];
+  let invites: NetworkSlicesWaitlistDefsInviteView[] = [];
+
+  try {
+    // Fetch hydrated requests with profile information
+    requests = await getHydratedWaitlistRequests(sliceClient, sliceUri);
+
+    // Fetch hydrated invites with profile information
+    invites = await getHydratedWaitlistInvites(sliceClient, sliceUri);
+  } catch (error) {
+    console.error("Error fetching waitlist data:", error);
+    // Continue with empty arrays if fetch fails
+  }
+
+  return renderHTML(
+    <SliceWaitlistPage
+      slice={context.sliceContext!.slice!}
+      sliceId={sliceParams.sliceId}
+      requests={requests}
+      invites={invites}
+      currentUser={authContext.currentUser}
+      hasSliceAccess={context.sliceContext?.hasAccess}
+      activeTab={activeTab}
+    />
+  );
+}
+
+async function handleCreateInviteModal(
+  req: Request,
+  params?: URLPatternResult
+): Promise<Response> {
+  const authContext = await withAuth(req);
+  const sliceParams = extractSliceParams(params);
+
+  if (!sliceParams) {
+    return new Response("Invalid slice parameters", { status: 400 });
+  }
+
+  const context = await withSliceAccess(
+    authContext,
+    sliceParams.handle,
+    sliceParams.sliceId
+  );
+
+  if (!context.sliceContext?.slice || !context.sliceContext?.hasAccess) {
+    return new Response("Slice not found or access denied", { status: 404 });
+  }
+
+  return renderHTML(
+    <CreateInviteModal
+      slice={context.sliceContext!.slice!}
+      sliceId={sliceParams.sliceId}
+    />
+  );
+}
+
+async function handleCreateInvite(
+  req: Request,
+  params?: URLPatternResult
+): Promise<Response> {
+  const authContext = await withAuth(req);
+  const sliceParams = extractSliceParams(params);
+
+  if (!sliceParams) {
+    return new Response("Invalid slice parameters", { status: 400 });
+  }
+
+  const context = await withSliceAccess(
+    authContext,
+    sliceParams.handle,
+    sliceParams.sliceId
+  );
+
+  if (!context.sliceContext?.slice || !context.sliceContext?.hasAccess) {
+    return new Response("Slice not found or access denied", { status: 404 });
+  }
+
+  const formData = await req.formData();
+  const did = formData.get("did")?.toString()?.trim();
+  const expiresAt = formData.get("expiresAt")?.toString();
+
+  if (!did) {
+    return new Response("DID is required", { status: 400 });
+  }
+
+  try {
+    const sliceClient = getSliceClient(
+      authContext,
+      sliceParams.sliceId,
+      context.sliceContext.profileDid
+    );
+
+    const sliceUri = buildSliceUri(
+      context.sliceContext.profileDid,
+      sliceParams.sliceId
+    );
+
+    const inviteData: NetworkSlicesWaitlistInvite = {
+      did,
+      slice: sliceUri,
+      createdAt: new Date().toISOString(),
+    };
+
+    // Convert datetime-local input to ISO 8601 string
+    if (expiresAt) {
+      // datetime-local gives us "2024-12-25T14:30" format
+      // We need to convert it to a proper ISO string with timezone
+      const expiresDate = new Date(expiresAt);
+      if (!isNaN(expiresDate.getTime())) {
+        inviteData.expiresAt = expiresDate.toISOString();
+      }
+    }
+
+    await sliceClient.network.slices.waitlist.invite.createRecord(inviteData);
+
+    // Redirect back to the waitlist page with invites tab
+    const redirectUrl = buildSliceUrlFromView(
+      context.sliceContext!.slice!,
+      sliceParams.sliceId,
+      "waitlist?tab=invites"
+    );
+    return hxRedirect(redirectUrl);
+  } catch (error) {
+    // Use the raw error message from the client
+    const userErrorMessage =
+      error instanceof Error ? error.message : "Failed to create invite";
+
+    // Return the error modal with the specific error message
+    return renderHTML(
+      <CreateInviteModal
+        slice={context.sliceContext!.slice!}
+        sliceId={sliceParams.sliceId}
+        error={userErrorMessage}
+      />
+    );
+  }
+}
+
+async function handleRevokeInvite(
+  req: Request,
+  params?: URLPatternResult
+): Promise<Response> {
+  const authContext = await withAuth(req);
+  const sliceParams = extractSliceParams(params);
+
+  if (!sliceParams) {
+    return new Response("Invalid slice parameters", { status: 400 });
+  }
+
+  const context = await withSliceAccess(
+    authContext,
+    sliceParams.handle,
+    sliceParams.sliceId
+  );
+
+  if (!context.sliceContext?.slice || !context.sliceContext?.hasAccess) {
+    return new Response("Slice not found or access denied", { status: 404 });
+  }
+
+  const formData = await req.formData();
+  const uri = formData.get("uri")?.toString();
+
+  if (!uri) {
+    return new Response("URI is required", { status: 400 });
+  }
+
+  try {
+    const sliceClient = getSliceClient(
+      authContext,
+      sliceParams.sliceId,
+      context.sliceContext.profileDid
+    );
+
+    const rkey = getRkeyFromUri(uri);
+    await sliceClient.network.slices.waitlist.invite.deleteRecord(rkey);
+
+    // Return success with HX-Refresh to reload the page
+    return new Response("", {
+      status: 200,
+      headers: {
+        "HX-Refresh": "true",
+      },
+    });
+  } catch (error) {
+    console.error("Error revoking invite:", error);
+    return new Response("Failed to revoke invite", { status: 500 });
+  }
+}
+
+async function handleCreateInviteFromRequest(
+  req: Request,
+  params?: URLPatternResult
+): Promise<Response> {
+  const authContext = await withAuth(req);
+  const sliceParams = extractSliceParams(params);
+
+  if (!sliceParams) {
+    return new Response("Invalid slice parameters", { status: 400 });
+  }
+
+  const context = await withSliceAccess(
+    authContext,
+    sliceParams.handle,
+    sliceParams.sliceId
+  );
+
+  if (!context.sliceContext?.slice || !context.sliceContext?.hasAccess) {
+    return new Response("Slice not found or access denied", { status: 404 });
+  }
+
+  try {
+    const sliceClient = getSliceClient(
+      authContext,
+      sliceParams.sliceId,
+      context.sliceContext.profileDid
+    );
+
+    const formData = await req.formData();
+    const did = formData.get("did")?.toString()?.trim();
+
+    console.log("Creating invite for DID:", did);
+
+    if (!did) {
+      return new Response("DID is required", { status: 400 });
+    }
+
+    const sliceUri = buildSliceUri(context.sliceContext.profileDid, sliceParams.sliceId);
+
+    const inviteData: NetworkSlicesWaitlistInvite = {
+      did,
+      slice: sliceUri,
+      createdAt: new Date().toISOString(),
+    };
+
+    await sliceClient.network.slices.waitlist.invite.createRecord(inviteData);
+
+    // Return success with HX-Refresh to reload the page
+    return new Response("", {
+      status: 200,
+      headers: {
+        "HX-Refresh": "true",
+      },
+    });
+  } catch (error) {
+    console.error("Error creating invite:", error);
+    const userErrorMessage =
+      error instanceof Error ? error.message : "Failed to create invite";
+    return new Response(userErrorMessage, { status: 500 });
+  }
+}
+
+export const waitlistRoutes: Route[] = [
+  {
+    method: "GET",
+    pattern: new URLPattern({
+      pathname: "/profile/:handle/slice/:rkey/waitlist",
+    }),
+    handler: handleSliceWaitlistPage,
+  },
+  {
+    method: "GET",
+    pattern: new URLPattern({
+      pathname: "/profile/:handle/slice/:rkey/waitlist/invite/new",
+    }),
+    handler: handleCreateInviteModal,
+  },
+  {
+    method: "POST",
+    pattern: new URLPattern({
+      pathname: "/profile/:handle/slice/:rkey/waitlist/invite",
+    }),
+    handler: handleCreateInvite,
+  },
+  {
+    method: "POST",
+    pattern: new URLPattern({
+      pathname: "/profile/:handle/slice/:rkey/waitlist/invite/from-request",
+    }),
+    handler: handleCreateInviteFromRequest,
+  },
+  {
+    method: "DELETE",
+    pattern: new URLPattern({
+      pathname: "/profile/:handle/slice/:rkey/waitlist/invite",
+    }),
+    handler: handleRevokeInvite,
+  },
+];

frontend/src/features/slices/waitlist/templates/SliceWaitlistPage.tsx

···
+import { SlicePage } from "../../shared/fragments/SlicePage.tsx";
+import { WaitlistRequestsList } from "./fragments/WaitlistRequestsList.tsx";
+import { WaitlistInvitesList } from "./fragments/WaitlistInvitesList.tsx";
+import { Button } from "../../../../shared/fragments/Button.tsx";
+import { Tabs } from "../../../../shared/fragments/Tabs.tsx";
+import { buildSliceUrlFromView } from "../../../../utils/slice-params.ts";
+import type { AuthenticatedUser } from "../../../../routes/middleware.ts";
+import type {
+  NetworkSlicesSliceDefsSliceView,
+  NetworkSlicesWaitlistDefsRequestView,
+  NetworkSlicesWaitlistDefsInviteView
+} from "../../../../client.ts";
+
+interface SliceWaitlistPageProps {
+  slice: NetworkSlicesSliceDefsSliceView;
+  sliceId: string;
+  requests?: NetworkSlicesWaitlistDefsRequestView[];
+  invites?: NetworkSlicesWaitlistDefsInviteView[];
+  currentUser?: AuthenticatedUser;
+  hasSliceAccess?: boolean;
+  activeTab?: string;
+}
+
+export function SliceWaitlistPage({
+  slice,
+  sliceId,
+  requests = [],
+  invites = [],
+  currentUser,
+  hasSliceAccess,
+  activeTab = "requests",
+}: SliceWaitlistPageProps) {
+  return (
+    <SlicePage
+      slice={slice}
+      sliceId={sliceId}
+      currentTab="waitlist"
+      currentUser={currentUser}
+      hasSliceAccess={hasSliceAccess}
+      title={`${slice.name} - Waitlist`}
+    >
+      <div className="space-y-6">
+        <div className="flex justify-end">
+          <Button
+            variant="primary"
+            size="md"
+            hx-get={buildSliceUrlFromView(slice, sliceId, "waitlist/invite/new")}
+            hx-target="#modal-container"
+          >
+            Create Invite
+          </Button>
+        </div>
+
+        <Tabs variant="bordered">
+          <Tabs.List>
+            <Tabs.Tab
+              active={activeTab === "requests"}
+              count={requests.length}
+              hxGet={buildSliceUrlFromView(slice, sliceId, "waitlist?tab=requests")}
+              hxTarget="body"
+            >
+              Requests
+            </Tabs.Tab>
+            <Tabs.Tab
+              active={activeTab === "invites"}
+              count={invites.length}
+              hxGet={buildSliceUrlFromView(slice, sliceId, "waitlist?tab=invites")}
+              hxTarget="body"
+            >
+              Invites
+            </Tabs.Tab>
+          </Tabs.List>
+
+          <Tabs.Content active={activeTab === "requests"}>
+            <WaitlistRequestsList
+              requests={requests}
+              invites={invites}
+              slice={slice}
+              sliceId={sliceId}
+            />
+          </Tabs.Content>
+
+          <Tabs.Content active={activeTab === "invites"}>
+            <WaitlistInvitesList
+              invites={invites}
+              slice={slice}
+              sliceId={sliceId}
+            />
+          </Tabs.Content>
+        </Tabs>
+      </div>
+    </SlicePage>
+  );
+}

frontend/src/features/slices/waitlist/templates/fragments/CreateInviteModal.tsx

···
+import { Modal } from "../../../../../shared/fragments/Modal.tsx";
+import { Input } from "../../../../../shared/fragments/Input.tsx";
+import { Button } from "../../../../../shared/fragments/Button.tsx";
+import { Text } from "../../../../../shared/fragments/Text.tsx";
+import { buildSliceUrlFromView } from "../../../../../utils/slice-params.ts";
+import type { NetworkSlicesSliceDefsSliceView } from "../../../../../client.ts";
+
+interface CreateInviteModalProps {
+  slice: NetworkSlicesSliceDefsSliceView;
+  sliceId: string;
+  error?: string;
+}
+
+export function CreateInviteModal({ slice, sliceId, error }: CreateInviteModalProps) {
+  return (
+    <Modal
+      title="Create Invite"
+      description="Grant a specific DID access to your slice"
+      size="md"
+    >
+      {error && (
+        <div className="mb-4 p-3 bg-red-50 dark:bg-red-900/20 border border-red-200 dark:border-red-800 rounded-md">
+          <Text as="p" variant="error" size="sm">
+            {error}
+          </Text>
+        </div>
+      )}
+      <form
+        hx-post={buildSliceUrlFromView(slice, sliceId, "waitlist/invite")}
+        className="space-y-4"
+      >
+        <div>
+          <Text as="label" variant="label" className="block mb-2">
+            DID
+          </Text>
+          <Input
+            type="text"
+            name="did"
+            placeholder="did:plc:example123..."
+            required
+            className="w-full"
+          />
+          <Text as="p" variant="muted" size="sm" className="mt-1">
+            The AT Protocol DID to grant access
+          </Text>
+        </div>
+
+        <div>
+          <Text as="label" variant="label" className="block mb-2">
+            Expires At (Optional)
+          </Text>
+          <Input type="datetime-local" name="expiresAt" className="w-full" />
+          <Text as="p" variant="muted" size="sm" className="mt-1">
+            Leave empty for no expiration
+          </Text>
+        </div>
+
+        <div className="flex justify-end gap-3 pt-4">
+          <Button
+            type="button"
+            variant="outline"
+            _="on click set #modal-container's innerHTML to ''"
+          >
+            Cancel
+          </Button>
+          <Button type="submit" variant="success">
+            Create Invite
+          </Button>
+        </div>
+      </form>
+    </Modal>
+  );
+}

frontend/src/features/slices/waitlist/templates/fragments/WaitlistInvitesList.tsx

···
+import { ListItem } from "../../../../../shared/fragments/ListItem.tsx";
+import { Button } from "../../../../../shared/fragments/Button.tsx";
+import { Text } from "../../../../../shared/fragments/Text.tsx";
+import { EmptyState } from "../../../../../shared/fragments/EmptyState.tsx";
+import { ActorAvatar } from "../../../../../shared/fragments/ActorAvatar.tsx";
+import { buildSliceUrlFromView } from "../../../../../utils/slice-params.ts";
+import { timeAgo } from "../../../../../utils/time.ts";
+import { UserCheck } from "lucide-preact";
+import type {
+  NetworkSlicesWaitlistDefsInviteView,
+  NetworkSlicesSliceDefsSliceView
+} from "../../../../../client.ts";
+
+interface WaitlistInvitesListProps {
+  invites: NetworkSlicesWaitlistDefsInviteView[];
+  slice: NetworkSlicesSliceDefsSliceView;
+  sliceId: string;
+}
+
+export function WaitlistInvitesList({
+  invites,
+  slice,
+  sliceId,
+}: WaitlistInvitesListProps) {
+  const isExpired = (invite: NetworkSlicesWaitlistDefsInviteView) => {
+    if (!invite.expiresAt) return false;
+    return new Date(invite.expiresAt) < new Date();
+  };
+
+  if (invites.length === 0) {
+    return (
+      <EmptyState
+        icon={<UserCheck size={48} strokeWidth={1} />}
+        title="No invites created"
+        description="Create invites to grant specific DIDs access to your slice."
+        withPadding
+      />
+    );
+  }
+
+  return (
+    <div className="bg-white dark:bg-zinc-900 border border-zinc-200 dark:border-zinc-700 rounded-sm">
+      {invites.map((invite, index) => (
+        <ListItem key={`invite-${index}`}>
+          <div className="flex items-center justify-between w-full px-6 py-4">
+            <div className="flex items-center gap-3 flex-1 min-w-0">
+              <ActorAvatar
+                profile={invite.profile || { handle: invite.did }}
+                size={40}
+              />
+              <div className="flex-1 min-w-0">
+                <Text as="div" size="sm" className="font-medium truncate">
+                  {invite.profile?.displayName || invite.profile?.handle || invite.did}
+                </Text>
+                <div className="flex items-center gap-4 mt-0.5">
+                  <Text as="div" size="xs" variant="muted">
+                    {invite.profile?.handle && invite.profile.handle !== invite.did && `@${invite.profile.handle} • `}Created {timeAgo(invite.createdAt)}
+                  </Text>
+                  {invite.expiresAt && (
+                    <Text
+                      as="div"
+                      size="xs"
+                      variant={isExpired(invite) ? "error" : "muted"}
+                    >
+                      {isExpired(invite) ? "Expired" : "Expires"} {timeAgo(invite.expiresAt)}
+                    </Text>
+                  )}
+                </div>
+              </div>
+            </div>
+            <div className="ml-4">
+              <form
+                hx-delete={buildSliceUrlFromView(slice, sliceId, "waitlist/invite")}
+                hx-trigger="submit"
+                hx-confirm="Revoke this invite?"
+                style="display: inline;"
+              >
+                <input type="hidden" name="uri" value={invite.uri} />
+                <Button
+                  type="submit"
+                  variant="outline"
+                  size="sm"
+                >
+                  Revoke
+                </Button>
+              </form>
+            </div>
+          </div>
+        </ListItem>
+      ))}
+    </div>
+  );
+}

frontend/src/features/slices/waitlist/templates/fragments/WaitlistRequestsList.tsx

···
+import { ListItem } from "../../../../../shared/fragments/ListItem.tsx";
+import { Button } from "../../../../../shared/fragments/Button.tsx";
+import { Text } from "../../../../../shared/fragments/Text.tsx";
+import { EmptyState } from "../../../../../shared/fragments/EmptyState.tsx";
+import { ActorAvatar } from "../../../../../shared/fragments/ActorAvatar.tsx";
+import { Users } from "lucide-preact";
+import type {
+  NetworkSlicesWaitlistDefsRequestView,
+  NetworkSlicesWaitlistDefsInviteView,
+  NetworkSlicesSliceDefsSliceView
+} from "../../../../../client.ts";
+import { buildSliceUrlFromView } from "../../../../../utils/slice-params.ts";
+import { timeAgo } from "../../../../../utils/time.ts";
+
+interface WaitlistRequestsListProps {
+  requests: NetworkSlicesWaitlistDefsRequestView[];
+  invites: NetworkSlicesWaitlistDefsInviteView[];
+  slice: NetworkSlicesSliceDefsSliceView;
+  sliceId: string;
+}
+
+export function WaitlistRequestsList({
+  requests,
+  invites,
+  slice,
+  sliceId,
+}: WaitlistRequestsListProps) {
+  if (requests.length === 0) {
+    return (
+      <EmptyState
+        icon={<Users size={48} strokeWidth={1} />}
+        title="No requests yet"
+        description="Waitlist requests will appear here when users request access."
+        withPadding
+      />
+    );
+  }
+
+  return (
+    <div className="bg-white dark:bg-zinc-900 border border-zinc-200 dark:border-zinc-700 rounded-sm">
+      {requests.map((request, index) => {
+        // Check if this DID already has an invite
+        const requestDid = request.profile?.did || "unknown";
+        const hasInvite = invites.some(invite => invite.did === requestDid);
+
+        return (
+          <ListItem key={`request-${index}`}>
+            <div className="flex items-center justify-between w-full px-6 py-4">
+              <div className="flex items-center gap-3 flex-1 min-w-0">
+                <ActorAvatar
+                  profile={request.profile || { handle: requestDid }}
+                  size={40}
+                />
+                <div className="flex-1 min-w-0">
+                  <Text
+                    as="div"
+                    size="sm"
+                    className="font-medium truncate"
+                  >
+                    {request.profile?.displayName || request.profile?.handle || requestDid}
+                  </Text>
+                  <Text as="div" size="xs" variant="muted" className="mt-0.5">
+                    {request.profile?.handle && request.profile.handle !== requestDid && `@${request.profile.handle} • `}Requested {timeAgo(request.createdAt)}
+                  </Text>
+                </div>
+              </div>
+              <div className="flex items-center gap-2 ml-4">
+                {!hasInvite && (
+                  <Button
+                    variant="success"
+                    size="sm"
+                    hx-post={buildSliceUrlFromView(slice, sliceId, "waitlist/invite/from-request")}
+                    hx-vals={JSON.stringify({ did: requestDid })}
+                    hx-target="closest div[class*='bg-white']"
+                    hx-swap="outerHTML"
+                  >
+                    Invite
+                  </Button>
+                )}
+                {hasInvite && (
+                  <Text size="sm" variant="muted">
+                    Already invited
+                  </Text>
+                )}
+              </div>
+            </div>
+          </ListItem>
+        );
+      })}
+    </div>
+  );
+}

frontend/src/features/waitlist/handlers.tsx

···
 import { withAuth } from "../../routes/middleware.ts";
 import { renderHTML } from "../../utils/render.tsx";
 import { WaitlistPage } from "./templates/WaitlistPage.tsx";
+import { publicClient, SLICE_URI } from "../../config.ts";
+import { getHydratedWaitlistRequests } from "../slices/waitlist/api.ts";
 
 async function handleWaitlistPage(req: Request): Promise<Response> {
   const context = await withAuth(req);
···
   const handle = url.searchParams.get("handle");
   const error = url.searchParams.get("error");
 
+  // Fetch recent waitlist requests to show avatars for social proof
+  let recentRequests;
+  if (SLICE_URI) {
+    try {
+      recentRequests = await getHydratedWaitlistRequests(publicClient, SLICE_URI);
+      // Limit to most recent 50 and reverse to show newest first
+      recentRequests = recentRequests.slice(0, 50);
+    } catch (error) {
+      console.error("Failed to fetch recent waitlist requests:", error);
+      // Continue without recent requests if fetch fails
+    }
+  }
+
   return renderHTML(
     <WaitlistPage
       success={success}
       handle={handle || undefined}
       error={error || undefined}
       currentUser={context.currentUser}
+      recentRequests={recentRequests}
     />
   );
 }

frontend/src/features/waitlist/templates/WaitlistPage.tsx

···
 import { WaitlistSuccess } from "./fragments/WaitlistSuccess.tsx";
 import { Text } from "../../../shared/fragments/Text.tsx";
 import type { AuthenticatedUser } from "../../../routes/middleware.ts";
+import type { NetworkSlicesWaitlistDefsRequestView } from "../../../client.ts";
 
 interface WaitlistPageProps {
   success?: boolean;
   handle?: string;
   error?: string;
   currentUser?: AuthenticatedUser;
+  recentRequests?: NetworkSlicesWaitlistDefsRequestView[];
 }
 
 export function WaitlistPage({
···
   handle,
   error,
   currentUser,
+  recentRequests,
 }: WaitlistPageProps) {
   return (
     <Layout title="Join the Waitlist - Slices" currentUser={currentUser}>
-      <div className="min-h-screen bg-white dark:bg-zinc-900 flex items-center justify-center px-4 py-16">
+      <div className="min-h-[calc(100vh-3.5rem)] bg-white dark:bg-zinc-900 flex items-center justify-center px-4 py-16">
         <div className="w-full max-w-md">
           {success ? (
-            <WaitlistSuccess handle={handle} />
+            <WaitlistSuccess handle={handle} recentRequests={recentRequests} />
           ) : (
             <>
               <div className="text-center mb-8">
···
                   Be among the first to experience the future of AT Protocol ecosystem tools.
                 </Text>
               </div>
-              <WaitlistForm error={error} />
+              <WaitlistForm error={error} recentRequests={recentRequests} />
             </>
           )}
         </div>

frontend/src/features/waitlist/templates/fragments/WaitlistForm.tsx

···
 import { Card } from "../../../../shared/fragments/Card.tsx";
 import { Text } from "../../../../shared/fragments/Text.tsx";
 import { FlashMessage } from "../../../../shared/fragments/FlashMessage.tsx";
+import { ActorAvatar } from "../../../../shared/fragments/ActorAvatar.tsx";
+import type { NetworkSlicesWaitlistDefsRequestView } from "../../../../client.ts";
 
 interface WaitlistFormProps {
   error?: string;
+  recentRequests?: NetworkSlicesWaitlistDefsRequestView[];
 }
 
-export function WaitlistForm({ error }: WaitlistFormProps) {
+export function WaitlistForm({ error, recentRequests }: WaitlistFormProps) {
   const getErrorMessage = (error: string) => {
     switch (error) {
       case "oauth_not_configured":
···
         return "Could not retrieve user information.";
       case "waitlist_failed":
         return "Failed to join waitlist. Please try again.";
+      case "invite_required":
+        return "You need an invite to access this service. Join the waitlist to request access.";
+      case "already_on_waitlist":
+        return "You're already on the waitlist! We'll notify you when your invite is ready.";
       default:
         return "An error occurred. Please try again.";
     }
   };
 
   return (
-    <Card>
+    <Card padding="md">
+      {recentRequests && recentRequests.length > 0 && (
+        <div className="mb-6 text-center">
+          <Text as="p" size="sm" variant="muted" className="mb-3">
+            Join {recentRequests.length} others who are waiting
+          </Text>
+          <div className="flex flex-wrap justify-center gap-1">
+            {recentRequests.slice(0, 20).map((request, index) => (
+              <div key={index} className="relative">
+                <ActorAvatar
+                  profile={request.profile || { handle: "user" }}
+                  size={24}
+                  className="border border-white dark:border-zinc-800"
+                />
+              </div>
+            ))}
+            {recentRequests.length > 20 && (
+              <div className="w-6 h-6 bg-zinc-100 dark:bg-zinc-800 border border-white dark:border-zinc-800 rounded-full flex items-center justify-center">
+                <Text size="xs" variant="muted">
+                  +{recentRequests.length - 20}
+                </Text>
+              </div>
+            )}
+          </div>
+        </div>
+      )}
+
       <form action="/auth/waitlist/initiate" method="POST">
         <div className="space-y-6">
           {error && (
···
             <Input
               label="Your handle"
               name="handle"
-              placeholder="alice.bsky.social"
+              placeholder="user.bsky.social"
               required
             />
             <Text as="p" size="xs" variant="muted">
···
           </div>
 
           <div className="space-y-4">
-            <Button type="submit" variant="primary" className="w-full justify-center">
+            <Button
+              type="submit"
+              variant="primary"
+              className="w-full justify-center"
+            >
               Join Waitlist
             </Button>
 
             <Text as="p" size="xs" variant="muted" className="text-center">
-              By joining the waitlist, you'll be notified when Slices is ready for you.
+              By joining the waitlist, you'll be notified when Slices is ready
+              for you.
             </Text>
           </div>
         </div>
       </form>
     </Card>
   );
-}
+}

frontend/src/features/waitlist/templates/fragments/WaitlistSuccess.tsx

···
 import { Card } from "../../../../shared/fragments/Card.tsx";
 import { Text } from "../../../../shared/fragments/Text.tsx";
 import { Link } from "../../../../shared/fragments/Link.tsx";
+import { ActorAvatar } from "../../../../shared/fragments/ActorAvatar.tsx";
 import { Check } from "lucide-preact";
+import type { NetworkSlicesWaitlistDefsRequestView } from "../../../../client.ts";
 
 interface WaitlistSuccessProps {
   handle?: string;
+  recentRequests?: NetworkSlicesWaitlistDefsRequestView[];
 }
 
-export function WaitlistSuccess({ handle }: WaitlistSuccessProps) {
+export function WaitlistSuccess({
+  handle,
+  recentRequests,
+}: WaitlistSuccessProps) {
   return (
-    <Card className="text-center">
+    <Card padding="md" className="text-center">
       <div className="flex justify-center mb-6">
         <div className="w-16 h-16 bg-green-100 dark:bg-green-900/30 rounded-full flex items-center justify-center">
           <Check size={32} className="text-green-600 dark:text-green-400" />
···
       </Text>
 
       <Text as="p" variant="secondary" className="mb-6">
-        Thanks for joining the waitlist{handle ? <>, <Text as="span" className="font-bold">{handle}</Text></> : ""}! We'll notify you as soon as Slices is ready for you.
+        Thanks for joining the waitlist
+        {handle ? (
+          <>
+            ,{" "}
+            <Text as="span" className="font-bold">
+              {handle}
+            </Text>
+          </>
+        ) : (
+          ""
+        )}
+        ! We'll notify you as soon as Slices is ready for you.
       </Text>
 
+      {recentRequests && recentRequests.length > 0 && (
+        <div className="mb-6">
+          <Text as="p" size="sm" variant="muted" className="mb-3">
+            You've joined {recentRequests.length} others
+          </Text>
+          <div className="flex flex-wrap justify-center gap-1">
+            {recentRequests.slice(0, 30).map((request, index) => (
+              <div key={index} className="relative">
+                <ActorAvatar
+                  profile={request.profile || { handle: "user" }}
+                  size={32}
+                  className="border border-white dark:border-zinc-800"
+                />
+              </div>
+            ))}
+            {recentRequests.length > 30 && (
+              <div className="w-8 h-8 bg-zinc-100 dark:bg-zinc-800 border border-white dark:border-zinc-800 rounded-full flex items-center justify-center">
+                <Text size="xs" variant="muted">
+                  +{recentRequests.length - 30}
+                </Text>
+              </div>
+            )}
+          </div>
+        </div>
+      )}
+
       <div className="space-y-4">
         <Button href="/" variant="primary" className="w-full justify-center">
           Back to Home
···
       </div>
     </Card>
   );
-}
+}

frontend/src/lib/api.ts

···
       if (creator) {
         const sparklineData = sparklinesMap[sliceRecord.uri];
         const statsData = statsMap[sliceRecord.uri];
-        sliceViews.push(sliceToView(sliceRecord, creator, sparklineData, statsData));
+        sliceViews.push(
+          sliceToView(sliceRecord, creator, sparklineData, statsData)
+        );
       }
     }
 
···
       if (creator) {
         const sparklineData = sparklinesMap[sliceRecord.uri];
         const statsData = statsMap[sliceRecord.uri];
-        sliceViews.push(sliceToView(sliceRecord, creator, sparklineData, statsData));
+        sliceViews.push(
+          sliceToView(sliceRecord, creator, sparklineData, statsData)
+        );
       }
     }
 
···
       if (creator) {
         const sparklineData = sparklinesMap[sliceRecord.uri];
         const statsData = statsMap[sliceRecord.uri];
-        sliceViews.push(sliceToView(sliceRecord, creator, sparklineData, statsData));
+        sliceViews.push(
+          sliceToView(sliceRecord, creator, sparklineData, statsData)
+        );
       }
     }
 

frontend/src/routes/mod.ts

···
 import type { Route } from "@std/http/unstable-route";
 import { landingRoutes } from "../features/landing/handlers.tsx";
 import { authRoutes } from "../features/auth/handlers.tsx";
-import { waitlistRoutes } from "../features/waitlist/handlers.tsx";
 import { dashboardRoutes } from "../features/dashboard/handlers.tsx";
+import { waitlistRoutes as globalWaitlistRoutes } from "../features/waitlist/handlers.tsx";
 import {
   apiDocsRoutes,
   codegenRoutes,
···
   settingsRoutes as sliceSettingsRoutes,
   syncLogsRoutes,
   syncRoutes,
+  waitlistRoutes as sliceWaitlistRoutes,
 } from "../features/slices/mod.ts";
 import { settingsRoutes } from "../features/settings/handlers.tsx";
 import { docsRoutes } from "../features/docs/handlers.tsx";
···
   // Auth routes (login, oauth, logout)
   ...authRoutes,
 
-  // Waitlist page
-  ...waitlistRoutes,
+  // Global waitlist page
+  ...globalWaitlistRoutes,
 
   // Documentation routes
   ...docsRoutes,
···
   ...syncRoutes,
   ...syncLogsRoutes,
   ...jetstreamRoutes,
+  ...sliceWaitlistRoutes,
 
   // Dashboard routes (home page, create slice)
   ...dashboardRoutes,

frontend/src/shared/fragments/Card.tsx

···
   variant?: CardVariant;
   padding?: "none" | "sm" | "md" | "lg";
   className?: string;
-  children: JSX.Element | JSX.Element[];
+  children: ComponentChildren;
 }
 
 interface CardHeaderProps {
···
 
 export function Card({
   variant = "default",
-  padding = "md",
+  padding = "none",
   className,
   children,
   ...props

frontend/src/shared/fragments/FlashMessage.tsx

···
   if (type === "success") {
     return (
       <Card padding="sm" className={`mb-4 bg-green-50 dark:bg-green-900/20 border-green-200 dark:border-green-800 ${className}`}>
-        <div className="flex items-center gap-2">
+        <div className="flex items-center gap-3">
           <CheckCircle2
-            size={16}
+            size={20}
+            className="flex-shrink-0"
             style={{ fill: '#16a34a', stroke: 'white', strokeWidth: 1 }}
           />
-          <Text variant="success">
+          <Text variant="success" className="flex-1">
             {message}
           </Text>
         </div>
···
 
   return (
     <Card padding="sm" className={`mb-4 bg-red-50 dark:bg-red-900/20 border-red-200 dark:border-red-800 ${className}`}>
-      <div className="flex items-center gap-2">
+      <div className="flex items-center gap-3">
         <XCircle
-          size={16}
+          size={20}
+          className="flex-shrink-0"
           style={{ fill: '#dc2626', stroke: 'white', strokeWidth: 1 }}
         />
-        <Text variant="error">
+        <Text variant="error" className="flex-1">
           {message}
         </Text>
       </div>

frontend/src/shared/fragments/Layout.tsx

···
         <meta name="description" content={description} />
 
         {/* Favicon - Letter S */}
-        <link rel="icon" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><rect width='100' height='100' fill='black'/><text x='50' y='70' font-size='60' font-family='system-ui' fill='white' text-anchor='middle' font-weight='bold'>S</text></svg>" />
+        <link
+          rel="icon"
+          href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><rect width='100' height='100' fill='black'/><text x='50' y='70' font-size='60' font-family='system-ui' fill='white' text-anchor='middle' font-weight='bold'>S</text></svg>"
+        />
 
         {/* Open Graph / Facebook */}
         <meta property="og:type" content="website" />
···
         {showNavigation && <Navigation currentUser={currentUser} />}
         <div
           className={`min-h-screen flex flex-col ${
-            fullWidth ? "" : "max-w-5xl mx-auto sm:border-x border-zinc-200 dark:border-zinc-800"
+            fullWidth
+              ? ""
+              : "max-w-5xl mx-auto sm:border-x border-zinc-200 dark:border-zinc-800"
           }`}
           style={backgroundStyle}
         >
-          {showNavigation
-            ? (
-              <main className={cn("flex-1 sm:pt-14", !backgroundStyle && "bg-white dark:bg-zinc-900")}>
-                {children}
-              </main>
-            )
-            : (
-              <main className={cn("flex-1", !backgroundStyle && "bg-white dark:bg-zinc-900")}>
-                {children}
-              </main>
-            )}
+          {showNavigation ? (
+            <main
+              className={cn(
+                "flex-1 sm:pt-14",
+                !backgroundStyle && "bg-white dark:bg-zinc-900"
+              )}
+            >
+              {children}
+            </main>
+          ) : (
+            <main
+              className={cn(
+                "flex-1",
+                !backgroundStyle && "bg-white dark:bg-zinc-900"
+              )}
+            >
+              {children}
+            </main>
+          )}
         </div>
+
+        {/* Modal container for HTMX modals */}
+        <div id="modal-container"></div>
       </body>
     </html>
   );

frontend/src/shared/fragments/LogViewer.tsx

···
   const infoCount = logs.filter((l) => l.level === "info").length;
 
   return (
-    <Card padding="none">
+    <Card>
       <div className="bg-zinc-50 dark:bg-zinc-800 px-6 py-3 border-b border-zinc-200 dark:border-zinc-700 rounded-t-sm">
         <div className="flex items-center gap-4">
           <Text as="span" size="sm">

frontend/src/shared/fragments/Navigation.tsx

···
           >
             Slices
           </a>
-          <a
-            href="/docs"
-            className="px-3 py-1.5 text-sm text-zinc-600 dark:text-zinc-400 hover:text-zinc-900 dark:hover:text-white hover:bg-zinc-100 dark:hover:bg-zinc-800 rounded-md transition-colors"
-          >
-            Docs
-          </a>
+          {currentUser?.isAuthenticated && (
+            <a
+              href="/docs"
+              className="px-3 py-1.5 text-sm text-zinc-600 dark:text-zinc-400 hover:text-zinc-900 dark:hover:text-white hover:bg-zinc-100 dark:hover:bg-zinc-800 rounded-md transition-colors"
+            >
+              Docs
+            </a>
+          )}
         </div>
         <div className="flex items-center space-x-2">
           {currentUser?.isAuthenticated

frontend/src/shared/fragments/Tabs.tsx

···
+import type { JSX, ComponentChildren } from "preact";
+import { cn } from "../../utils/cn.ts";
+import { passPropsToChildren } from "../../utils/preact.ts";
+
+type TabVariant = "underline" | "bordered";
+
+interface TabsProps {
+  variant?: TabVariant;
+  className?: string;
+  children: ComponentChildren;
+}
+
+interface TabsListProps {
+  variant?: TabVariant;
+  className?: string;
+  children: ComponentChildren;
+}
+
+interface TabProps {
+  variant?: TabVariant;
+  active?: boolean;
+  className?: string;
+  children: ComponentChildren;
+  count?: number;
+  hxGet?: string;
+  hxTarget?: string;
+}
+
+interface TabsContentProps {
+  active?: boolean;
+  className?: string;
+  children: ComponentChildren;
+}
+
+export function Tabs({
+  variant = "underline",
+  className,
+  children,
+}: TabsProps): JSX.Element {
+  const childrenWithVariant = passPropsToChildren(children, { variant });
+
+  return <div className={cn("w-full", className)}>{childrenWithVariant}</div>;
+}
+
+Tabs.List = function TabsList({
+  variant = "underline",
+  className,
+  children,
+}: TabsListProps): JSX.Element {
+  const listClasses =
+    variant === "bordered"
+      ? "bg-zinc-50 dark:bg-zinc-800/50 relative after:absolute after:bottom-0 after:left-0 after:right-0 after:h-px after:bg-zinc-200 after:dark:bg-zinc-700"
+      : "border-b border-zinc-200 dark:border-zinc-700";
+
+  const childrenWithVariant = passPropsToChildren(children, { variant });
+
+  return (
+    <nav className={cn(listClasses, className)}>
+      <div
+        className={cn(
+          "flex overflow-x-auto scrollbar-hide",
+          variant === "bordered" ? "space-x-0" : "space-x-1"
+        )}
+      >
+        {childrenWithVariant}
+      </div>
+    </nav>
+  );
+};
+
+Tabs.Tab = function Tab({
+  variant = "underline",
+  active = false,
+  className,
+  children,
+  count,
+  hxGet,
+  hxTarget,
+}: TabProps): JSX.Element {
+  const getTabClasses = () => {
+    if (variant === "bordered") {
+      return cn(
+        "py-2 px-4 font-medium text-sm whitespace-nowrap flex-shrink-0 transition-colors relative",
+        active
+          ? "bg-white dark:bg-zinc-900 text-zinc-900 dark:text-zinc-100 border border-zinc-200 dark:border-zinc-700 border-b-white dark:border-b-zinc-900 rounded-t-md z-20 relative"
+          : "bg-transparent text-zinc-500 dark:text-zinc-400"
+      );
+    }
+
+    return cn(
+      "py-2 px-4 border-b-2 font-medium text-sm whitespace-nowrap flex-shrink-0 transition-colors",
+      active
+        ? "border-blue-500 dark:border-blue-400 text-blue-600 dark:text-blue-400"
+        : "border-transparent text-zinc-500 dark:text-zinc-400 hover:text-zinc-700 dark:hover:text-zinc-300 hover:border-zinc-300 dark:hover:border-zinc-600"
+    );
+  };
+
+  return (
+    <button
+      type="button"
+      className={cn(getTabClasses(), className)}
+      hx-get={hxGet}
+      hx-target={hxTarget}
+      hx-push-url="true"
+    >
+      {children}
+      {count !== undefined && (
+        <span
+          className={cn(
+            "ml-2 px-2 py-0.5 text-xs rounded-full",
+            active
+              ? "bg-blue-100 dark:bg-blue-900 text-blue-800 dark:text-blue-200"
+              : "bg-zinc-100 dark:bg-zinc-700 text-zinc-600 dark:text-zinc-300"
+          )}
+        >
+          {count}
+        </span>
+      )}
+    </button>
+  );
+};
+
+Tabs.Content = function TabsContent({
+  active = false,
+  className,
+  children,
+}: TabsContentProps): JSX.Element | null {
+  if (!active) return null;
+
+  return <div className={cn("py-6", className)}>{children}</div>;
+};

frontend/src/shared/fragments/Text.tsx

···
   | "h3"
   | "h4"
   | "h5"
-  | "h6";
+  | "h6"
+  | "dt"
+  | "dd";
 
 interface TextProps {
   variant?: TextVariant;

frontend/src/utils/preact.ts

···
+import type { ComponentChildren } from "preact";
+import { cloneElement } from "preact";
+
+/**
+ * Passes props down to all children that accept them
+ */
+export function passPropsToChildren(
+  children: ComponentChildren,
+  props: Record<string, unknown>
+): ComponentChildren {
+  if (Array.isArray(children)) {
+    return children.map(child => {
+      if (child && typeof child === 'object' && 'type' in child) {
+        return cloneElement(child as any, props);
+      }
+      return child;
+    });
+  }
+
+  if (children && typeof children === 'object' && 'type' in children) {
+    return cloneElement(children as any, props);
+  }
+
+  return children;
+}

lexicons/app/bsky/actor/defs.json

···
+{
+  "lexicon": 1,
+  "id": "app.bsky.actor.defs",
+  "defs": {
+    "nux": {
+      "type": "object",
+      "required": [
+        "id",
+        "completed"
+      ],
+      "properties": {
+        "id": {
+          "type": "string",
+          "maxLength": 100
+        },
+        "data": {
+          "type": "string",
+          "maxLength": 3000,
+          "description": "Arbitrary data for the NUX. The structure is defined by the NUX itself. Limited to 300 characters.",
+          "maxGraphemes": 300
+        },
+        "completed": {
+          "type": "boolean",
+          "default": false
+        },
+        "expiresAt": {
+          "type": "string",
+          "format": "datetime",
+          "description": "The date and time at which the NUX will expire and should be considered completed."
+        }
+      },
+      "description": "A new user experiences (NUX) storage object"
+    },
+    "mutedWord": {
+      "type": "object",
+      "required": [
+        "value",
+        "targets"
+      ],
+      "properties": {
+        "id": {
+          "type": "string"
+        },
+        "value": {
+          "type": "string",
+          "maxLength": 10000,
+          "description": "The muted word itself.",
+          "maxGraphemes": 1000
+        },
+        "targets": {
+          "type": "array",
+          "items": {
+            "ref": "app.bsky.actor.defs#mutedWordTarget",
+            "type": "ref"
+          },
+          "description": "The intended targets of the muted word."
+        },
+        "expiresAt": {
+          "type": "string",
+          "format": "datetime",
+          "description": "The date and time at which the muted word will expire and no longer be applied."
+        },
+        "actorTarget": {
+          "type": "string",
+          "default": "all",
+          "description": "Groups of users to apply the muted word to. If undefined, applies to all users.",
+          "knownValues": [
+            "all",
+            "exclude-following"
+          ]
+        }
+      },
+      "description": "A word that the account owner has muted."
+    },
+    "savedFeed": {
+      "type": "object",
+      "required": [
+        "id",
+        "type",
+        "value",
+        "pinned"
+      ],
+      "properties": {
+        "id": {
+          "type": "string"
+        },
+        "type": {
+          "type": "string",
+          "knownValues": [
+            "feed",
+            "list",
+            "timeline"
+          ]
+        },
+        "value": {
+          "type": "string"
+        },
+        "pinned": {
+          "type": "boolean"
+        }
+      }
+    },
+    "preferences": {
+      "type": "array",
+      "items": {
+        "refs": [
+          "#adultContentPref",
+          "#contentLabelPref",
+          "#savedFeedsPref",
+          "#savedFeedsPrefV2",
+          "#personalDetailsPref",
+          "#feedViewPref",
+          "#threadViewPref",
+          "#interestsPref",
+          "#mutedWordsPref",
+          "#hiddenPostsPref",
+          "#bskyAppStatePref",
+          "#labelersPref",
+          "#postInteractionSettingsPref"
+        ],
+        "type": "union"
+      }
+    },
+    "profileView": {
+      "type": "object",
+      "required": [
+        "did",
+        "handle"
+      ],
+      "properties": {
+        "did": {
+          "type": "string",
+          "format": "did"
+        },
+        "avatar": {
+          "type": "string",
+          "format": "uri"
+        },
+        "handle": {
+          "type": "string",
+          "format": "handle"
+        },
+        "labels": {
+          "type": "array",
+          "items": {
+            "ref": "com.atproto.label.defs#label",
+            "type": "ref"
+          }
+        },
+        "viewer": {
+          "ref": "#viewerState",
+          "type": "ref"
+        },
+        "createdAt": {
+          "type": "string",
+          "format": "datetime"
+        },
+        "indexedAt": {
+          "type": "string",
+          "format": "datetime"
+        },
+        "associated": {
+          "ref": "#profileAssociated",
+          "type": "ref"
+        },
+        "description": {
+          "type": "string",
+          "maxLength": 2560,
+          "maxGraphemes": 256
+        },
+        "displayName": {
+          "type": "string",
+          "maxLength": 640,
+          "maxGraphemes": 64
+        }
+      }
+    },
+    "viewerState": {
+      "type": "object",
+      "properties": {
+        "muted": {
+          "type": "boolean"
+        },
+        "blocking": {
+          "type": "string",
+          "format": "at-uri"
+        },
+        "blockedBy": {
+          "type": "boolean"
+        },
+        "following": {
+          "type": "string",
+          "format": "at-uri"
+        },
+        "followedBy": {
+          "type": "string",
+          "format": "at-uri"
+        },
+        "mutedByList": {
+          "ref": "app.bsky.graph.defs#listViewBasic",
+          "type": "ref"
+        },
+        "blockingByList": {
+          "ref": "app.bsky.graph.defs#listViewBasic",
+          "type": "ref"
+        },
+        "knownFollowers": {
+          "ref": "#knownFollowers",
+          "type": "ref"
+        }
+      },
+      "description": "Metadata about the requesting account's relationship with the subject account. Only has meaningful content for authed requests."
+    },
+    "feedViewPref": {
+      "type": "object",
+      "required": [
+        "feed"
+      ],
+      "properties": {
+        "feed": {
+          "type": "string",
+          "description": "The URI of the feed, or an identifier which describes the feed."
+        },
+        "hideReplies": {
+          "type": "boolean",
+          "description": "Hide replies in the feed."
+        },
+        "hideReposts": {
+          "type": "boolean",
+          "description": "Hide reposts in the feed."
+        },
+        "hideQuotePosts": {
+          "type": "boolean",
+          "description": "Hide quote posts in the feed."
+        },
+        "hideRepliesByLikeCount": {
+          "type": "integer",
+          "description": "Hide replies in the feed if they do not have this number of likes."
+        },
+        "hideRepliesByUnfollowed": {
+          "type": "boolean",
+          "default": true,
+          "description": "Hide replies in the feed if they are not by followed users."
+        }
+      }
+    },
+    "labelersPref": {
+      "type": "object",
+      "required": [
+        "labelers"
+      ],
+      "properties": {
+        "labelers": {
+          "type": "array",
+          "items": {
+            "ref": "#labelerPrefItem",
+            "type": "ref"
+          }
+        }
+      }
+    },
+    "interestsPref": {
+      "type": "object",
+      "required": [
+        "tags"
+      ],
+      "properties": {
+        "tags": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "maxLength": 640,
+            "maxGraphemes": 64
+          },
+          "maxLength": 100,
+          "description": "A list of tags which describe the account owner's interests gathered during onboarding."
+        }
+      }
+    },
+    "knownFollowers": {
+      "type": "object",
+      "required": [
+        "count",
+        "followers"
+      ],
+      "properties": {
+        "count": {
+          "type": "integer"
+        },
+        "followers": {
+          "type": "array",
+          "items": {
+            "ref": "#profileViewBasic",
+            "type": "ref"
+          },
+          "maxLength": 5,
+          "minLength": 0
+        }
+      },
+      "description": "The subject's followers whom you also follow"
+    },
+    "mutedWordsPref": {
+      "type": "object",
+      "required": [
+        "items"
+      ],
+      "properties": {
+        "items": {
+          "type": "array",
+          "items": {
+            "ref": "app.bsky.actor.defs#mutedWord",
+            "type": "ref"
+          },
+          "description": "A list of words the account owner has muted."
+        }
+      }
+    },
+    "savedFeedsPref": {
+      "type": "object",
+      "required": [
+        "pinned",
+        "saved"
+      ],
+      "properties": {
+        "saved": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "format": "at-uri"
+          }
+        },
+        "pinned": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "format": "at-uri"
+          }
+        },
+        "timelineIndex": {
+          "type": "integer"
+        }
+      }
+    },
+    "threadViewPref": {
+      "type": "object",
+      "properties": {
+        "sort": {
+          "type": "string",
+          "description": "Sorting mode for threads.",
+          "knownValues": [
+            "oldest",
+            "newest",
+            "most-likes",
+            "random",
+            "hotness"
+          ]
+        },
+        "prioritizeFollowedUsers": {
+          "type": "boolean",
+          "description": "Show followed users at the top of all replies."
+        }
+      }
+    },
+    "hiddenPostsPref": {
+      "type": "object",
+      "required": [
+        "items"
+      ],
+      "properties": {
+        "items": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "format": "at-uri"
+          },
+          "description": "A list of URIs of posts the account owner has hidden."
+        }
+      }
+    },
+    "labelerPrefItem": {
+      "type": "object",
+      "required": [
+        "did"
+      ],
+      "properties": {
+        "did": {
+          "type": "string",
+          "format": "did"
+        }
+      }
+    },
+    "mutedWordTarget": {
+      "type": "string",
+      "maxLength": 640,
+      "knownValues": [
+        "content",
+        "tag"
+      ],
+      "maxGraphemes": 64
+    },
+    "adultContentPref": {
+      "type": "object",
+      "required": [
+        "enabled"
+      ],
+      "properties": {
+        "enabled": {
+          "type": "boolean",
+          "default": false
+        }
+      }
+    },
+    "bskyAppStatePref": {
+      "type": "object",
+      "properties": {
+        "nuxs": {
+          "type": "array",
+          "items": {
+            "ref": "app.bsky.actor.defs#nux",
+            "type": "ref"
+          },
+          "maxLength": 100,
+          "description": "Storage for NUXs the user has encountered."
+        },
+        "queuedNudges": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "maxLength": 100
+          },
+          "maxLength": 1000,
+          "description": "An array of tokens which identify nudges (modals, popups, tours, highlight dots) that should be shown to the user."
+        },
+        "activeProgressGuide": {
+          "ref": "#bskyAppProgressGuide",
+          "type": "ref"
+        }
+      },
+      "description": "A grab bag of state that's specific to the bsky.app program. Third-party apps shouldn't use this."
+    },
+    "contentLabelPref": {
+      "type": "object",
+      "required": [
+        "label",
+        "visibility"
+      ],
+      "properties": {
+        "label": {
+          "type": "string"
+        },
+        "labelerDid": {
+          "type": "string",
+          "format": "did",
+          "description": "Which labeler does this preference apply to? If undefined, applies globally."
+        },
+        "visibility": {
+          "type": "string",
+          "knownValues": [
+            "ignore",
+            "show",
+            "warn",
+            "hide"
+          ]
+        }
+      }
+    },
+    "profileViewBasic": {
+      "type": "object",
+      "required": [
+        "did",
+        "handle"
+      ],
+      "properties": {
+        "did": {
+          "type": "string",
+          "format": "did"
+        },
+        "avatar": {
+          "type": "string",
+          "format": "uri"
+        },
+        "handle": {
+          "type": "string",
+          "format": "handle"
+        },
+        "labels": {
+          "type": "array",
+          "items": {
+            "ref": "com.atproto.label.defs#label",
+            "type": "ref"
+          }
+        },
+        "viewer": {
+          "ref": "#viewerState",
+          "type": "ref"
+        },
+        "createdAt": {
+          "type": "string",
+          "format": "datetime"
+        },
+        "associated": {
+          "ref": "#profileAssociated",
+          "type": "ref"
+        },
+        "displayName": {
+          "type": "string",
+          "maxLength": 640,
+          "maxGraphemes": 64
+        }
+      }
+    },
+    "savedFeedsPrefV2": {
+      "type": "object",
+      "required": [
+        "items"
+      ],
+      "properties": {
+        "items": {
+          "type": "array",
+          "items": {
+            "ref": "app.bsky.actor.defs#savedFeed",
+            "type": "ref"
+          }
+        }
+      }
+    },
+    "profileAssociated": {
+      "type": "object",
+      "properties": {
+        "chat": {
+          "ref": "#profileAssociatedChat",
+          "type": "ref"
+        },
+        "lists": {
+          "type": "integer"
+        },
+        "labeler": {
+          "type": "boolean"
+        },
+        "feedgens": {
+          "type": "integer"
+        },
+        "starterPacks": {
+          "type": "integer"
+        }
+      }
+    },
+    "personalDetailsPref": {
+      "type": "object",
+      "properties": {
+        "birthDate": {
+          "type": "string",
+          "format": "datetime",
+          "description": "The birth date of account owner."
+        }
+      }
+    },
+    "profileViewDetailed": {
+      "type": "object",
+      "required": [
+        "did",
+        "handle"
+      ],
+      "properties": {
+        "did": {
+          "type": "string",
+          "format": "did"
+        },
+        "avatar": {
+          "type": "string",
+          "format": "uri"
+        },
+        "banner": {
+          "type": "string",
+          "format": "uri"
+        },
+        "handle": {
+          "type": "string",
+          "format": "handle"
+        },
+        "labels": {
+          "type": "array",
+          "items": {
+            "ref": "com.atproto.label.defs#label",
+            "type": "ref"
+          }
+        },
+        "viewer": {
+          "ref": "#viewerState",
+          "type": "ref"
+        },
+        "createdAt": {
+          "type": "string",
+          "format": "datetime"
+        },
+        "indexedAt": {
+          "type": "string",
+          "format": "datetime"
+        },
+        "associated": {
+          "ref": "#profileAssociated",
+          "type": "ref"
+        },
+        "pinnedPost": {
+          "ref": "com.atproto.repo.strongRef",
+          "type": "ref"
+        },
+        "postsCount": {
+          "type": "integer"
+        },
+        "description": {
+          "type": "string",
+          "maxLength": 2560,
+          "maxGraphemes": 256
+        },
+        "displayName": {
+          "type": "string",
+          "maxLength": 640,
+          "maxGraphemes": 64
+        },
+        "followsCount": {
+          "type": "integer"
+        },
+        "followersCount": {
+          "type": "integer"
+        },
+        "joinedViaStarterPack": {
+          "ref": "app.bsky.graph.defs#starterPackViewBasic",
+          "type": "ref"
+        }
+      }
+    },
+    "bskyAppProgressGuide": {
+      "type": "object",
+      "required": [
+        "guide"
+      ],
+      "properties": {
+        "guide": {
+          "type": "string",
+          "maxLength": 100
+        }
+      },
+      "description": "If set, an active progress guide. Once completed, can be set to undefined. Should have unspecced fields tracking progress."
+    },
+    "profileAssociatedChat": {
+      "type": "object",
+      "required": [
+        "allowIncoming"
+      ],
+      "properties": {
+        "allowIncoming": {
+          "type": "string",
+          "knownValues": [
+            "all",
+            "none",
+            "following"
+          ]
+        }
+      }
+    },
+    "postInteractionSettingsPref": {
+      "type": "object",
+      "required": [],
+      "properties": {
+        "threadgateAllowRules": {
+          "type": "array",
+          "items": {
+            "refs": [
+              "app.bsky.feed.threadgate#mentionRule",
+              "app.bsky.feed.threadgate#followerRule",
+              "app.bsky.feed.threadgate#followingRule",
+              "app.bsky.feed.threadgate#listRule"
+            ],
+            "type": "union"
+          },
+          "maxLength": 5,
+          "description": "Matches threadgate record. List of rules defining who can reply to this users posts. If value is an empty array, no one can reply. If value is undefined, anyone can reply."
+        },
+        "postgateEmbeddingRules": {
+          "type": "array",
+          "items": {
+            "refs": [
+              "app.bsky.feed.postgate#disableRule"
+            ],
+            "type": "union"
+          },
+          "maxLength": 5,
+          "description": "Matches postgate record. List of rules defining who can embed this users posts. If value is an empty array or is undefined, no particular rules apply and anyone can embed."
+        }
+      },
+      "description": "Default post interaction settings for the account. These values should be applied as default values when creating new posts. These refs should mirror the threadgate and postgate records exactly."
+    }
+  }
+}

lexicons/app/bsky/actor/profile.json

···
         "properties": {
           "avatar": {
             "type": "blob",
-            "accept": ["image/png", "image/jpeg"],
+            "accept": [
+              "image/png",
+              "image/jpeg"
+            ],
             "maxSize": 1000000,
             "description": "Small image to be displayed next to posts from account. AKA, 'profile picture'"
           },
           "banner": {
             "type": "blob",
-            "accept": ["image/png", "image/jpeg"],
+            "accept": [
+              "image/png",
+              "image/jpeg"
+            ],
             "maxSize": 1000000,
             "description": "Larger horizontal image to display behind profile view."
           },
           "labels": {
-            "refs": ["com.atproto.label.defs#selfLabels"],
+            "refs": [
+              "com.atproto.label.defs#selfLabels"
+            ],
             "type": "union",
             "description": "Self-label values, specific to the Bluesky application, on the overall account."
           },
···
       "description": "A declaration of a Bluesky account profile."
     }
   }
-}
+}

lexicons/app/bsky/embed/defs.json

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

lexicons/app/bsky/embed/external.json

···
+{
+  "lexicon": 1,
+  "id": "app.bsky.embed.external",
+  "defs": {
+    "main": {
+      "type": "object",
+      "required": [
+        "external"
+      ],
+      "properties": {
+        "external": {
+          "ref": "#external",
+          "type": "ref"
+        }
+      },
+      "description": "A representation of some externally linked content (eg, a URL and 'card'), embedded in a Bluesky record (eg, a post)."
+    },
+    "view": {
+      "type": "object",
+      "required": [
+        "external"
+      ],
+      "properties": {
+        "external": {
+          "ref": "#viewExternal",
+          "type": "ref"
+        }
+      }
+    },
+    "external": {
+      "type": "object",
+      "required": [
+        "uri",
+        "title",
+        "description"
+      ],
+      "properties": {
+        "uri": {
+          "type": "string",
+          "format": "uri"
+        },
+        "thumb": {
+          "type": "blob",
+          "accept": [
+            "image/*"
+          ],
+          "maxSize": 1000000
+        },
+        "title": {
+          "type": "string"
+        },
+        "description": {
+          "type": "string"
+        }
+      }
+    },
+    "viewExternal": {
+      "type": "object",
+      "required": [
+        "uri",
+        "title",
+        "description"
+      ],
+      "properties": {
+        "uri": {
+          "type": "string",
+          "format": "uri"
+        },
+        "thumb": {
+          "type": "string",
+          "format": "uri"
+        },
+        "title": {
+          "type": "string"
+        },
+        "description": {
+          "type": "string"
+        }
+      }
+    }
+  }
+}

lexicons/app/bsky/embed/images.json

···
+{
+  "lexicon": 1,
+  "id": "app.bsky.embed.images",
+  "description": "A set of images embedded in a Bluesky record (eg, a post).",
+  "defs": {
+    "main": {
+      "type": "object",
+      "required": [
+        "images"
+      ],
+      "properties": {
+        "images": {
+          "type": "array",
+          "items": {
+            "ref": "#image",
+            "type": "ref"
+          },
+          "maxLength": 4
+        }
+      }
+    },
+    "view": {
+      "type": "object",
+      "required": [
+        "images"
+      ],
+      "properties": {
+        "images": {
+          "type": "array",
+          "items": {
+            "ref": "#viewImage",
+            "type": "ref"
+          },
+          "maxLength": 4
+        }
+      }
+    },
+    "image": {
+      "type": "object",
+      "required": [
+        "image",
+        "alt"
+      ],
+      "properties": {
+        "alt": {
+          "type": "string",
+          "description": "Alt text description of the image, for accessibility."
+        },
+        "image": {
+          "type": "blob",
+          "accept": [
+            "image/*"
+          ],
+          "maxSize": 1000000
+        },
+        "aspectRatio": {
+          "ref": "app.bsky.embed.defs#aspectRatio",
+          "type": "ref"
+        }
+      }
+    },
+    "viewImage": {
+      "type": "object",
+      "required": [
+        "thumb",
+        "fullsize",
+        "alt"
+      ],
+      "properties": {
+        "alt": {
+          "type": "string",
+          "description": "Alt text description of the image, for accessibility."
+        },
+        "thumb": {
+          "type": "string",
+          "format": "uri",
+          "description": "Fully-qualified URL where a thumbnail of the image can be fetched. For example, CDN location provided by the App View."
+        },
+        "fullsize": {
+          "type": "string",
+          "format": "uri",
+          "description": "Fully-qualified URL where a large version of the image can be fetched. May or may not be the exact original blob. For example, CDN location provided by the App View."
+        },
+        "aspectRatio": {
+          "ref": "app.bsky.embed.defs#aspectRatio",
+          "type": "ref"
+        }
+      }
+    }
+  }
+}

lexicons/app/bsky/embed/record.json

···
+{
+  "lexicon": 1,
+  "id": "app.bsky.embed.record",
+  "description": "A representation of a record embedded in a Bluesky record (eg, a post). For example, a quote-post, or sharing a feed generator record.",
+  "defs": {
+    "main": {
+      "type": "object",
+      "required": [
+        "record"
+      ],
+      "properties": {
+        "record": {
+          "ref": "com.atproto.repo.strongRef",
+          "type": "ref"
+        }
+      }
+    },
+    "view": {
+      "type": "object",
+      "required": [
+        "record"
+      ],
+      "properties": {
+        "record": {
+          "refs": [
+            "#viewRecord",
+            "#viewNotFound",
+            "#viewBlocked",
+            "#viewDetached",
+            "app.bsky.feed.defs#generatorView",
+            "app.bsky.graph.defs#listView",
+            "app.bsky.labeler.defs#labelerView",
+            "app.bsky.graph.defs#starterPackViewBasic"
+          ],
+          "type": "union"
+        }
+      }
+    },
+    "viewRecord": {
+      "type": "object",
+      "required": [
+        "uri",
+        "cid",
+        "author",
+        "value",
+        "indexedAt"
+      ],
+      "properties": {
+        "cid": {
+          "type": "string",
+          "format": "cid"
+        },
+        "uri": {
+          "type": "string",
+          "format": "at-uri"
+        },
+        "value": {
+          "type": "unknown",
+          "description": "The record data itself."
+        },
+        "author": {
+          "ref": "app.bsky.actor.defs#profileViewBasic",
+          "type": "ref"
+        },
+        "embeds": {
+          "type": "array",
+          "items": {
+            "refs": [
+              "app.bsky.embed.images#view",
+              "app.bsky.embed.video#view",
+              "app.bsky.embed.external#view",
+              "app.bsky.embed.record#view",
+              "app.bsky.embed.recordWithMedia#view"
+            ],
+            "type": "union"
+          }
+        },
+        "labels": {
+          "type": "array",
+          "items": {
+            "ref": "com.atproto.label.defs#label",
+            "type": "ref"
+          }
+        },
+        "indexedAt": {
+          "type": "string",
+          "format": "datetime"
+        },
+        "likeCount": {
+          "type": "integer"
+        },
+        "quoteCount": {
+          "type": "integer"
+        },
+        "replyCount": {
+          "type": "integer"
+        },
+        "repostCount": {
+          "type": "integer"
+        }
+      }
+    },
+    "viewBlocked": {
+      "type": "object",
+      "required": [
+        "uri",
+        "blocked",
+        "author"
+      ],
+      "properties": {
+        "uri": {
+          "type": "string",
+          "format": "at-uri"
+        },
+        "author": {
+          "ref": "app.bsky.feed.defs#blockedAuthor",
+          "type": "ref"
+        },
+        "blocked": {
+          "type": "boolean",
+          "const": true
+        }
+      }
+    },
+    "viewDetached": {
+      "type": "object",
+      "required": [
+        "uri",
+        "detached"
+      ],
+      "properties": {
+        "uri": {
+          "type": "string",
+          "format": "at-uri"
+        },
+        "detached": {
+          "type": "boolean",
+          "const": true
+        }
+      }
+    },
+    "viewNotFound": {
+      "type": "object",
+      "required": [
+        "uri",
+        "notFound"
+      ],
+      "properties": {
+        "uri": {
+          "type": "string",
+          "format": "at-uri"
+        },
+        "notFound": {
+          "type": "boolean",
+          "const": true
+        }
+      }
+    }
+  }
+}

lexicons/app/bsky/embed/recordWithMedia.json

···
+{
+  "lexicon": 1,
+  "id": "app.bsky.embed.recordWithMedia",
+  "description": "A representation of a record embedded in a Bluesky record (eg, a post), alongside other compatible embeds. For example, a quote post and image, or a quote post and external URL card.",
+  "defs": {
+    "main": {
+      "type": "object",
+      "required": [
+        "record",
+        "media"
+      ],
+      "properties": {
+        "media": {
+          "refs": [
+            "app.bsky.embed.images",
+            "app.bsky.embed.video",
+            "app.bsky.embed.external"
+          ],
+          "type": "union"
+        },
+        "record": {
+          "ref": "app.bsky.embed.record",
+          "type": "ref"
+        }
+      }
+    },
+    "view": {
+      "type": "object",
+      "required": [
+        "record",
+        "media"
+      ],
+      "properties": {
+        "media": {
+          "refs": [
+            "app.bsky.embed.images#view",
+            "app.bsky.embed.video#view",
+            "app.bsky.embed.external#view"
+          ],
+          "type": "union"
+        },
+        "record": {
+          "ref": "app.bsky.embed.record#view",
+          "type": "ref"
+        }
+      }
+    }
+  }
+}

lexicons/app/bsky/embed/video.json

···
+{
+  "lexicon": 1,
+  "id": "app.bsky.embed.video",
+  "description": "A video embedded in a Bluesky record (eg, a post).",
+  "defs": {
+    "main": {
+      "type": "object",
+      "required": [
+        "video"
+      ],
+      "properties": {
+        "alt": {
+          "type": "string",
+          "maxLength": 10000,
+          "description": "Alt text description of the video, for accessibility.",
+          "maxGraphemes": 1000
+        },
+        "video": {
+          "type": "blob",
+          "accept": [
+            "video/mp4"
+          ],
+          "maxSize": 50000000
+        },
+        "captions": {
+          "type": "array",
+          "items": {
+            "ref": "#caption",
+            "type": "ref"
+          },
+          "maxLength": 20
+        },
+        "aspectRatio": {
+          "ref": "app.bsky.embed.defs#aspectRatio",
+          "type": "ref"
+        }
+      }
+    },
+    "view": {
+      "type": "object",
+      "required": [
+        "cid",
+        "playlist"
+      ],
+      "properties": {
+        "alt": {
+          "type": "string",
+          "maxLength": 10000,
+          "maxGraphemes": 1000
+        },
+        "cid": {
+          "type": "string",
+          "format": "cid"
+        },
+        "playlist": {
+          "type": "string",
+          "format": "uri"
+        },
+        "thumbnail": {
+          "type": "string",
+          "format": "uri"
+        },
+        "aspectRatio": {
+          "ref": "app.bsky.embed.defs#aspectRatio",
+          "type": "ref"
+        }
+      }
+    },
+    "caption": {
+      "type": "object",
+      "required": [
+        "lang",
+        "file"
+      ],
+      "properties": {
+        "file": {
+          "type": "blob",
+          "accept": [
+            "text/vtt"
+          ],
+          "maxSize": 20000
+        },
+        "lang": {
+          "type": "string",
+          "format": "language"
+        }
+      }
+    }
+  }
+}

lexicons/app/bsky/feed/defs.json

···
+{
+  "lexicon": 1,
+  "id": "app.bsky.feed.defs",
+  "defs": {
+    "postView": {
+      "type": "object",
+      "required": [
+        "uri",
+        "cid",
+        "author",
+        "record",
+        "indexedAt"
+      ],
+      "properties": {
+        "cid": {
+          "type": "string",
+          "format": "cid"
+        },
+        "uri": {
+          "type": "string",
+          "format": "at-uri"
+        },
+        "embed": {
+          "refs": [
+            "app.bsky.embed.images#view",
+            "app.bsky.embed.video#view",
+            "app.bsky.embed.external#view",
+            "app.bsky.embed.record#view",
+            "app.bsky.embed.recordWithMedia#view"
+          ],
+          "type": "union"
+        },
+        "author": {
+          "ref": "app.bsky.actor.defs#profileViewBasic",
+          "type": "ref"
+        },
+        "labels": {
+          "type": "array",
+          "items": {
+            "ref": "com.atproto.label.defs#label",
+            "type": "ref"
+          }
+        },
+        "record": {
+          "type": "unknown"
+        },
+        "viewer": {
+          "ref": "#viewerState",
+          "type": "ref"
+        },
+        "indexedAt": {
+          "type": "string",
+          "format": "datetime"
+        },
+        "likeCount": {
+          "type": "integer"
+        },
+        "quoteCount": {
+          "type": "integer"
+        },
+        "replyCount": {
+          "type": "integer"
+        },
+        "threadgate": {
+          "ref": "#threadgateView",
+          "type": "ref"
+        },
+        "repostCount": {
+          "type": "integer"
+        }
+      }
+    },
+    "replyRef": {
+      "type": "object",
+      "required": [
+        "root",
+        "parent"
+      ],
+      "properties": {
+        "root": {
+          "refs": [
+            "#postView",
+            "#notFoundPost",
+            "#blockedPost"
+          ],
+          "type": "union"
+        },
+        "parent": {
+          "refs": [
+            "#postView",
+            "#notFoundPost",
+            "#blockedPost"
+          ],
+          "type": "union"
+        },
+        "grandparentAuthor": {
+          "ref": "app.bsky.actor.defs#profileViewBasic",
+          "type": "ref",
+          "description": "When parent is a reply to another post, this is the author of that post."
+        }
+      }
+    },
+    "reasonPin": {
+      "type": "object",
+      "properties": {}
+    },
+    "blockedPost": {
+      "type": "object",
+      "required": [
+        "uri",
+        "blocked",
+        "author"
+      ],
+      "properties": {
+        "uri": {
+          "type": "string",
+          "format": "at-uri"
+        },
+        "author": {
+          "ref": "#blockedAuthor",
+          "type": "ref"
+        },
+        "blocked": {
+          "type": "boolean",
+          "const": true
+        }
+      }
+    },
+    "interaction": {
+      "type": "object",
+      "properties": {
+        "item": {
+          "type": "string",
+          "format": "at-uri"
+        },
+        "event": {
+          "type": "string",
+          "knownValues": [
+            "app.bsky.feed.defs#requestLess",
+            "app.bsky.feed.defs#requestMore",
+            "app.bsky.feed.defs#clickthroughItem",
+            "app.bsky.feed.defs#clickthroughAuthor",
+            "app.bsky.feed.defs#clickthroughReposter",
+            "app.bsky.feed.defs#clickthroughEmbed",
+            "app.bsky.feed.defs#interactionSeen",
+            "app.bsky.feed.defs#interactionLike",
+            "app.bsky.feed.defs#interactionRepost",
+            "app.bsky.feed.defs#interactionReply",
+            "app.bsky.feed.defs#interactionQuote",
+            "app.bsky.feed.defs#interactionShare"
+          ]
+        },
+        "feedContext": {
+          "type": "string",
+          "maxLength": 2000,
+          "description": "Context on a feed item that was originally supplied by the feed generator on getFeedSkeleton."
+        }
+      }
+    },
+    "requestLess": {
+      "type": "token",
+      "description": "Request that less content like the given feed item be shown in the feed"
+    },
+    "requestMore": {
+      "type": "token",
+      "description": "Request that more content like the given feed item be shown in the feed"
+    },
+    "viewerState": {
+      "type": "object",
+      "properties": {
+        "like": {
+          "type": "string",
+          "format": "at-uri"
+        },
+        "pinned": {
+          "type": "boolean"
+        },
+        "repost": {
+          "type": "string",
+          "format": "at-uri"
+        },
+        "threadMuted": {
+          "type": "boolean"
+        },
+        "replyDisabled": {
+          "type": "boolean"
+        },
+        "embeddingDisabled": {
+          "type": "boolean"
+        }
+      },
+      "description": "Metadata about the requesting account's relationship with the subject content. Only has meaningful content for authed requests."
+    },
+    "feedViewPost": {
+      "type": "object",
+      "required": [
+        "post"
+      ],
+      "properties": {
+        "post": {
+          "ref": "#postView",
+          "type": "ref"
+        },
+        "reply": {
+          "ref": "#replyRef",
+          "type": "ref"
+        },
+        "reason": {
+          "refs": [
+            "#reasonRepost",
+            "#reasonPin"
+          ],
+          "type": "union"
+        },
+        "feedContext": {
+          "type": "string",
+          "maxLength": 2000,
+          "description": "Context provided by feed generator that may be passed back alongside interactions."
+        }
+      }
+    },
+    "notFoundPost": {
+      "type": "object",
+      "required": [
+        "uri",
+        "notFound"
+      ],
+      "properties": {
+        "uri": {
+          "type": "string",
+          "format": "at-uri"
+        },
+        "notFound": {
+          "type": "boolean",
+          "const": true
+        }
+      }
+    },
+    "reasonRepost": {
+      "type": "object",
+      "required": [
+        "by",
+        "indexedAt"
+      ],
+      "properties": {
+        "by": {
+          "ref": "app.bsky.actor.defs#profileViewBasic",
+          "type": "ref"
+        },
+        "indexedAt": {
+          "type": "string",
+          "format": "datetime"
+        }
+      }
+    },
+    "blockedAuthor": {
+      "type": "object",
+      "required": [
+        "did"
+      ],
+      "properties": {
+        "did": {
+          "type": "string",
+          "format": "did"
+        },
+        "viewer": {
+          "ref": "app.bsky.actor.defs#viewerState",
+          "type": "ref"
+        }
+      }
+    },
+    "generatorView": {
+      "type": "object",
+      "required": [
+        "uri",
+        "cid",
+        "did",
+        "creator",
+        "displayName",
+        "indexedAt"
+      ],
+      "properties": {
+        "cid": {
+          "type": "string",
+          "format": "cid"
+        },
+        "did": {
+          "type": "string",
+          "format": "did"
+        },
+        "uri": {
+          "type": "string",
+          "format": "at-uri"
+        },
+        "avatar": {
+          "type": "string",
+          "format": "uri"
+        },
+        "labels": {
+          "type": "array",
+          "items": {
+            "ref": "com.atproto.label.defs#label",
+            "type": "ref"
+          }
+        },
+        "viewer": {
+          "ref": "#generatorViewerState",
+          "type": "ref"
+        },
+        "creator": {
+          "ref": "app.bsky.actor.defs#profileView",
+          "type": "ref"
+        },
+        "indexedAt": {
+          "type": "string",
+          "format": "datetime"
+        },
+        "likeCount": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "contentMode": {
+          "type": "string",
+          "knownValues": [
+            "app.bsky.feed.defs#contentModeUnspecified",
+            "app.bsky.feed.defs#contentModeVideo"
+          ]
+        },
+        "description": {
+          "type": "string",
+          "maxLength": 3000,
+          "maxGraphemes": 300
+        },
+        "displayName": {
+          "type": "string"
+        },
+        "descriptionFacets": {
+          "type": "array",
+          "items": {
+            "ref": "app.bsky.richtext.facet",
+            "type": "ref"
+          }
+        },
+        "acceptsInteractions": {
+          "type": "boolean"
+        }
+      }
+    },
+    "threadContext": {
+      "type": "object",
+      "properties": {
+        "rootAuthorLike": {
+          "type": "string",
+          "format": "at-uri"
+        }
+      },
+      "description": "Metadata about this post within the context of the thread it is in."
+    },
+    "threadViewPost": {
+      "type": "object",
+      "required": [
+        "post"
+      ],
+      "properties": {
+        "post": {
+          "ref": "#postView",
+          "type": "ref"
+        },
+        "parent": {
+          "refs": [
+            "#threadViewPost",
+            "#notFoundPost",
+            "#blockedPost"
+          ],
+          "type": "union"
+        },
+        "replies": {
+          "type": "array",
+          "items": {
+            "refs": [
+              "#threadViewPost",
+              "#notFoundPost",
+              "#blockedPost"
+            ],
+            "type": "union"
+          }
+        },
+        "threadContext": {
+          "ref": "#threadContext",
+          "type": "ref"
+        }
+      }
+    },
+    "threadgateView": {
+      "type": "object",
+      "properties": {
+        "cid": {
+          "type": "string",
+          "format": "cid"
+        },
+        "uri": {
+          "type": "string",
+          "format": "at-uri"
+        },
+        "lists": {
+          "type": "array",
+          "items": {
+            "ref": "app.bsky.graph.defs#listViewBasic",
+            "type": "ref"
+          }
+        },
+        "record": {
+          "type": "unknown"
+        }
+      }
+    },
+    "interactionLike": {
+      "type": "token",
+      "description": "User liked the feed item"
+    },
+    "interactionSeen": {
+      "type": "token",
+      "description": "Feed item was seen by user"
+    },
+    "clickthroughItem": {
+      "type": "token",
+      "description": "User clicked through to the feed item"
+    },
+    "contentModeVideo": {
+      "type": "token",
+      "description": "Declares the feed generator returns posts containing app.bsky.embed.video embeds."
+    },
+    "interactionQuote": {
+      "type": "token",
+      "description": "User quoted the feed item"
+    },
+    "interactionReply": {
+      "type": "token",
+      "description": "User replied to the feed item"
+    },
+    "interactionShare": {
+      "type": "token",
+      "description": "User shared the feed item"
+    },
+    "skeletonFeedPost": {
+      "type": "object",
+      "required": [
+        "post"
+      ],
+      "properties": {
+        "post": {
+          "type": "string",
+          "format": "at-uri"
+        },
+        "reason": {
+          "refs": [
+            "#skeletonReasonRepost",
+            "#skeletonReasonPin"
+          ],
+          "type": "union"
+        },
+        "feedContext": {
+          "type": "string",
+          "maxLength": 2000,
+          "description": "Context that will be passed through to client and may be passed to feed generator back alongside interactions."
+        }
+      }
+    },
+    "clickthroughEmbed": {
+      "type": "token",
+      "description": "User clicked through to the embedded content of the feed item"
+    },
+    "interactionRepost": {
+      "type": "token",
+      "description": "User reposted the feed item"
+    },
+    "skeletonReasonPin": {
+      "type": "object",
+      "properties": {}
+    },
+    "clickthroughAuthor": {
+      "type": "token",
+      "description": "User clicked through to the author of the feed item"
+    },
+    "clickthroughReposter": {
+      "type": "token",
+      "description": "User clicked through to the reposter of the feed item"
+    },
+    "generatorViewerState": {
+      "type": "object",
+      "properties": {
+        "like": {
+          "type": "string",
+          "format": "at-uri"
+        }
+      }
+    },
+    "skeletonReasonRepost": {
+      "type": "object",
+      "required": [
+        "repost"
+      ],
+      "properties": {
+        "repost": {
+          "type": "string",
+          "format": "at-uri"
+        }
+      }
+    },
+    "contentModeUnspecified": {
+      "type": "token",
+      "description": "Declares the feed generator returns any types of posts."
+    }
+  }
+}

lexicons/app/bsky/feed/postgate.json

···
+{
+  "lexicon": 1,
+  "id": "app.bsky.feed.postgate",
+  "defs": {
+    "main": {
+      "key": "tid",
+      "type": "record",
+      "record": {
+        "type": "object",
+        "required": [
+          "post",
+          "createdAt"
+        ],
+        "properties": {
+          "post": {
+            "type": "string",
+            "format": "at-uri",
+            "description": "Reference (AT-URI) to the post record."
+          },
+          "createdAt": {
+            "type": "string",
+            "format": "datetime"
+          },
+          "embeddingRules": {
+            "type": "array",
+            "items": {
+              "refs": [
+                "#disableRule"
+              ],
+              "type": "union"
+            },
+            "maxLength": 5,
+            "description": "List of rules defining who can embed this post. If value is an empty array or is undefined, no particular rules apply and anyone can embed."
+          },
+          "detachedEmbeddingUris": {
+            "type": "array",
+            "items": {
+              "type": "string",
+              "format": "at-uri"
+            },
+            "maxLength": 50,
+            "description": "List of AT-URIs embedding this post that the author has detached from."
+          }
+        }
+      },
+      "description": "Record defining interaction rules for a post. The record key (rkey) of the postgate record must match the record key of the post, and that record must be in the same repository."
+    },
+    "disableRule": {
+      "type": "object",
+      "properties": {},
+      "description": "Disables embedding of this post."
+    }
+  }
+}

lexicons/app/bsky/feed/threadgate.json

···
+{
+  "lexicon": 1,
+  "id": "app.bsky.feed.threadgate",
+  "defs": {
+    "main": {
+      "key": "tid",
+      "type": "record",
+      "record": {
+        "type": "object",
+        "required": [
+          "post",
+          "createdAt"
+        ],
+        "properties": {
+          "post": {
+            "type": "string",
+            "format": "at-uri",
+            "description": "Reference (AT-URI) to the post record."
+          },
+          "allow": {
+            "type": "array",
+            "items": {
+              "refs": [
+                "#mentionRule",
+                "#followerRule",
+                "#followingRule",
+                "#listRule"
+              ],
+              "type": "union"
+            },
+            "maxLength": 5,
+            "description": "List of rules defining who can reply to this post. If value is an empty array, no one can reply. If value is undefined, anyone can reply."
+          },
+          "createdAt": {
+            "type": "string",
+            "format": "datetime"
+          },
+          "hiddenReplies": {
+            "type": "array",
+            "items": {
+              "type": "string",
+              "format": "at-uri"
+            },
+            "maxLength": 50,
+            "description": "List of hidden reply URIs."
+          }
+        }
+      },
+      "description": "Record defining interaction gating rules for a thread (aka, reply controls). The record key (rkey) of the threadgate record must match the record key of the thread's root post, and that record must be in the same repository."
+    },
+    "listRule": {
+      "type": "object",
+      "required": [
+        "list"
+      ],
+      "properties": {
+        "list": {
+          "type": "string",
+          "format": "at-uri"
+        }
+      },
+      "description": "Allow replies from actors on a list."
+    },
+    "mentionRule": {
+      "type": "object",
+      "properties": {},
+      "description": "Allow replies from actors mentioned in your post."
+    },
+    "followerRule": {
+      "type": "object",
+      "properties": {},
+      "description": "Allow replies from actors who follow you."
+    },
+    "followingRule": {
+      "type": "object",
+      "properties": {},
+      "description": "Allow replies from actors you follow."
+    }
+  }
+}

lexicons/app/bsky/graph/defs.json

···
+{
+  "lexicon": 1,
+  "id": "app.bsky.graph.defs",
+  "defs": {
+    "modlist": {
+      "type": "token",
+      "description": "A list of actors to apply an aggregate moderation action (mute/block) on."
+    },
+    "listView": {
+      "type": "object",
+      "required": [
+        "uri",
+        "cid",
+        "creator",
+        "name",
+        "purpose",
+        "indexedAt"
+      ],
+      "properties": {
+        "cid": {
+          "type": "string",
+          "format": "cid"
+        },
+        "uri": {
+          "type": "string",
+          "format": "at-uri"
+        },
+        "name": {
+          "type": "string",
+          "maxLength": 64,
+          "minLength": 1
+        },
+        "avatar": {
+          "type": "string",
+          "format": "uri"
+        },
+        "labels": {
+          "type": "array",
+          "items": {
+            "ref": "com.atproto.label.defs#label",
+            "type": "ref"
+          }
+        },
+        "viewer": {
+          "ref": "#listViewerState",
+          "type": "ref"
+        },
+        "creator": {
+          "ref": "app.bsky.actor.defs#profileView",
+          "type": "ref"
+        },
+        "purpose": {
+          "ref": "#listPurpose",
+          "type": "ref"
+        },
+        "indexedAt": {
+          "type": "string",
+          "format": "datetime"
+        },
+        "description": {
+          "type": "string",
+          "maxLength": 3000,
+          "maxGraphemes": 300
+        },
+        "listItemCount": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "descriptionFacets": {
+          "type": "array",
+          "items": {
+            "ref": "app.bsky.richtext.facet",
+            "type": "ref"
+          }
+        }
+      }
+    },
+    "curatelist": {
+      "type": "token",
+      "description": "A list of actors used for curation purposes such as list feeds or interaction gating."
+    },
+    "listPurpose": {
+      "type": "string",
+      "knownValues": [
+        "app.bsky.graph.defs#modlist",
+        "app.bsky.graph.defs#curatelist",
+        "app.bsky.graph.defs#referencelist"
+      ]
+    },
+    "listItemView": {
+      "type": "object",
+      "required": [
+        "uri",
+        "subject"
+      ],
+      "properties": {
+        "uri": {
+          "type": "string",
+          "format": "at-uri"
+        },
+        "subject": {
+          "ref": "app.bsky.actor.defs#profileView",
+          "type": "ref"
+        }
+      }
+    },
+    "relationship": {
+      "type": "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"
+        }
+      },
+      "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)"
+    },
+    "listViewBasic": {
+      "type": "object",
+      "required": [
+        "uri",
+        "cid",
+        "name",
+        "purpose"
+      ],
+      "properties": {
+        "cid": {
+          "type": "string",
+          "format": "cid"
+        },
+        "uri": {
+          "type": "string",
+          "format": "at-uri"
+        },
+        "name": {
+          "type": "string",
+          "maxLength": 64,
+          "minLength": 1
+        },
+        "avatar": {
+          "type": "string",
+          "format": "uri"
+        },
+        "labels": {
+          "type": "array",
+          "items": {
+            "ref": "com.atproto.label.defs#label",
+            "type": "ref"
+          }
+        },
+        "viewer": {
+          "ref": "#listViewerState",
+          "type": "ref"
+        },
+        "purpose": {
+          "ref": "#listPurpose",
+          "type": "ref"
+        },
+        "indexedAt": {
+          "type": "string",
+          "format": "datetime"
+        },
+        "listItemCount": {
+          "type": "integer",
+          "minimum": 0
+        }
+      }
+    },
+    "notFoundActor": {
+      "type": "object",
+      "required": [
+        "actor",
+        "notFound"
+      ],
+      "properties": {
+        "actor": {
+          "type": "string",
+          "format": "at-identifier"
+        },
+        "notFound": {
+          "type": "boolean",
+          "const": true
+        }
+      },
+      "description": "indicates that a handle or DID could not be resolved"
+    },
+    "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"
+        }
+      }
+    },
+    "starterPackView": {
+      "type": "object",
+      "required": [
+        "uri",
+        "cid",
+        "record",
+        "creator",
+        "indexedAt"
+      ],
+      "properties": {
+        "cid": {
+          "type": "string",
+          "format": "cid"
+        },
+        "uri": {
+          "type": "string",
+          "format": "at-uri"
+        },
+        "list": {
+          "ref": "#listViewBasic",
+          "type": "ref"
+        },
+        "feeds": {
+          "type": "array",
+          "items": {
+            "ref": "app.bsky.feed.defs#generatorView",
+            "type": "ref"
+          },
+          "maxLength": 3
+        },
+        "labels": {
+          "type": "array",
+          "items": {
+            "ref": "com.atproto.label.defs#label",
+            "type": "ref"
+          }
+        },
+        "record": {
+          "type": "unknown"
+        },
+        "creator": {
+          "ref": "app.bsky.actor.defs#profileViewBasic",
+          "type": "ref"
+        },
+        "indexedAt": {
+          "type": "string",
+          "format": "datetime"
+        },
+        "joinedWeekCount": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "listItemsSample": {
+          "type": "array",
+          "items": {
+            "ref": "#listItemView",
+            "type": "ref"
+          },
+          "maxLength": 12
+        },
+        "joinedAllTimeCount": {
+          "type": "integer",
+          "minimum": 0
+        }
+      }
+    },
+    "starterPackViewBasic": {
+      "type": "object",
+      "required": [
+        "uri",
+        "cid",
+        "record",
+        "creator",
+        "indexedAt"
+      ],
+      "properties": {
+        "cid": {
+          "type": "string",
+          "format": "cid"
+        },
+        "uri": {
+          "type": "string",
+          "format": "at-uri"
+        },
+        "labels": {
+          "type": "array",
+          "items": {
+            "ref": "com.atproto.label.defs#label",
+            "type": "ref"
+          }
+        },
+        "record": {
+          "type": "unknown"
+        },
+        "creator": {
+          "ref": "app.bsky.actor.defs#profileViewBasic",
+          "type": "ref"
+        },
+        "indexedAt": {
+          "type": "string",
+          "format": "datetime"
+        },
+        "listItemCount": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "joinedWeekCount": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "joinedAllTimeCount": {
+          "type": "integer",
+          "minimum": 0
+        }
+      }
+    }
+  }
+}

lexicons/app/bsky/graph/follow.json

···
+{
+  "lexicon": 1,
+  "id": "app.bsky.graph.follow",
+  "defs": {
+    "main": {
+      "key": "tid",
+      "type": "record",
+      "record": {
+        "type": "object",
+        "required": [
+          "subject",
+          "createdAt"
+        ],
+        "properties": {
+          "subject": {
+            "type": "string",
+            "format": "did"
+          },
+          "createdAt": {
+            "type": "string",
+            "format": "datetime"
+          }
+        }
+      },
+      "description": "Record declaring a social 'follow' relationship of another account. Duplicate follows will be ignored by the AppView."
+    }
+  }
+}

lexicons/app/bsky/labeler/defs.json

···
+{
+  "lexicon": 1,
+  "id": "app.bsky.labeler.defs",
+  "defs": {
+    "labelerView": {
+      "type": "object",
+      "required": [
+        "uri",
+        "cid",
+        "creator",
+        "indexedAt"
+      ],
+      "properties": {
+        "cid": {
+          "type": "string",
+          "format": "cid"
+        },
+        "uri": {
+          "type": "string",
+          "format": "at-uri"
+        },
+        "labels": {
+          "type": "array",
+          "items": {
+            "ref": "com.atproto.label.defs#label",
+            "type": "ref"
+          }
+        },
+        "viewer": {
+          "ref": "#labelerViewerState",
+          "type": "ref"
+        },
+        "creator": {
+          "ref": "app.bsky.actor.defs#profileView",
+          "type": "ref"
+        },
+        "indexedAt": {
+          "type": "string",
+          "format": "datetime"
+        },
+        "likeCount": {
+          "type": "integer",
+          "minimum": 0
+        }
+      }
+    },
+    "labelerPolicies": {
+      "type": "object",
+      "required": [
+        "labelValues"
+      ],
+      "properties": {
+        "labelValues": {
+          "type": "array",
+          "items": {
+            "ref": "com.atproto.label.defs#labelValue",
+            "type": "ref"
+          },
+          "description": "The label values which this labeler publishes. May include global or custom labels."
+        },
+        "labelValueDefinitions": {
+          "type": "array",
+          "items": {
+            "ref": "com.atproto.label.defs#labelValueDefinition",
+            "type": "ref"
+          },
+          "description": "Label values created by this labeler and scoped exclusively to it. Labels defined here will override global label definitions for this labeler."
+        }
+      }
+    },
+    "labelerViewerState": {
+      "type": "object",
+      "properties": {
+        "like": {
+          "type": "string",
+          "format": "at-uri"
+        }
+      }
+    },
+    "labelerViewDetailed": {
+      "type": "object",
+      "required": [
+        "uri",
+        "cid",
+        "creator",
+        "policies",
+        "indexedAt"
+      ],
+      "properties": {
+        "cid": {
+          "type": "string",
+          "format": "cid"
+        },
+        "uri": {
+          "type": "string",
+          "format": "at-uri"
+        },
+        "labels": {
+          "type": "array",
+          "items": {
+            "ref": "com.atproto.label.defs#label",
+            "type": "ref"
+          }
+        },
+        "viewer": {
+          "ref": "#labelerViewerState",
+          "type": "ref"
+        },
+        "creator": {
+          "ref": "app.bsky.actor.defs#profileView",
+          "type": "ref"
+        },
+        "policies": {
+          "ref": "app.bsky.labeler.defs#labelerPolicies",
+          "type": "ref"
+        },
+        "indexedAt": {
+          "type": "string",
+          "format": "datetime"
+        },
+        "likeCount": {
+          "type": "integer",
+          "minimum": 0
+        }
+      }
+    }
+  }
+}

lexicons/app/bsky/richtext/facet.json

···
+{
+  "lexicon": 1,
+  "id": "app.bsky.richtext.facet",
+  "defs": {
+    "tag": {
+      "type": "object",
+      "required": [
+        "tag"
+      ],
+      "properties": {
+        "tag": {
+          "type": "string",
+          "maxLength": 640,
+          "maxGraphemes": 64
+        }
+      },
+      "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')."
+    },
+    "link": {
+      "type": "object",
+      "required": [
+        "uri"
+      ],
+      "properties": {
+        "uri": {
+          "type": "string",
+          "format": "uri"
+        }
+      },
+      "description": "Facet feature for a URL. The text URL may have been simplified or truncated, but the facet reference should be a complete URL."
+    },
+    "main": {
+      "type": "object",
+      "required": [
+        "index",
+        "features"
+      ],
+      "properties": {
+        "index": {
+          "ref": "#byteSlice",
+          "type": "ref"
+        },
+        "features": {
+          "type": "array",
+          "items": {
+            "refs": [
+              "#mention",
+              "#link",
+              "#tag"
+            ],
+            "type": "union"
+          }
+        }
+      },
+      "description": "Annotation of a sub-string within rich text."
+    },
+    "mention": {
+      "type": "object",
+      "required": [
+        "did"
+      ],
+      "properties": {
+        "did": {
+          "type": "string",
+          "format": "did"
+        }
+      },
+      "description": "Facet feature for mention of another account. The text is usually a handle, including a '@' prefix, but the facet reference is a DID."
+    },
+    "byteSlice": {
+      "type": "object",
+      "required": [
+        "byteStart",
+        "byteEnd"
+      ],
+      "properties": {
+        "byteEnd": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "byteStart": {
+          "type": "integer",
+          "minimum": 0
+        }
+      },
+      "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."
+    }
+  }
+}

lexicons/network/slices/waiting.json

···
-{
-  "lexicon": 1,
-  "id": "network.slices.waiting",
-  "defs": {
-    "main": {
-      "type": "record",
-      "description": "Existence of this record means you're on the waitist",
-      "key": "literal:self",
-      "record": {
-        "type": "object",
-        "required": ["createdAt"],
-        "properties": {
-          "createdAt": {
-            "type": "string",
-            "format": "datetime",
-            "description": "When the user joined the waitlist"
-          }
-        }
-      }
-    }
-  }
-}

lexicons/network/slices/waitlist/defs.json

···
+{
+  "lexicon": 1,
+  "id": "network.slices.waitlist.defs",
+  "defs": {
+    "requestView": {
+      "type": "object",
+      "description": "A request to join the waitlist with profile information",
+      "required": ["slice", "createdAt"],
+      "properties": {
+        "slice": {
+          "type": "string",
+          "format": "at-uri",
+          "description": "The AT URI of the slice being requested access to"
+        },
+        "createdAt": {
+          "type": "string",
+          "format": "datetime",
+          "description": "When the user joined the waitlist"
+        },
+        "profile": {
+          "type": "ref",
+          "ref": "app.bsky.actor.defs#profileViewBasic",
+          "description": "Profile of the requester"
+        }
+      }
+    },
+    "inviteView": {
+      "type": "object",
+      "description": "An invite granting a DID access with profile information",
+      "required": ["did", "slice", "createdAt"],
+      "properties": {
+        "did": {
+          "type": "string",
+          "format": "did",
+          "description": "The DID being invited"
+        },
+        "slice": {
+          "type": "string",
+          "format": "at-uri",
+          "description": "The AT URI of the slice this invite is for"
+        },
+        "createdAt": {
+          "type": "string",
+          "format": "datetime",
+          "description": "When this invitation was created"
+        },
+        "expiresAt": {
+          "type": "string",
+          "format": "datetime",
+          "description": "Optional expiration date for this invitation"
+        },
+        "uri": {
+          "type": "string",
+          "format": "at-uri",
+          "description": "The AT URI of this invite record"
+        },
+        "profile": {
+          "type": "ref",
+          "ref": "app.bsky.actor.defs#profileViewBasic",
+          "description": "Profile of the invitee"
+        }
+      }
+    }
+  }
+}

lexicons/network/slices/waitlist/invite.json

···
+{
+  "lexicon": 1,
+  "id": "network.slices.waitlist.invite",
+  "defs": {
+    "main": {
+      "type": "record",
+      "description": "An invite granting a DID access, created by the slice owner",
+      "key": "tid",
+      "record": {
+        "type": "object",
+        "required": ["did", "slice", "createdAt"],
+        "properties": {
+          "did": {
+            "type": "string",
+            "format": "did",
+            "description": "The DID being invited"
+          },
+          "slice": {
+            "type": "string",
+            "format": "at-uri",
+            "description": "The AT URI of the slice this invite is for"
+          },
+          "createdAt": {
+            "type": "string",
+            "format": "datetime",
+            "description": "When this invitation was created"
+          },
+          "expiresAt": {
+            "type": "string",
+            "format": "datetime",
+            "description": "Optional expiration date for this invitation"
+          }
+        }
+      }
+    }
+  }
+}

lexicons/network/slices/waitlist/request.json

···
+{
+  "lexicon": 1,
+  "id": "network.slices.waitlist.request",
+  "defs": {
+    "main": {
+      "type": "record",
+      "description": "A request to join the waitlist",
+      "key": "literal:self",
+      "record": {
+        "type": "object",
+        "required": ["slice", "createdAt"],
+        "properties": {
+          "slice": {
+            "type": "string",
+            "format": "at-uri",
+            "description": "The AT URI of the slice being requested access to"
+          },
+          "createdAt": {
+            "type": "string",
+            "format": "datetime",
+            "description": "When the user joined the waitlist"
+          }
+        }
+      }
+    }
+  }
+}

packages/client/deno.json

···
 {
   "name": "@slices/client",
-  "version": "0.1.0-alpha.2",
+  "version": "0.1.0-alpha.3",
   "exports": "./src/mod.ts",
   "imports": {
     "@slices/oauth": "jsr:@slices/oauth@^0.4.1"

packages/client/src/mod.ts

···
   | "collection"
   | "uri"
   | "cid"
-  | "indexedAt";
+  | "indexedAt"
+  | "json";
 
 export interface SortField<TField extends string = string> {
   field: TField;
···
         }
       }
 
-      throw new Error(
-        `Request failed: ${response.status} ${response.statusText}`
-      );
+      // Try to read the response body for detailed error information
+      let errorMessage = `Request failed: ${response.status} ${response.statusText}`;
+      try {
+        const errorBody = await response.json();
+        if (errorBody?.message) {
+          errorMessage += ` - ${errorBody.message}`;
+        } else if (errorBody?.error) {
+          errorMessage += ` - ${errorBody.error}`;
+        }
+      } catch {
+        // If we can't parse the response body, just use the status message
+      }
+
+      throw new Error(errorMessage);
     }
 
     return (await response.json()) as T;
···
         }
       }
 
-      throw new Error(
-        `Blob upload failed: ${response.status} ${response.statusText}`
-      );
+      // Try to read the response body for detailed error information
+      let errorMessage = `Blob upload failed: ${response.status} ${response.statusText}`;
+      try {
+        const errorBody = await response.json();
+        if (errorBody?.message) {
+          errorMessage += ` - ${errorBody.message}`;
+        } else if (errorBody?.error) {
+          errorMessage += ` - ${errorBody.error}`;
+        }
+      } catch {
+        // If we can't parse the response body, just use the status message
+      }
+
+      throw new Error(errorMessage);
     }
 
     return await response.json();