@atproto/bsky 0.0.9 → 0.0.11

package/dist/index.js

@@ -105856,6 +105856,20 @@ var MethodNotImplementedError = class extends XRPCError2 {
   }
 };
 
+// ../common/src/dates.ts
+var import_iso_datestring_validator2 = __toESM(require_dist2());
+function toSimplifiedISOSafe(dateStr) {
+  const date = new Date(dateStr);
+  if (isNaN(date.getTime())) {
+    return new Date(0).toISOString();
+  }
+  const iso = date.toISOString();
+  if (!(0, import_iso_datestring_validator2.isValidISODateString)(iso)) {
+    return new Date(0).toISOString();
+  }
+  return iso;
+}
+
 // ../common/src/ipld.ts
 var import_crypto3 = __toESM(require("crypto"));
 var import_stream = require("stream");
@@ -119883,6 +119897,10 @@ var schemaDict = {
           type: "params",
           properties: {
             term: {
+              type: "string",
+              description: "DEPRECATED: use 'q' instead"
+            },
+            q: {
               type: "string"
             },
             invitedBy: {
@@ -120988,6 +121006,45 @@ var schemaDict = {
       }
     }
   },
+  ComAtprotoServerConfirmEmail: {
+    lexicon: 1,
+    id: "com.atproto.server.confirmEmail",
+    defs: {
+      main: {
+        type: "procedure",
+        description: "Confirm an email using a token from com.atproto.server.requestEmailConfirmation.",
+        input: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["email", "token"],
+            properties: {
+              email: {
+                type: "string"
+              },
+              token: {
+                type: "string"
+              }
+            }
+          }
+        },
+        errors: [
+          {
+            name: "AccountNotFound"
+          },
+          {
+            name: "ExpiredToken"
+          },
+          {
+            name: "InvalidToken"
+          },
+          {
+            name: "InvalidEmail"
+          }
+        ]
+      }
+    }
+  },
   ComAtprotoServerCreateAccount: {
     lexicon: 1,
     id: "com.atproto.server.createAccount",
@@ -121270,6 +121327,9 @@ var schemaDict = {
               },
               email: {
                 type: "string"
+              },
+              emailConfirmed: {
+                type: "boolean"
               }
             }
           }
@@ -121499,6 +121559,9 @@ var schemaDict = {
               },
               email: {
                 type: "string"
+              },
+              emailConfirmed: {
+                type: "boolean"
               }
             }
           }
@@ -121598,6 +121661,38 @@ var schemaDict = {
       }
     }
   },
+  ComAtprotoServerRequestEmailConfirmation: {
+    lexicon: 1,
+    id: "com.atproto.server.requestEmailConfirmation",
+    defs: {
+      main: {
+        type: "procedure",
+        description: "Request an email with a code to confirm ownership of email"
+      }
+    }
+  },
+  ComAtprotoServerRequestEmailUpdate: {
+    lexicon: 1,
+    id: "com.atproto.server.requestEmailUpdate",
+    defs: {
+      main: {
+        type: "procedure",
+        description: "Request a token in order to update email.",
+        output: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["tokenRequired"],
+            properties: {
+              tokenRequired: {
+                type: "boolean"
+              }
+            }
+          }
+        }
+      }
+    }
+  },
   ComAtprotoServerRequestPasswordReset: {
     lexicon: 1,
     id: "com.atproto.server.requestPasswordReset",
@@ -121675,6 +121770,43 @@ var schemaDict = {
       }
     }
   },
