@atproto/repo 0.3.6 → 0.3.8

package/dist/index.js

@@ -8866,30 +8866,292 @@ var require_dist = __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];
@@ -8911,7 +9173,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) {
       }
@@ -8927,7 +9189,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];
@@ -9050,8 +9312,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;
@@ -9062,9 +9327,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);
   }
 });
@@ -10846,7 +11111,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) {
@@ -10897,7 +11162,7 @@ var require_wait = __commonJS({
       };
       check2(1);
     }
-    module2.exports = { wait, waitDiff };
+    module2.exports = { wait: wait2, waitDiff };
   }
 });
 
@@ -10923,7 +11188,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
@@ -11148,7 +11413,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);
@@ -13151,6 +13416,7 @@ __export(src_exports4, {
   WriteOpAction: () => WriteOpAction,
   blocksToCarFile: () => blocksToCarFile,
   blocksToCarStream: () => blocksToCarStream,
+  carToBlocks: () => carToBlocks,
   cborToLex: () => cborToLex,
   cborToLexRecord: () => cborToLexRecord,
   cidForRecord: () => cidForRecord,
@@ -13159,6 +13425,8 @@ __export(src_exports4, {
   ensureCreates: () => ensureCreates,
   ensureV3Commit: () => ensureV3Commit,
   formatDataKey: () => formatDataKey,
+  getAndParseByDef: () => getAndParseByDef,
+  getAndParseRecord: () => getAndParseRecord,
   getFullRepo: () => getFullRepo,
   getRecords: () => getRecords,
   metaEqual: () => metaEqual,
@@ -13167,7 +13435,9 @@ __export(src_exports4, {
   nodeDataDef: () => nodeDataDef,
   nullDiff: () => nullDiff,
   parseDataKey: () => parseDataKey,
+  parseObjByDef: () => parseObjByDef,
   readCar: () => readCar,
+  readCarStream: () => readCarStream,
   readCarWithRoot: () => readCarWithRoot,
   schema: () => schema2,
   signCommit: () => signCommit,
@@ -22635,14 +22905,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({
@@ -23525,7 +23795,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));
@@ -23605,7 +23875,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;
     }
@@ -24801,9 +25071,12 @@ var UnexpectedObjectError = class extends Error {
   }
 };
 
+// src/util.ts
+var import_promises = require("node:timers/promises");
+
 // ../../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);
@@ -25013,13 +25286,15 @@ function asyncIterableReader(asyncIterable) {
   return chunkReader(readChunk);
 }
 
-// ../../node_modules/.pnpm/@ipld+car@3.2.3/node_modules/@ipld/car/esm/lib/reader-browser.js
-var CarReader = class {
-  constructor(version2, roots, blocks) {
+// ../../node_modules/.pnpm/@ipld+car@3.2.3/node_modules/@ipld/car/esm/lib/reader.js
+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._blocks = blocks;
-    this._keys = blocks.map((b) => b.cid.toString());
+    this._iterator = iterator;
   }
   get version() {
     return this._version;
@@ -25027,73 +25302,120 @@ var CarReader = class {
   async getRoots() {
     return this._roots;
   }
-  async has(key) {
-    return this._keys.indexOf(key.toString()) > -1;
-  }
-  async get(key) {
-    const index = this._keys.indexOf(key.toString());
-    return index > -1 ? this._blocks[index] : void 0;
-  }
-  async *blocks() {
-    for (const block of this._blocks) {
-      yield block;
-    }
-  }
-  async *cids() {
-    for (const block of this._blocks) {
-      yield block.cid;
-    }
+  [Symbol.asyncIterator]() {
+    return this._iterator;
   }
   static async fromBytes(bytes3) {
     if (!(bytes3 instanceof Uint8Array)) {
       throw new TypeError("fromBytes() requires a Uint8Array");
     }
-    return decodeReaderComplete(bytesReader(bytes3));
+    return decodeIndexerComplete(bytesReader(bytes3));
   }
   static async fromIterable(asyncIterable) {
     if (!asyncIterable || !(typeof asyncIterable[Symbol.asyncIterator] === "function")) {
       throw new TypeError("fromIterable() requires an async iterable");
     }
-    return decodeReaderComplete(asyncIterableReader(asyncIterable));
+    return decodeIndexerComplete(asyncIterableReader(asyncIterable));
   }
 };
-async function decodeReaderComplete(reader) {
+async function decodeIndexerComplete(reader) {
   const decoder2 = createDecoder(reader);
   const { version: version2, roots } = await decoder2.header();
-  const blocks = [];
-  for await (const block of decoder2.blocks()) {
-    blocks.push(block);
-  }
-  return new CarReader(version2, roots, blocks);
+  return new CarIndexer(version2, roots, decoder2.blocksIndex());
 }
 
-// ../../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 CarReader2 = class extends CarReader {
-  static async readRaw(fd, blockIndex) {
-    const { cid: cid2, blockLength, blockOffset } = blockIndex;
-    const bytes3 = new Uint8Array(blockLength);
-    let read3;
-    if (typeof fd === "number") {
-      read3 = (await fsread(fd, bytes3, 0, blockLength, blockOffset)).bytesRead;
-    } else if (typeof fd === "object" && typeof fd.read === "function") {
-      read3 = (await fd.read(bytes3, 0, blockLength, blockOffset)).bytesRead;
-    } else {
-      throw new TypeError("Bad fd");
+// ../../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 (read3 !== blockLength) {
-      throw new Error(`Failed to read entire block (${read3} instead of ${blockLength})`);
+    if (!this._iterable) {
+      throw new Error("Block iterable not found");
     }
+    this._decoded = true;
+    const iterable = this._iterable[Symbol.asyncIterator]();
     return {
-      cid: cid2,
-      bytes: bytes3
+      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);
@@ -25308,8 +25630,8 @@ function toRoots(roots) {
 }
 
 // ../../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);
 var CarWriter2 = class extends CarWriter {
   static async updateRootsInFile(fd, roots) {
     const chunkSize = 256;
@@ -25374,18 +25696,26 @@ var blocksToCarFile = (root, blocks) => {
   const carStream = blocksToCarStream(root, blocks);
   return streamToBuffer(carStream);
 };
-var readCar = async (bytes3) => {
-  const car = await CarReader2.fromBytes(bytes3);
+var carToBlocks = async (car) => {
   const roots = await car.getRoots();
   const blocks = new block_map_default();
-  for await (const block of verifyIncomingCarBlocks(car.blocks())) {
+  for await (const block of verifyIncomingCarBlocks(car)) {
     blocks.set(block.cid, block.bytes);
+    await (0, import_promises.setImmediate)();
   }
   return {
     roots,
     blocks
   };
 };
+var readCar = async (bytes3) => {
+  const car = await CarBlockIterator.fromBytes(bytes3);
+  return carToBlocks(car);
+};
+var readCarStream = async (stream) => {
+  const car = await CarBlockIterator.fromIterable(stream);
+  return carToBlocks(car);
+};
 var readCarWithRoot = async (bytes3) => {
   const { roots, blocks } = await readCar(bytes3);
   if (roots.length !== 1) {
@@ -25397,29 +25727,25 @@ var readCarWithRoot = async (bytes3) => {
     blocks
   };
 };
-var diffToWriteDescripts = (diff, blocks) => {
+var diffToWriteDescripts = (diff) => {
   return Promise.all([
     ...diff.addList().map(async (add) => {
       const { collection, rkey } = parseDataKey(add.key);
-      const value = await getAndParseRecord(blocks, add.cid);
       return {
         action: "create" /* Create */,
         collection,
         rkey,
-        cid: add.cid,
-        record: value.record
+        cid: add.cid
       };
     }),
     ...diff.updateList().map(async (upd) => {
       const { collection, rkey } = parseDataKey(upd.key);
-      const value = await getAndParseRecord(blocks, upd.cid);
       return {
         action: "update" /* Update */,
         collection,
         rkey,
         cid: upd.cid,
-        prev: upd.prev,
-        record: value.record
+        prev: upd.prev
       };
     }),
     ...diff.deleteList().map((del) => {
@@ -26390,6 +26716,13 @@ var ReadableRepo = class {
   get version() {
     return this.commit.version;
   }
+  async *walkRecords(from3) {
+    for await (const leaf of this.data.walkLeavesFrom(from3 ?? "")) {
+      const { collection, rkey } = parseDataKey(leaf.key);
+      const record = await this.storage.readRecord(leaf.value);
+      yield { collection, rkey, cid: leaf.value, record };
+    }
+  }
   async getRecord(collection, rkey) {
     const dataKey = collection + "/" + rkey;
     const cid2 = await this.data.get(dataKey);
@@ -26532,6 +26865,29 @@ var Repo = class extends ReadableRepo {
     const commit2 = await this.formatCommit(toWrite, keypair);
     return this.applyCommit(commit2);
   }
+  async formatResignCommit(rev, keypair) {
+    const commit2 = await signCommit({
+      did: this.did,
+      version: 3,
+      rev,
+      prev: null,
+      data: this.commit.data
+    }, keypair);
+    const newBlocks = new block_map_default();
+    const commitCid = await newBlocks.add(commit2);
+    return {
+      cid: commitCid,
+      rev,
+      since: null,
+      prev: null,
+      newBlocks,
+      removedCids: new cid_set_default([this.cid])
+    };
+  }
+  async resignCommit(rev, keypair) {
+    const formatted = await this.formatResignCommit(rev, keypair);
+    return this.applyCommit(formatted);
+  }
 };
 
 // src/storage/readable-blockstore.ts
@@ -26575,6 +26931,7 @@ var MemoryBlockstore = class extends readable_blockstore_default {
   constructor(blocks) {
     super();
     this.root = null;
+    this.rev = null;
     this.blocks = new block_map_default();
     if (blocks) {
       this.blocks.addMap(blocks);
@@ -26598,8 +26955,9 @@ var MemoryBlockstore = class extends readable_blockstore_default {
   async putMany(blocks) {
     this.blocks.addMap(blocks);
   }
-  async updateRoot(cid2) {
+  async updateRoot(cid2, rev) {
     this.root = cid2;
+    this.rev = rev;
   }
   async applyCommit(commit2) {
     this.root = commit2.cid;
@@ -26660,27 +27018,28 @@ var verifyRepoCar = async (carBytes, did2, signingKey) => {
   const car = await readCarWithRoot(carBytes);
   return verifyRepo(car.blocks, car.root, did2, signingKey);
 };
-var verifyRepo = async (blocks, head, did2, signingKey) => {
-  const diff = await verifyDiff(null, blocks, head, did2, signingKey);
+var verifyRepo = async (blocks, head, did2, signingKey, opts) => {
+  const diff = await verifyDiff(null, blocks, head, did2, signingKey, opts);
   const creates = ensureCreates(diff.writes);
   return {
     creates,
     commit: diff.commit
   };
 };
-var verifyDiffCar = async (repo, carBytes, did2, signingKey) => {
+var verifyDiffCar = async (repo, carBytes, did2, signingKey, opts) => {
   const car = await readCarWithRoot(carBytes);
-  return verifyDiff(repo, car.blocks, car.root, did2, signingKey);
+  return verifyDiff(repo, car.blocks, car.root, did2, signingKey, opts);
 };
-var verifyDiff = async (repo, updateBlocks, updateRoot, did2, signingKey) => {
+var verifyDiff = async (repo, updateBlocks, updateRoot, did2, signingKey, opts) => {
+  const { ensureLeaves = true } = opts ?? {};
   const stagedStorage = new MemoryBlockstore(updateBlocks);
   const updateStorage = repo ? new SyncStorage(stagedStorage, repo.storage) : stagedStorage;
   const updated = await verifyRepoRoot(updateStorage, updateRoot, did2, signingKey);
   const diff = await data_diff_default.of(updated.data, repo?.data ?? null);
-  const writes = await diffToWriteDescripts(diff, updateBlocks);
+  const writes = await diffToWriteDescripts(diff);
   const newBlocks = diff.newMstBlocks;
   const leaves = updateBlocks.getMany(diff.newLeafCids.toList());
-  if (leaves.missing.length > 0) {
+  if (leaves.missing.length > 0 && ensureLeaves) {
     throw new Error(`missing leaf blocks: ${leaves.missing}`);
   }
   newBlocks.addMap(leaves.blocks);
@@ -26826,6 +27185,7 @@ var getRecords = (storage, commitCid, paths) => {
   WriteOpAction,
   blocksToCarFile,
   blocksToCarStream,
+  carToBlocks,
   cborToLex,
   cborToLexRecord,
   cidForRecord,
@@ -26834,6 +27194,8 @@ var getRecords = (storage, commitCid, paths) => {
   ensureCreates,
   ensureV3Commit,
   formatDataKey,
+  getAndParseByDef,
+  getAndParseRecord,
   getFullRepo,
   getRecords,
   metaEqual,
@@ -26842,7 +27204,9 @@ var getRecords = (storage, commitCid, paths) => {
   nodeDataDef,
   nullDiff,
   parseDataKey,
+  parseObjByDef,
   readCar,
+  readCarStream,
   readCarWithRoot,
   schema,
   signCommit,