@wovin/core 0.1.35 → 0.2.0

package/dist/chunk-WXLCBTHX.min.js

@@ -1,1606 +0,0 @@
-import {
-  keepTruthy
-} from "./chunk-QPGEBDMJ.min.js";
-import {
-  lastWriteWins
-} from "./chunk-COXXILXC.min.js";
-import {
-  CID as CID2,
-  areCidsEqual,
-  decode as decode3,
-  encodeBlockOriginal,
-  ensureTsPvAndFinalizeApplog,
-  g,
-  getLogsFromThread,
-  prepareForPub,
-  rollingFilter,
-  src_exports,
-  wrapper_default
-} from "./chunk-GDX2OO7L.min.js";
-import {
-  CID,
-  Token,
-  Type,
-  decode,
-  decode2,
-  encode,
-  makeCborEncoders
-} from "./chunk-QO2KMGDN.min.js";
-import {
-  __commonJS,
-  __toESM
-} from "./chunk-PHITDXZT.min.js";
-
-// ../../../node_modules/.pnpm/varint@6.0.0/node_modules/varint/encode.js
-var require_encode = __commonJS({
-  "../../../node_modules/.pnpm/varint@6.0.0/node_modules/varint/encode.js"(exports, module) {
-    "use strict";
-    module.exports = encode3;
-    var MSB = 128;
-    var REST = 127;
-    var MSBALL = ~REST;
-    var INT = Math.pow(2, 31);
-    function encode3(num, out, offset) {
-      if (Number.MAX_SAFE_INTEGER && num > Number.MAX_SAFE_INTEGER) {
-        encode3.bytes = 0;
-        throw new RangeError("Could not encode varint");
-      }
-      out = out || [];
-      offset = offset || 0;
-      var oldOffset = offset;
-      while (num >= INT) {
-        out[offset++] = num & 255 | MSB;
-        num /= 128;
-      }
-      while (num & MSBALL) {
-        out[offset++] = num & 255 | MSB;
-        num >>>= 7;
-      }
-      out[offset] = num | 0;
-      encode3.bytes = offset - oldOffset + 1;
-      return out;
-    }
-  }
-});
-
-// ../../../node_modules/.pnpm/varint@6.0.0/node_modules/varint/decode.js
-var require_decode = __commonJS({
-  "../../../node_modules/.pnpm/varint@6.0.0/node_modules/varint/decode.js"(exports, module) {
-    "use strict";
-    module.exports = read;
-    var MSB = 128;
-    var REST = 127;
-    function read(buf, offset) {
-      var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf.length;
-      do {
-        if (counter >= l || shift > 49) {
-          read.bytes = 0;
-          throw new RangeError("Could not decode varint");
-        }
-        b = buf[counter++];
-        res += shift < 28 ? (b & REST) << shift : (b & REST) * Math.pow(2, shift);
-        shift += 7;
-      } while (b >= MSB);
-      read.bytes = counter - offset;
-      return res;
-    }
-  }
-});
-
-// ../../../node_modules/.pnpm/varint@6.0.0/node_modules/varint/length.js
-var require_length = __commonJS({
-  "../../../node_modules/.pnpm/varint@6.0.0/node_modules/varint/length.js"(exports, module) {
-    "use strict";
-    var N1 = Math.pow(2, 7);
-    var N2 = Math.pow(2, 14);
-    var N3 = Math.pow(2, 21);
-    var N4 = Math.pow(2, 28);
-    var N5 = Math.pow(2, 35);
-    var N6 = Math.pow(2, 42);
-    var N7 = Math.pow(2, 49);
-    var N8 = Math.pow(2, 56);
-    var N9 = Math.pow(2, 63);
-    module.exports = function(value) {
-      return value < N1 ? 1 : value < N2 ? 2 : value < N3 ? 3 : value < N4 ? 4 : value < N5 ? 5 : value < N6 ? 6 : value < N7 ? 7 : value < N8 ? 8 : value < N9 ? 9 : 10;
-    };
-  }
-});
-
-// ../../../node_modules/.pnpm/varint@6.0.0/node_modules/varint/index.js
-var require_varint = __commonJS({
-  "../../../node_modules/.pnpm/varint@6.0.0/node_modules/varint/index.js"(exports, module) {
-    "use strict";
-    module.exports = {
-      encode: require_encode(),
-      decode: require_decode(),
-      encodingLength: require_length()
-    };
-  }
-});
-
-// ../../../node_modules/.pnpm/@ipld+dag-cbor@9.2.5/node_modules/@ipld/dag-cbor/src/index.js
-var CID_CBOR_TAG = 42;
-function toByteView(buf) {
-  if (buf instanceof ArrayBuffer) {
-    return new Uint8Array(buf, 0, buf.byteLength);
-  }
-  return buf;
-}
-function cidEncoder(obj) {
-  if (obj.asCID !== obj && obj["/"] !== obj.bytes) {
-    return null;
-  }
-  const cid = CID.asCID(obj);
-  if (!cid) {
-    return null;
-  }
-  const bytes = new Uint8Array(cid.bytes.byteLength + 1);
-  bytes.set(cid.bytes, 1);
-  return [
-    new Token(Type.tag, CID_CBOR_TAG),
-    new Token(Type.bytes, bytes)
-  ];
-}
-function undefinedEncoder() {
-  throw new Error("`undefined` is not supported by the IPLD Data Model and cannot be encoded");
-}
-function numberEncoder(num) {
-  if (Number.isNaN(num)) {
-    throw new Error("`NaN` is not supported by the IPLD Data Model and cannot be encoded");
-  }
-  if (num === Infinity || num === -Infinity) {
-    throw new Error("`Infinity` and `-Infinity` is not supported by the IPLD Data Model and cannot be encoded");
-  }
-  return null;
-}
-function mapEncoder(map) {
-  for (const key of map.keys()) {
-    if (typeof key !== "string" || key.length === 0) {
-      throw new Error("Non-string Map keys are not supported by the IPLD Data Model and cannot be encoded");
-    }
-  }
-  return null;
-}
-var _encodeOptions = {
-  float64: true,
-  typeEncoders: {
-    Map: mapEncoder,
-    Object: cidEncoder,
-    undefined: undefinedEncoder,
-    number: numberEncoder
-  }
-};
-var encodeOptions = {
-  ..._encodeOptions,
-  typeEncoders: {
-    ..._encodeOptions.typeEncoders
-  }
-};
-function cidDecoder(bytes) {
-  if (bytes[0] !== 0) {
-    throw new Error("Invalid CID for CBOR tag 42; expected leading 0x00");
-  }
-  return CID.decode(bytes.subarray(1));
-}
-var _decodeOptions = {
-  allowIndefinite: false,
-  coerceUndefinedToNull: true,
-  allowNaN: false,
-  allowInfinity: false,
-  allowBigInt: true,
-  // this will lead to BigInt for ints outside of
-  // safe-integer range, which may surprise users
-  strict: true,
-  useMaps: false,
-  rejectDuplicateMapKeys: true,
-  /** @type {import('cborg').TagDecoder[]} */
-  tags: []
-};
-_decodeOptions.tags[CID_CBOR_TAG] = cidDecoder;
-var decodeOptions = {
-  ..._decodeOptions,
-  tags: _decodeOptions.tags.slice()
-};
-var encode2 = (node) => encode(node, _encodeOptions);
-var decode4 = (data) => decode(toByteView(data), _decodeOptions);
-
-// ../../../node_modules/.pnpm/@ipld+car@5.4.2/node_modules/@ipld/car/src/decoder-common.js
-var import_varint = __toESM(require_varint(), 1);
-var CIDV0_BYTES = {
-  SHA2_256: 18,
-  LENGTH: 32,
-  DAG_PB: 112
-};
-var V2_HEADER_LENGTH = (
-  /* characteristics */
-  16 + 8 + 8 + 8
-);
-function decodeVarint(bytes, seeker) {
-  if (!bytes.length) {
-    throw new Error("Unexpected end of data");
-  }
-  const i = import_varint.default.decode(bytes);
-  seeker.seek(
-    /** @type {number} */
-    import_varint.default.decode.bytes
-  );
-  return i;
-}
-function decodeV2Header(bytes) {
-  const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  let offset = 0;
-  const header = {
-    version: 2,
-    /** @type {[bigint, bigint]} */
-    characteristics: [
-      dv.getBigUint64(offset, true),
-      dv.getBigUint64(offset += 8, true)
-    ],
-    dataOffset: Number(dv.getBigUint64(offset += 8, true)),
-    dataSize: Number(dv.getBigUint64(offset += 8, true)),
-    indexOffset: Number(dv.getBigUint64(offset += 8, true))
-  };
-  return header;
-}
-function getMultihashLength(bytes) {
-  import_varint.default.decode(bytes);
-  const codeLength = (
-    /** @type {number} */
-    import_varint.default.decode.bytes
-  );
-  const length = import_varint.default.decode(bytes.subarray(import_varint.default.decode.bytes));
-  const lengthLength = (
-    /** @type {number} */
-    import_varint.default.decode.bytes
-  );
-  const mhLength = codeLength + lengthLength + length;
-  return mhLength;
-}
-
-// ../../../node_modules/.pnpm/@ipld+car@5.4.2/node_modules/@ipld/car/src/header-validator.js
-var Kinds = {
-  Null: (
-    /**
-     * @param obj
-     * @returns {undefined|null}
-     */
-    (obj) => obj === null ? obj : void 0
-  ),
-  Int: (
-    /**
-     * @param obj
-     * @returns {undefined|number}
-     */
-    (obj) => Number.isInteger(obj) ? obj : void 0
-  ),
-  Float: (
-    /**
-     * @param obj
-     * @returns {undefined|number}
-     */
-    (obj) => typeof obj === "number" && Number.isFinite(obj) ? obj : void 0
-  ),
-  String: (
-    /**
-     * @param obj
-     * @returns {undefined|string}
-     */
-    (obj) => typeof obj === "string" ? obj : void 0
-  ),
-  Bool: (
-    /**
-     * @param obj
-     * @returns {undefined|boolean}
-     */
-    (obj) => typeof obj === "boolean" ? obj : void 0
-  ),
-  Bytes: (
-    /**
-     * @param obj
-     * @returns {undefined|Uint8Array}
-     */
-    (obj) => obj instanceof Uint8Array ? obj : void 0
-  ),
-  Link: (
-    /**
-     * @param obj
-     * @returns {undefined|object}
-     */
-    (obj) => obj !== null && typeof obj === "object" && obj.asCID === obj ? obj : void 0
-  ),
-  List: (
-    /**
-     * @param obj
-     * @returns {undefined|Array<any>}
-     */
-    (obj) => Array.isArray(obj) ? obj : void 0
-  ),
-  Map: (
-    /**
-     * @param obj
-     * @returns {undefined|object}
-     */
-    (obj) => obj !== null && typeof obj === "object" && obj.asCID !== obj && !Array.isArray(obj) && !(obj instanceof Uint8Array) ? obj : void 0
-  )
-};
-var Types = {
-  "CarV1HeaderOrV2Pragma > roots (anon) > valueType (anon)": Kinds.Link,
-  "CarV1HeaderOrV2Pragma > roots (anon)": (
-    /**
-     * @param obj
-     * @returns {undefined|any}
-     */
-    (obj) => {
-      if (Kinds.List(obj) === void 0) {
-        return void 0;
-      }
-      for (let i = 0; i < obj.length; i++) {
-        let v = obj[i];
-        v = Types["CarV1HeaderOrV2Pragma > roots (anon) > valueType (anon)"](v);
-        if (v === void 0) {
-          return void 0;
-        }
-        if (v !== obj[i]) {
-          const ret = obj.slice(0, i);
-          for (let j = i; j < obj.length; j++) {
-            let v2 = obj[j];
-            v2 = Types["CarV1HeaderOrV2Pragma > roots (anon) > valueType (anon)"](v2);
-            if (v2 === void 0) {
-              return void 0;
-            }
-            ret.push(v2);
-          }
-          return ret;
-        }
-      }
-      return obj;
-    }
-  ),
-  Int: Kinds.Int,
-  CarV1HeaderOrV2Pragma: (
-    /**
-     * @param obj
-     * @returns {undefined|any}
-     */
-    (obj) => {
-      if (Kinds.Map(obj) === void 0) {
-        return void 0;
-      }
-      const entries = Object.entries(obj);
-      let ret = obj;
-      let requiredCount = 1;
-      for (let i = 0; i < entries.length; i++) {
-        const [key, value] = entries[i];
-        switch (key) {
-          case "roots":
-            {
-              const v = Types["CarV1HeaderOrV2Pragma > roots (anon)"](obj[key]);
-              if (v === void 0) {
-                return void 0;
-              }
-              if (v !== value || ret !== obj) {
-                if (ret === obj) {
-                  ret = {};
-                  for (let j = 0; j < i; j++) {
-                    ret[entries[j][0]] = entries[j][1];
-                  }
-                }
-                ret.roots = v;
-              }
-            }
-            break;
-          case "version":
-            {
-              requiredCount--;
-              const v = Types.Int(obj[key]);
-              if (v === void 0) {
-                return void 0;
-              }
-              if (v !== value || ret !== obj) {
-                if (ret === obj) {
-                  ret = {};
-                  for (let j = 0; j < i; j++) {
-                    ret[entries[j][0]] = entries[j][1];
-                  }
-                }
-                ret.version = v;
-              }
-            }
-            break;
-          default:
-            return void 0;
-        }
-      }
-      if (requiredCount > 0) {
-        return void 0;
-      }
-      return ret;
-    }
-  )
-};
-var Reprs = {
-  "CarV1HeaderOrV2Pragma > roots (anon) > valueType (anon)": Kinds.Link,
-  "CarV1HeaderOrV2Pragma > roots (anon)": (
-    /**
-     * @param obj
-     * @returns {undefined|any}
-     */
-    (obj) => {
-      if (Kinds.List(obj) === void 0) {
-        return void 0;
-      }
-      for (let i = 0; i < obj.length; i++) {
-        let v = obj[i];
-        v = Reprs["CarV1HeaderOrV2Pragma > roots (anon) > valueType (anon)"](v);
-        if (v === void 0) {
-          return void 0;
-        }
-        if (v !== obj[i]) {
-          const ret = obj.slice(0, i);
-          for (let j = i; j < obj.length; j++) {
-            let v2 = obj[j];
-            v2 = Reprs["CarV1HeaderOrV2Pragma > roots (anon) > valueType (anon)"](v2);
-            if (v2 === void 0) {
-              return void 0;
-            }
-            ret.push(v2);
-          }
-          return ret;
-        }
-      }
-      return obj;
-    }
-  ),
-  Int: Kinds.Int,
-  CarV1HeaderOrV2Pragma: (
-    /**
-     * @param obj
-     * @returns {undefined|any}
-     */
-    (obj) => {
-      if (Kinds.Map(obj) === void 0) {
-        return void 0;
-      }
-      const entries = Object.entries(obj);
-      let ret = obj;
-      let requiredCount = 1;
-      for (let i = 0; i < entries.length; i++) {
-        const [key, value] = entries[i];
-        switch (key) {
-          case "roots":
-            {
-              const v = Reprs["CarV1HeaderOrV2Pragma > roots (anon)"](value);
-              if (v === void 0) {
-                return void 0;
-              }
-              if (v !== value || ret !== obj) {
-                if (ret === obj) {
-                  ret = {};
-                  for (let j = 0; j < i; j++) {
-                    ret[entries[j][0]] = entries[j][1];
-                  }
-                }
-                ret.roots = v;
-              }
-            }
-            break;
-          case "version":
-            {
-              requiredCount--;
-              const v = Reprs.Int(value);
-              if (v === void 0) {
-                return void 0;
-              }
-              if (v !== value || ret !== obj) {
-                if (ret === obj) {
-                  ret = {};
-                  for (let j = 0; j < i; j++) {
-                    ret[entries[j][0]] = entries[j][1];
-                  }
-                }
-                ret.version = v;
-              }
-            }
-            break;
-          default:
-            return void 0;
-        }
-      }
-      if (requiredCount > 0) {
-        return void 0;
-      }
-      return ret;
-    }
-  )
-};
-var CarV1HeaderOrV2Pragma = {
-  toTyped: Types.CarV1HeaderOrV2Pragma,
-  toRepresentation: Reprs.CarV1HeaderOrV2Pragma
-};
-
-// ../../../node_modules/.pnpm/cborg@4.5.8/node_modules/cborg/lib/length.js
-var cborEncoders = makeCborEncoders();
-
-// ../../../node_modules/.pnpm/@ipld+car@5.4.2/node_modules/@ipld/car/src/buffer-writer.js
-var import_varint2 = __toESM(require_varint(), 1);
-var headerPreludeTokens = [
-  new Token(Type.map, 2),
-  new Token(Type.string, "version"),
-  new Token(Type.uint, 1),
-  new Token(Type.string, "roots")
-];
-var CID_TAG = new Token(Type.tag, 42);
-
-// ../../../node_modules/.pnpm/@ipld+car@5.4.2/node_modules/@ipld/car/src/decoder.js
-async function readHeader(reader, strictVersion) {
-  const length = decodeVarint(await reader.upTo(8), reader);
-  if (length === 0) {
-    throw new Error("Invalid CAR header (zero length)");
-  }
-  const header = await reader.exactly(length, true);
-  const block = decode4(header);
-  if (CarV1HeaderOrV2Pragma.toTyped(block) === void 0) {
-    throw new Error("Invalid CAR header format");
-  }
-  if (block.version !== 1 && block.version !== 2 || strictVersion !== void 0 && block.version !== strictVersion) {
-    throw new Error(`Invalid CAR version: ${block.version}${strictVersion !== void 0 ? ` (expected ${strictVersion})` : ""}`);
-  }
-  if (block.version === 1) {
-    if (!Array.isArray(block.roots)) {
-      throw new Error("Invalid CAR header format");
-    }
-    return block;
-  }
-  if (block.roots !== void 0) {
-    throw new Error("Invalid CAR header format");
-  }
-  const v2Header = decodeV2Header(await reader.exactly(V2_HEADER_LENGTH, true));
-  reader.seek(v2Header.dataOffset - reader.pos);
-  const v1Header = await readHeader(reader, 1);
-  return Object.assign(v1Header, v2Header);
-}
-async function readCid(reader) {
-  const first = await reader.exactly(2, false);
-  if (first[0] === CIDV0_BYTES.SHA2_256 && first[1] === CIDV0_BYTES.LENGTH) {
-    const bytes2 = await reader.exactly(34, true);
-    const multihash2 = decode2(bytes2);
-    return CID.create(0, CIDV0_BYTES.DAG_PB, multihash2);
-  }
-  const version = decodeVarint(await reader.upTo(8), reader);
-  if (version !== 1) {
-    throw new Error(`Unexpected CID version (${version})`);
-  }
-  const codec = decodeVarint(await reader.upTo(8), reader);
-  const bytes = await reader.exactly(getMultihashLength(await reader.upTo(8)), true);
-  const multihash = decode2(bytes);
-  return CID.create(version, codec, multihash);
-}
-async function readBlockHead(reader) {
-  const start = reader.pos;
-  let length = decodeVarint(await reader.upTo(8), reader);
-  if (length === 0) {
-    throw new Error("Invalid CAR section (zero length)");
-  }
-  length += reader.pos - start;
-  const cid = await readCid(reader);
-  const blockLength = length - Number(reader.pos - start);
-  return { cid, length, blockLength };
-}
-async function readBlock(reader) {
-  const { cid, blockLength } = await readBlockHead(reader);
-  const bytes = await reader.exactly(blockLength, true);
-  return { bytes, cid };
-}
-async function readBlockIndex(reader) {
-  const offset = reader.pos;
-  const { cid, length, blockLength } = await readBlockHead(reader);
-  const index = { cid, length, blockLength, offset, blockOffset: reader.pos };
-  reader.seek(index.blockLength);
-  return index;
-}
-function createDecoder(reader) {
-  const headerPromise = (async () => {
-    const header = await readHeader(reader);
-    if (header.version === 2) {
-      const v1length = reader.pos - header.dataOffset;
-      reader = limitReader(reader, header.dataSize - v1length);
-    }
-    return header;
-  })();
-  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(bytes) {
-  let pos = 0;
-  return {
-    async upTo(length) {
-      const out = bytes.subarray(pos, pos + Math.min(length, bytes.length - pos));
-      return out;
-    },
-    async exactly(length, seek = false) {
-      if (length > bytes.length - pos) {
-        throw new Error("Unexpected end of data");
-      }
-      const out = bytes.subarray(pos, pos + length);
-      if (seek) {
-        pos += length;
-      }
-      return out;
-    },
-    seek(length) {
-      pos += length;
-    },
-    get pos() {
-      return pos;
-    }
-  };
-}
-function chunkReader(readChunk) {
-  let pos = 0;
-  let have = 0;
-  let offset = 0;
-  let currentChunk = new Uint8Array(0);
-  const read = async (length) => {
-    have = currentChunk.length - offset;
-    const bufa = (
-      /** @type {Uint8Array<ArrayBufferLike>[]} */
-      [currentChunk.subarray(offset)]
-    );
-    while (have < length) {
-      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(length) {
-      if (currentChunk.length - offset < length) {
-        await read(length);
-      }
-      return currentChunk.subarray(offset, offset + Math.min(currentChunk.length - offset, length));
-    },
-    async exactly(length, seek = false) {
-      if (currentChunk.length - offset < length) {
-        await read(length);
-      }
-      if (currentChunk.length - offset < length) {
-        throw new Error("Unexpected end of data");
-      }
-      const out = currentChunk.subarray(offset, offset + length);
-      if (seek) {
-        pos += length;
-        offset += length;
-      }
-      return out;
-    },
-    seek(length) {
-      pos += length;
-      offset += length;
-    },
-    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);
-}
-function limitReader(reader, byteLimit) {
-  let bytesRead = 0;
-  return {
-    async upTo(length) {
-      let bytes = await reader.upTo(length);
-      if (bytes.length + bytesRead > byteLimit) {
-        bytes = bytes.subarray(0, byteLimit - bytesRead);
-      }
-      return bytes;
-    },
-    async exactly(length, seek = false) {
-      const bytes = await reader.exactly(length, seek);
-      if (bytes.length + bytesRead > byteLimit) {
-        throw new Error("Unexpected end of data");
-      }
-      if (seek) {
-        bytesRead += length;
-      }
-      return bytes;
-    },
-    seek(length) {
-      bytesRead += length;
-      reader.seek(length);
-    },
-    get pos() {
-      return reader.pos;
-    }
-  };
-}
-
-// ../../../node_modules/.pnpm/@ipld+car@5.4.2/node_modules/@ipld/car/src/reader-browser.js
-var CarReader = class {
-  /**
-   * @constructs CarReader
-   * @param {CarHeader|CarV2Header} header
-   * @param {Block[]} blocks
-   */
-  constructor(header, blocks) {
-    this._header = header;
-    this._blocks = blocks;
-    this._keys = blocks.map((b) => b.cid.toString());
-  }
-  /**
-   * @property
-   * @memberof CarReader
-   * @instance
-   */
-  get version() {
-    return this._header.version;
-  }
-  /**
-   * Get the list of roots defined by the CAR referenced by this reader. May be
-   * zero or more `CID`s.
-   *
-   * @function
-   * @memberof CarReader
-   * @instance
-   * @async
-   * @returns {Promise<CID[]>}
-   */
-  async getRoots() {
-    return this._header.roots;
-  }
-  /**
-   * Check whether a given `CID` exists within the CAR referenced by this
-   * reader.
-   *
-   * @function
-   * @memberof CarReader
-   * @instance
-   * @async
-   * @param {CID} key
-   * @returns {Promise<boolean>}
-   */
-  async has(key) {
-    return this._keys.indexOf(key.toString()) > -1;
-  }
-  /**
-   * Fetch a `Block` (a `{ cid:CID, bytes:Uint8Array }` pair) from the CAR
-   * referenced by this reader matching the provided `CID`. In the case where
-   * the provided `CID` doesn't exist within the CAR, `undefined` will be
-   * returned.
-   *
-   * @function
-   * @memberof CarReader
-   * @instance
-   * @async
-   * @param {CID} key
-   * @returns {Promise<Block | undefined>}
-   */
-  async get(key) {
-    const index = this._keys.indexOf(key.toString());
-    return index > -1 ? this._blocks[index] : void 0;
-  }
-  /**
-   * Returns a `BlockIterator` (`AsyncIterable<Block>`) that iterates over all
-   * of the `Block`s (`{ cid:CID, bytes:Uint8Array }` pairs) contained within
-   * the CAR referenced by this reader.
-   *
-   * @function
-   * @memberof CarReader
-   * @instance
-   * @async
-   * @generator
-   * @returns {AsyncGenerator<Block>}
-   */
-  async *blocks() {
-    for (const block of this._blocks) {
-      yield block;
-    }
-  }
-  /**
-   * Returns a `CIDIterator` (`AsyncIterable<CID>`) that iterates over all of
-   * the `CID`s contained within the CAR referenced by this reader.
-   *
-   * @function
-   * @memberof CarReader
-   * @instance
-   * @async
-   * @generator
-   * @returns {AsyncGenerator<CID>}
-   */
-  async *cids() {
-    for (const block of this._blocks) {
-      yield block.cid;
-    }
-  }
-  /**
-   * Instantiate a {@link CarReader} from a `Uint8Array` blob. This performs a
-   * decode fully in memory and maintains the decoded state in memory for full
-   * access to the data via the `CarReader` API.
-   *
-   * @async
-   * @static
-   * @memberof CarReader
-   * @param {Uint8Array} bytes
-   * @returns {Promise<CarReader>}
-   */
-  static async fromBytes(bytes) {
-    if (!(bytes instanceof Uint8Array)) {
-      throw new TypeError("fromBytes() requires a Uint8Array");
-    }
-    return decodeReaderComplete(bytesReader(bytes));
-  }
-  /**
-   * Instantiate a {@link CarReader} from a `AsyncIterable<Uint8Array>`, such as
-   * a [modern Node.js stream](https://nodejs.org/api/stream.html#stream_streams_compatibility_with_async_generators_and_async_iterators).
-   * This performs a decode fully in memory and maintains the decoded state in
-   * memory for full access to the data via the `CarReader` API.
-   *
-   * Care should be taken for large archives; this API may not be appropriate
-   * where memory is a concern or the archive is potentially larger than the
-   * amount of memory that the runtime can handle.
-   *
-   * @async
-   * @static
-   * @memberof CarReader
-   * @param {AsyncIterable<Uint8Array>} asyncIterable
-   * @returns {Promise<CarReader>}
-   */
-  static async fromIterable(asyncIterable) {
-    if (!asyncIterable || !(typeof asyncIterable[Symbol.asyncIterator] === "function")) {
-      throw new TypeError("fromIterable() requires an async iterable");
-    }
-    return decodeReaderComplete(asyncIterableReader(asyncIterable));
-  }
-};
-async function decodeReaderComplete(reader) {
-  const decoder = createDecoder(reader);
-  const header = await decoder.header();
-  const blocks = [];
-  for await (const block of decoder.blocks()) {
-    blocks.push(block);
-  }
-  return new CarReader(header, blocks);
-}
-
-// ../../../node_modules/.pnpm/@ipld+car@5.4.2/node_modules/@ipld/car/src/encoder.js
-var import_varint3 = __toESM(require_varint(), 1);
-var CAR_V1_VERSION = 1;
-function createHeader(roots) {
-  const headerBytes = encode2({ version: CAR_V1_VERSION, roots });
-  const varintBytes = import_varint3.default.encode(headerBytes.length);
-  const header = new Uint8Array(varintBytes.length + headerBytes.length);
-  header.set(varintBytes, 0);
-  header.set(headerBytes, varintBytes.length);
-  return header;
-}
-function createEncoder(writer) {
-  return {
-    /**
-     * @param {CID[]} roots
-     * @returns {Promise<void>}
-     */
-    async setRoots(roots) {
-      const bytes = createHeader(roots);
-      await writer.write(bytes);
-    },
-    /**
-     * @param {Block} block
-     * @returns {Promise<void>}
-     */
-    async writeBlock(block) {
-      const { cid, bytes } = block;
-      await writer.write(new Uint8Array(import_varint3.default.encode(cid.bytes.length + bytes.length)));
-      await writer.write(cid.bytes);
-      if (bytes.length) {
-        await writer.write(bytes);
-      }
-    },
-    /**
-     * @returns {Promise<void>}
-     */
-    async close() {
-      await writer.end();
-    },
-    /**
-     * @returns {number}
-     */
-    version() {
-      return CAR_V1_VERSION;
-    }
-  };
-}
-
-// ../../../node_modules/.pnpm/@ipld+car@5.4.2/node_modules/@ipld/car/src/iterator-channel.js
-function noop() {
-}
-function create() {
-  const chunkQueue = [];
-  let drainer = null;
-  let drainerResolver = noop;
-  let ended = false;
-  let outWait = null;
-  let outWaitResolver = noop;
-  const makeDrainer = () => {
-    if (!drainer) {
-      drainer = new Promise((resolve) => {
-        drainerResolver = () => {
-          drainer = null;
-          drainerResolver = noop;
-          resolve();
-        };
-      });
-    }
-    return drainer;
-  };
-  const writer = {
-    /**
-     * @param {T} chunk
-     * @returns {Promise<void>}
-     */
-    write(chunk) {
-      chunkQueue.push(chunk);
-      const drainer2 = makeDrainer();
-      outWaitResolver();
-      return drainer2;
-    },
-    async end() {
-      ended = true;
-      const drainer2 = makeDrainer();
-      outWaitResolver();
-      await drainer2;
-    }
-  };
-  const iterator = {
-    /** @returns {Promise<IteratorResult<T>>} */
-    async next() {
-      const chunk = chunkQueue.shift();
-      if (chunk) {
-        if (chunkQueue.length === 0) {
-          drainerResolver();
-        }
-        return { done: false, value: chunk };
-      }
-      if (ended) {
-        drainerResolver();
-        return { done: true, value: void 0 };
-      }
-      if (!outWait) {
-        outWait = new Promise((resolve) => {
-          outWaitResolver = () => {
-            outWait = null;
-            outWaitResolver = noop;
-            return resolve(iterator.next());
-          };
-        });
-      }
-      return outWait;
-    }
-  };
-  return { writer, iterator };
-}
-
-// ../../../node_modules/.pnpm/@ipld+car@5.4.2/node_modules/@ipld/car/src/writer-browser.js
-var CarWriter = class _CarWriter {
-  /**
-   * @param {CID[]} roots
-   * @param {CarEncoder} encoder
-   */
-  constructor(roots, encoder) {
-    this._encoder = encoder;
-    this._mutex = encoder.setRoots(roots);
-    this._ended = false;
-  }
-  /**
-   * Write a `Block` (a `{ cid:CID, bytes:Uint8Array }` pair) to the archive.
-   *
-   * @function
-   * @memberof CarWriter
-   * @instance
-   * @async
-   * @param {Block} block - A `{ cid:CID, bytes:Uint8Array }` pair.
-   * @returns {Promise<void>} The returned promise will only resolve once the
-   * bytes this block generates are written to the `out` iterable.
-   */
-  async put(block) {
-    if (!(block.bytes instanceof Uint8Array) || !block.cid) {
-      throw new TypeError("Can only write {cid, bytes} objects");
-    }
-    if (this._ended) {
-      throw new Error("Already closed");
-    }
-    const cid = CID.asCID(block.cid);
-    if (!cid) {
-      throw new TypeError("Can only write {cid, bytes} objects");
-    }
-    this._mutex = this._mutex.then(() => this._encoder.writeBlock({ cid, bytes: block.bytes }));
-    return this._mutex;
-  }
-  /**
-   * Finalise the CAR archive and signal that the `out` iterable should end once
-   * any remaining bytes are written.
-   *
-   * @function
-   * @memberof CarWriter
-   * @instance
-   * @async
-   * @returns {Promise<void>}
-   */
-  async close() {
-    if (this._ended) {
-      throw new Error("Already closed");
-    }
-    await this._mutex;
-    this._ended = true;
-    return this._encoder.close();
-  }
-  /**
-   * Returns the version number of the CAR file being written
-   *
-   * @returns {number}
-   */
-  version() {
-    return this._encoder.version();
-  }
-  /**
-   * Create a new CAR writer "channel" which consists of a
-   * `{ writer:CarWriter, out:AsyncIterable<Uint8Array> }` pair.
-   *
-   * @async
-   * @static
-   * @memberof CarWriter
-   * @param {CID[] | CID | void} roots
-   * @returns {WriterChannel} The channel takes the form of
-   * `{ writer:CarWriter, out:AsyncIterable<Uint8Array> }`.
-   */
-  static create(roots) {
-    roots = toRoots(roots);
-    const { encoder, iterator } = encodeWriter();
-    const writer = new _CarWriter(roots, encoder);
-    const out = new CarWriterOut(iterator);
-    return { writer, out };
-  }
-  /**
-   * Create a new CAR appender "channel" which consists of a
-   * `{ writer:CarWriter, out:AsyncIterable<Uint8Array> }` pair.
-   * This appender does not consider roots and does not produce a CAR header.
-   * It is designed to append blocks to an _existing_ CAR archive. It is
-   * expected that `out` will be concatenated onto the end of an existing
-   * archive that already has a properly formatted header.
-   *
-   * @async
-   * @static
-   * @memberof CarWriter
-   * @returns {WriterChannel} The channel takes the form of
-   * `{ writer:CarWriter, out:AsyncIterable<Uint8Array> }`.
-   */
-  static createAppender() {
-    const { encoder, iterator } = encodeWriter();
-    encoder.setRoots = () => Promise.resolve();
-    const writer = new _CarWriter([], encoder);
-    const out = new CarWriterOut(iterator);
-    return { writer, out };
-  }
-  /**
-   * Update the list of roots in the header of an existing CAR as represented
-   * in a Uint8Array.
-   *
-   * This operation is an _overwrite_, the total length of the CAR will not be
-   * modified. A rejection will occur if the new header will not be the same
-   * length as the existing header, in which case the CAR will not be modified.
-   * It is the responsibility of the user to ensure that the roots being
-   * replaced encode as the same length as the new roots.
-   *
-   * The byte array passed in an argument will be modified and also returned
-   * upon successful modification.
-   *
-   * @async
-   * @static
-   * @memberof CarWriter
-   * @param {Uint8Array} bytes
-   * @param {CID[]} roots - A new list of roots to replace the existing list in
-   * the CAR header. The new header must take up the same number of bytes as the
-   * existing header, so the roots should collectively be the same byte length
-   * as the existing roots.
-   * @returns {Promise<Uint8Array>}
-   */
-  static async updateRootsInBytes(bytes, roots) {
-    const reader = bytesReader(bytes);
-    await readHeader(reader);
-    const newHeader = createHeader(roots);
-    if (Number(reader.pos) !== newHeader.length) {
-      throw new Error(`updateRoots() can only overwrite a header of the same length (old header is ${reader.pos} bytes, new header is ${newHeader.length} bytes)`);
-    }
-    bytes.set(newHeader, 0);
-    return bytes;
-  }
-};
-var CarWriterOut = class {
-  /**
-   * @param {AsyncIterator<Uint8Array>} iterator
-   */
-  constructor(iterator) {
-    this._iterator = iterator;
-  }
-  [Symbol.asyncIterator]() {
-    if (this._iterating) {
-      throw new Error("Multiple iterator not supported");
-    }
-    this._iterating = true;
-    return this._iterator;
-  }
-};
-function encodeWriter() {
-  const iw = create();
-  const { writer, iterator } = iw;
-  const encoder = createEncoder(writer);
-  return { encoder, iterator };
-}
-function toRoots(roots) {
-  if (roots === void 0) {
-    return [];
-  }
-  if (!Array.isArray(roots)) {
-    const cid = CID.asCID(roots);
-    if (!cid) {
-      throw new TypeError("roots must be a single CID or an array of CIDs");
-    }
-    return [cid];
-  }
-  const _roots = [];
-  for (const root of roots) {
-    const _root = CID.asCID(root);
-    if (!_root) {
-      throw new TypeError("roots must be a single CID or an array of CIDs");
-    }
-    _roots.push(_root);
-  }
-  return _roots;
-}
-
-// src/ipfs/car.ts
-var { WARN, LOG, DEBUG, VERBOSE, ERROR } = g.setup(g.INFO);
-async function decodePubFromCar(car) {
-  const decoded = await getBlocksOfCar(car);
-  return await decodePubFromBlocks(decoded);
-}
-async function decodePubFromBlocks({ rootCID, blockStore }, _recursionTrace = [], stopAtCID) {
-  if (!rootCID || !blockStore) {
-    throw ERROR("Empty roots/blocks", { rootCID, blockStore });
-  }
-  let allApplogs = [];
-  let firstInfo = null;
-  let currentCID = rootCID;
-  const visited = /* @__PURE__ */ new Set();
-  let applogsCID = null;
-  while (currentCID) {
-    const cidStr = currentCID.toString();
-    if (visited.has(cidStr)) {
-      throw ERROR("[decodePubFromBlocks] pub chain has a loop", {
-        currentCID: cidStr,
-        visited: [...visited]
-      });
-    }
-    visited.add(cidStr);
-    const root = await getDecodedBlock(blockStore, currentCID);
-    VERBOSE(`[decodePubFromBlocks] root:`, cidStr, root, { blockStore });
-    if (!root) {
-      throw ERROR("[decodePubFromBlocks] root not found in blockStore", { blockStore, currentCID: cidStr });
-    }
-    let pubLogsArray;
-    if (root?.info) {
-      if (!applogsCID) applogsCID = root.applogs;
-      const applogsBlock = await getDecodedBlock(blockStore, root.applogs);
-      pubLogsArray = await unchunkApplogsBlock(applogsBlock, blockStore);
-      if (!firstInfo) {
-        firstInfo = await getDecodedBlock(blockStore, root.info);
-        DEBUG(`new format - infoLogs`, firstInfo.logs.map((l) => ({ [l.toString()]: l })));
-      }
-    } else {
-      pubLogsArray = root.applogs;
-    }
-    const resolveLogFromCidLink = async (cidOrLink) => {
-      const cid = cidOrLink;
-      const applog = await getDecodedBlock(blockStore, cid);
-      if (!applog) {
-        ERROR(`Could not find applog CID in pub blocks:`, cid.toString(), { cid, root, blockStore });
-        throw new Error(`Could not find applog CID in pub blocks: ${cid.toString()}`);
-      }
-      if (applog.pv instanceof CID2) applog.pv = applog.pv.toV1().toString();
-      return {
-        ...applog,
-        cid: cid.toV1().toString()
-      };
-    };
-    const snapshotApplogs = await Promise.all(pubLogsArray.map(resolveLogFromCidLink));
-    allApplogs = allApplogs.concat(snapshotApplogs);
-    if (!root.prev) {
-      break;
-    }
-    if (stopAtCID && areCidsEqual(root.prev, stopAtCID)) {
-      DEBUG("[decodePubFromBlocks] stopping at stopAtCID:", stopAtCID.toString());
-      break;
-    }
-    const prevBytes = await blockStore.get(root.prev);
-    if (!prevBytes) {
-      throw ERROR("[decodePubFromBlocks] prev snapshot missing from blockStore", {
-        currentCID: cidStr,
-        prev: root.prev.toString(),
-        stopAtCID: stopAtCID?.toString(),
-        visited: [...visited]
-      });
-    }
-    currentCID = root.prev;
-  }
-  const result = {
-    cid: rootCID,
-    info: firstInfo ? {
-      ...firstInfo,
-      logs: await Promise.all(firstInfo.logs.map(async (cidOrLink) => {
-        const cid = cidOrLink;
-        const applog = await getDecodedBlock(blockStore, cid);
-        if (!applog) {
-          ERROR(`Could not find info log CID in pub blocks:`, cid.toString(), { cid, blockStore });
-          throw new Error(`Could not find info log CID in pub blocks: ${cid.toString()}`);
-        }
-        if (applog.pv instanceof CID2) applog.pv = applog.pv.toV1().toString();
-        return {
-          ...applog,
-          cid: cid.toV1().toString()
-        };
-      }))
-    } : null,
-    applogsCID,
-    applogs: allApplogs
-  };
-  DEBUG("[decodePubFromBlocks] result:", result, { rootCID: rootCID.toString(), blockStore, applogs: allApplogs });
-  return result;
-}
-async function getBlocksOfCar(car) {
-  const rootsFromCar = await car.getRoots();
-  const roots = rootsFromCar.map((c) => (typeof c.toV1 === "function" ? c : CID2.decode(c.bytes)).toV1().toString());
-  const blocks = /* @__PURE__ */ new Map();
-  for await (const { cid: cidFromCarblocks, bytes } of car.blocks()) {
-    const cid = typeof cidFromCarblocks.toV1 === "function" ? cidFromCarblocks : CID2.decode(cidFromCarblocks.bytes);
-    VERBOSE({ cidFromCarblocks, cid });
-    blocks.set(cid.toV1().toString(), bytes);
-  }
-  if (roots.length !== 1) {
-    WARN("Unexpected roots count:", roots);
-  }
-  return {
-    rootCID: CID2.parse(roots[0]),
-    blockStore: {
-      get: (cid) => blocks.get(cid.toV1().toString())
-    }
-  };
-}
-async function getDecodedBlock(blockStore, cid) {
-  try {
-    var blob = await blockStore.get(cid);
-    if (!blob) {
-      WARN("returning null");
-      return null;
-    }
-  } catch (err) {
-    if (err.message === "Not Found") return null;
-    throw err;
-  }
-  return decode3(blob);
-}
-async function makeCarOut(roots, blocks) {
-  const { writer, out } = CarWriter.create(Array.isArray(roots) ? roots : [roots]);
-  VERBOSE(`Writing ${blocks.length} blocks to CAR`, { roots, blocks });
-  blocks.forEach((b) => writer.put(b));
-  writer.close();
-  return out;
-}
-async function makeCarBlob(roots, blocks) {
-  const carOut = await makeCarOut(roots, blocks);
-  const chunks = [];
-  for await (const chunk of carOut) {
-    chunks.push(chunk);
-  }
-  const blob = new Blob(chunks);
-  return blob;
-}
-async function carFromBlob(blob) {
-  return CarReader.fromBytes(new Uint8Array(await blob.arrayBuffer()));
-}
-function extractCids(value) {
-  if (value instanceof CID2) return [value];
-  if (Array.isArray(value)) return value.flatMap(extractCids);
-  if (value && typeof value === "object") return Object.values(value).flatMap(extractCids);
-  return [];
-}
-var MAX_COLLECT_BLOCKS = 1e6;
-async function collectDagBlocks(startCID, blockStore) {
-  const visited = /* @__PURE__ */ new Set();
-  const blocks = [];
-  const queue = [startCID];
-  while (queue.length > 0) {
-    if (blocks.length >= MAX_COLLECT_BLOCKS) {
-      WARN(`[collectDagBlocks] hit ${MAX_COLLECT_BLOCKS} block limit, returning partial result`);
-      break;
-    }
-    const cid = queue.shift();
-    const cidStr = cid.toString();
-    if (visited.has(cidStr)) continue;
-    visited.add(cidStr);
-    let bytes;
-    try {
-      bytes = await blockStore.get(cid);
-    } catch {
-      WARN(`[collectDagBlocks] block not found: ${cidStr}, stopping this branch`);
-      continue;
-    }
-    if (!bytes) {
-      WARN(`[collectDagBlocks] block not found: ${cidStr}, stopping this branch`);
-      continue;
-    }
-    blocks.push({ cid, bytes });
-    if (blocks.length % 1e3 === 0) {
-      LOG(`[collectDagBlocks] collected ${blocks.length} blocks...`);
-    }
-    try {
-      const decoded = decode3(bytes);
-      const childCids = extractCids(decoded);
-      for (const child of childCids) {
-        if (!visited.has(child.toString())) {
-          queue.push(child);
-        }
-      }
-    } catch {
-    }
-  }
-  DEBUG(`[collectDagBlocks] collected ${blocks.length} blocks from ${startCID.toString()}`);
-  return blocks;
-}
-function streamReaderToIterable(bodyReader) {
-  return (async function* () {
-    while (true) {
-      const { done, value } = await bodyReader.read();
-      VERBOSE(`[car] chunk`, { done, value });
-      if (done) {
-        break;
-      }
-      yield value;
-    }
-  })();
-}
-
-// src/pubsub/snap-push.ts
-var { WARN: WARN2, LOG: LOG2, DEBUG: DEBUG2, VERBOSE: VERBOSE2, ERROR: ERROR2 } = g.setup(g.INFO);
-async function prepareSnapshotForPush(agent, appThread, threadToPublish, share, prevSnapCID, prevCounter) {
-  if (prevCounter !== null && !prevSnapCID) {
-    throw ERROR2("[prepareSnapshotForPush] prevCounter provided without prevSnapCID");
-  }
-  let logsToPublish = getLogsFromThread(threadToPublish);
-  DEBUG2(`[preparePubForPush] Collected ${logsToPublish.length} logs :`, {
-    logsToPublish,
-    threadOrLogsCount: threadToPublish.nameAndSizeUntracked || `[${threadToPublish.length}]`
-  });
-  const { sharedAgents, sharedKeyMap, sharedKey, pubCounter } = share ?? {};
-  const getExistingOrNewLog = (thread, share2, ag, at, vl) => {
-    let logInQuestion = rollingFilter(lastWriteWins(thread), { en: share2.id, at }).latestLog;
-    if (!logInQuestion && vl !== void 0) {
-      logInQuestion = ensureTsPvAndFinalizeApplog({ ag, en: share2.id, at, vl }, thread);
-    }
-    return logInQuestion;
-  };
-  const shareNameLog = getExistingOrNewLog(appThread, share, agent.ag, "share/name", share.name);
-  const shareCounterLog = getExistingOrNewLog(appThread, share, agent.ag, "share/counter", `${agent.did}<::>${pubCounter}`);
-  const encryptApplog = async (applog, keyToUse) => {
-    const { log: eachLog, cid } = prepareForPub(applog);
-    const enc = new TextEncoder();
-    const stringified = wrapper_default(eachLog);
-    const stringifiedEncodedAppLogPayload = enc.encode(stringified);
-    VERBOSE2("[odd]", { eachLog, stringified, stringifiedEncodedAppLogPayload });
-    try {
-      const encPayload = await agent.crypto?.aes.encrypt(stringifiedEncodedAppLogPayload, keyToUse, "AES-GCM");
-      VERBOSE2("[odd] encrypted length:", stringifiedEncodedAppLogPayload.length, { encPayload });
-      return encPayload;
-    } catch (err) {
-      throw ERROR2("FAILED TO ENC payload length:", stringifiedEncodedAppLogPayload.length, { err });
-    }
-  };
-  let maybeEncryptedApplogs;
-  const encryptedApplogs = [];
-  const agentSharedKeyLogs = [];
-  if (sharedAgents) {
-    if (!sharedKey || !sharedKeyMap) {
-      throw ERROR2("sharedAgents but no Keys/Map", { sharedAgents, sharedKeyMap, sharedKey });
-    }
-    VERBOSE2("encrypting", { sharedAgents, sharedKeyMap });
-    for (const [eachAgent, eachEncKey] of Array.from(sharedKeyMap.entries())) {
-      VERBOSE2("adding key", { eachAgent, eachEncKey });
-      agentSharedKeyLogs.push({
-        ag: agent.ag,
-        en: eachAgent,
-        at: "share/sharedKey",
-        vl: eachEncKey
-        // these are encrypted with the derived key from the local agent private and remote agent public keys
-      });
-    }
-    const CIDlist = [];
-    const pubCIDmap = {};
-    for (const eachLog of logsToPublish) {
-      VERBOSE2("[crypto] encrypting ", { eachLog, sharedKey });
-      const encPayload = await encryptApplog(eachLog, sharedKey);
-      DEBUG2("[crypto] encrypted ", { eachLog, encPayload, sharedKey });
-      encryptedApplogs.push({ enc: encPayload });
-    }
-    maybeEncryptedApplogs = encryptedApplogs;
-  } else {
-    maybeEncryptedApplogs = logsToPublish;
-  }
-  DEBUG2("adding all agent info and shareAtoms", {
-    share,
-    agent,
-    logsToPublish,
-    // threadToPublish, - very verbose
-    agentSharedKeyLogs
-  });
-  const infoLogs = [
-    ...rollingFilter(lastWriteWins(appThread), {
-      // TODO: use static filter for performance
-      en: agent.ag,
-      at: ["agent/ecdh", "agent/jwkd", "agent/appAgent"]
-    }).applogs,
-    ...shareNameLog ? [shareNameLog] : [],
-    ...shareCounterLog ? [shareCounterLog] : [],
-    ...agentSharedKeyLogs
-  ];
-  DEBUG2(`[prepareSnapshotForPush] info logs:`, infoLogs);
-  if (!infoLogs.find(({ at }) => at === "agent/appAgent")) throw ERROR2(`[prepareSnapshotForPush] appThread missing agent/appAgent log`);
-  const applogsToEncode = keepTruthy(maybeEncryptedApplogs);
-  const infologsToEncode = keepTruthy(infoLogs);
-  if (!applogsToEncode.length) {
-    throw ERROR2("no valid applogs", { agent, maybeEncryptedApplogs, infoLogs, applogsToEncode, infologsToEncode, prevSnapCID });
-  }
-  if (!infologsToEncode.length) {
-    throw ERROR2("no valid infologs", { agent, maybeEncryptedApplogs, infoLogs, applogsToEncode, infologsToEncode, prevSnapCID });
-  }
-  const encodedSnapshot = await encodeSnapshotAsCar(agent, applogsToEncode, infologsToEncode, prevSnapCID, prevCounter);
-  DEBUG2("inPrepareSnapshotForPush", { encodedSnapshot });
-  return encodedSnapshot;
-}
-async function encodeSnapshotAsCar(agent, applogs, infoLogs, prevSnapCID, prevCounter) {
-  DEBUG2(`[encodeSnapshotAsCar] encoding`, { agent, applogs, infoLogs });
-  const { cids: infoLogCids, encodedApplogs: encodedInfoLogs } = await encodeApplogsAsIPLD(infoLogs);
-  const { cids: applogCids, encodedApplogs } = await encodeApplogsAsIPLD(applogs);
-  let blocks = encodedApplogs.concat(encodedInfoLogs);
-  const infoLogsWrap = await encodeBlockOriginal({ logs: infoLogCids });
-  blocks.push(infoLogsWrap);
-  const { rootCID: chunkRootCID, blocks: chunkBlocks } = await chunkApplogs(applogCids);
-  blocks = blocks.concat(chunkBlocks);
-  const infoSignature = await agent.sign(infoLogsWrap.cid.bytes);
-  const applogsSignature = await agent.sign(chunkRootCID.bytes);
-  const root = {
-    info: infoLogsWrap.cid,
-    applogs: chunkRootCID,
-    infoSignature,
-    applogsSignature,
-    prev: prevSnapCID,
-    prevCounter: !prevSnapCID ? 0 : prevCounter !== null ? prevCounter + 1 : null
-  };
-  DEBUG2("[encodeSnapshotAsCar] encoding root", { root, logCids: applogCids, infoLogCids });
-  const encodedRoot = await encodeBlockOriginal(root);
-  blocks.push(encodedRoot);
-  DEBUG2("[encodeSnapshotAsCar] => root", { encodedRoot });
-  return {
-    cid: encodedRoot.cid,
-    blob: await makeCarBlob(encodedRoot.cid, blocks),
-    // TODO: create CarBuilder (incl .encodeAndAdd({...}))
-    blocks,
-    infoLogCids,
-    applogCids
-  };
-}
-async function chunkApplogs(applogCids, size = 1e4) {
-  if (!applogCids.length) throw ERROR2(`[chunkApplogs] called with empty array`);
-  const chunks = [];
-  for (let i = 0; i < applogCids.length; i += size) {
-    const chunk = await encodeBlockOriginal({ logs: applogCids.slice(i, Math.min(i + applogCids.length, i + size)) });
-    chunks.push(chunk);
-  }
-  if (chunks.length === 1) return { rootCID: chunks[0].cid, blocks: chunks };
-  const root = await encodeBlockOriginal({ chunks: chunks.map((chunk) => chunk.cid) });
-  const blocks = [root, ...chunks];
-  DEBUG2(`[chunkApplogs] ${applogCids.length} logs chunked into ${chunks.length}`, { applogCids, root, blocks, chunks, dagJson: src_exports });
-  return { rootCID: root.cid, blocks, chunks };
-}
-async function unchunkApplogsBlock(block, blockStore) {
-  if (isSnapBlockChunks(block)) {
-    return (await Promise.all(
-      block.chunks.map(async (chunkCid) => {
-        const block2 = await getDecodedBlock(blockStore, chunkCid);
-        if (!block2.logs) throw ERROR2(`Weird chunk`, block2);
-        return block2.logs;
-      })
-    )).flat();
-  } else {
-    return block.logs;
-  }
-}
-function isSnapBlockChunks(block) {
-  return block.chunks;
-}
-async function encodeSnapshotApplogsAsCar(applogs) {
-  const encoded = await encodeApplogsAsIPLD(applogs);
-  if (!encoded) throw ERROR2("invalid applogs cannot continue", { applogs, encoded });
-  const { cids, encodedApplogs } = encoded;
-  const root = { applogs: cids };
-  const encodedRoot = await encodeBlockOriginal(root);
-  DEBUG2("[encodeSnapshotApplogsAsCar] encoded root", { cids, encodedRoot });
-  return await makeCarBlob(encodedRoot.cid, [encodedRoot, ...encodedApplogs]);
-}
-async function encodeApplogsAsIPLD(applogs) {
-  DEBUG2({ applogs });
-  const validApplogs = applogs.filter((eachLog) => !!eachLog);
-  DEBUG2({ validApplogs });
-  if (!validApplogs.length) throw ERROR2("no valid applogs");
-  const preppedLogs = validApplogs.map((log) => prepareForPub(log).log);
-  const encodedApplogs = await Promise.all(preppedLogs.map(encodeBlockOriginal));
-  DEBUG2("[encodeApplogsAsIpld] encoded applogs", { preppedLogs, encodedApplogs });
-  const cids = encodedApplogs.map((b) => {
-    if (!b.cid) throw ERROR2(`[publish] no cid for encoded log:`, b);
-    return b.cid;
-  });
-  return { cids, encodedApplogs };
-}
-
-export {
-  prepareSnapshotForPush,
-  encodeSnapshotAsCar,
-  chunkApplogs,
-  unchunkApplogsBlock,
-  isSnapBlockChunks,
-  encodeSnapshotApplogsAsCar,
-  decodePubFromCar,
-  decodePubFromBlocks,
-  getBlocksOfCar,
-  getDecodedBlock,
-  makeCarOut,
-  makeCarBlob,
-  carFromBlob,
-  collectDagBlocks,
-  streamReaderToIterable
-};
-//# sourceMappingURL=chunk-WXLCBTHX.min.js.map