+  ComAtprotoServerUpdateEmail: {
+    lexicon: 1,
+    id: "com.atproto.server.updateEmail",
+    defs: {
+      main: {
+        type: "procedure",
+        description: "Update an account's email.",
+        input: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["email"],
+            properties: {
+              email: {
+                type: "string"
+              },
+              token: {
+                type: "string",
+                description: "Requires a token from com.atproto.sever.requestEmailUpdate if the account's email has been confirmed."
+              }
+            }
+          }
+        },
+        errors: [
+          {
+            name: "ExpiredToken"
+          },
+          {
+            name: "InvalidToken"
+          },
+          {
+            name: "TokenRequired"
+          }
+        ]
+      }
+    }
+  },
   ComAtprotoSyncGetBlob: {
     lexicon: 1,
     id: "com.atproto.sync.getBlob",
@@ -122735,18 +122867,23 @@ var schemaDict = {
     defs: {
       main: {
         type: "query",
-        description: "Find actors matching search criteria.",
+        description: "Find actors (profiles) matching search criteria.",
         parameters: {
           type: "params",
           properties: {
             term: {
-              type: "string"
+              type: "string",
+              description: "DEPRECATED: use 'q' instead"
+            },
+            q: {
+              type: "string",
+              description: "search query string; syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended"
             },
             limit: {
               type: "integer",
               minimum: 1,
               maximum: 100,
-              default: 50
+              default: 25
             },
             cursor: {
               type: "string"
@@ -122786,13 +122923,18 @@ var schemaDict = {
           type: "params",
           properties: {
             term: {
-              type: "string"
+              type: "string",
+              description: "DEPRECATED: use 'q' instead"
+            },
+            q: {
+              type: "string",
+              description: "search query prefix; not a full query string"
             },
             limit: {
               type: "integer",
               minimum: 1,
               maximum: 100,
-              default: 50
+              default: 10
             }
           }
         },
@@ -124442,6 +124584,64 @@ var schemaDict = {
       }
     }
   },
+  AppBskyFeedSearchPosts: {
+    lexicon: 1,
+    id: "app.bsky.feed.searchPosts",
+    defs: {
+      main: {
+        type: "query",
+        description: "Find posts matching search criteria",
+        parameters: {
+          type: "params",
+          required: ["q"],
+          properties: {
+            q: {
+              type: "string",
+              description: "search query string; syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended"
+            },
+            limit: {
+              type: "integer",
+              minimum: 1,
+              maximum: 100,
+              default: 25
+            },
+            cursor: {
+              type: "string",
+              description: "optional pagination mechanism; may not necessarily allow scrolling through entire result set"
+            }
+          }
+        },
+        output: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["posts"],
+            properties: {
+              cursor: {
+                type: "string"
+              },
+              hitsTotal: {
+                type: "integer",
+                description: "count of search hits. optional, may be rounded/truncated, and may not be possible to paginate through all hits"
+              },
+              posts: {
+                type: "array",
+                items: {
+                  type: "ref",
+                  ref: "lex:app.bsky.feed.defs#postView"
+                }
+              }
+            }
+          }
+        },
+        errors: [
+          {
+            name: "BadQueryString"
+          }
+        ]
+      }
+    }
+  },
   AppBskyFeedThreadgate: {
     lexicon: 1,
     id: "app.bsky.feed.threadgate",
@@ -125553,24 +125753,71 @@ var schemaDict = {
       }
     }
   },
-  AppBskyUnspeccedApplyLabels: {
+  AppBskyUnspeccedDefs: {
     lexicon: 1,
-    id: "app.bsky.unspecced.applyLabels",
+    id: "app.bsky.unspecced.defs",
+    defs: {
+      skeletonSearchPost: {
+        type: "object",
+        required: ["uri"],
+        properties: {
+          uri: {
+            type: "string",
+            format: "at-uri"
+          }
+        }
+      },
+      skeletonSearchActor: {
+        type: "object",
+        required: ["did"],
+        properties: {
+          did: {
+            type: "string",
+            format: "did"
+          }
+        }
+      }
+    }
+  },
+  AppBskyUnspeccedGetPopular: {
+    lexicon: 1,
+    id: "app.bsky.unspecced.getPopular",
     defs: {
       main: {
-        type: "procedure",
-        description: "Allow a labeler to apply labels directly.",
-        input: {
+        type: "query",
+        description: "DEPRECATED: will be removed soon, please find a feed generator alternative",
+        parameters: {
+          type: "params",
+          properties: {
+            includeNsfw: {
+              type: "boolean",
+              default: false
+            },
+            limit: {
+              type: "integer",
+              minimum: 1,
+              maximum: 100,
+              default: 50
+            },
+            cursor: {
+              type: "string"
+            }
+          }
+        },
+        output: {
           encoding: "application/json",
           schema: {
             type: "object",
-            required: ["labels"],
+            required: ["feed"],
             properties: {
-              labels: {
+              cursor: {
+                type: "string"
+              },
+              feed: {
                 type: "array",
                 items: {
                   type: "ref",
-                  ref: "lex:com.atproto.label.defs#label"
+                  ref: "lex:app.bsky.feed.defs#feedViewPost"
                 }
               }
             }
@@ -125579,20 +125826,62 @@ var schemaDict = {
       }
     }
   },
-  AppBskyUnspeccedGetPopular: {
+  AppBskyUnspeccedGetPopularFeedGenerators: {
     lexicon: 1,
-    id: "app.bsky.unspecced.getPopular",
+    id: "app.bsky.unspecced.getPopularFeedGenerators",
     defs: {
       main: {
         type: "query",
-        description: "DEPRECATED: will be removed soon, please find a feed generator alternative",
+        description: "An unspecced view of globally popular feed generators",
         parameters: {
           type: "params",
           properties: {
-            includeNsfw: {
-              type: "boolean",
-              default: false
+            limit: {
+              type: "integer",
+              minimum: 1,
+              maximum: 100,
+              default: 50
+            },
+            cursor: {
+              type: "string"
             },
+            query: {
+              type: "string"
+            }
+          }
+        },
+        output: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["feeds"],
+            properties: {
+              cursor: {
+                type: "string"
+              },
+              feeds: {
+                type: "array",
+                items: {
+                  type: "ref",
+                  ref: "lex:app.bsky.feed.defs#generatorView"
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  AppBskyUnspeccedGetTimelineSkeleton: {
+    lexicon: 1,
+    id: "app.bsky.unspecced.getTimelineSkeleton",
+    defs: {
+      main: {
+        type: "query",
+        description: "A skeleton of a timeline - UNSPECCED & WILL GO AWAY SOON",
+        parameters: {
+          type: "params",
+          properties: {
             limit: {
               type: "integer",
               minimum: 1,
@@ -125617,36 +125906,48 @@ var schemaDict = {
                 type: "array",
                 items: {
                   type: "ref",
-                  ref: "lex:app.bsky.feed.defs#feedViewPost"
+                  ref: "lex:app.bsky.feed.defs#skeletonFeedPost"
                 }
               }
             }
           }
-        }
+        },
+        errors: [
+          {
+            name: "UnknownFeed"
+          }
+        ]
       }
     }
   },
-  AppBskyUnspeccedGetPopularFeedGenerators: {
+  AppBskyUnspeccedSearchActorsSkeleton: {
     lexicon: 1,
-    id: "app.bsky.unspecced.getPopularFeedGenerators",
+    id: "app.bsky.unspecced.searchActorsSkeleton",
     defs: {
       main: {
         type: "query",
-        description: "An unspecced view of globally popular feed generators",
+        description: "Backend Actors (profile) search, returning only skeleton",
         parameters: {
           type: "params",
+          required: ["q"],
           properties: {
+            q: {
+              type: "string",
+              description: "search query string; syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended. For typeahead search, only simple term match is supported, not full syntax"
+            },
+            typeahead: {
+              type: "boolean",
+              description: "if true, acts as fast/simple 'typeahead' query"
+            },
             limit: {
               type: "integer",
               minimum: 1,
               maximum: 100,
-              default: 50
+              default: 25
             },
             cursor: {
-              type: "string"
-            },
-            query: {
-              type: "string"
+              type: "string",
+              description: "optional pagination mechanism; may not necessarily allow scrolling through entire result set"
             }
           }
         },
@@ -125654,42 +125955,57 @@ var schemaDict = {
           encoding: "application/json",
           schema: {
             type: "object",
-            required: ["feeds"],
+            required: ["actors"],
             properties: {
               cursor: {
                 type: "string"
               },
-              feeds: {
+              hitsTotal: {
+                type: "integer",
+                description: "count of search hits. optional, may be rounded/truncated, and may not be possible to paginate through all hits"
+              },
+              actors: {
                 type: "array",
                 items: {
                   type: "ref",
-                  ref: "lex:app.bsky.feed.defs#generatorView"
+                  ref: "lex:app.bsky.unspecced.defs#skeletonSearchActor"
                 }
               }
             }
           }
-        }
+        },
+        errors: [
+          {
+            name: "BadQueryString"
+          }
+        ]
       }
     }
   },
-  AppBskyUnspeccedGetTimelineSkeleton: {
+  AppBskyUnspeccedSearchPostsSkeleton: {
     lexicon: 1,
-    id: "app.bsky.unspecced.getTimelineSkeleton",
+    id: "app.bsky.unspecced.searchPostsSkeleton",
     defs: {
       main: {
         type: "query",
-        description: "A skeleton of a timeline - UNSPECCED & WILL GO AWAY SOON",
+        description: "Backend Posts search, returning only skeleton",
         parameters: {
           type: "params",
+          required: ["q"],
           properties: {
+            q: {
+              type: "string",
+              description: "search query string; syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended"
+            },
             limit: {
               type: "integer",
               minimum: 1,
               maximum: 100,
-              default: 50
+              default: 25
             },
             cursor: {
-              type: "string"
+              type: "string",
+              description: "optional pagination mechanism; may not necessarily allow scrolling through entire result set"
             }
           }
         },
@@ -125697,16 +126013,20 @@ var schemaDict = {
           encoding: "application/json",
           schema: {
             type: "object",
-            required: ["feed"],
+            required: ["posts"],
             properties: {
               cursor: {
                 type: "string"
               },
-              feed: {
+              hitsTotal: {
+                type: "integer",
+                description: "count of search hits. optional, may be rounded/truncated, and may not be possible to paginate through all hits"
+              },
+              posts: {
                 type: "array",
                 items: {
                   type: "ref",
-                  ref: "lex:app.bsky.feed.defs#skeletonFeedPost"
+                  ref: "lex:app.bsky.unspecced.defs#skeletonSearchPost"
                 }
               }
             }
@@ -125714,7 +126034,7 @@ var schemaDict = {
         },
         errors: [
           {
-            name: "UnknownFeed"
+            name: "BadQueryString"
           }
         ]
       }
@@ -125976,6 +126296,41 @@ function toKnownErr29(e) {
   return e;
 }
 
+// ../api/src/client/types/com/atproto/server/confirmEmail.ts
+var AccountNotFoundError = class extends XRPCError {
+  constructor(src3) {
+    super(src3.status, src3.error, src3.message, src3.headers);
+  }
+};
+var ExpiredTokenError = class extends XRPCError {
+  constructor(src3) {
+    super(src3.status, src3.error, src3.message, src3.headers);
+  }
+};
+var InvalidTokenError = class extends XRPCError {
+  constructor(src3) {
+    super(src3.status, src3.error, src3.message, src3.headers);
+  }
+};
+var InvalidEmailError = class extends XRPCError {
+  constructor(src3) {
+    super(src3.status, src3.error, src3.message, src3.headers);
+  }
+};
+function toKnownErr30(e) {
+  if (e instanceof XRPCError) {
+    if (e.error === "AccountNotFound")
+      return new AccountNotFoundError(e);
+    if (e.error === "ExpiredToken")
+      return new ExpiredTokenError(e);
+    if (e.error === "InvalidToken")
+      return new InvalidTokenError(e);
+    if (e.error === "InvalidEmail")
+      return new InvalidEmailError(e);
+  }
+  return e;
+}
+
 // ../api/src/client/types/com/atproto/server/createAccount.ts
 var InvalidHandleError2 = class extends XRPCError {
   constructor(src3) {
@@ -126012,7 +126367,7 @@ var IncompatibleDidDocError = class extends XRPCError {
     super(src3.status, src3.error, src3.message, src3.headers);
   }
 };
-function toKnownErr30(e) {
+function toKnownErr31(e) {
   if (e instanceof XRPCError) {
     if (e.error === "InvalidHandle")
       return new InvalidHandleError2(e);
@@ -126038,7 +126393,7 @@ var AccountTakedownError = class extends XRPCError {
     super(src3.status, src3.error, src3.message, src3.headers);
   }
 };
-function toKnownErr31(e) {
+function toKnownErr32(e) {
   if (e instanceof XRPCError) {
     if (e.error === "AccountTakedown")
       return new AccountTakedownError(e);
@@ -126047,14 +126402,14 @@ function toKnownErr31(e) {
 }
 
 // ../api/src/client/types/com/atproto/server/createInviteCode.ts
-function toKnownErr32(e) {
+function toKnownErr33(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/com/atproto/server/createInviteCodes.ts
-function toKnownErr33(e) {
+function toKnownErr34(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -126066,7 +126421,7 @@ var AccountTakedownError2 = class extends XRPCError {
     super(src3.status, src3.error, src3.message, src3.headers);
   }
 };
-function toKnownErr34(e) {
+function toKnownErr35(e) {
   if (e instanceof XRPCError) {
     if (e.error === "AccountTakedown")
       return new AccountTakedownError2(e);
@@ -126075,35 +126430,35 @@ function toKnownErr34(e) {
 }
 
 // ../api/src/client/types/com/atproto/server/deleteAccount.ts
-var ExpiredTokenError = class extends XRPCError {
+var ExpiredTokenError2 = class extends XRPCError {
   constructor(src3) {
     super(src3.status, src3.error, src3.message, src3.headers);
   }
 };
-var InvalidTokenError = class extends XRPCError {
+var InvalidTokenError2 = class extends XRPCError {
   constructor(src3) {
     super(src3.status, src3.error, src3.message, src3.headers);
   }
 };
-function toKnownErr35(e) {
+function toKnownErr36(e) {
   if (e instanceof XRPCError) {
     if (e.error === "ExpiredToken")
-      return new ExpiredTokenError(e);
+      return new ExpiredTokenError2(e);
     if (e.error === "InvalidToken")
-      return new InvalidTokenError(e);
+      return new InvalidTokenError2(e);
   }
   return e;
 }
 
 // ../api/src/client/types/com/atproto/server/deleteSession.ts
-function toKnownErr36(e) {
+function toKnownErr37(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/com/atproto/server/describeServer.ts
-function toKnownErr37(e) {
+function toKnownErr38(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -126115,7 +126470,7 @@ var DuplicateCreateError = class extends XRPCError {
     super(src3.status, src3.error, src3.message, src3.headers);
   }
 };
-function toKnownErr38(e) {
+function toKnownErr39(e) {
   if (e instanceof XRPCError) {
     if (e.error === "DuplicateCreate")
       return new DuplicateCreateError(e);
@@ -126124,7 +126479,7 @@ function toKnownErr38(e) {
 }
 
 // ../api/src/client/types/com/atproto/server/getSession.ts
-function toKnownErr39(e) {
+function toKnownErr40(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -126136,7 +126491,7 @@ var AccountTakedownError3 = class extends XRPCError {
     super(src3.status, src3.error, src3.message, src3.headers);
   }
 };
-function toKnownErr40(e) {
+function toKnownErr41(e) {
   if (e instanceof XRPCError) {
     if (e.error === "AccountTakedown")
       return new AccountTakedownError3(e);
@@ -126150,7 +126505,7 @@ var AccountTakedownError4 = class extends XRPCError {
     super(src3.status, src3.error, src3.message, src3.headers);
   }
 };
-function toKnownErr41(e) {
+function toKnownErr42(e) {
   if (e instanceof XRPCError) {
     if (e.error === "AccountTakedown")
       return new AccountTakedownError4(e);
@@ -126159,63 +126514,105 @@ function toKnownErr41(e) {
 }
 
 // ../api/src/client/types/com/atproto/server/requestAccountDelete.ts
-function toKnownErr42(e) {
+function toKnownErr43(e) {
+  if (e instanceof XRPCError) {
+  }
+  return e;
+}
+
+// ../api/src/client/types/com/atproto/server/requestEmailConfirmation.ts
+function toKnownErr44(e) {
+  if (e instanceof XRPCError) {
+  }
+  return e;
+}
+
+// ../api/src/client/types/com/atproto/server/requestEmailUpdate.ts
+function toKnownErr45(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/com/atproto/server/requestPasswordReset.ts
-function toKnownErr43(e) {
+function toKnownErr46(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/com/atproto/server/resetPassword.ts
-var ExpiredTokenError2 = class extends XRPCError {
+var ExpiredTokenError3 = class extends XRPCError {
   constructor(src3) {
     super(src3.status, src3.error, src3.message, src3.headers);
   }
 };
-var InvalidTokenError2 = class extends XRPCError {
+var InvalidTokenError3 = class extends XRPCError {
   constructor(src3) {
     super(src3.status, src3.error, src3.message, src3.headers);
   }
 };
-function toKnownErr44(e) {
+function toKnownErr47(e) {
   if (e instanceof XRPCError) {
     if (e.error === "ExpiredToken")
-      return new ExpiredTokenError2(e);
+      return new ExpiredTokenError3(e);
     if (e.error === "InvalidToken")
-      return new InvalidTokenError2(e);
+      return new InvalidTokenError3(e);
   }
   return e;
 }
 
 // ../api/src/client/types/com/atproto/server/revokeAppPassword.ts
-function toKnownErr45(e) {
+function toKnownErr48(e) {
+  if (e instanceof XRPCError) {
+  }
+  return e;
+}
+
+// ../api/src/client/types/com/atproto/server/updateEmail.ts
+var ExpiredTokenError4 = class extends XRPCError {
+  constructor(src3) {
+    super(src3.status, src3.error, src3.message, src3.headers);
+  }
+};
+var InvalidTokenError4 = class extends XRPCError {
+  constructor(src3) {
+    super(src3.status, src3.error, src3.message, src3.headers);
+  }
+};
+var TokenRequiredError = class extends XRPCError {
+  constructor(src3) {
+    super(src3.status, src3.error, src3.message, src3.headers);
+  }
+};
+function toKnownErr49(e) {
   if (e instanceof XRPCError) {
+    if (e.error === "ExpiredToken")
+      return new ExpiredTokenError4(e);
+    if (e.error === "InvalidToken")
+      return new InvalidTokenError4(e);
+    if (e.error === "TokenRequired")
+      return new TokenRequiredError(e);
   }
   return e;
 }
 
 // ../api/src/client/types/com/atproto/sync/getBlob.ts
-function toKnownErr46(e) {
+function toKnownErr50(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/com/atproto/sync/getBlocks.ts
-function toKnownErr47(e) {
+function toKnownErr51(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/com/atproto/sync/getCheckout.ts
-function toKnownErr48(e) {
+function toKnownErr52(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -126227,7 +126624,7 @@ var HeadNotFoundError = class extends XRPCError {
     super(src3.status, src3.error, src3.message, src3.headers);
   }
 };
-function toKnownErr49(e) {
+function toKnownErr53(e) {
   if (e instanceof XRPCError) {
     if (e.error === "HeadNotFound")
       return new HeadNotFoundError(e);
@@ -126239,14 +126636,14 @@ function toKnownErr49(e) {
 var getLatestCommit_exports = {};
 __export(getLatestCommit_exports, {
   RepoNotFoundError: () => RepoNotFoundError2,
-  toKnownErr: () => toKnownErr50
+  toKnownErr: () => toKnownErr54
 });
 var RepoNotFoundError2 = class extends XRPCError {
   constructor(src3) {
     super(src3.status, src3.error, src3.message, src3.headers);
   }
 };
-function toKnownErr50(e) {
+function toKnownErr54(e) {
   if (e instanceof XRPCError) {
     if (e.error === "RepoNotFound")
       return new RepoNotFoundError2(e);
@@ -126255,105 +126652,105 @@ function toKnownErr50(e) {
 }
 
 // ../api/src/client/types/com/atproto/sync/getRecord.ts
-function toKnownErr51(e) {
+function toKnownErr55(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/com/atproto/sync/getRepo.ts
-function toKnownErr52(e) {
+function toKnownErr56(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/com/atproto/sync/listBlobs.ts
-function toKnownErr53(e) {
+function toKnownErr57(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/com/atproto/sync/listRepos.ts
-function toKnownErr54(e) {
+function toKnownErr58(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/com/atproto/sync/notifyOfUpdate.ts
-function toKnownErr55(e) {
+function toKnownErr59(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/com/atproto/sync/requestCrawl.ts
-function toKnownErr56(e) {
+function toKnownErr60(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/actor/getPreferences.ts
-function toKnownErr57(e) {
+function toKnownErr61(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/actor/getProfile.ts
-function toKnownErr58(e) {
+function toKnownErr62(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/actor/getProfiles.ts
-function toKnownErr59(e) {
+function toKnownErr63(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/actor/getSuggestions.ts
-function toKnownErr60(e) {
+function toKnownErr64(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/actor/putPreferences.ts
-function toKnownErr61(e) {
+function toKnownErr65(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/actor/searchActors.ts
-function toKnownErr62(e) {
+function toKnownErr66(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/actor/searchActorsTypeahead.ts
-function toKnownErr63(e) {
+function toKnownErr67(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/feed/describeFeedGenerator.ts
-function toKnownErr64(e) {
+function toKnownErr68(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/feed/getActorFeeds.ts
-function toKnownErr65(e) {
+function toKnownErr69(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -126370,7 +126767,7 @@ var BlockedByActorError = class extends XRPCError {
     super(src3.status, src3.error, src3.message, src3.headers);
   }
 };
-function toKnownErr66(e) {
+function toKnownErr70(e) {
   if (e instanceof XRPCError) {
     if (e.error === "BlockedActor")
       return new BlockedActorError(e);
@@ -126391,7 +126788,7 @@ var BlockedByActorError2 = class extends XRPCError {
     super(src3.status, src3.error, src3.message, src3.headers);
   }
 };
-function toKnownErr67(e) {
+function toKnownErr71(e) {
   if (e instanceof XRPCError) {
     if (e.error === "BlockedActor")
       return new BlockedActorError2(e);
@@ -126407,7 +126804,7 @@ var UnknownFeedError = class extends XRPCError {
     super(src3.status, src3.error, src3.message, src3.headers);
   }
 };
-function toKnownErr68(e) {
+function toKnownErr72(e) {
   if (e instanceof XRPCError) {
     if (e.error === "UnknownFeed")
       return new UnknownFeedError(e);
@@ -126416,14 +126813,14 @@ function toKnownErr68(e) {
 }
 
 // ../api/src/client/types/app/bsky/feed/getFeedGenerator.ts
-function toKnownErr69(e) {
+function toKnownErr73(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/feed/getFeedGenerators.ts
-function toKnownErr70(e) {
+function toKnownErr74(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -126433,14 +126830,14 @@ function toKnownErr70(e) {
 var getFeedSkeleton_exports = {};
 __export(getFeedSkeleton_exports, {
   UnknownFeedError: () => UnknownFeedError2,
-  toKnownErr: () => toKnownErr71
+  toKnownErr: () => toKnownErr75
 });
 var UnknownFeedError2 = class extends XRPCError {
   constructor(src3) {
     super(src3.status, src3.error, src3.message, src3.headers);
   }
 };
-function toKnownErr71(e) {
+function toKnownErr75(e) {
   if (e instanceof XRPCError) {
     if (e.error === "UnknownFeed")
       return new UnknownFeedError2(e);
@@ -126449,7 +126846,7 @@ function toKnownErr71(e) {
 }
 
 // ../api/src/client/types/app/bsky/feed/getLikes.ts
-function toKnownErr72(e) {
+function toKnownErr76(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -126461,7 +126858,7 @@ var UnknownListError = class extends XRPCError {
     super(src3.status, src3.error, src3.message, src3.headers);
   }
 };
-function toKnownErr73(e) {
+function toKnownErr77(e) {
   if (e instanceof XRPCError) {
     if (e.error === "UnknownList")
       return new UnknownListError(e);
@@ -126475,7 +126872,7 @@ var NotFoundError = class extends XRPCError {
     super(src3.status, src3.error, src3.message, src3.headers);
   }
 };
-function toKnownErr74(e) {
+function toKnownErr78(e) {
   if (e instanceof XRPCError) {
     if (e.error === "NotFound")
       return new NotFoundError(e);
@@ -126484,168 +126881,175 @@ function toKnownErr74(e) {
 }
 
 // ../api/src/client/types/app/bsky/feed/getPosts.ts
-function toKnownErr75(e) {
+function toKnownErr79(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/feed/getRepostedBy.ts
-function toKnownErr76(e) {
+function toKnownErr80(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/feed/getSuggestedFeeds.ts
-function toKnownErr77(e) {
+function toKnownErr81(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/feed/getTimeline.ts
-function toKnownErr78(e) {
+function toKnownErr82(e) {
+  if (e instanceof XRPCError) {
+  }
+  return e;
+}
+
+// ../api/src/client/types/app/bsky/feed/searchPosts.ts
+var BadQueryStringError = class extends XRPCError {
+  constructor(src3) {
+    super(src3.status, src3.error, src3.message, src3.headers);
+  }
+};
+function toKnownErr83(e) {
   if (e instanceof XRPCError) {
+    if (e.error === "BadQueryString")
+      return new BadQueryStringError(e);
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/graph/getBlocks.ts
-function toKnownErr79(e) {
+function toKnownErr84(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/graph/getFollowers.ts
-function toKnownErr80(e) {
+function toKnownErr85(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/graph/getFollows.ts
-function toKnownErr81(e) {
+function toKnownErr86(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/graph/getList.ts
-function toKnownErr82(e) {
+function toKnownErr87(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/graph/getListBlocks.ts
-function toKnownErr83(e) {
+function toKnownErr88(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/graph/getListMutes.ts
-function toKnownErr84(e) {
+function toKnownErr89(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/graph/getLists.ts
-function toKnownErr85(e) {
+function toKnownErr90(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/graph/getMutes.ts
-function toKnownErr86(e) {
+function toKnownErr91(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/graph/getSuggestedFollowsByActor.ts
-function toKnownErr87(e) {
+function toKnownErr92(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/graph/muteActor.ts
-function toKnownErr88(e) {
+function toKnownErr93(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/graph/muteActorList.ts
-function toKnownErr89(e) {
+function toKnownErr94(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/graph/unmuteActor.ts
-function toKnownErr90(e) {
+function toKnownErr95(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/graph/unmuteActorList.ts
-function toKnownErr91(e) {
+function toKnownErr96(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/notification/getUnreadCount.ts
-function toKnownErr92(e) {
+function toKnownErr97(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/notification/listNotifications.ts
-function toKnownErr93(e) {
+function toKnownErr98(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/notification/registerPush.ts
-function toKnownErr94(e) {
+function toKnownErr99(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/notification/updateSeen.ts
-function toKnownErr95(e) {
-  if (e instanceof XRPCError) {
-  }
-  return e;
-}
-
-// ../api/src/client/types/app/bsky/unspecced/applyLabels.ts
-function toKnownErr96(e) {
+function toKnownErr100(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/unspecced/getPopular.ts
-function toKnownErr97(e) {
+function toKnownErr101(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/unspecced/getPopularFeedGenerators.ts
-function toKnownErr98(e) {
+function toKnownErr102(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -126657,7 +127061,7 @@ var UnknownFeedError3 = class extends XRPCError {
     super(src3.status, src3.error, src3.message, src3.headers);
   }
 };
-function toKnownErr99(e) {
+function toKnownErr103(e) {
   if (e instanceof XRPCError) {
     if (e.error === "UnknownFeed")
       return new UnknownFeedError3(e);
@@ -126665,6 +127069,34 @@ function toKnownErr99(e) {
   return e;
 }
 
+// ../api/src/client/types/app/bsky/unspecced/searchActorsSkeleton.ts
+var BadQueryStringError2 = class extends XRPCError {
+  constructor(src3) {
+    super(src3.status, src3.error, src3.message, src3.headers);
+  }
+};
+function toKnownErr104(e) {
+  if (e instanceof XRPCError) {
+    if (e.error === "BadQueryString")
+      return new BadQueryStringError2(e);
+  }
+  return e;
+}
+
+// ../api/src/client/types/app/bsky/unspecced/searchPostsSkeleton.ts
+var BadQueryStringError3 = class extends XRPCError {
+  constructor(src3) {
+    super(src3.status, src3.error, src3.message, src3.headers);
+  }
+};
+function toKnownErr105(e) {
+  if (e instanceof XRPCError) {
+    if (e.error === "BadQueryString")
+      return new BadQueryStringError3(e);
+  }
+  return e;
+}
+
 // ../api/src/client/index.ts
 var AtpBaseClient = class {
   constructor() {
@@ -126878,84 +127310,104 @@ var ServerNS = class {
   constructor(service2) {
     this._service = service2;
   }
+  confirmEmail(data, opts) {
+    return this._service.xrpc.call("com.atproto.server.confirmEmail", opts?.qp, data, opts).catch((e) => {
+      throw toKnownErr30(e);
+    });
+  }
   createAccount(data, opts) {
     return this._service.xrpc.call("com.atproto.server.createAccount", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr30(e);
+      throw toKnownErr31(e);
     });
   }
   createAppPassword(data, opts) {
     return this._service.xrpc.call("com.atproto.server.createAppPassword", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr31(e);
+      throw toKnownErr32(e);
     });
   }
   createInviteCode(data, opts) {
     return this._service.xrpc.call("com.atproto.server.createInviteCode", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr32(e);
+      throw toKnownErr33(e);
     });
   }
   createInviteCodes(data, opts) {
     return this._service.xrpc.call("com.atproto.server.createInviteCodes", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr33(e);
+      throw toKnownErr34(e);
     });
   }
   createSession(data, opts) {
     return this._service.xrpc.call("com.atproto.server.createSession", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr34(e);
+      throw toKnownErr35(e);
     });
   }
   deleteAccount(data, opts) {
     return this._service.xrpc.call("com.atproto.server.deleteAccount", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr35(e);
+      throw toKnownErr36(e);
     });
   }
   deleteSession(data, opts) {
     return this._service.xrpc.call("com.atproto.server.deleteSession", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr36(e);
+      throw toKnownErr37(e);
     });
   }
   describeServer(params2, opts) {
     return this._service.xrpc.call("com.atproto.server.describeServer", params2, void 0, opts).catch((e) => {
-      throw toKnownErr37(e);
+      throw toKnownErr38(e);
     });
   }
   getAccountInviteCodes(params2, opts) {
     return this._service.xrpc.call("com.atproto.server.getAccountInviteCodes", params2, void 0, opts).catch((e) => {
-      throw toKnownErr38(e);
+      throw toKnownErr39(e);
     });
   }
   getSession(params2, opts) {
     return this._service.xrpc.call("com.atproto.server.getSession", params2, void 0, opts).catch((e) => {
-      throw toKnownErr39(e);
+      throw toKnownErr40(e);
     });
   }
   listAppPasswords(params2, opts) {
     return this._service.xrpc.call("com.atproto.server.listAppPasswords", params2, void 0, opts).catch((e) => {
-      throw toKnownErr40(e);
+      throw toKnownErr41(e);
     });
   }
   refreshSession(data, opts) {
     return this._service.xrpc.call("com.atproto.server.refreshSession", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr41(e);
+      throw toKnownErr42(e);
     });
   }
   requestAccountDelete(data, opts) {
     return this._service.xrpc.call("com.atproto.server.requestAccountDelete", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr42(e);
+      throw toKnownErr43(e);
+    });
+  }
+  requestEmailConfirmation(data, opts) {
+    return this._service.xrpc.call("com.atproto.server.requestEmailConfirmation", opts?.qp, data, opts).catch((e) => {
+      throw toKnownErr44(e);
+    });
+  }
+  requestEmailUpdate(data, opts) {
+    return this._service.xrpc.call("com.atproto.server.requestEmailUpdate", opts?.qp, data, opts).catch((e) => {
+      throw toKnownErr45(e);
     });
   }
   requestPasswordReset(data, opts) {
     return this._service.xrpc.call("com.atproto.server.requestPasswordReset", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr43(e);
+      throw toKnownErr46(e);
     });
   }
   resetPassword(data, opts) {
     return this._service.xrpc.call("com.atproto.server.resetPassword", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr44(e);
+      throw toKnownErr47(e);
     });
   }
   revokeAppPassword(data, opts) {
     return this._service.xrpc.call("com.atproto.server.revokeAppPassword", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr45(e);
+      throw toKnownErr48(e);
+    });
+  }
+  updateEmail(data, opts) {
+    return this._service.xrpc.call("com.atproto.server.updateEmail", opts?.qp, data, opts).catch((e) => {
+      throw toKnownErr49(e);
     });
   }
 };
@@ -126965,57 +127417,57 @@ var SyncNS = class {
   }
   getBlob(params2, opts) {
     return this._service.xrpc.call("com.atproto.sync.getBlob", params2, void 0, opts).catch((e) => {
-      throw toKnownErr46(e);
+      throw toKnownErr50(e);
     });
   }
   getBlocks(params2, opts) {
     return this._service.xrpc.call("com.atproto.sync.getBlocks", params2, void 0, opts).catch((e) => {
-      throw toKnownErr47(e);
+      throw toKnownErr51(e);
     });
   }
   getCheckout(params2, opts) {
     return this._service.xrpc.call("com.atproto.sync.getCheckout", params2, void 0, opts).catch((e) => {
-      throw toKnownErr48(e);
+      throw toKnownErr52(e);
     });
   }
   getHead(params2, opts) {
     return this._service.xrpc.call("com.atproto.sync.getHead", params2, void 0, opts).catch((e) => {
-      throw toKnownErr49(e);
+      throw toKnownErr53(e);
     });
   }
   getLatestCommit(params2, opts) {
     return this._service.xrpc.call("com.atproto.sync.getLatestCommit", params2, void 0, opts).catch((e) => {
-      throw toKnownErr50(e);
+      throw toKnownErr54(e);
     });
   }
   getRecord(params2, opts) {
     return this._service.xrpc.call("com.atproto.sync.getRecord", params2, void 0, opts).catch((e) => {
-      throw toKnownErr51(e);
+      throw toKnownErr55(e);
     });
   }
   getRepo(params2, opts) {
     return this._service.xrpc.call("com.atproto.sync.getRepo", params2, void 0, opts).catch((e) => {
-      throw toKnownErr52(e);
+      throw toKnownErr56(e);
     });
   }
   listBlobs(params2, opts) {
     return this._service.xrpc.call("com.atproto.sync.listBlobs", params2, void 0, opts).catch((e) => {
-      throw toKnownErr53(e);
+      throw toKnownErr57(e);
     });
   }
   listRepos(params2, opts) {
     return this._service.xrpc.call("com.atproto.sync.listRepos", params2, void 0, opts).catch((e) => {
-      throw toKnownErr54(e);
+      throw toKnownErr58(e);
     });
   }
   notifyOfUpdate(data, opts) {
     return this._service.xrpc.call("com.atproto.sync.notifyOfUpdate", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr55(e);
+      throw toKnownErr59(e);
     });
   }
   requestCrawl(data, opts) {
     return this._service.xrpc.call("com.atproto.sync.requestCrawl", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr56(e);
+      throw toKnownErr60(e);
     });
   }
 };
@@ -127044,37 +127496,37 @@ var ActorNS = class {
   }
   getPreferences(params2, opts) {
     return this._service.xrpc.call("app.bsky.actor.getPreferences", params2, void 0, opts).catch((e) => {
-      throw toKnownErr57(e);
+      throw toKnownErr61(e);
     });
   }
   getProfile(params2, opts) {
     return this._service.xrpc.call("app.bsky.actor.getProfile", params2, void 0, opts).catch((e) => {
-      throw toKnownErr58(e);
+      throw toKnownErr62(e);
     });
   }
   getProfiles(params2, opts) {
     return this._service.xrpc.call("app.bsky.actor.getProfiles", params2, void 0, opts).catch((e) => {
-      throw toKnownErr59(e);
+      throw toKnownErr63(e);
     });
   }
   getSuggestions(params2, opts) {
     return this._service.xrpc.call("app.bsky.actor.getSuggestions", params2, void 0, opts).catch((e) => {
-      throw toKnownErr60(e);
+      throw toKnownErr64(e);
     });
   }
   putPreferences(data, opts) {
     return this._service.xrpc.call("app.bsky.actor.putPreferences", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr61(e);
+      throw toKnownErr65(e);
     });
   }
   searchActors(params2, opts) {
     return this._service.xrpc.call("app.bsky.actor.searchActors", params2, void 0, opts).catch((e) => {
-      throw toKnownErr62(e);
+      throw toKnownErr66(e);
     });
   }
   searchActorsTypeahead(params2, opts) {
     return this._service.xrpc.call("app.bsky.actor.searchActorsTypeahead", params2, void 0, opts).catch((e) => {
-      throw toKnownErr63(e);
+      throw toKnownErr67(e);
     });
   }
 };
@@ -127121,77 +127573,82 @@ var FeedNS = class {
   }
   describeFeedGenerator(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.describeFeedGenerator", params2, void 0, opts).catch((e) => {
-      throw toKnownErr64(e);
+      throw toKnownErr68(e);
     });
   }
   getActorFeeds(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getActorFeeds", params2, void 0, opts).catch((e) => {
-      throw toKnownErr65(e);
+      throw toKnownErr69(e);
     });
   }
   getActorLikes(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getActorLikes", params2, void 0, opts).catch((e) => {
-      throw toKnownErr66(e);
+      throw toKnownErr70(e);
     });
   }
   getAuthorFeed(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getAuthorFeed", params2, void 0, opts).catch((e) => {
-      throw toKnownErr67(e);
+      throw toKnownErr71(e);
     });
   }
   getFeed(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getFeed", params2, void 0, opts).catch((e) => {
-      throw toKnownErr68(e);
+      throw toKnownErr72(e);
     });
   }
   getFeedGenerator(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getFeedGenerator", params2, void 0, opts).catch((e) => {
-      throw toKnownErr69(e);
+      throw toKnownErr73(e);
     });
   }
   getFeedGenerators(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getFeedGenerators", params2, void 0, opts).catch((e) => {
-      throw toKnownErr70(e);
+      throw toKnownErr74(e);
     });
   }
   getFeedSkeleton(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getFeedSkeleton", params2, void 0, opts).catch((e) => {
-      throw toKnownErr71(e);
+      throw toKnownErr75(e);
     });
   }
   getLikes(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getLikes", params2, void 0, opts).catch((e) => {
-      throw toKnownErr72(e);
+      throw toKnownErr76(e);
     });
   }
   getListFeed(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getListFeed", params2, void 0, opts).catch((e) => {
-      throw toKnownErr73(e);
+      throw toKnownErr77(e);
     });
   }
   getPostThread(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getPostThread", params2, void 0, opts).catch((e) => {
-      throw toKnownErr74(e);
+      throw toKnownErr78(e);
     });
   }
   getPosts(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getPosts", params2, void 0, opts).catch((e) => {
-      throw toKnownErr75(e);
+      throw toKnownErr79(e);
     });
   }
   getRepostedBy(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getRepostedBy", params2, void 0, opts).catch((e) => {
-      throw toKnownErr76(e);
+      throw toKnownErr80(e);
     });
   }
   getSuggestedFeeds(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getSuggestedFeeds", params2, void 0, opts).catch((e) => {
-      throw toKnownErr77(e);
+      throw toKnownErr81(e);
     });
   }
   getTimeline(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getTimeline", params2, void 0, opts).catch((e) => {
-      throw toKnownErr78(e);
+      throw toKnownErr82(e);
+    });
+  }
+  searchPosts(params2, opts) {
+    return this._service.xrpc.call("app.bsky.feed.searchPosts", params2, void 0, opts).catch((e) => {
+      throw toKnownErr83(e);
     });
   }
 };
@@ -127341,67 +127798,67 @@ var GraphNS = class {
   }
   getBlocks(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getBlocks", params2, void 0, opts).catch((e) => {
-      throw toKnownErr79(e);
+      throw toKnownErr84(e);
     });
   }
   getFollowers(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getFollowers", params2, void 0, opts).catch((e) => {
-      throw toKnownErr80(e);
+      throw toKnownErr85(e);
     });
   }
   getFollows(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getFollows", params2, void 0, opts).catch((e) => {
-      throw toKnownErr81(e);
+      throw toKnownErr86(e);
     });
   }
   getList(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getList", params2, void 0, opts).catch((e) => {
-      throw toKnownErr82(e);
+      throw toKnownErr87(e);
     });
   }
   getListBlocks(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getListBlocks", params2, void 0, opts).catch((e) => {
-      throw toKnownErr83(e);
+      throw toKnownErr88(e);
     });
   }
   getListMutes(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getListMutes", params2, void 0, opts).catch((e) => {
-      throw toKnownErr84(e);
+      throw toKnownErr89(e);
     });
   }
   getLists(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getLists", params2, void 0, opts).catch((e) => {
-      throw toKnownErr85(e);
+      throw toKnownErr90(e);
     });
   }
   getMutes(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getMutes", params2, void 0, opts).catch((e) => {
-      throw toKnownErr86(e);
+      throw toKnownErr91(e);
     });
   }
   getSuggestedFollowsByActor(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getSuggestedFollowsByActor", params2, void 0, opts).catch((e) => {
-      throw toKnownErr87(e);
+      throw toKnownErr92(e);
     });
   }
   muteActor(data, opts) {
     return this._service.xrpc.call("app.bsky.graph.muteActor", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr88(e);
+      throw toKnownErr93(e);
     });
   }
   muteActorList(data, opts) {
     return this._service.xrpc.call("app.bsky.graph.muteActorList", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr89(e);
+      throw toKnownErr94(e);
     });
   }
   unmuteActor(data, opts) {
     return this._service.xrpc.call("app.bsky.graph.unmuteActor", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr90(e);
+      throw toKnownErr95(e);
     });
   }
   unmuteActorList(data, opts) {
     return this._service.xrpc.call("app.bsky.graph.unmuteActorList", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr91(e);
+      throw toKnownErr96(e);
     });
   }
 };
@@ -127546,22 +128003,22 @@ var NotificationNS = class {
   }
   getUnreadCount(params2, opts) {
     return this._service.xrpc.call("app.bsky.notification.getUnreadCount", params2, void 0, opts).catch((e) => {
-      throw toKnownErr92(e);
+      throw toKnownErr97(e);
     });
   }
   listNotifications(params2, opts) {
     return this._service.xrpc.call("app.bsky.notification.listNotifications", params2, void 0, opts).catch((e) => {
-      throw toKnownErr93(e);
+      throw toKnownErr98(e);
     });
   }
   registerPush(data, opts) {
     return this._service.xrpc.call("app.bsky.notification.registerPush", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr94(e);
+      throw toKnownErr99(e);
     });
   }
   updateSeen(data, opts) {
     return this._service.xrpc.call("app.bsky.notification.updateSeen", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr95(e);
+      throw toKnownErr100(e);
     });
   }
 };
@@ -127574,24 +128031,29 @@ var UnspeccedNS = class {
   constructor(service2) {
     this._service = service2;
   }
-  applyLabels(data, opts) {
-    return this._service.xrpc.call("app.bsky.unspecced.applyLabels", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr96(e);
-    });
-  }
   getPopular(params2, opts) {
     return this._service.xrpc.call("app.bsky.unspecced.getPopular", params2, void 0, opts).catch((e) => {
-      throw toKnownErr97(e);
+      throw toKnownErr101(e);
     });
   }
   getPopularFeedGenerators(params2, opts) {
     return this._service.xrpc.call("app.bsky.unspecced.getPopularFeedGenerators", params2, void 0, opts).catch((e) => {
-      throw toKnownErr98(e);
+      throw toKnownErr102(e);
     });
   }
   getTimelineSkeleton(params2, opts) {
     return this._service.xrpc.call("app.bsky.unspecced.getTimelineSkeleton", params2, void 0, opts).catch((e) => {
-      throw toKnownErr99(e);
+      throw toKnownErr103(e);
+    });
+  }
+  searchActorsSkeleton(params2, opts) {
+    return this._service.xrpc.call("app.bsky.unspecced.searchActorsSkeleton", params2, void 0, opts).catch((e) => {
+      throw toKnownErr104(e);
+    });
+  }
+  searchPostsSkeleton(params2, opts) {
+    return this._service.xrpc.call("app.bsky.unspecced.searchPostsSkeleton", params2, void 0, opts).catch((e) => {
+      throw toKnownErr105(e);
     });
   }
 };
@@ -127635,7 +128097,8 @@ var _AtpAgent = class {
         refreshJwt: res.data.refreshJwt,
         handle: res.data.handle,
         did: res.data.did,
-        email: opts.email
+        email: opts.email,
+        emailConfirmed: false
       };
       return res;
     } catch (e) {
@@ -127660,7 +128123,8 @@ var _AtpAgent = class {
         refreshJwt: res.data.refreshJwt,
         handle: res.data.handle,
         did: res.data.did,
-        email: res.data.email
+        email: res.data.email,
+        emailConfirmed: res.data.emailConfirmed
       };
       return res;
     } catch (e) {
@@ -127683,6 +128147,7 @@ var _AtpAgent = class {
       }
       this.session.email = res.data.email;
       this.session.handle = res.data.handle;
+      this.session.emailConfirmed = res.data.emailConfirmed;
       return res;
     } catch (e) {
       this.session = void 0;
@@ -127744,6 +128209,7 @@ var _AtpAgent = class {
       this._persistSession?.("expired", void 0);
     } else if (isNewSessionObject(this._baseClient, res.body)) {
       this.session = {
+        ...this.session || {},
         accessJwt: res.body.accessJwt,
         refreshJwt: res.body.refreshJwt,
         handle: res.body.handle,
@@ -130188,6 +130654,10 @@ var schemaDict2 = {
           type: "params",
           properties: {
             term: {
+              type: "string",
+              description: "DEPRECATED: use 'q' instead"
+            },
+            q: {
               type: "string"
             },
             invitedBy: {
@@ -131293,6 +131763,45 @@ var schemaDict2 = {
       }
     }
   },
+  ComAtprotoServerConfirmEmail: {
+    lexicon: 1,
+    id: "com.atproto.server.confirmEmail",
+    defs: {
+      main: {
+        type: "procedure",
+        description: "Confirm an email using a token from com.atproto.server.requestEmailConfirmation.",
+        input: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["email", "token"],
+            properties: {
+              email: {
+                type: "string"
+              },
+              token: {
+                type: "string"
+              }
+            }
+          }
+        },
+        errors: [
+          {
+            name: "AccountNotFound"
+          },
+          {
+            name: "ExpiredToken"
+          },
+          {
+            name: "InvalidToken"
+          },
+          {
+            name: "InvalidEmail"
+          }
+        ]
+      }
+    }
+  },
   ComAtprotoServerCreateAccount: {
     lexicon: 1,
     id: "com.atproto.server.createAccount",
@@ -131575,6 +132084,9 @@ var schemaDict2 = {
               },
               email: {
                 type: "string"
+              },
+              emailConfirmed: {
+                type: "boolean"
               }
             }
           }
@@ -131804,6 +132316,9 @@ var schemaDict2 = {
               },
               email: {
                 type: "string"
+              },
+              emailConfirmed: {
+                type: "boolean"
               }
             }
           }
@@ -131903,6 +132418,38 @@ var schemaDict2 = {
       }
     }
   },
+  ComAtprotoServerRequestEmailConfirmation: {
+    lexicon: 1,
+    id: "com.atproto.server.requestEmailConfirmation",
+    defs: {
+      main: {
+        type: "procedure",
+        description: "Request an email with a code to confirm ownership of email"
+      }
+    }
+  },
+  ComAtprotoServerRequestEmailUpdate: {
+    lexicon: 1,
+    id: "com.atproto.server.requestEmailUpdate",
+    defs: {
+      main: {
+        type: "procedure",
+        description: "Request a token in order to update email.",
+        output: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["tokenRequired"],
+            properties: {
+              tokenRequired: {
+                type: "boolean"
+              }
+            }
+          }
+        }
+      }
+    }
+  },
   ComAtprotoServerRequestPasswordReset: {
     lexicon: 1,
     id: "com.atproto.server.requestPasswordReset",
@@ -131980,6 +132527,43 @@ var schemaDict2 = {
       }
     }
   },
+  ComAtprotoServerUpdateEmail: {
+    lexicon: 1,
+    id: "com.atproto.server.updateEmail",
+    defs: {
+      main: {
+        type: "procedure",
+        description: "Update an account's email.",
+        input: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["email"],
+            properties: {
+              email: {
+                type: "string"
+              },
+              token: {
+                type: "string",
+                description: "Requires a token from com.atproto.sever.requestEmailUpdate if the account's email has been confirmed."
+              }
+            }
+          }
+        },
+        errors: [
+          {
+            name: "ExpiredToken"
+          },
+          {
+            name: "InvalidToken"
+          },
+          {
+            name: "TokenRequired"
+          }
+        ]
+      }
+    }
+  },
   ComAtprotoSyncGetBlob: {
     lexicon: 1,
     id: "com.atproto.sync.getBlob",
@@ -133040,18 +133624,23 @@ var schemaDict2 = {
     defs: {
       main: {
         type: "query",
-        description: "Find actors matching search criteria.",
+        description: "Find actors (profiles) matching search criteria.",
         parameters: {
           type: "params",
           properties: {
             term: {
-              type: "string"
+              type: "string",
+              description: "DEPRECATED: use 'q' instead"
+            },
+            q: {
+              type: "string",
+              description: "search query string; syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended"
             },
             limit: {
               type: "integer",
               minimum: 1,
               maximum: 100,
-              default: 50
+              default: 25
             },
             cursor: {
               type: "string"
@@ -133091,13 +133680,18 @@ var schemaDict2 = {
           type: "params",
           properties: {
             term: {
-              type: "string"
+              type: "string",
+              description: "DEPRECATED: use 'q' instead"
+            },
+            q: {
+              type: "string",
+              description: "search query prefix; not a full query string"
             },
             limit: {
               type: "integer",
               minimum: 1,
               maximum: 100,
-              default: 50
+              default: 10
             }
           }
         },
@@ -134747,6 +135341,64 @@ var schemaDict2 = {
       }
     }
   },
+  AppBskyFeedSearchPosts: {
+    lexicon: 1,
+    id: "app.bsky.feed.searchPosts",
+    defs: {
+      main: {
+        type: "query",
+        description: "Find posts matching search criteria",
+        parameters: {
+          type: "params",
+          required: ["q"],
+          properties: {
+            q: {
+              type: "string",
+              description: "search query string; syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended"
+            },
+            limit: {
+              type: "integer",
+              minimum: 1,
+              maximum: 100,
+              default: 25
+            },
+            cursor: {
+              type: "string",
+              description: "optional pagination mechanism; may not necessarily allow scrolling through entire result set"
+            }
+          }
+        },
+        output: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["posts"],
+            properties: {
+              cursor: {
+                type: "string"
+              },
+              hitsTotal: {
+                type: "integer",
+                description: "count of search hits. optional, may be rounded/truncated, and may not be possible to paginate through all hits"
+              },
+              posts: {
+                type: "array",
+                items: {
+                  type: "ref",
+                  ref: "lex:app.bsky.feed.defs#postView"
+                }
+              }
+            }
+          }
+        },
+        errors: [
+          {
+            name: "BadQueryString"
+          }
+        ]
+      }
+    }
+  },
   AppBskyFeedThreadgate: {
     lexicon: 1,
     id: "app.bsky.feed.threadgate",
@@ -135858,27 +136510,27 @@ var schemaDict2 = {
       }
     }
   },
-  AppBskyUnspeccedApplyLabels: {
+  AppBskyUnspeccedDefs: {
     lexicon: 1,
-    id: "app.bsky.unspecced.applyLabels",
+    id: "app.bsky.unspecced.defs",
     defs: {
-      main: {
-        type: "procedure",
-        description: "Allow a labeler to apply labels directly.",
-        input: {
-          encoding: "application/json",
-          schema: {
-            type: "object",
-            required: ["labels"],
-            properties: {
-              labels: {
-                type: "array",
-                items: {
-                  type: "ref",
-                  ref: "lex:com.atproto.label.defs#label"
-                }
-              }
-            }
+      skeletonSearchPost: {
+        type: "object",
+        required: ["uri"],
+        properties: {
+          uri: {
+            type: "string",
+            format: "at-uri"
+          }
+        }
+      },
+      skeletonSearchActor: {
+        type: "object",
+        required: ["did"],
+        properties: {
+          did: {
+            type: "string",
+            format: "did"
           }
         }
       }
@@ -136024,6 +136676,126 @@ var schemaDict2 = {
         ]
       }
     }
+  },
+  AppBskyUnspeccedSearchActorsSkeleton: {
+    lexicon: 1,
+    id: "app.bsky.unspecced.searchActorsSkeleton",
+    defs: {
+      main: {
+        type: "query",
+        description: "Backend Actors (profile) search, returning only skeleton",
+        parameters: {
+          type: "params",
+          required: ["q"],
+          properties: {
+            q: {
+              type: "string",
+              description: "search query string; syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended. For typeahead search, only simple term match is supported, not full syntax"
+            },
+            typeahead: {
+              type: "boolean",
+              description: "if true, acts as fast/simple 'typeahead' query"
+            },
+            limit: {
+              type: "integer",
+              minimum: 1,
+              maximum: 100,
+              default: 25
+            },
+            cursor: {
+              type: "string",
+              description: "optional pagination mechanism; may not necessarily allow scrolling through entire result set"
+            }
+          }
+        },
+        output: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["actors"],
+            properties: {
+              cursor: {
+                type: "string"
+              },
+              hitsTotal: {
+                type: "integer",
+                description: "count of search hits. optional, may be rounded/truncated, and may not be possible to paginate through all hits"
+              },
+              actors: {
+                type: "array",
+                items: {
+                  type: "ref",
+                  ref: "lex:app.bsky.unspecced.defs#skeletonSearchActor"
+                }
+              }
+            }
+          }
+        },
+        errors: [
+          {
+            name: "BadQueryString"
+          }
+        ]
+      }
+    }
+  },
+  AppBskyUnspeccedSearchPostsSkeleton: {
+    lexicon: 1,
+    id: "app.bsky.unspecced.searchPostsSkeleton",
+    defs: {
+      main: {
+        type: "query",
+        description: "Backend Posts search, returning only skeleton",
+        parameters: {
+          type: "params",
+          required: ["q"],
+          properties: {
+            q: {
+              type: "string",
+              description: "search query string; syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended"
+            },
+            limit: {
+              type: "integer",
+              minimum: 1,
+              maximum: 100,
+              default: 25
+            },
+            cursor: {
+              type: "string",
+              description: "optional pagination mechanism; may not necessarily allow scrolling through entire result set"
+            }
+          }
+        },
+        output: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["posts"],
+            properties: {
+              cursor: {
+                type: "string"
+              },
+              hitsTotal: {
+                type: "integer",
+                description: "count of search hits. optional, may be rounded/truncated, and may not be possible to paginate through all hits"
+              },
+              posts: {
+                type: "array",
+                items: {
+                  type: "ref",
+                  ref: "lex:app.bsky.unspecced.defs#skeletonSearchPost"
+                }
+              }
+            }
+          }
+        },
+        errors: [
+          {
+            name: "BadQueryString"
+          }
+        ]
+      }
+    }
   }
 };
 var schemas2 = Object.values(schemaDict2);
@@ -136063,6 +136835,7 @@ var ids = {
   ComAtprotoRepoPutRecord: "com.atproto.repo.putRecord",
   ComAtprotoRepoStrongRef: "com.atproto.repo.strongRef",
   ComAtprotoRepoUploadBlob: "com.atproto.repo.uploadBlob",
+  ComAtprotoServerConfirmEmail: "com.atproto.server.confirmEmail",
   ComAtprotoServerCreateAccount: "com.atproto.server.createAccount",
   ComAtprotoServerCreateAppPassword: "com.atproto.server.createAppPassword",
   ComAtprotoServerCreateInviteCode: "com.atproto.server.createInviteCode",
@@ -136077,9 +136850,12 @@ var ids = {
   ComAtprotoServerListAppPasswords: "com.atproto.server.listAppPasswords",
   ComAtprotoServerRefreshSession: "com.atproto.server.refreshSession",
   ComAtprotoServerRequestAccountDelete: "com.atproto.server.requestAccountDelete",
+  ComAtprotoServerRequestEmailConfirmation: "com.atproto.server.requestEmailConfirmation",
+  ComAtprotoServerRequestEmailUpdate: "com.atproto.server.requestEmailUpdate",
   ComAtprotoServerRequestPasswordReset: "com.atproto.server.requestPasswordReset",
   ComAtprotoServerResetPassword: "com.atproto.server.resetPassword",
   ComAtprotoServerRevokeAppPassword: "com.atproto.server.revokeAppPassword",
+  ComAtprotoServerUpdateEmail: "com.atproto.server.updateEmail",
   ComAtprotoSyncGetBlob: "com.atproto.sync.getBlob",
   ComAtprotoSyncGetBlocks: "com.atproto.sync.getBlocks",
   ComAtprotoSyncGetCheckout: "com.atproto.sync.getCheckout",
@@ -136125,6 +136901,7 @@ var ids = {
   AppBskyFeedLike: "app.bsky.feed.like",
   AppBskyFeedPost: "app.bsky.feed.post",
   AppBskyFeedRepost: "app.bsky.feed.repost",
+  AppBskyFeedSearchPosts: "app.bsky.feed.searchPosts",
   AppBskyFeedThreadgate: "app.bsky.feed.threadgate",
   AppBskyGraphBlock: "app.bsky.graph.block",
   AppBskyGraphDefs: "app.bsky.graph.defs",
@@ -136150,10 +136927,12 @@ var ids = {
   AppBskyNotificationRegisterPush: "app.bsky.notification.registerPush",
   AppBskyNotificationUpdateSeen: "app.bsky.notification.updateSeen",
   AppBskyRichtextFacet: "app.bsky.richtext.facet",
-  AppBskyUnspeccedApplyLabels: "app.bsky.unspecced.applyLabels",
+  AppBskyUnspeccedDefs: "app.bsky.unspecced.defs",
   AppBskyUnspeccedGetPopular: "app.bsky.unspecced.getPopular",
   AppBskyUnspeccedGetPopularFeedGenerators: "app.bsky.unspecced.getPopularFeedGenerators",
-  AppBskyUnspeccedGetTimelineSkeleton: "app.bsky.unspecced.getTimelineSkeleton"
+  AppBskyUnspeccedGetTimelineSkeleton: "app.bsky.unspecced.getTimelineSkeleton",
+  AppBskyUnspeccedSearchActorsSkeleton: "app.bsky.unspecced.searchActorsSkeleton",
+  AppBskyUnspeccedSearchPostsSkeleton: "app.bsky.unspecced.searchPostsSkeleton"
 };
 
 // src/lexicon/util.ts
@@ -137287,7 +138066,7 @@ function getSuggestedFollowsByActor_default(server, ctx) {
 }
 async function getSkeleton(params2, ctx) {
   const actorsViewerFollows = ctx.db.db.selectFrom("follow").where("creator", "=", params2.viewer).select("subjectDid");
-  const mostLikedAccounts = await ctx.db.db.selectFrom(ctx.db.db.selectFrom("like").where("creator", "=", params2.actor).select(sql`split_part(subject, '/', 3)`.as("subjectDid")).limit(1e3).as("likes")).select("likes.subjectDid as did").select((qb) => qb.fn.count("likes.subjectDid").as("count")).where("likes.subjectDid", "not in", actorsViewerFollows).where("likes.subjectDid", "not in", [params2.actor, params2.viewer]).groupBy("likes.subjectDid").orderBy("count", "desc").limit(RESULT_LENGTH).execute();
+  const mostLikedAccounts = await ctx.db.db.selectFrom(ctx.db.db.selectFrom("like").where("creator", "=", params2.actor).select(sql`split_part(subject, '/', 3)`.as("subjectDid")).orderBy("sortAt", "desc").limit(1e3).as("likes")).select("likes.subjectDid as did").select((qb) => qb.fn.count("likes.subjectDid").as("count")).where("likes.subjectDid", "not in", actorsViewerFollows).where("likes.subjectDid", "not in", [params2.actor, params2.viewer]).groupBy("likes.subjectDid").orderBy("count", "desc").limit(RESULT_LENGTH).execute();
   const resultDids = mostLikedAccounts.map((a) => ({ did: a.did }));
   if (resultDids.length < RESULT_LENGTH) {
     const mostPopularAccountsActorFollows = await ctx.db.db.selectFrom("follow").innerJoin("profile_agg", "follow.subjectDid", "profile_agg.did").select("follow.subjectDid as did").where("follow.creator", "=", params2.actor).where("follow.subjectDid", "!=", params2.viewer).where("follow.subjectDid", "not in", actorsViewerFollows).if(resultDids.length > 0, (qb) => qb.where("subjectDid", "not in", resultDids.map((a) => a.did))).orderBy("profile_agg.followersCount", "desc").limit(RESULT_LENGTH).execute();
@@ -137303,17 +138082,17 @@ async function getSkeleton(params2, ctx) {
 // src/services/util/search.ts
 var getUserSearchQuery = (db, opts) => {
   const { ref } = db.db.dynamic;
-  const { term, limit, cursor, includeSoftDeleted } = opts;
-  const distanceAccount = distance(term, ref("handle"));
-  let accountsQb = getMatchingAccountsQb(db, { term, includeSoftDeleted });
+  const { query, limit, cursor, includeSoftDeleted } = opts;
+  const distanceAccount = distance(query, ref("handle"));
+  let accountsQb = getMatchingAccountsQb(db, { query, includeSoftDeleted });
   accountsQb = paginate(accountsQb, {
     limit,
     cursor,
     direction: "asc",
     keyset: new SearchKeyset(distanceAccount, ref("actor.did"))
   });
-  const distanceProfile = distance(term, ref("displayName"));
-  let profilesQb = getMatchingProfilesQb(db, { term, includeSoftDeleted });
+  const distanceProfile = distance(query, ref("displayName"));
+  let profilesQb = getMatchingProfilesQb(db, { query, includeSoftDeleted });
   profilesQb = paginate(profilesQb, {
     limit,
     cursor,
@@ -137329,9 +138108,9 @@ var getUserSearchQuery = (db, opts) => {
 };
 var getUserSearchQuerySimple = (db, opts) => {
   const { ref } = db.db.dynamic;
-  const { term, limit } = opts;
-  const accountsQb = getMatchingAccountsQb(db, { term }).orderBy("distance", "asc").limit(limit);
-  const profilesQb = getMatchingProfilesQb(db, { term }).orderBy("distance", "asc").limit(limit);
+  const { query, limit } = opts;
+  const accountsQb = getMatchingAccountsQb(db, { query }).orderBy("distance", "asc").limit(limit);
+  const profilesQb = getMatchingProfilesQb(db, { query }).orderBy("distance", "asc").limit(limit);
   return paginate(combineAccountsAndProfilesQb(db, accountsQb, profilesQb), {
     limit,
     direction: "asc",
@@ -137340,24 +138119,24 @@ var getUserSearchQuerySimple = (db, opts) => {
 };
 var getMatchingAccountsQb = (db, opts) => {
   const { ref } = db.db.dynamic;
-  const { term, includeSoftDeleted } = opts;
-  const distanceAccount = distance(term, ref("handle"));
-  return db.db.selectFrom("actor").if(!includeSoftDeleted, (qb) => qb.where(notSoftDeletedClause(ref("actor")))).where("actor.handle", "is not", null).where(similar(term, ref("handle"))).select(["actor.did as did", distanceAccount.as("distance")]);
+  const { query, includeSoftDeleted } = opts;
+  const distanceAccount = distance(query, ref("handle"));
+  return db.db.selectFrom("actor").if(!includeSoftDeleted, (qb) => qb.where(notSoftDeletedClause(ref("actor")))).where("actor.handle", "is not", null).where(similar(query, ref("handle"))).select(["actor.did as did", distanceAccount.as("distance")]);
 };
 var getMatchingProfilesQb = (db, opts) => {
   const { ref } = db.db.dynamic;
-  const { term, includeSoftDeleted } = opts;
-  const distanceProfile = distance(term, ref("displayName"));
-  return db.db.selectFrom("profile").innerJoin("actor", "actor.did", "profile.creator").if(!includeSoftDeleted, (qb) => qb.where(notSoftDeletedClause(ref("actor")))).where("actor.handle", "is not", null).where(similar(term, ref("displayName"))).select(["profile.creator as did", distanceProfile.as("distance")]);
+  const { query, includeSoftDeleted } = opts;
+  const distanceProfile = distance(query, ref("displayName"));
+  return db.db.selectFrom("profile").innerJoin("actor", "actor.did", "profile.creator").if(!includeSoftDeleted, (qb) => qb.where(notSoftDeletedClause(ref("actor")))).where("actor.handle", "is not", null).where(similar(query, ref("displayName"))).select(["profile.creator as did", distanceProfile.as("distance")]);
 };
 var combineAccountsAndProfilesQb = (db, accountsQb, profilesQb) => {
   const emptyQb = db.db.selectFrom("actor").where(sql`1 = 0`).select([sql.literal("").as("did"), sql`0`.as("distance")]);
   const resultsQb = db.db.selectFrom(emptyQb.unionAll(sql`${accountsQb}`).unionAll(sql`${profilesQb}`).as("accounts_and_profiles")).selectAll().distinctOn("did").orderBy("did").orderBy("distance");
   return db.db.selectFrom(resultsQb.as("results")).innerJoin("actor", "actor.did", "results.did");
 };
-var cleanTerm = (term) => term.trim().replace(/^@/g, "");
-var distance = (term, ref) => sql`(${term} <<-> ${ref})`;
-var similar = (term, ref) => sql`(${term} <% ${ref})`;
+var cleanQuery = (query) => query.trim().replace(/^@/g, "");
+var distance = (query, ref) => sql`(${query} <<-> ${ref})`;
+var similar = (query, ref) => sql`(${query} <% ${ref})`;
 var SearchKeyset = class extends GenericKeyset {
   labelResult(result) {
     return {
@@ -137388,18 +138167,41 @@ function searchActors_default(server, ctx) {
   server.app.bsky.actor.searchActors({
     auth: ctx.authOptionalVerifier,
     handler: async ({ auth, params: params2 }) => {
-      const { cursor, limit, term: rawTerm } = params2;
+      const { cursor, limit } = params2;
       const requester = auth.credentials.did;
-      const term = cleanTerm(rawTerm || "");
+      const rawQuery = params2.q ?? params2.term;
+      const query = cleanQuery(rawQuery || "");
       const db = ctx.db.getReplica("search");
-      const results = term ? await getUserSearchQuery(db, { term, limit, cursor }).select("distance").selectAll("actor").execute() : [];
-      const keyset = new SearchKeyset(sql``, sql``);
-      const actors = await ctx.services.actor(db).views.profilesList(results, requester);
-      const filtered = actors.filter((actor) => !actor.viewer?.blocking && !actor.viewer?.blockedBy);
+      let results;
+      let resCursor;
+      if (ctx.searchAgent) {
+        const res = await ctx.searchAgent.api.app.bsky.unspecced.searchActorsSkeleton({
+          q: query,
+          cursor,
+          limit
+        });
+        results = res.data.actors.map((a) => a.did);
+        resCursor = res.data.cursor;
+      } else {
+        const res = query ? await getUserSearchQuery(db, { query, limit, cursor }).select("distance").selectAll("actor").execute() : [];
+        results = res.map((a) => a.did);
+        const keyset = new SearchKeyset(sql``, sql``);
+        resCursor = keyset.packFromResult(res);
+      }
+      const actors = await ctx.services.actor(db).views.profiles(results, requester);
+      const SKIP = [];
+      const filtered = results.flatMap((did2) => {
+        const actor = actors[did2];
+        if (!actor)
+          return SKIP;
+        if (actor.viewer?.blocking || actor.viewer?.blockedBy)
+          return SKIP;
+        return actor;
+      });
       return {
         encoding: "application/json",
         body: {
-          cursor: keyset.packFromResult(results),
+          cursor: resCursor,
           actors: filtered
         }
       };
@@ -137412,15 +138214,29 @@ function searchActorsTypeahead_default(server, ctx) {
   server.app.bsky.actor.searchActorsTypeahead({
     auth: ctx.authOptionalVerifier,
     handler: async ({ params: params2, auth }) => {
-      const { limit, term: rawTerm } = params2;
+      const { limit } = params2;
       const requester = auth.credentials.did;
-      const term = cleanTerm(rawTerm || "");
+      const rawQuery = params2.q ?? params2.term;
+      const query = cleanQuery(rawQuery || "");
       const db = ctx.db.getReplica("search");
-      const results = term ? await getUserSearchQuerySimple(db, { term, limit }).selectAll("actor").execute() : [];
+      let results;
+      if (ctx.searchAgent) {
+        const res = await ctx.searchAgent.api.app.bsky.unspecced.searchActorsSkeleton({
+          q: query,
+          typeahead: true,
+          limit
+        });
+        results = res.data.actors.map((a) => a.did);
+      } else {
+        const res = query ? await getUserSearchQuerySimple(db, { query, limit }).selectAll("actor").execute() : [];
+        results = res.map((a) => a.did);
+      }
       const actors = await ctx.services.actor(db).views.profilesBasic(results, requester, { omitLabels: true });
       const SKIP = [];
-      const filtered = results.flatMap((res) => {
-        const actor = actors[res.did];
+      const filtered = results.flatMap((did2) => {
+        const actor = actors[did2];
+        if (!actor)
+          return SKIP;
         if (actor.viewer?.blocking || actor.viewer?.blockedBy)
           return SKIP;
         return actor;
@@ -137516,20 +138332,6 @@ function isSelfLabels(v) {
   return isObj3(v) && hasProp3(v, "$type") && v.$type === "com.atproto.label.defs#selfLabels";
 }
 
-// src/services/indexing/util.ts
-var import_iso_datestring_validator2 = __toESM(require_dist2());
-function toSimplifiedISOSafe(dateStr) {
-  const date = new Date(dateStr);
-  if (isNaN(date.getTime())) {
-    return new Date(0).toISOString();
-  }
-  const iso = date.toISOString();
-  if (!(0, import_iso_datestring_validator2.isValidISODateString)(iso)) {
-    return new Date(0).toISOString();
-  }
-  return iso;
-}
-
 // src/services/label/index.ts
 var LabelService = class {
   constructor(db, cache) {
@@ -138104,15 +138906,16 @@ function searchRepos_default(server, ctx) {
     handler: async ({ params: params2 }) => {
       const db = ctx.db.getPrimary();
       const moderationService = ctx.services.moderation(db);
-      const { invitedBy } = params2;
+      const { invitedBy, limit, cursor } = params2;
       if (invitedBy) {
         throw new InvalidRequestError("The invitedBy parameter is unsupported");
       }
-      const { results, cursor } = await ctx.services.actor(db).getSearchResults({ ...params2, includeSoftDeleted: true });
+      const query = params2.q ?? params2.term;
+      const { results, cursor: resCursor } = await ctx.services.actor(db).getSearchResults({ query, limit, cursor, includeSoftDeleted: true });
       return {
         encoding: "application/json",
         body: {
-          cursor,
+          cursor: resCursor,
           repos: await moderationService.views.repo(results)
         }
       };
@@ -138765,6 +139568,10 @@ var ServerNS2 = class {
   constructor(server) {
     this._server = server;
   }
+  confirmEmail(cfg) {
+    const nsid2 = "com.atproto.server.confirmEmail";
+    return this._server.xrpc.method(nsid2, cfg);
+  }
   createAccount(cfg) {
     const nsid2 = "com.atproto.server.createAccount";
     return this._server.xrpc.method(nsid2, cfg);
@@ -138817,6 +139624,14 @@ var ServerNS2 = class {
     const nsid2 = "com.atproto.server.requestAccountDelete";
     return this._server.xrpc.method(nsid2, cfg);
   }
+  requestEmailConfirmation(cfg) {
+    const nsid2 = "com.atproto.server.requestEmailConfirmation";
+    return this._server.xrpc.method(nsid2, cfg);
+  }
+  requestEmailUpdate(cfg) {
+    const nsid2 = "com.atproto.server.requestEmailUpdate";
+    return this._server.xrpc.method(nsid2, cfg);
+  }
   requestPasswordReset(cfg) {
     const nsid2 = "com.atproto.server.requestPasswordReset";
     return this._server.xrpc.method(nsid2, cfg);
@@ -138829,6 +139644,10 @@ var ServerNS2 = class {
     const nsid2 = "com.atproto.server.revokeAppPassword";
     return this._server.xrpc.method(nsid2, cfg);
   }
+  updateEmail(cfg) {
+    const nsid2 = "com.atproto.server.updateEmail";
+    return this._server.xrpc.method(nsid2, cfg);
+  }
 };
 var SyncNS2 = class {
   constructor(server) {
@@ -139003,6 +139822,10 @@ var FeedNS2 = class {
     const nsid2 = "app.bsky.feed.getTimeline";
     return this._server.xrpc.method(nsid2, cfg);
   }
+  searchPosts(cfg) {
+    const nsid2 = "app.bsky.feed.searchPosts";
+    return this._server.xrpc.method(nsid2, cfg);
+  }
 };
 var GraphNS2 = class {
   constructor(server) {
@@ -139091,10 +139914,6 @@ var UnspeccedNS2 = class {
   constructor(server) {
     this._server = server;
   }
-  applyLabels(cfg) {
-    const nsid2 = "app.bsky.unspecced.applyLabels";
-    return this._server.xrpc.method(nsid2, cfg);
-  }
   getPopular(cfg) {
     const nsid2 = "app.bsky.unspecced.getPopular";
     return this._server.xrpc.method(nsid2, cfg);
@@ -139107,6 +139926,14 @@ var UnspeccedNS2 = class {
     const nsid2 = "app.bsky.unspecced.getTimelineSkeleton";
     return this._server.xrpc.method(nsid2, cfg);
   }
+  searchActorsSkeleton(cfg) {
+    const nsid2 = "app.bsky.unspecced.searchActorsSkeleton";
+    return this._server.xrpc.method(nsid2, cfg);
+  }
+  searchPostsSkeleton(cfg) {
+    const nsid2 = "app.bsky.unspecced.searchPostsSkeleton";
+    return this._server.xrpc.method(nsid2, cfg);
+  }
 };
 
 // src/image/uri.ts
@@ -141675,10 +142502,10 @@ var ActorService = class {
   async getSearchResults({
     cursor,
     limit = 25,
-    term = "",
+    query = "",
     includeSoftDeleted
   }) {
-    const searchField = term.startsWith("did:") ? "did" : "handle";
+    const searchField = query.startsWith("did:") ? "did" : "handle";
     let paginatedBuilder;
     const { ref } = this.db.db.dynamic;
     const paginationOptions = {
@@ -141687,18 +142514,18 @@ var ActorService = class {
       direction: "asc"
     };
     let keyset;
-    if (term && searchField === "handle") {
+    if (query && searchField === "handle") {
       keyset = new SearchKeyset(sql``, sql``);
       paginatedBuilder = getUserSearchQuery(this.db, {
-        term,
+        query,
         includeSoftDeleted,
         ...paginationOptions
       }).select("distance");
     } else {
       paginatedBuilder = this.db.db.selectFrom("actor").select([sql`0`.as("distance")]);
       keyset = new ListKeyset(ref("indexedAt"), ref("did"));
-      if (term && searchField === "did") {
-        paginatedBuilder = paginatedBuilder.where("actor.did", "=", term);
+      if (query && searchField === "did") {
+        paginatedBuilder = paginatedBuilder.where("actor.did", "=", query);
       }
       paginatedBuilder = paginate(paginatedBuilder, {
         keyset,
@@ -143100,6 +143927,9 @@ var AppContext = class {
   get notifServer() {
     return this.opts.notifServer;
   }
+  get searchAgent() {
+    return this.opts.searchAgent;
+  }
   get authVerifier() {
     return authVerifier(this.idResolver, { aud: this.cfg.serverDid });
   }
@@ -143538,6 +144368,7 @@ var ServerConfig = class {
     const handleResolveNameservers = process.env.HANDLE_RESOLVE_NAMESERVERS ? process.env.HANDLE_RESOLVE_NAMESERVERS.split(",") : [];
     const imgUriEndpoint = process.env.IMG_URI_ENDPOINT;
     const blobCacheLocation = process.env.BLOB_CACHE_LOC;
+    const searchEndpoint = process.env.SEARCH_ENDPOINT;
     const dbPrimaryPostgresUrl = overrides?.dbPrimaryPostgresUrl || process.env.DB_PRIMARY_POSTGRES_URL;
     let dbReplicaPostgresUrls = overrides?.dbReplicaPostgresUrls;
     if (!dbReplicaPostgresUrls && process.env.DB_REPLICA_POSTGRES_URLS) {
@@ -143575,6 +144406,7 @@ var ServerConfig = class {
       handleResolveNameservers,
       imgUriEndpoint,
       blobCacheLocation,
+      searchEndpoint,
       labelerDid,
       adminPassword,
       moderatorPassword,
@@ -143639,6 +144471,9 @@ var ServerConfig = class {
   get blobCacheLocation() {
     return this.cfg.blobCacheLocation;
   }
+  get searchEndpoint() {
+    return this.cfg.searchEndpoint;
+  }
   get labelerDid() {
     return this.cfg.labelerDid;
   }
@@ -147004,20 +147839,7 @@ var AutoModerator = class {
     if (labels.length < 1)
       return;
     const labelSrvc = this.services.label(this.ctx.db);
-    const formatted = await labelSrvc.formatAndCreate(this.ctx.cfg.labelerDid, uri2.toString(), cid2.toString(), { create: labels });
-    if (this.pushAgent) {
-      const agent = this.pushAgent;
-      try {
-        await agent.api.app.bsky.unspecced.applyLabels({ labels: formatted });
-      } catch (err) {
-        labelerLogger.error({
-          err,
-          uri: uri2.toString(),
-          labels,
-          receiver: agent.service.toString()
-        }, "failed to push labels");
-      }
-    }
+    await labelSrvc.formatAndCreate(this.ctx.cfg.labelerDid, uri2.toString(), cid2.toString(), { create: labels });
   }
   async processAll() {
     await this.ctx.backgroundQueue.processAll();
@@ -147719,6 +148541,7 @@ var BskyAppView = class {
     const backgroundQueue = new BackgroundQueue(db.getPrimary());
     const labelCache = new LabelCache(db.getPrimary());
     const notifServer = new NotificationServer(db.getPrimary());
+    const searchAgent = config2.searchEndpoint ? new AtpAgent({ service: config2.searchEndpoint }) : void 0;
     const services = createServices({
       imgUriBuilder,
       imgInvalidator,
@@ -147733,6 +148556,7 @@ var BskyAppView = class {
       didCache,
       labelCache,
       backgroundQueue,
+      searchAgent,
       algos,
       notifServer
     });