@atproto/bsky 0.0.9 → 0.0.10

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: {
@@ -122735,18 +122753,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 +122809,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 +124470,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,27 +125639,27 @@ var schemaDict = {
       }
     }
   },
-  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"
           }
         }
       }
@@ -125719,6 +125805,126 @@ var schemaDict = {
         ]
       }
     }
+  },
+  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 schemas = Object.values(schemaDict);
@@ -126511,126 +126717,133 @@ function toKnownErr78(e) {
   return e;
 }
 
-// ../api/src/client/types/app/bsky/graph/getBlocks.ts
+// ../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 toKnownErr79(e) {
   if (e instanceof XRPCError) {
+    if (e.error === "BadQueryString")
+      return new BadQueryStringError(e);
   }
   return e;
 }
 
-// ../api/src/client/types/app/bsky/graph/getFollowers.ts
+// ../api/src/client/types/app/bsky/graph/getBlocks.ts
 function toKnownErr80(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
-// ../api/src/client/types/app/bsky/graph/getFollows.ts
+// ../api/src/client/types/app/bsky/graph/getFollowers.ts
 function toKnownErr81(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
-// ../api/src/client/types/app/bsky/graph/getList.ts
+// ../api/src/client/types/app/bsky/graph/getFollows.ts
 function toKnownErr82(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
-// ../api/src/client/types/app/bsky/graph/getListBlocks.ts
+// ../api/src/client/types/app/bsky/graph/getList.ts
 function toKnownErr83(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
-// ../api/src/client/types/app/bsky/graph/getListMutes.ts
+// ../api/src/client/types/app/bsky/graph/getListBlocks.ts
 function toKnownErr84(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
-// ../api/src/client/types/app/bsky/graph/getLists.ts
+// ../api/src/client/types/app/bsky/graph/getListMutes.ts
 function toKnownErr85(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
-// ../api/src/client/types/app/bsky/graph/getMutes.ts
+// ../api/src/client/types/app/bsky/graph/getLists.ts
 function toKnownErr86(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
-// ../api/src/client/types/app/bsky/graph/getSuggestedFollowsByActor.ts
+// ../api/src/client/types/app/bsky/graph/getMutes.ts
 function toKnownErr87(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
-// ../api/src/client/types/app/bsky/graph/muteActor.ts
+// ../api/src/client/types/app/bsky/graph/getSuggestedFollowsByActor.ts
 function toKnownErr88(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
-// ../api/src/client/types/app/bsky/graph/muteActorList.ts
+// ../api/src/client/types/app/bsky/graph/muteActor.ts
 function toKnownErr89(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
-// ../api/src/client/types/app/bsky/graph/unmuteActor.ts
+// ../api/src/client/types/app/bsky/graph/muteActorList.ts
 function toKnownErr90(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
-// ../api/src/client/types/app/bsky/graph/unmuteActorList.ts
+// ../api/src/client/types/app/bsky/graph/unmuteActor.ts
 function toKnownErr91(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
-// ../api/src/client/types/app/bsky/notification/getUnreadCount.ts
+// ../api/src/client/types/app/bsky/graph/unmuteActorList.ts
 function toKnownErr92(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
-// ../api/src/client/types/app/bsky/notification/listNotifications.ts
+// ../api/src/client/types/app/bsky/notification/getUnreadCount.ts
 function toKnownErr93(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
-// ../api/src/client/types/app/bsky/notification/registerPush.ts
+// ../api/src/client/types/app/bsky/notification/listNotifications.ts
 function toKnownErr94(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
-// ../api/src/client/types/app/bsky/notification/updateSeen.ts
+// ../api/src/client/types/app/bsky/notification/registerPush.ts
 function toKnownErr95(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
-// ../api/src/client/types/app/bsky/unspecced/applyLabels.ts
+// ../api/src/client/types/app/bsky/notification/updateSeen.ts
 function toKnownErr96(e) {
   if (e instanceof XRPCError) {
   }
@@ -126665,6 +126878,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 toKnownErr100(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 toKnownErr101(e) {
+  if (e instanceof XRPCError) {
+    if (e.error === "BadQueryString")
+      return new BadQueryStringError3(e);
+  }
+  return e;
+}
+
 // ../api/src/client/index.ts
 var AtpBaseClient = class {
   constructor() {
@@ -127194,6 +127435,11 @@ var FeedNS = class {
       throw toKnownErr78(e);
     });
   }
+  searchPosts(params2, opts) {
+    return this._service.xrpc.call("app.bsky.feed.searchPosts", params2, void 0, opts).catch((e) => {
+      throw toKnownErr79(e);
+    });
+  }
 };
 var GeneratorRecord = class {
   constructor(service2) {
@@ -127341,67 +127587,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 toKnownErr80(e);
     });
   }
   getFollowers(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getFollowers", params2, void 0, opts).catch((e) => {
-      throw toKnownErr80(e);
+      throw toKnownErr81(e);
     });
   }
   getFollows(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getFollows", params2, void 0, opts).catch((e) => {
-      throw toKnownErr81(e);
+      throw toKnownErr82(e);
     });
   }
   getList(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getList", params2, void 0, opts).catch((e) => {
-      throw toKnownErr82(e);
+      throw toKnownErr83(e);
     });
   }
   getListBlocks(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getListBlocks", params2, void 0, opts).catch((e) => {
-      throw toKnownErr83(e);
+      throw toKnownErr84(e);
     });
   }
   getListMutes(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getListMutes", params2, void 0, opts).catch((e) => {
-      throw toKnownErr84(e);
+      throw toKnownErr85(e);
     });
   }
   getLists(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getLists", params2, void 0, opts).catch((e) => {
-      throw toKnownErr85(e);
+      throw toKnownErr86(e);
     });
   }
   getMutes(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getMutes", params2, void 0, opts).catch((e) => {
-      throw toKnownErr86(e);
+      throw toKnownErr87(e);
     });
   }
   getSuggestedFollowsByActor(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getSuggestedFollowsByActor", params2, void 0, opts).catch((e) => {
-      throw toKnownErr87(e);
+      throw toKnownErr88(e);
     });
   }
   muteActor(data, opts) {
     return this._service.xrpc.call("app.bsky.graph.muteActor", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr88(e);
+      throw toKnownErr89(e);
     });
   }
   muteActorList(data, opts) {
     return this._service.xrpc.call("app.bsky.graph.muteActorList", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr89(e);
+      throw toKnownErr90(e);
     });
   }
   unmuteActor(data, opts) {
     return this._service.xrpc.call("app.bsky.graph.unmuteActor", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr90(e);
+      throw toKnownErr91(e);
     });
   }
   unmuteActorList(data, opts) {
     return this._service.xrpc.call("app.bsky.graph.unmuteActorList", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr91(e);
+      throw toKnownErr92(e);
     });
   }
 };
