@atproto/aws 0.1.6 → 0.1.8

package/dist/index.js

@@ -91867,30 +91867,292 @@ var require_dist2 = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/node-gyp-build-optional-packages@5.0.3/node_modules/node-gyp-build-optional-packages/index.js
+// ../../node_modules/.pnpm/detect-libc@2.0.2/node_modules/detect-libc/lib/process.js
+var require_process = __commonJS({
+  "../../node_modules/.pnpm/detect-libc@2.0.2/node_modules/detect-libc/lib/process.js"(exports, module2) {
+    "use strict";
+    var isLinux = () => process.platform === "linux";
+    var report = null;
+    var getReport = () => {
+      if (!report) {
+        report = isLinux() && process.report ? process.report.getReport() : {};
+      }
+      return report;
+    };
+    module2.exports = { isLinux, getReport };
+  }
+});
+
+// ../../node_modules/.pnpm/detect-libc@2.0.2/node_modules/detect-libc/lib/filesystem.js
+var require_filesystem = __commonJS({
+  "../../node_modules/.pnpm/detect-libc@2.0.2/node_modules/detect-libc/lib/filesystem.js"(exports, module2) {
+    "use strict";
+    var fs3 = require("fs");
+    var LDD_PATH = "/usr/bin/ldd";
+    var readFileSync = (path) => fs3.readFileSync(path, "utf-8");
+    var readFile = (path) => new Promise((resolve, reject) => {
+      fs3.readFile(path, "utf-8", (err, data) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(data);
+        }
+      });
+    });
+    module2.exports = {
+      LDD_PATH,
+      readFileSync,
+      readFile
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/detect-libc@2.0.2/node_modules/detect-libc/lib/detect-libc.js
+var require_detect_libc = __commonJS({
+  "../../node_modules/.pnpm/detect-libc@2.0.2/node_modules/detect-libc/lib/detect-libc.js"(exports, module2) {
+    "use strict";
+    var childProcess = require("child_process");
+    var { isLinux, getReport } = require_process();
+    var { LDD_PATH, readFile, readFileSync } = require_filesystem();
+    var cachedFamilyFilesystem;
+    var cachedVersionFilesystem;
+    var command = "getconf GNU_LIBC_VERSION 2>&1 || true; ldd --version 2>&1 || true";
+    var commandOut = "";
+    var safeCommand = () => {
+      if (!commandOut) {
+        return new Promise((resolve) => {
+          childProcess.exec(command, (err, out) => {
+            commandOut = err ? " " : out;
+            resolve(commandOut);
+          });
+        });
+      }
+      return commandOut;
+    };
+    var safeCommandSync = () => {
+      if (!commandOut) {
+        try {
+          commandOut = childProcess.execSync(command, { encoding: "utf8" });
+        } catch (_err) {
+          commandOut = " ";
+        }
+      }
+      return commandOut;
+    };
+    var GLIBC = "glibc";
+    var RE_GLIBC_VERSION = /GLIBC\s(\d+\.\d+)/;
+    var MUSL = "musl";
+    var GLIBC_ON_LDD = GLIBC.toUpperCase();
+    var MUSL_ON_LDD = MUSL.toLowerCase();
+    var isFileMusl = (f) => f.includes("libc.musl-") || f.includes("ld-musl-");
+    var familyFromReport = () => {
+      const report = getReport();
+      if (report.header && report.header.glibcVersionRuntime) {
+        return GLIBC;
+      }
+      if (Array.isArray(report.sharedObjects)) {
+        if (report.sharedObjects.some(isFileMusl)) {
+          return MUSL;
+        }
+      }
+      return null;
+    };
+    var familyFromCommand = (out) => {
+      const [getconf, ldd1] = out.split(/[\r\n]+/);
+      if (getconf && getconf.includes(GLIBC)) {
+        return GLIBC;
+      }
+      if (ldd1 && ldd1.includes(MUSL)) {
+        return MUSL;
+      }
+      return null;
+    };
+    var getFamilyFromLddContent = (content) => {
+      if (content.includes(MUSL_ON_LDD)) {
+        return MUSL;
+      }
+      if (content.includes(GLIBC_ON_LDD)) {
+        return GLIBC;
+      }
+      return null;
+    };
+    var familyFromFilesystem = async () => {
+      if (cachedFamilyFilesystem !== void 0) {
+        return cachedFamilyFilesystem;
+      }
+      cachedFamilyFilesystem = null;
+      try {
+        const lddContent = await readFile(LDD_PATH);
+        cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
+      } catch (e) {
+      }
+      return cachedFamilyFilesystem;
+    };
+    var familyFromFilesystemSync = () => {
+      if (cachedFamilyFilesystem !== void 0) {
+        return cachedFamilyFilesystem;
+      }
+      cachedFamilyFilesystem = null;
+      try {
+        const lddContent = readFileSync(LDD_PATH);
+        cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
+      } catch (e) {
+      }
+      return cachedFamilyFilesystem;
+    };
+    var family = async () => {
+      let family2 = null;
+      if (isLinux()) {
+        family2 = await familyFromFilesystem();
+        if (!family2) {
+          family2 = familyFromReport();
+        }
+        if (!family2) {
+          const out = await safeCommand();
+          family2 = familyFromCommand(out);
+        }
+      }
+      return family2;
+    };
+    var familySync = () => {
+      let family2 = null;
+      if (isLinux()) {
+        family2 = familyFromFilesystemSync();
+        if (!family2) {
+          family2 = familyFromReport();
+        }
+        if (!family2) {
+          const out = safeCommandSync();
+          family2 = familyFromCommand(out);
+        }
+      }
+      return family2;
+    };
+    var isNonGlibcLinux = async () => isLinux() && await family() !== GLIBC;
+    var isNonGlibcLinuxSync = () => isLinux() && familySync() !== GLIBC;
+    var versionFromFilesystem = async () => {
+      if (cachedVersionFilesystem !== void 0) {
+        return cachedVersionFilesystem;
+      }
+      cachedVersionFilesystem = null;
+      try {
+        const lddContent = await readFile(LDD_PATH);
+        const versionMatch = lddContent.match(RE_GLIBC_VERSION);
+        if (versionMatch) {
+          cachedVersionFilesystem = versionMatch[1];
+        }
+      } catch (e) {
+      }
+      return cachedVersionFilesystem;
+    };
+    var versionFromFilesystemSync = () => {
+      if (cachedVersionFilesystem !== void 0) {
+        return cachedVersionFilesystem;
+      }
+      cachedVersionFilesystem = null;
+      try {
+        const lddContent = readFileSync(LDD_PATH);
+        const versionMatch = lddContent.match(RE_GLIBC_VERSION);
+        if (versionMatch) {
+          cachedVersionFilesystem = versionMatch[1];
+        }
+      } catch (e) {
+      }
+      return cachedVersionFilesystem;
+    };
+    var versionFromReport = () => {
+      const report = getReport();
+      if (report.header && report.header.glibcVersionRuntime) {
+        return report.header.glibcVersionRuntime;
+      }
+      return null;
+    };
+    var versionSuffix = (s) => s.trim().split(/\s+/)[1];
+    var versionFromCommand = (out) => {
+      const [getconf, ldd1, ldd2] = out.split(/[\r\n]+/);
+      if (getconf && getconf.includes(GLIBC)) {
+        return versionSuffix(getconf);
+      }
+      if (ldd1 && ldd2 && ldd1.includes(MUSL)) {
+        return versionSuffix(ldd2);
+      }
+      return null;
+    };
+    var version2 = async () => {
+      let version3 = null;
+      if (isLinux()) {
+        version3 = await versionFromFilesystem();
+        if (!version3) {
+          version3 = versionFromReport();
+        }
+        if (!version3) {
+          const out = await safeCommand();
+          version3 = versionFromCommand(out);
+        }
+      }
+      return version3;
+    };
+    var versionSync = () => {
+      let version3 = null;
+      if (isLinux()) {
+        version3 = versionFromFilesystemSync();
+        if (!version3) {
+          version3 = versionFromReport();
+        }
+        if (!version3) {
+          const out = safeCommandSync();
+          version3 = versionFromCommand(out);
+        }
+      }
+      return version3;
+    };
+    module2.exports = {
+      GLIBC,
+      MUSL,
+      family,
+      familySync,
+      isNonGlibcLinux,
+      isNonGlibcLinuxSync,
+      version: version2,
+      versionSync
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/node-gyp-build-optional-packages@5.1.1/node_modules/node-gyp-build-optional-packages/index.js
 var require_node_gyp_build_optional_packages = __commonJS({
-  "../../node_modules/.pnpm/node-gyp-build-optional-packages@5.0.3/node_modules/node-gyp-build-optional-packages/index.js"(exports, module2) {
+  "../../node_modules/.pnpm/node-gyp-build-optional-packages@5.1.1/node_modules/node-gyp-build-optional-packages/index.js"(exports, module2) {
     var fs3 = require("fs");
     var path = require("path");
-    var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : require;
+    var url = require("url");
     var vars = process.config && process.config.variables || {};
     var prebuildsOnly = !!process.env.PREBUILDS_ONLY;
-    var abi = process.versions.modules;
+    var versions = process.versions;
+    var abi = versions.modules;
+    if (versions.deno || process.isBun) {
+      abi = "unsupported";
+    }
     var runtime = isElectron() ? "electron" : "node";
     var arch = process.arch;
     var platform = process.platform;
-    var libc = process.env.LIBC || (isAlpine(platform) ? "musl" : "glibc");
+    var libc = process.env.LIBC || (isMusl(platform) ? "musl" : "glibc");
     var armv = process.env.ARM_VERSION || (arch === "arm64" ? "8" : vars.arm_version) || "";
-    var uv = (process.versions.uv || "").split(".")[0];
+    var uv = (versions.uv || "").split(".")[0];
     module2.exports = load;
     function load(dir) {
-      return runtimeRequire(load.path(dir));
+      if (typeof __webpack_require__ === "function")
+        return __non_webpack_require__(load.path(dir));
+      else
+        return require(load.path(dir));
     }
     load.path = function(dir) {
       dir = path.resolve(dir || ".");
-      var packageName;
+      var packageName = "";
       try {
-        packageName = runtimeRequire(path.join(dir, "package.json")).name;
+        if (typeof __webpack_require__ === "function")
+          packageName = __non_webpack_require__(path.join(dir, "package.json")).name;
+        else
+          packageName = require(path.join(dir, "package.json")).name;
         var varName = packageName.toUpperCase().replace(/-/g, "_") + "_PREBUILD";
         if (process.env[varName])
           dir = process.env[varName];
@@ -91912,7 +92174,7 @@ var require_node_gyp_build_optional_packages = __commonJS({
         return nearby;
       var platformPackage = (packageName[0] == "@" ? "" : "@" + packageName + "/") + packageName + "-" + platform + "-" + arch;
       try {
-        var prebuildPackage = path.dirname(require("module").createRequire(path.join(dir, "package.json")).resolve(platformPackage));
+        var prebuildPackage = path.dirname(require("module").createRequire(url.pathToFileURL(path.join(dir, "package.json"))).resolve(platformPackage));
         return resolveFile(prebuildPackage);
       } catch (error) {
       }
@@ -91928,7 +92190,7 @@ var require_node_gyp_build_optional_packages = __commonJS({
         process.versions.electron ? "electron=" + process.versions.electron : "",
         typeof __webpack_require__ === "function" ? "webpack=true" : ""
       ].filter(Boolean).join(" ");
-      throw new Error("No native build was found for " + target2 + "\n    loaded from: " + dir + " and package: " + platformPackage + "\n");
+      throw new Error("No native build was found for " + target2 + "\n    attempted loading from: " + dir + " and package: " + platformPackage + "\n");
       function resolve(dir2) {
         var tuples = readdirSync(path.join(dir2, "prebuilds")).map(parseTuple);
         var tuple = tuples.filter(matchTuple(platform, arch)).sort(compareTuples)[0];
@@ -92051,8 +92313,11 @@ var require_node_gyp_build_optional_packages = __commonJS({
         return true;
       return typeof window !== "undefined" && window.process && window.process.type === "renderer";
     }
-    function isAlpine(platform2) {
-      return platform2 === "linux" && fs3.existsSync("/etc/alpine-release");
+    function isMusl(platform2) {
+      if (platform2 !== "linux")
+        return false;
+      const { familySync, MUSL } = require_detect_libc();
+      return familySync() === MUSL;
     }
     load.parseTags = parseTags;
     load.matchTags = matchTags;
@@ -92063,9 +92328,9 @@ var require_node_gyp_build_optional_packages = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/cbor-extract@2.1.1/node_modules/cbor-extract/index.js
+// ../../node_modules/.pnpm/cbor-extract@2.2.0/node_modules/cbor-extract/index.js
 var require_cbor_extract = __commonJS({
-  "../../node_modules/.pnpm/cbor-extract@2.1.1/node_modules/cbor-extract/index.js"(exports, module2) {
+  "../../node_modules/.pnpm/cbor-extract@2.2.0/node_modules/cbor-extract/index.js"(exports, module2) {
     module2.exports = require_node_gyp_build_optional_packages()(__dirname);
   }
 });
@@ -93847,7 +94112,7 @@ var require_wait = __commonJS({
   "../../node_modules/.pnpm/thread-stream@2.4.0/node_modules/thread-stream/lib/wait.js"(exports, module2) {
     "use strict";
     var MAX_TIMEOUT = 1e3;
-    function wait(state, index, expected, timeout, done) {
+    function wait2(state, index, expected, timeout, done) {
       const max = Date.now() + timeout;
       let current = Atomics.load(state, index);
       if (current === expected) {
@@ -93898,7 +94163,7 @@ var require_wait = __commonJS({
       };
       check2(1);
     }
-    module2.exports = { wait, waitDiff };
+    module2.exports = { wait: wait2, waitDiff };
   }
 });
 
@@ -93924,7 +94189,7 @@ var require_thread_stream = __commonJS({
     var { Worker } = require("worker_threads");
     var { join } = require("path");
     var { pathToFileURL } = require("url");
-    var { wait } = require_wait();
+    var { wait: wait2 } = require_wait();
     var {
       WRITE_INDEX,
       READ_INDEX
@@ -94149,7 +94414,7 @@ var require_thread_stream = __commonJS({
           return;
         }
         const writeIndex = Atomics.load(this[kImpl].state, WRITE_INDEX);
-        wait(this[kImpl].state, READ_INDEX, writeIndex, Infinity, (err, res) => {
+        wait2(this[kImpl].state, READ_INDEX, writeIndex, Infinity, (err, res) => {
           if (err) {
             destroy(this, err);
             process.nextTick(cb, err);
@@ -136581,7 +136846,7 @@ function weierstrassPoints(opts) {
     const a = point.toAffine();
     return concatBytes2(Uint8Array.from([4]), Fp3.toBytes(a.x), Fp3.toBytes(a.y));
   });
-  const fromBytes = CURVE.fromBytes || ((bytes3) => {
+  const fromBytes2 = CURVE.fromBytes || ((bytes3) => {
     const tail = bytes3.subarray(1);
     const x = Fp3.fromBytes(tail.subarray(0, Fp3.BYTES));
     const y = Fp3.fromBytes(tail.subarray(Fp3.BYTES, 2 * Fp3.BYTES));
@@ -136661,7 +136926,7 @@ function weierstrassPoints(opts) {
       return points.map((p, i) => p.toAffine(toInv[i])).map(Point2.fromAffine);
     }
     static fromHex(hex) {
-      const P = Point2.fromAffine(fromBytes(ensureBytes("pointHex", hex)));
+      const P = Point2.fromAffine(fromBytes2(ensureBytes("pointHex", hex)));
       P.assertValidity();
       return P;
     }
@@ -143965,8 +144230,134 @@ function sortMapEntries(entries, options) {
 }
 
 // ../../node_modules/.pnpm/cborg@1.10.2/node_modules/cborg/esm/lib/decode.js
+var defaultDecodeOptions = {
+  strict: false,
+  allowIndefinite: true,
+  allowUndefined: true,
+  allowBigInt: true
+};
+var Tokeniser = class {
+  constructor(data, options = {}) {
+    this.pos = 0;
+    this.data = data;
+    this.options = options;
+  }
+  done() {
+    return this.pos >= this.data.length;
+  }
+  next() {
+    const byt = this.data[this.pos];
+    let token = quick[byt];
+    if (token === void 0) {
+      const decoder2 = jump[byt];
+      if (!decoder2) {
+        throw new Error(`${decodeErrPrefix} no decoder for major type ${byt >>> 5} (byte 0x${byt.toString(16).padStart(2, "0")})`);
+      }
+      const minor = byt & 31;
+      token = decoder2(this.data, this.pos, minor, this.options);
+    }
+    this.pos += token.encodedLength;
+    return token;
+  }
+};
 var DONE = Symbol.for("DONE");
 var BREAK = Symbol.for("BREAK");
+function tokenToArray(token, tokeniser, options) {
+  const arr = [];
+  for (let i = 0; i < token.value; i++) {
+    const value = tokensToObject(tokeniser, options);
+    if (value === BREAK) {
+      if (token.value === Infinity) {
+        break;
+      }
+      throw new Error(`${decodeErrPrefix} got unexpected break to lengthed array`);
+    }
+    if (value === DONE) {
+      throw new Error(`${decodeErrPrefix} found array but not enough entries (got ${i}, expected ${token.value})`);
+    }
+    arr[i] = value;
+  }
+  return arr;
+}
+function tokenToMap(token, tokeniser, options) {
+  const useMaps = options.useMaps === true;
+  const obj = useMaps ? void 0 : {};
+  const m = useMaps ? /* @__PURE__ */ new Map() : void 0;
+  for (let i = 0; i < token.value; i++) {
+    const key = tokensToObject(tokeniser, options);
+    if (key === BREAK) {
+      if (token.value === Infinity) {
+        break;
+      }
+      throw new Error(`${decodeErrPrefix} got unexpected break to lengthed map`);
+    }
+    if (key === DONE) {
+      throw new Error(`${decodeErrPrefix} found map but not enough entries (got ${i} [no key], expected ${token.value})`);
+    }
+    if (useMaps !== true && typeof key !== "string") {
+      throw new Error(`${decodeErrPrefix} non-string keys not supported (got ${typeof key})`);
+    }
+    if (options.rejectDuplicateMapKeys === true) {
+      if (useMaps && m.has(key) || !useMaps && key in obj) {
+        throw new Error(`${decodeErrPrefix} found repeat map key "${key}"`);
+      }
+    }
+    const value = tokensToObject(tokeniser, options);
+    if (value === DONE) {
+      throw new Error(`${decodeErrPrefix} found map but not enough entries (got ${i} [no value], expected ${token.value})`);
+    }
+    if (useMaps) {
+      m.set(key, value);
+    } else {
+      obj[key] = value;
+    }
+  }
+  return useMaps ? m : obj;
+}
+function tokensToObject(tokeniser, options) {
+  if (tokeniser.done()) {
+    return DONE;
+  }
+  const token = tokeniser.next();
+  if (token.type === Type.break) {
+    return BREAK;
+  }
+  if (token.type.terminal) {
+    return token.value;
+  }
+  if (token.type === Type.array) {
+    return tokenToArray(token, tokeniser, options);
+  }
+  if (token.type === Type.map) {
+    return tokenToMap(token, tokeniser, options);
+  }
+  if (token.type === Type.tag) {
+    if (options.tags && typeof options.tags[token.value] === "function") {
+      const tagged = tokensToObject(tokeniser, options);
+      return options.tags[token.value](tagged);
+    }
+    throw new Error(`${decodeErrPrefix} tag not supported (${token.value})`);
+  }
+  throw new Error("unsupported");
+}
+function decode6(data, options) {
+  if (!(data instanceof Uint8Array)) {
+    throw new Error(`${decodeErrPrefix} data to decode must be a Uint8Array`);
+  }
+  options = Object.assign({}, defaultDecodeOptions, options);
+  const tokeniser = options.tokenizer || new Tokeniser(data, options);
+  const decoded = tokensToObject(tokeniser, options);
+  if (decoded === DONE) {
+    throw new Error(`${decodeErrPrefix} did not find any content to decode`);
+  }
+  if (decoded === BREAK) {
+    throw new Error(`${decodeErrPrefix} got unexpected break`);
+  }
+  if (!tokeniser.done()) {
+    throw new Error(`${decodeErrPrefix} too many terminals, data makes no sense`);
+  }
+  return decoded;
+}
 
 // ../../node_modules/.pnpm/@ipld+dag-cbor@7.0.3/node_modules/@ipld/dag-cbor/esm/index.js
 var CID_CBOR_TAG = 42;
@@ -143987,6 +144378,7 @@ var decodeOptions = {
   tags: []
 };
 decodeOptions.tags[CID_CBOR_TAG] = cidDecoder;
+var decode7 = (data) => decode6(data, decodeOptions);
 
 // ../../node_modules/.pnpm/cbor-x@1.5.1/node_modules/cbor-x/decode.js
 var decoder;
@@ -146274,14 +146666,14 @@ var unsignedCommit = z.object({
   version: z.literal(3),
   data: schema.cid,
   rev: z.string(),
-  prev: schema.cid.nullable().optional()
+  prev: schema.cid.nullable()
 });
 var commit = z.object({
   did: z.string(),
   version: z.literal(3),
   data: schema.cid,
   rev: z.string(),
-  prev: schema.cid.nullable().optional(),
+  prev: schema.cid.nullable(),
   sig: schema.bytes
 });
 var legacyV2Commit = z.object({
@@ -146316,17 +146708,346 @@ var def2 = {
 
 // ../../node_modules/.pnpm/@ipld+car@3.2.3/node_modules/@ipld/car/esm/lib/reader.js
 var import_fs = __toESM(require("fs"), 1);
-var import_util7 = require("util");
+var import_util8 = require("util");
 
 // ../../node_modules/.pnpm/@ipld+car@3.2.3/node_modules/@ipld/car/esm/lib/decoder.js
 var import_varint2 = __toESM(require_varint(), 1);
+var CIDV0_BYTES = {
+  SHA2_256: 18,
+  LENGTH: 32,
+  DAG_PB: 112
+};
+async function readVarint(reader) {
+  const bytes3 = await reader.upTo(8);
+  const i = import_varint2.default.decode(bytes3);
+  reader.seek(import_varint2.default.decode.bytes);
+  return i;
+}
+async function readHeader(reader) {
+  const length2 = await readVarint(reader);
+  if (length2 === 0) {
+    throw new Error("Invalid CAR header (zero length)");
+  }
+  const header = await reader.exactly(length2);
+  reader.seek(length2);
+  const block = decode7(header);
+  if (block == null || Array.isArray(block) || typeof block !== "object") {
+    throw new Error("Invalid CAR header format");
+  }
+  if (block.version !== 1) {
+    if (typeof block.version === "string") {
+      throw new Error(`Invalid CAR version: "${block.version}"`);
+    }
+    throw new Error(`Invalid CAR version: ${block.version}`);
+  }
+  if (!Array.isArray(block.roots)) {
+    throw new Error("Invalid CAR header format");
+  }
+  if (Object.keys(block).filter((p) => p !== "roots" && p !== "version").length) {
+    throw new Error("Invalid CAR header format");
+  }
+  return block;
+}
+async function readMultihash(reader) {
+  const bytes3 = await reader.upTo(8);
+  import_varint2.default.decode(bytes3);
+  const codeLength = import_varint2.default.decode.bytes;
+  const length2 = import_varint2.default.decode(bytes3.subarray(import_varint2.default.decode.bytes));
+  const lengthLength = import_varint2.default.decode.bytes;
+  const mhLength = codeLength + lengthLength + length2;
+  const multihash = await reader.exactly(mhLength);
+  reader.seek(mhLength);
+  return multihash;
+}
+async function readCid(reader) {
+  const first = await reader.exactly(2);
+  if (first[0] === CIDV0_BYTES.SHA2_256 && first[1] === CIDV0_BYTES.LENGTH) {
+    const bytes4 = await reader.exactly(34);
+    reader.seek(34);
+    const multihash2 = decode5(bytes4);
+    return CID.create(0, CIDV0_BYTES.DAG_PB, multihash2);
+  }
+  const version2 = await readVarint(reader);
+  if (version2 !== 1) {
+    throw new Error(`Unexpected CID version (${version2})`);
+  }
+  const codec = await readVarint(reader);
+  const bytes3 = await readMultihash(reader);
+  const multihash = decode5(bytes3);
+  return CID.create(version2, codec, multihash);
+}
+async function readBlockHead(reader) {
+  const start = reader.pos;
+  let length2 = await readVarint(reader);
+  if (length2 === 0) {
+    throw new Error("Invalid CAR section (zero length)");
+  }
+  length2 += reader.pos - start;
+  const cid2 = await readCid(reader);
+  const blockLength = length2 - (reader.pos - start);
+  return {
+    cid: cid2,
+    length: length2,
+    blockLength
+  };
+}
+async function readBlock(reader) {
+  const { cid: cid2, blockLength } = await readBlockHead(reader);
+  const bytes3 = await reader.exactly(blockLength);
+  reader.seek(blockLength);
+  return {
+    bytes: bytes3,
+    cid: cid2
+  };
+}
+async function readBlockIndex(reader) {
+  const offset = reader.pos;
+  const { cid: cid2, length: length2, blockLength } = await readBlockHead(reader);
+  const index = {
+    cid: cid2,
+    length: length2,
+    blockLength,
+    offset,
+    blockOffset: reader.pos
+  };
+  reader.seek(index.blockLength);
+  return index;
+}
+function createDecoder(reader) {
+  const headerPromise = readHeader(reader);
+  return {
+    header: () => headerPromise,
+    async *blocks() {
+      await headerPromise;
+      while ((await reader.upTo(8)).length > 0) {
+        yield await readBlock(reader);
+      }
+    },
+    async *blocksIndex() {
+      await headerPromise;
+      while ((await reader.upTo(8)).length > 0) {
+        yield await readBlockIndex(reader);
+      }
+    }
+  };
+}
+function bytesReader(bytes3) {
+  let pos = 0;
+  return {
+    async upTo(length2) {
+      return bytes3.subarray(pos, pos + Math.min(length2, bytes3.length - pos));
+    },
+    async exactly(length2) {
+      if (length2 > bytes3.length - pos) {
+        throw new Error("Unexpected end of data");
+      }
+      return bytes3.subarray(pos, pos + length2);
+    },
+    seek(length2) {
+      pos += length2;
+    },
+    get pos() {
+      return pos;
+    }
+  };
+}
+function chunkReader(readChunk) {
+  let pos = 0;
+  let have = 0;
+  let offset = 0;
+  let currentChunk = new Uint8Array(0);
+  const read3 = async (length2) => {
+    have = currentChunk.length - offset;
+    const bufa = [currentChunk.subarray(offset)];
+    while (have < length2) {
+      const chunk = await readChunk();
+      if (chunk == null) {
+        break;
+      }
+      if (have < 0) {
+        if (chunk.length > have) {
+          bufa.push(chunk.subarray(-have));
+        }
+      } else {
+        bufa.push(chunk);
+      }
+      have += chunk.length;
+    }
+    currentChunk = new Uint8Array(bufa.reduce((p, c) => p + c.length, 0));
+    let off = 0;
+    for (const b of bufa) {
+      currentChunk.set(b, off);
+      off += b.length;
+    }
+    offset = 0;
+  };
+  return {
+    async upTo(length2) {
+      if (currentChunk.length - offset < length2) {
+        await read3(length2);
+      }
+      return currentChunk.subarray(offset, offset + Math.min(currentChunk.length - offset, length2));
+    },
+    async exactly(length2) {
+      if (currentChunk.length - offset < length2) {
+        await read3(length2);
+      }
+      if (currentChunk.length - offset < length2) {
+        throw new Error("Unexpected end of data");
+      }
+      return currentChunk.subarray(offset, offset + length2);
+    },
+    seek(length2) {
+      pos += length2;
+      offset += length2;
+    },
+    get pos() {
+      return pos;
+    }
+  };
+}
+function asyncIterableReader(asyncIterable) {
+  const iterator = asyncIterable[Symbol.asyncIterator]();
+  async function readChunk() {
+    const next = await iterator.next();
+    if (next.done) {
+      return null;
+    }
+    return next.value;
+  }
+  return chunkReader(readChunk);
+}
 
 // ../../node_modules/.pnpm/@ipld+car@3.2.3/node_modules/@ipld/car/esm/lib/reader.js
-var fsread = (0, import_util7.promisify)(import_fs.default.read);
+var fsread = (0, import_util8.promisify)(import_fs.default.read);
+
+// ../../node_modules/.pnpm/@ipld+car@3.2.3/node_modules/@ipld/car/esm/lib/indexer.js
+var CarIndexer = class {
+  constructor(version2, roots, iterator) {
+    this._version = version2;
+    this._roots = roots;
+    this._iterator = iterator;
+  }
+  get version() {
+    return this._version;
+  }
+  async getRoots() {
+    return this._roots;
+  }
+  [Symbol.asyncIterator]() {
+    return this._iterator;
+  }
+  static async fromBytes(bytes3) {
+    if (!(bytes3 instanceof Uint8Array)) {
+      throw new TypeError("fromBytes() requires a Uint8Array");
+    }
+    return decodeIndexerComplete(bytesReader(bytes3));
+  }
+  static async fromIterable(asyncIterable) {
+    if (!asyncIterable || !(typeof asyncIterable[Symbol.asyncIterator] === "function")) {
+      throw new TypeError("fromIterable() requires an async iterable");
+    }
+    return decodeIndexerComplete(asyncIterableReader(asyncIterable));
+  }
+};
+async function decodeIndexerComplete(reader) {
+  const decoder2 = createDecoder(reader);
+  const { version: version2, roots } = await decoder2.header();
+  return new CarIndexer(version2, roots, decoder2.blocksIndex());
+}
+
+// ../../node_modules/.pnpm/@ipld+car@3.2.3/node_modules/@ipld/car/esm/lib/iterator.js
+var CarIteratorBase = class {
+  constructor(version2, roots, iterable) {
+    this._version = version2;
+    this._roots = roots;
+    this._iterable = iterable;
+    this._decoded = false;
+  }
+  get version() {
+    return this._version;
+  }
+  async getRoots() {
+    return this._roots;
+  }
+};
+var CarBlockIterator = class extends CarIteratorBase {
+  [Symbol.asyncIterator]() {
+    if (this._decoded) {
+      throw new Error("Cannot decode more than once");
+    }
+    if (!this._iterable) {
+      throw new Error("Block iterable not found");
+    }
+    this._decoded = true;
+    return this._iterable[Symbol.asyncIterator]();
+  }
+  static async fromBytes(bytes3) {
+    const { version: version2, roots, iterator } = await fromBytes(bytes3);
+    return new CarBlockIterator(version2, roots, iterator);
+  }
+  static async fromIterable(asyncIterable) {
+    const { version: version2, roots, iterator } = await fromIterable(asyncIterable);
+    return new CarBlockIterator(version2, roots, iterator);
+  }
+};
+var CarCIDIterator = class extends CarIteratorBase {
+  [Symbol.asyncIterator]() {
+    if (this._decoded) {
+      throw new Error("Cannot decode more than once");
+    }
+    if (!this._iterable) {
+      throw new Error("Block iterable not found");
+    }
+    this._decoded = true;
+    const iterable = this._iterable[Symbol.asyncIterator]();
+    return {
+      async next() {
+        const next = await iterable.next();
+        if (next.done) {
+          return next;
+        }
+        return {
+          done: false,
+          value: next.value.cid
+        };
+      }
+    };
+  }
+  static async fromBytes(bytes3) {
+    const { version: version2, roots, iterator } = await fromBytes(bytes3);
+    return new CarCIDIterator(version2, roots, iterator);
+  }
+  static async fromIterable(asyncIterable) {
+    const { version: version2, roots, iterator } = await fromIterable(asyncIterable);
+    return new CarCIDIterator(version2, roots, iterator);
+  }
+};
+async function fromBytes(bytes3) {
+  if (!(bytes3 instanceof Uint8Array)) {
+    throw new TypeError("fromBytes() requires a Uint8Array");
+  }
+  return decodeIterator(bytesReader(bytes3));
+}
+async function fromIterable(asyncIterable) {
+  if (!asyncIterable || !(typeof asyncIterable[Symbol.asyncIterator] === "function")) {
+    throw new TypeError("fromIterable() requires an async iterable");
+  }
+  return decodeIterator(asyncIterableReader(asyncIterable));
+}
+async function decodeIterator(reader) {
+  const decoder2 = createDecoder(reader);
+  const { version: version2, roots } = await decoder2.header();
+  return {
+    version: version2,
+    roots,
+    iterator: decoder2.blocks()
+  };
+}
 
 // ../../node_modules/.pnpm/@ipld+car@3.2.3/node_modules/@ipld/car/esm/lib/writer.js
 var import_fs2 = __toESM(require("fs"), 1);
-var import_util8 = require("util");
+var import_util9 = require("util");
 
 // ../../node_modules/.pnpm/@ipld+car@3.2.3/node_modules/@ipld/car/esm/lib/encoder.js
 var import_varint3 = __toESM(require_varint(), 1);
@@ -146346,8 +147067,8 @@ var CarWriterOut = class {
 };
 
 // ../../node_modules/.pnpm/@ipld+car@3.2.3/node_modules/@ipld/car/esm/lib/writer.js
-var fsread2 = (0, import_util8.promisify)(import_fs2.default.read);
-var fswrite = (0, import_util8.promisify)(import_fs2.default.write);
+var fsread2 = (0, import_util9.promisify)(import_fs2.default.read);
+var fswrite = (0, import_util9.promisify)(import_fs2.default.write);
 
 // ../repo/src/mst/mst.ts
 var subTreePointer = z.nullable(schema.cid);
@@ -146371,7 +147092,8 @@ var BlobNotFoundError = class extends Error {
 
 // src/s3.ts
 var S3BlobStore = class {
-  constructor(cfg) {
+  constructor(did2, cfg) {
+    this.did = did2;
     const { bucket, ...rest } = cfg;
     this.bucket = bucket;
     this.client = new aws2.S3({
@@ -146379,17 +147101,22 @@ var S3BlobStore = class {
       apiVersion: "2006-03-01"
     });
   }
+  static creator(cfg) {
+    return (did2) => {
+      return new S3BlobStore(did2, cfg);
+    };
+  }
   genKey() {
     return randomStr(32, "base32");
   }
   getTmpPath(key) {
-    return `tmp/${key}`;
+    return `tmp/${this.did}/${key}`;
   }
   getStoredPath(cid2) {
-    return `blocks/${cid2.toString()}`;
+    return `blocks/${this.did}/${cid2.toString()}`;
   }
   getQuarantinedPath(cid2) {
-    return `quarantine/${cid2.toString()}`;
+    return `quarantine/${this.did}/${cid2.toString()}`;
   }
   async putTemp(bytes3) {
     const key = this.genKey();
@@ -146458,11 +147185,21 @@ var S3BlobStore = class {
   async delete(cid2) {
     await this.deleteKey(this.getStoredPath(cid2));
   }
+  async deleteMany(cids) {
+    const keys = cids.map((cid2) => this.getStoredPath(cid2));
+    await this.deleteManyKeys(keys);
+  }
   async hasStored(cid2) {
+    return this.hasKey(this.getStoredPath(cid2));
+  }
+  async hasTemp(key) {
+    return this.hasKey(this.getTmpPath(key));
+  }
+  async hasKey(key) {
     try {
       const res = await this.client.headObject({
         Bucket: this.bucket,
-        Key: this.getStoredPath(cid2)
+        Key: key
       });
       return res.$metadata.httpStatusCode === 200;
     } catch (err) {
@@ -146475,17 +147212,36 @@ var S3BlobStore = class {
       Key: key
     });
   }
-  async move(keys) {
-    await this.client.copyObject({
+  async deleteManyKeys(keys) {
+    await this.client.deleteObjects({
       Bucket: this.bucket,
-      CopySource: `${this.bucket}/${keys.from}`,
-      Key: keys.to
-    });
-    await this.client.deleteObject({
-      Bucket: this.bucket,
-      Key: keys.from
+      Delete: {
+        Objects: keys.map((k) => ({ Key: k }))
+      }
     });
   }
+  async move(keys) {
+    try {
+      await this.client.copyObject({
+        Bucket: this.bucket,
+        CopySource: `${this.bucket}/${keys.from}`,
+        Key: keys.to
+      });
+      await this.client.deleteObject({
+        Bucket: this.bucket,
+        Key: keys.from
+      });
+    } catch (err) {
+      handleErr(err);
+    }
+  }
+};
+var handleErr = (err) => {
+  if (err?.["Code"] === "NoSuchKey") {
+    throw new BlobNotFoundError();
+  } else {
+    throw err;
+  }
 };
 
 // src/cloudfront.ts