@atproto/pds 0.3.0-beta.2 → 0.3.0-beta.3

package/dist/index.js

@@ -221804,6 +221804,32 @@ var schemaDict = {
       }
     }
   },
+  ComAtprotoTempUpgradeRepoVersion: {
+    lexicon: 1,
+    id: "com.atproto.temp.upgradeRepoVersion",
+    defs: {
+      main: {
+        type: "procedure",
+        description: "Upgrade a repo to v3",
+        input: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["did"],
+            properties: {
+              did: {
+                type: "string",
+                format: "did"
+              },
+              force: {
+                type: "boolean"
+              }
+            }
+          }
+        }
+      }
+    }
+  },
   AppBskyActorDefs: {
     lexicon: 1,
     id: "app.bsky.actor.defs",
@@ -225107,6 +225133,7 @@ var ids = {
   ComAtprotoSyncNotifyOfUpdate: "com.atproto.sync.notifyOfUpdate",
   ComAtprotoSyncRequestCrawl: "com.atproto.sync.requestCrawl",
   ComAtprotoSyncSubscribeRepos: "com.atproto.sync.subscribeRepos",
+  ComAtprotoTempUpgradeRepoVersion: "com.atproto.temp.upgradeRepoVersion",
   AppBskyActorDefs: "app.bsky.actor.defs",
   AppBskyActorGetPreferences: "app.bsky.actor.getPreferences",
   AppBskyActorGetProfile: "app.bsky.actor.getProfile",
@@ -235414,6 +235441,60 @@ var ReadableBlockstore = class {
     return cborToLexRecord(bytes4);
   }
 };
+var readable_blockstore_default = ReadableBlockstore;
+
+// ../repo/src/storage/memory-blockstore.ts
+var MemoryBlockstore = class extends readable_blockstore_default {
+  constructor(blocks) {
+    super();
+    this.root = null;
+    this.blocks = new block_map_default();
+    if (blocks) {
+      this.blocks.addMap(blocks);
+    }
+  }
+  async getRoot() {
+    return this.root;
+  }
+  async getBytes(cid2) {
+    return this.blocks.get(cid2) || null;
+  }
+  async has(cid2) {
+    return this.blocks.has(cid2);
+  }
+  async getBlocks(cids) {
+    return this.blocks.getMany(cids);
+  }
+  async putBlock(cid2, block) {
+    this.blocks.set(cid2, block);
+  }
+  async putMany(blocks) {
+    this.blocks.addMap(blocks);
+  }
+  async updateRoot(cid2) {
+    this.root = cid2;
+  }
+  async applyCommit(commit2) {
+    this.root = commit2.cid;
+    const rmCids = commit2.removedCids.toList();
+    for (const cid2 of rmCids) {
+      this.blocks.delete(cid2);
+    }
+    commit2.newBlocks.forEach((bytes4, cid2) => {
+      this.blocks.set(cid2, bytes4);
+    });
+  }
+  async sizeInBytes() {
+    let total = 0;
+    this.blocks.forEach((bytes4) => {
+      total += bytes4.byteLength;
+    });
+    return total;
+  }
+  async destroy() {
+    this.blocks.clear();
+  }
+};
 
 // ../repo/src/storage/types.ts
 var BlobNotFoundError = class extends Error {
@@ -240802,6 +240883,93 @@ function sync_default(server, ctx) {
   getHead_default(server, ctx);
 }
 
+// src/api/com/atproto/upgradeRepoVersion.ts
+function upgradeRepoVersion_default(server, ctx) {
+  server.com.atproto.temp.upgradeRepoVersion({
+    auth: ctx.roleVerifier,
+    handler: async ({ input, auth }) => {
+      if (!auth.credentials.admin) {
+        throw new InvalidRequestError("must be admin");
+      }
+      const { did: did2, force } = input.body;
+      await ctx.db.transaction(async (dbTxn) => {
+        const storage = new sql_repo_storage_default(dbTxn, did2);
+        await obtainLock(storage);
+        const prevCid = await storage.getRoot();
+        if (!prevCid) {
+          throw new InvalidRequestError("Could not find repo");
+        }
+        const prev = await storage.readObj(prevCid, def2.versionedCommit);
+        const records = await dbTxn.db.selectFrom("record").select(["collection", "rkey", "cid"]).where("did", "=", did2).execute();
+        const memoryStore = new MemoryBlockstore();
+        let data = await MST.create(memoryStore);
+        for (const record of records) {
+          const dataKey = record.collection + "/" + record.rkey;
+          const cid2 = CID.parse(record.cid);
+          data = await data.add(dataKey, cid2);
+        }
+        const dataCid = await data.getPointer();
+        if (!force && !dataCid.equals(prev.data)) {
+          throw new InvalidRequestError("Data cid did not match");
+        }
+        const recordCids = records.map((r) => r.cid);
+        const diff = await DataDiff.of(data, null);
+        const cidsToKeep = [...recordCids, ...diff.newMstBlocks.cids()];
+        const rev = TID.nextStr(prev.rev);
+        if (force) {
+          const got = await storage.getBlocks(diff.newMstBlocks.cids());
+          const toAdd = diff.newMstBlocks.getMany(got.missing);
+          httpLogger.info({ missing: got.missing.length }, "force added missing blocks");
+          await storage.putMany(toAdd.blocks, rev);
+        }
+        for (const chunk of chunkArray(cidsToKeep, 500)) {
+          const cidStrs = chunk.map((c) => c.toString());
+          await dbTxn.db.updateTable("ipld_block").set({ repoRev: rev }).where("creator", "=", did2).where("cid", "in", cidStrs).execute();
+        }
+        await dbTxn.db.deleteFrom("ipld_block").where("creator", "=", did2).where((qb) => qb.where("repoRev", "is", null).orWhere("repoRev", "!=", rev)).execute();
+        await dbTxn.db.updateTable("repo_blob").set({ repoRev: rev }).where("did", "=", did2).execute();
+        await dbTxn.db.updateTable("record").set({ repoRev: rev }).where("did", "=", did2).execute();
+        const commit2 = await signCommit({
+          did: did2,
+          version: 3,
+          rev: TID.nextStr(),
+          prev: prevCid,
+          data: dataCid
+        }, ctx.repoSigningKey);
+        const newBlocks = new BlockMap();
+        const commitCid = await newBlocks.add(commit2);
+        await storage.putMany(newBlocks, rev);
+        await dbTxn.db.updateTable("repo_root").set({
+          root: commitCid.toString(),
+          rev,
+          indexedAt: storage.getTimestamp()
+        }).where("did", "=", did2).execute();
+        const commitData = {
+          cid: commitCid,
+          rev,
+          prev: prevCid,
+          since: null,
+          newBlocks,
+          removedCids: new CidSet()
+        };
+        const seqEvt = await formatSeqCommit(did2, commitData, []);
+        await sequenceEvt(dbTxn, seqEvt);
+      });
+    }
+  });
+}
+var obtainLock = async (storage, tries = 20) => {
+  const obtained = await storage.lockRepo();
+  if (obtained) {
+    return;
+  }
+  if (tries < 1) {
+    throw new InvalidRequestError("could not obtain lock");
+  }
+  await wait(50);
+  return obtainLock(storage, tries - 1);
+};
+
 // src/api/com/atproto/index.ts
 function atproto_default(server, ctx) {
   admin_default(server, ctx);
@@ -240810,6 +240978,7 @@ function atproto_default(server, ctx) {
   repo_default(server, ctx);
   server_default(server, ctx);
   sync_default(server, ctx);
+  upgradeRepoVersion_default(server, ctx);
 }
 
 // src/api/app/bsky/simple.ts
@@ -244570,6 +244739,32 @@ var schemaDict2 = {
       }
     }
   },
+  ComAtprotoTempUpgradeRepoVersion: {
+    lexicon: 1,
+    id: "com.atproto.temp.upgradeRepoVersion",
+    defs: {
+      main: {
+        type: "procedure",
+        description: "Upgrade a repo to v3",
+        input: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["did"],
+            properties: {
+              did: {
+                type: "string",
+                format: "did"
+              },
+              force: {
+                type: "boolean"
+              }
+            }
+          }
+        }
+      }
+    }
+  },
   AppBskyActorDefs: {
     lexicon: 1,
     id: "app.bsky.actor.defs",
@@ -248377,69 +248572,76 @@ function toKnownErr56(e) {
   return e;
 }
 
-// ../api/src/client/types/app/bsky/actor/getPreferences.ts
+// ../api/src/client/types/com/atproto/temp/upgradeRepoVersion.ts
 function toKnownErr57(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
-// ../api/src/client/types/app/bsky/actor/getProfile.ts
+// ../api/src/client/types/app/bsky/actor/getPreferences.ts
 function toKnownErr58(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
-// ../api/src/client/types/app/bsky/actor/getProfiles.ts
+// ../api/src/client/types/app/bsky/actor/getProfile.ts
 function toKnownErr59(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
-// ../api/src/client/types/app/bsky/actor/getSuggestions.ts
+// ../api/src/client/types/app/bsky/actor/getProfiles.ts
 function toKnownErr60(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
-// ../api/src/client/types/app/bsky/actor/putPreferences.ts
+// ../api/src/client/types/app/bsky/actor/getSuggestions.ts
 function toKnownErr61(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
-// ../api/src/client/types/app/bsky/actor/searchActors.ts
+// ../api/src/client/types/app/bsky/actor/putPreferences.ts
 function toKnownErr62(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
-// ../api/src/client/types/app/bsky/actor/searchActorsTypeahead.ts
+// ../api/src/client/types/app/bsky/actor/searchActors.ts
 function toKnownErr63(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
-// ../api/src/client/types/app/bsky/feed/describeFeedGenerator.ts
+// ../api/src/client/types/app/bsky/actor/searchActorsTypeahead.ts
 function toKnownErr64(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
-// ../api/src/client/types/app/bsky/feed/getActorFeeds.ts
+// ../api/src/client/types/app/bsky/feed/describeFeedGenerator.ts
 function toKnownErr65(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
+// ../api/src/client/types/app/bsky/feed/getActorFeeds.ts
+function toKnownErr66(e) {
+  if (e instanceof XRPCError) {
+  }
+  return e;
+}
+
 // ../api/src/client/types/app/bsky/feed/getActorLikes.ts
 var BlockedActorError = class extends XRPCError {
   constructor(src3) {
@@ -248451,7 +248653,7 @@ var BlockedByActorError = class extends XRPCError {
     super(src3.status, src3.error, src3.message, src3.headers);
   }
 };
-function toKnownErr66(e) {
+function toKnownErr67(e) {
   if (e instanceof XRPCError) {
     if (e.error === "BlockedActor")
       return new BlockedActorError(e);
@@ -248472,7 +248674,7 @@ var BlockedByActorError2 = class extends XRPCError {
     super(src3.status, src3.error, src3.message, src3.headers);
   }
 };
-function toKnownErr67(e) {
+function toKnownErr68(e) {
   if (e instanceof XRPCError) {
     if (e.error === "BlockedActor")
       return new BlockedActorError2(e);
@@ -248488,7 +248690,7 @@ var UnknownFeedError = class extends XRPCError {
     super(src3.status, src3.error, src3.message, src3.headers);
   }
 };
-function toKnownErr68(e) {
+function toKnownErr69(e) {
   if (e instanceof XRPCError) {
     if (e.error === "UnknownFeed")
       return new UnknownFeedError(e);
@@ -248497,14 +248699,14 @@ function toKnownErr68(e) {
 }
 
 // ../api/src/client/types/app/bsky/feed/getFeedGenerator.ts
-function toKnownErr69(e) {
+function toKnownErr70(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/feed/getFeedGenerators.ts
-function toKnownErr70(e) {
+function toKnownErr71(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -248516,7 +248718,7 @@ var UnknownFeedError2 = class extends XRPCError {
     super(src3.status, src3.error, src3.message, src3.headers);
   }
 };
-function toKnownErr71(e) {
+function toKnownErr72(e) {
   if (e instanceof XRPCError) {
     if (e.error === "UnknownFeed")
       return new UnknownFeedError2(e);
@@ -248525,7 +248727,7 @@ function toKnownErr71(e) {
 }
 
 // ../api/src/client/types/app/bsky/feed/getLikes.ts
-function toKnownErr72(e) {
+function toKnownErr73(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -248535,14 +248737,14 @@ function toKnownErr72(e) {
 var getPostThread_exports = {};
 __export(getPostThread_exports, {
   NotFoundError: () => NotFoundError,
-  toKnownErr: () => toKnownErr73
+  toKnownErr: () => toKnownErr74
 });
 var NotFoundError = class extends XRPCError {
   constructor(src3) {
     super(src3.status, src3.error, src3.message, src3.headers);
   }
 };
-function toKnownErr73(e) {
+function toKnownErr74(e) {
   if (e instanceof XRPCError) {
     if (e.error === "NotFound")
       return new NotFoundError(e);
@@ -248551,168 +248753,168 @@ function toKnownErr73(e) {
 }
 
 // ../api/src/client/types/app/bsky/feed/getPosts.ts
-function toKnownErr74(e) {
+function toKnownErr75(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/feed/getRepostedBy.ts
-function toKnownErr75(e) {
+function toKnownErr76(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/feed/getSuggestedFeeds.ts
-function toKnownErr76(e) {
+function toKnownErr77(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/feed/getTimeline.ts
-function toKnownErr77(e) {
+function toKnownErr78(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/graph/getBlocks.ts
-function toKnownErr78(e) {
+function toKnownErr79(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/graph/getFollowers.ts
-function toKnownErr79(e) {
+function toKnownErr80(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/graph/getFollows.ts
-function toKnownErr80(e) {
+function toKnownErr81(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/graph/getList.ts
-function toKnownErr81(e) {
+function toKnownErr82(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/graph/getListBlocks.ts
-function toKnownErr82(e) {
+function toKnownErr83(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/graph/getListMutes.ts
-function toKnownErr83(e) {
+function toKnownErr84(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/graph/getLists.ts
-function toKnownErr84(e) {
+function toKnownErr85(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/graph/getMutes.ts
-function toKnownErr85(e) {
+function toKnownErr86(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/graph/getSuggestedFollowsByActor.ts
-function toKnownErr86(e) {
+function toKnownErr87(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/graph/muteActor.ts
-function toKnownErr87(e) {
+function toKnownErr88(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/graph/muteActorList.ts
-function toKnownErr88(e) {
+function toKnownErr89(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/graph/unmuteActor.ts
-function toKnownErr89(e) {
+function toKnownErr90(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/graph/unmuteActorList.ts
-function toKnownErr90(e) {
+function toKnownErr91(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/notification/getUnreadCount.ts
-function toKnownErr91(e) {
+function toKnownErr92(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/notification/listNotifications.ts
-function toKnownErr92(e) {
+function toKnownErr93(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/notification/registerPush.ts
-function toKnownErr93(e) {
+function toKnownErr94(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/notification/updateSeen.ts
-function toKnownErr94(e) {
+function toKnownErr95(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/unspecced/applyLabels.ts
-function toKnownErr95(e) {
+function toKnownErr96(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/unspecced/getPopular.ts
-function toKnownErr96(e) {
+function toKnownErr97(e) {
   if (e instanceof XRPCError) {
   }
   return e;
 }
 
 // ../api/src/client/types/app/bsky/unspecced/getPopularFeedGenerators.ts
-function toKnownErr97(e) {
+function toKnownErr98(e) {
   if (e instanceof XRPCError) {
   }
   return e;
@@ -248724,7 +248926,7 @@ var UnknownFeedError3 = class extends XRPCError {
     super(src3.status, src3.error, src3.message, src3.headers);
   }
 };
-function toKnownErr98(e) {
+function toKnownErr99(e) {
   if (e instanceof XRPCError) {
     if (e.error === "UnknownFeed")
       return new UnknownFeedError3(e);
@@ -248769,6 +248971,7 @@ var AtprotoNS = class {
     this.repo = new RepoNS(service2);
     this.server = new ServerNS(service2);
     this.sync = new SyncNS(service2);
+    this.temp = new TempNS(service2);
   }
 };
 var AdminNS = class {
@@ -249086,6 +249289,16 @@ var SyncNS = class {
     });
   }
 };
+var TempNS = class {
+  constructor(service2) {
+    this._service = service2;
+  }
+  upgradeRepoVersion(data, opts) {
+    return this._service.xrpc.call("com.atproto.temp.upgradeRepoVersion", opts?.qp, data, opts).catch((e) => {
+      throw toKnownErr57(e);
+    });
+  }
+};
 var AppNS = class {
   constructor(service2) {
     this._service = service2;
@@ -249111,37 +249324,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 toKnownErr58(e);
     });
   }
   getProfile(params2, opts) {
     return this._service.xrpc.call("app.bsky.actor.getProfile", params2, void 0, opts).catch((e) => {
-      throw toKnownErr58(e);
+      throw toKnownErr59(e);
     });
   }
   getProfiles(params2, opts) {
     return this._service.xrpc.call("app.bsky.actor.getProfiles", params2, void 0, opts).catch((e) => {
-      throw toKnownErr59(e);
+      throw toKnownErr60(e);
     });
   }
   getSuggestions(params2, opts) {
     return this._service.xrpc.call("app.bsky.actor.getSuggestions", params2, void 0, opts).catch((e) => {
-      throw toKnownErr60(e);
+      throw toKnownErr61(e);
     });
   }
   putPreferences(data, opts) {
     return this._service.xrpc.call("app.bsky.actor.putPreferences", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr61(e);
+      throw toKnownErr62(e);
     });
   }
   searchActors(params2, opts) {
     return this._service.xrpc.call("app.bsky.actor.searchActors", params2, void 0, opts).catch((e) => {
-      throw toKnownErr62(e);
+      throw toKnownErr63(e);
     });
   }
   searchActorsTypeahead(params2, opts) {
     return this._service.xrpc.call("app.bsky.actor.searchActorsTypeahead", params2, void 0, opts).catch((e) => {
-      throw toKnownErr63(e);
+      throw toKnownErr64(e);
     });
   }
 };
@@ -249187,72 +249400,72 @@ 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 toKnownErr65(e);
     });
   }
   getActorFeeds(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getActorFeeds", params2, void 0, opts).catch((e) => {
-      throw toKnownErr65(e);
+      throw toKnownErr66(e);
     });
   }
   getActorLikes(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getActorLikes", params2, void 0, opts).catch((e) => {
-      throw toKnownErr66(e);
+      throw toKnownErr67(e);
     });
   }
   getAuthorFeed(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getAuthorFeed", params2, void 0, opts).catch((e) => {
-      throw toKnownErr67(e);
+      throw toKnownErr68(e);
     });
   }
   getFeed(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getFeed", params2, void 0, opts).catch((e) => {
-      throw toKnownErr68(e);
+      throw toKnownErr69(e);
     });
   }
   getFeedGenerator(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getFeedGenerator", params2, void 0, opts).catch((e) => {
-      throw toKnownErr69(e);
+      throw toKnownErr70(e);
     });
   }
   getFeedGenerators(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getFeedGenerators", params2, void 0, opts).catch((e) => {
-      throw toKnownErr70(e);
+      throw toKnownErr71(e);
     });
   }
   getFeedSkeleton(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getFeedSkeleton", params2, void 0, opts).catch((e) => {
-      throw toKnownErr71(e);
+      throw toKnownErr72(e);
     });
   }
   getLikes(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getLikes", params2, void 0, opts).catch((e) => {
-      throw toKnownErr72(e);
+      throw toKnownErr73(e);
     });
   }
   getPostThread(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getPostThread", params2, void 0, opts).catch((e) => {
-      throw toKnownErr73(e);
+      throw toKnownErr74(e);
     });
   }
   getPosts(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getPosts", params2, void 0, opts).catch((e) => {
-      throw toKnownErr74(e);
+      throw toKnownErr75(e);
     });
   }
   getRepostedBy(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getRepostedBy", params2, void 0, opts).catch((e) => {
-      throw toKnownErr75(e);
+      throw toKnownErr76(e);
     });
   }
   getSuggestedFeeds(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getSuggestedFeeds", params2, void 0, opts).catch((e) => {
-      throw toKnownErr76(e);
+      throw toKnownErr77(e);
     });
   }
   getTimeline(params2, opts) {
     return this._service.xrpc.call("app.bsky.feed.getTimeline", params2, void 0, opts).catch((e) => {
-      throw toKnownErr77(e);
+      throw toKnownErr78(e);
     });
   }
 };
@@ -249375,67 +249588,67 @@ var GraphNS = class {
   }
   getBlocks(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getBlocks", params2, void 0, opts).catch((e) => {
-      throw toKnownErr78(e);
+      throw toKnownErr79(e);
     });
   }
   getFollowers(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getFollowers", params2, void 0, opts).catch((e) => {
-      throw toKnownErr79(e);
+      throw toKnownErr80(e);
     });
   }
   getFollows(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getFollows", params2, void 0, opts).catch((e) => {
-      throw toKnownErr80(e);
+      throw toKnownErr81(e);
     });
   }
   getList(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getList", params2, void 0, opts).catch((e) => {
-      throw toKnownErr81(e);
+      throw toKnownErr82(e);
     });
   }
   getListBlocks(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getListBlocks", params2, void 0, opts).catch((e) => {
-      throw toKnownErr82(e);
+      throw toKnownErr83(e);
     });
   }
   getListMutes(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getListMutes", params2, void 0, opts).catch((e) => {
-      throw toKnownErr83(e);
+      throw toKnownErr84(e);
     });
   }
   getLists(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getLists", params2, void 0, opts).catch((e) => {
-      throw toKnownErr84(e);
+      throw toKnownErr85(e);
     });
   }
   getMutes(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getMutes", params2, void 0, opts).catch((e) => {
-      throw toKnownErr85(e);
+      throw toKnownErr86(e);
     });
   }
   getSuggestedFollowsByActor(params2, opts) {
     return this._service.xrpc.call("app.bsky.graph.getSuggestedFollowsByActor", params2, void 0, opts).catch((e) => {
-      throw toKnownErr86(e);
+      throw toKnownErr87(e);
     });
   }
   muteActor(data, opts) {
     return this._service.xrpc.call("app.bsky.graph.muteActor", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr87(e);
+      throw toKnownErr88(e);
     });
   }
   muteActorList(data, opts) {
     return this._service.xrpc.call("app.bsky.graph.muteActorList", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr88(e);
+      throw toKnownErr89(e);
     });
   }
   unmuteActor(data, opts) {
     return this._service.xrpc.call("app.bsky.graph.unmuteActor", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr89(e);
+      throw toKnownErr90(e);
     });
   }
   unmuteActorList(data, opts) {
     return this._service.xrpc.call("app.bsky.graph.unmuteActorList", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr90(e);
+      throw toKnownErr91(e);
     });
   }
 };
@@ -249580,22 +249793,22 @@ var NotificationNS = class {
   }
   getUnreadCount(params2, opts) {
     return this._service.xrpc.call("app.bsky.notification.getUnreadCount", params2, void 0, opts).catch((e) => {
-      throw toKnownErr91(e);
+      throw toKnownErr92(e);
     });
   }
   listNotifications(params2, opts) {
     return this._service.xrpc.call("app.bsky.notification.listNotifications", params2, void 0, opts).catch((e) => {
-      throw toKnownErr92(e);
+      throw toKnownErr93(e);
     });
   }
   registerPush(data, opts) {
     return this._service.xrpc.call("app.bsky.notification.registerPush", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr93(e);
+      throw toKnownErr94(e);
     });
   }
   updateSeen(data, opts) {
     return this._service.xrpc.call("app.bsky.notification.updateSeen", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr94(e);
+      throw toKnownErr95(e);
     });
   }
 };
@@ -249610,22 +249823,22 @@ var UnspeccedNS = class {
   }
   applyLabels(data, opts) {
     return this._service.xrpc.call("app.bsky.unspecced.applyLabels", opts?.qp, data, opts).catch((e) => {
-      throw toKnownErr95(e);
+      throw toKnownErr96(e);
     });
   }
   getPopular(params2, opts) {
     return this._service.xrpc.call("app.bsky.unspecced.getPopular", params2, void 0, opts).catch((e) => {
-      throw toKnownErr96(e);
+      throw toKnownErr97(e);
     });
   }
   getPopularFeedGenerators(params2, opts) {
     return this._service.xrpc.call("app.bsky.unspecced.getPopularFeedGenerators", params2, void 0, opts).catch((e) => {
-      throw toKnownErr97(e);
+      throw toKnownErr98(e);
     });
   }
   getTimelineSkeleton(params2, opts) {
     return this._service.xrpc.call("app.bsky.unspecced.getTimelineSkeleton", params2, void 0, opts).catch((e) => {
-      throw toKnownErr98(e);
+      throw toKnownErr99(e);
     });
   }
 };
@@ -251287,6 +251500,7 @@ var AtprotoNS2 = class {
     this.repo = new RepoNS2(server);
     this.server = new ServerNS2(server);
     this.sync = new SyncNS2(server);
+    this.temp = new TempNS2(server);
   }
 };
 var AdminNS2 = class {
@@ -251556,6 +251770,15 @@ var SyncNS2 = class {
     return this._server.xrpc.streamMethod(nsid2, cfg);
   }
 };
+var TempNS2 = class {
+  constructor(server) {
+    this._server = server;
+  }
+  upgradeRepoVersion(cfg) {
+    const nsid2 = "com.atproto.temp.upgradeRepoVersion";
+    return this._server.xrpc.method(nsid2, cfg);
+  }
+};
 var AppNS2 = class {
   constructor(server) {
     this._server = server;
@@ -253156,19 +253379,20 @@ function isMain5(v) {
 
 // src/services/local/index.ts
 var LocalService = class {
-  constructor(db, signingKey, appviewAgent, appviewDid, appviewCdnUrlPattern) {
+  constructor(db, signingKey, pdsHostname, appviewAgent, appviewDid, appviewCdnUrlPattern) {
     this.db = db;
     this.signingKey = signingKey;
+    this.pdsHostname = pdsHostname;
     this.appviewAgent = appviewAgent;
     this.appviewDid = appviewDid;
     this.appviewCdnUrlPattern = appviewCdnUrlPattern;
   }
-  static creator(signingKey, appviewAgent, appviewDid, appviewCdnUrlPattern) {
-    return (db) => new LocalService(db, signingKey, appviewAgent, appviewDid, appviewCdnUrlPattern);
+  static creator(signingKey, pdsHostname, appviewAgent, appviewDid, appviewCdnUrlPattern) {
+    return (db) => new LocalService(db, signingKey, pdsHostname, appviewAgent, appviewDid, appviewCdnUrlPattern);
   }
   getImageUrl(pattern, did2, cid2) {
     if (!this.appviewCdnUrlPattern) {
-      return "";
+      return `https://${this.pdsHostname}/xrpc/${ids.ComAtprotoSyncGetBlob}?did=${did2}&cid=${cid2}`;
     }
     return import_util98.default.format(this.appviewCdnUrlPattern, pattern, did2, cid2);
   }
@@ -253375,6 +253599,7 @@ function createServices(resources) {
   const {
     repoSigningKey,
     blobstore,
+    pdsHostname,
     appViewAgent,
     appViewDid,
     appViewCdnUrlPattern,
@@ -253386,7 +253611,7 @@ function createServices(resources) {
     auth: AuthService.creator(),
     record: RecordService.creator(),
     repo: RepoService.creator(repoSigningKey, blobstore, backgroundQueue, crawlers),
-    local: LocalService.creator(repoSigningKey, appViewAgent, appViewDid, appViewCdnUrlPattern),
+    local: LocalService.creator(repoSigningKey, pdsHostname, appViewAgent, appViewDid, appViewCdnUrlPattern),
     moderation: ModerationService.creator(blobstore)
   };
 }
@@ -254889,6 +255114,7 @@ var AppContext = class {
       repoSigningKey,
       blobstore,
       appViewAgent,
+      pdsHostname: cfg.service.hostname,
       appViewDid: cfg.bskyAppView.did,
       appViewCdnUrlPattern: cfg.bskyAppView.cdnUrlPattern,
       backgroundQueue,