@@ -127546,22 +127792,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 toKnownErr93(e);
     });
   }
   listNotifications(params2, opts) {
     return this._service.xrpc.call("app.bsky.notification.listNotifications", params2, void 0, opts).catch((e) => {
-      throw toKnownErr93(e);
+      throw toKnownErr94(e);
     });
   }
   registerPush(data, opts) {
     return this._service.xrpc.call("app.bsky.notification.registerPush", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr94(e);
+      throw toKnownErr95(e);
     });
   }
   updateSeen(data, opts) {
     return this._service.xrpc.call("app.bsky.notification.updateSeen", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr95(e);
+      throw toKnownErr96(e);
     });
   }
 };
@@ -127574,11 +127820,6 @@ 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);
@@ -127594,6 +127835,16 @@ var UnspeccedNS = class {
       throw toKnownErr99(e);
     });
   }
+  searchActorsSkeleton(params2, opts) {
+    return this._service.xrpc.call("app.bsky.unspecced.searchActorsSkeleton", params2, void 0, opts).catch((e) => {
+      throw toKnownErr100(e);
+    });
+  }
+  searchPostsSkeleton(params2, opts) {
+    return this._service.xrpc.call("app.bsky.unspecced.searchPostsSkeleton", params2, void 0, opts).catch((e) => {
+      throw toKnownErr101(e);
+    });
+  }
 };
 
 // ../api/src/agent.ts
@@ -130188,6 +130439,10 @@ var schemaDict2 = {
           type: "params",
           properties: {
             term: {
+              type: "string",
+              description: "DEPRECATED: use 'q' instead"
+            },
+            q: {
               type: "string"
             },
             invitedBy: {
@@ -133040,18 +133295,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 +133351,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 +135012,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 +136181,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 +136347,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);
@@ -136125,6 +136568,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 +136594,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
@@ -137388,8 +137834,11 @@ function searchActors_default(server, ctx) {
   server.app.bsky.actor.searchActors({
     auth: ctx.authOptionalVerifier,
     handler: async ({ auth, params: params2 }) => {
-      const { cursor, limit, term: rawTerm } = params2;
+      let { cursor, limit, term: rawTerm, q: rawQ } = params2;
       const requester = auth.credentials.did;
+      if (rawQ) {
+        rawTerm = rawQ;
+      }
       const term = cleanTerm(rawTerm || "");
       const db = ctx.db.getReplica("search");
       const results = term ? await getUserSearchQuery(db, { term, limit, cursor }).select("distance").selectAll("actor").execute() : [];
@@ -137412,8 +137861,11 @@ function searchActorsTypeahead_default(server, ctx) {
   server.app.bsky.actor.searchActorsTypeahead({
     auth: ctx.authOptionalVerifier,
     handler: async ({ params: params2, auth }) => {
-      const { limit, term: rawTerm } = params2;
+      let { limit, term: rawTerm, q: rawQ } = params2;
       const requester = auth.credentials.did;
+      if (rawQ) {
+        rawTerm = rawQ;
+      }
       const term = cleanTerm(rawTerm || "");
       const db = ctx.db.getReplica("search");
       const results = term ? await getUserSearchQuerySimple(db, { term, limit }).selectAll("actor").execute() : [];
@@ -137516,20 +137968,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) {
@@ -138108,6 +138546,10 @@ function searchRepos_default(server, ctx) {
       if (invitedBy) {
         throw new InvalidRequestError("The invitedBy parameter is unsupported");
       }
+      const { q } = params2;
+      if (q) {
+        params2.term = q;
+      }
       const { results, cursor } = await ctx.services.actor(db).getSearchResults({ ...params2, includeSoftDeleted: true });
       return {
         encoding: "application/json",
@@ -139003,6 +139445,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 +139537,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 +139549,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
@@ -147004,20 +147454,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();