@wovin/core 0.0.10 → 0.0.11

package/dist/{chunk-BLAIQY2K.min.js → chunk-C75X52ZX.min.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-QPGEBDMJ.min.js";
 import {
   lastWriteWins
-} from "./chunk-4432UCLM.min.js";
+} from "./chunk-TPRWMCU7.min.js";
 import {
   CID,
   E,
@@ -11,7 +11,6 @@ import {
   Type,
   areCidsEqual,
   containsCid,
-  cyrb53hash,
   decode,
   decode2,
   decode3,
@@ -24,7 +23,7 @@ import {
   rollingFilter,
   src_exports,
   wrapper_default
-} from "./chunk-ITYJ7DMX.min.js";
+} from "./chunk-UQJEOS7T.min.js";
 import {
   __commonJS,
   __toESM
@@ -34,29 +33,29 @@ import {
 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) {
+    module.exports = encode5;
+    var MSB2 = 128;
+    var REST2 = 127;
+    var MSBALL2 = ~REST2;
+    var INT2 = Math.pow(2, 31);
+    function encode5(num, out, offset) {
       if (Number.MAX_SAFE_INTEGER && num > Number.MAX_SAFE_INTEGER) {
-        encode3.bytes = 0;
+        encode5.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;
+      while (num >= INT2) {
+        out[offset++] = num & 255 | MSB2;
         num /= 128;
       }
-      while (num & MSBALL) {
-        out[offset++] = num & 255 | MSB;
+      while (num & MSBALL2) {
+        out[offset++] = num & 255 | MSB2;
         num >>>= 7;
       }
       out[offset] = num | 0;
-      encode3.bytes = offset - oldOffset + 1;
+      encode5.bytes = offset - oldOffset + 1;
       return out;
     }
   }
@@ -66,21 +65,21 @@ var require_encode = __commonJS({
 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) {
+    module.exports = read2;
+    var MSB2 = 128;
+    var REST2 = 127;
+    function read2(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;
+          read2.bytes = 0;
           throw new RangeError("Could not decode varint");
         }
         b = buf[counter++];
-        res += shift < 28 ? (b & REST) << shift : (b & REST) * Math.pow(2, shift);
+        res += shift < 28 ? (b & REST2) << shift : (b & REST2) * Math.pow(2, shift);
         shift += 7;
-      } while (b >= MSB);
-      read.bytes = counter - offset;
+      } while (b >= MSB2);
+      read2.bytes = counter - offset;
       return res;
     }
   }
@@ -90,17 +89,17 @@ var require_decode = __commonJS({
 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);
+    var N12 = Math.pow(2, 7);
+    var N22 = Math.pow(2, 14);
+    var N32 = Math.pow(2, 21);
+    var N42 = Math.pow(2, 28);
+    var N52 = Math.pow(2, 35);
+    var N62 = Math.pow(2, 42);
+    var N72 = Math.pow(2, 49);
+    var N82 = Math.pow(2, 56);
+    var N92 = 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;
+      return value < N12 ? 1 : value < N22 ? 2 : value < N32 ? 3 : value < N42 ? 4 : value < N52 ? 5 : value < N62 ? 6 : value < N72 ? 7 : value < N82 ? 8 : value < N92 ? 9 : 10;
     };
   }
 });
@@ -117,13 +116,879 @@ var require_varint = __commonJS({
   }
 });
 
+// ../../../node_modules/.pnpm/multiformats@13.3.1/node_modules/multiformats/dist/src/bytes.js
+var empty = new Uint8Array(0);
+function equals(aa, bb) {
+  if (aa === bb)
+    return true;
+  if (aa.byteLength !== bb.byteLength) {
+    return false;
+  }
+  for (let ii = 0; ii < aa.byteLength; ii++) {
+    if (aa[ii] !== bb[ii]) {
+      return false;
+    }
+  }
+  return true;
+}
+function coerce(o) {
+  if (o instanceof Uint8Array && o.constructor.name === "Uint8Array")
+    return o;
+  if (o instanceof ArrayBuffer)
+    return new Uint8Array(o);
+  if (ArrayBuffer.isView(o)) {
+    return new Uint8Array(o.buffer, o.byteOffset, o.byteLength);
+  }
+  throw new Error("Unknown type, must be binary type");
+}
+
+// ../../../node_modules/.pnpm/multiformats@13.3.1/node_modules/multiformats/dist/src/vendor/base-x.js
+function base(ALPHABET, name) {
+  if (ALPHABET.length >= 255) {
+    throw new TypeError("Alphabet too long");
+  }
+  var BASE_MAP = new Uint8Array(256);
+  for (var j = 0; j < BASE_MAP.length; j++) {
+    BASE_MAP[j] = 255;
+  }
+  for (var i = 0; i < ALPHABET.length; i++) {
+    var x = ALPHABET.charAt(i);
+    var xc = x.charCodeAt(0);
+    if (BASE_MAP[xc] !== 255) {
+      throw new TypeError(x + " is ambiguous");
+    }
+    BASE_MAP[xc] = i;
+  }
+  var BASE = ALPHABET.length;
+  var LEADER = ALPHABET.charAt(0);
+  var FACTOR = Math.log(BASE) / Math.log(256);
+  var iFACTOR = Math.log(256) / Math.log(BASE);
+  function encode5(source) {
+    if (source instanceof Uint8Array)
+      ;
+    else if (ArrayBuffer.isView(source)) {
+      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+    } else if (Array.isArray(source)) {
+      source = Uint8Array.from(source);
+    }
+    if (!(source instanceof Uint8Array)) {
+      throw new TypeError("Expected Uint8Array");
+    }
+    if (source.length === 0) {
+      return "";
+    }
+    var zeroes = 0;
+    var length2 = 0;
+    var pbegin = 0;
+    var pend = source.length;
+    while (pbegin !== pend && source[pbegin] === 0) {
+      pbegin++;
+      zeroes++;
+    }
+    var size = (pend - pbegin) * iFACTOR + 1 >>> 0;
+    var b58 = new Uint8Array(size);
+    while (pbegin !== pend) {
+      var carry = source[pbegin];
+      var i2 = 0;
+      for (var it1 = size - 1; (carry !== 0 || i2 < length2) && it1 !== -1; it1--, i2++) {
+        carry += 256 * b58[it1] >>> 0;
+        b58[it1] = carry % BASE >>> 0;
+        carry = carry / BASE >>> 0;
+      }
+      if (carry !== 0) {
+        throw new Error("Non-zero carry");
+      }
+      length2 = i2;
+      pbegin++;
+    }
+    var it2 = size - length2;
+    while (it2 !== size && b58[it2] === 0) {
+      it2++;
+    }
+    var str = LEADER.repeat(zeroes);
+    for (; it2 < size; ++it2) {
+      str += ALPHABET.charAt(b58[it2]);
+    }
+    return str;
+  }
+  function decodeUnsafe(source) {
+    if (typeof source !== "string") {
+      throw new TypeError("Expected String");
+    }
+    if (source.length === 0) {
+      return new Uint8Array();
+    }
+    var psz = 0;
+    if (source[psz] === " ") {
+      return;
+    }
+    var zeroes = 0;
+    var length2 = 0;
+    while (source[psz] === LEADER) {
+      zeroes++;
+      psz++;
+    }
+    var size = (source.length - psz) * FACTOR + 1 >>> 0;
+    var b256 = new Uint8Array(size);
+    while (source[psz]) {
+      var carry = BASE_MAP[source.charCodeAt(psz)];
+      if (carry === 255) {
+        return;
+      }
+      var i2 = 0;
+      for (var it3 = size - 1; (carry !== 0 || i2 < length2) && it3 !== -1; it3--, i2++) {
+        carry += BASE * b256[it3] >>> 0;
+        b256[it3] = carry % 256 >>> 0;
+        carry = carry / 256 >>> 0;
+      }
+      if (carry !== 0) {
+        throw new Error("Non-zero carry");
+      }
+      length2 = i2;
+      psz++;
+    }
+    if (source[psz] === " ") {
+      return;
+    }
+    var it4 = size - length2;
+    while (it4 !== size && b256[it4] === 0) {
+      it4++;
+    }
+    var vch = new Uint8Array(zeroes + (size - it4));
+    var j2 = zeroes;
+    while (it4 !== size) {
+      vch[j2++] = b256[it4++];
+    }
+    return vch;
+  }
+  function decode9(string) {
+    var buffer = decodeUnsafe(string);
+    if (buffer) {
+      return buffer;
+    }
+    throw new Error(`Non-${name} character`);
+  }
+  return {
+    encode: encode5,
+    decodeUnsafe,
+    decode: decode9
+  };
+}
+var src = base;
+var _brrp__multiformats_scope_baseX = src;
+var base_x_default = _brrp__multiformats_scope_baseX;
+
+// ../../../node_modules/.pnpm/multiformats@13.3.1/node_modules/multiformats/dist/src/bases/base.js
+var Encoder = class {
+  name;
+  prefix;
+  baseEncode;
+  constructor(name, prefix, baseEncode) {
+    this.name = name;
+    this.prefix = prefix;
+    this.baseEncode = baseEncode;
+  }
+  encode(bytes) {
+    if (bytes instanceof Uint8Array) {
+      return `${this.prefix}${this.baseEncode(bytes)}`;
+    } else {
+      throw Error("Unknown type, must be binary type");
+    }
+  }
+};
+var Decoder = class {
+  name;
+  prefix;
+  baseDecode;
+  prefixCodePoint;
+  constructor(name, prefix, baseDecode) {
+    this.name = name;
+    this.prefix = prefix;
+    const prefixCodePoint = prefix.codePointAt(0);
+    if (prefixCodePoint === void 0) {
+      throw new Error("Invalid prefix character");
+    }
+    this.prefixCodePoint = prefixCodePoint;
+    this.baseDecode = baseDecode;
+  }
+  decode(text) {
+    if (typeof text === "string") {
+      if (text.codePointAt(0) !== this.prefixCodePoint) {
+        throw Error(`Unable to decode multibase string ${JSON.stringify(text)}, ${this.name} decoder only supports inputs prefixed with ${this.prefix}`);
+      }
+      return this.baseDecode(text.slice(this.prefix.length));
+    } else {
+      throw Error("Can only multibase decode strings");
+    }
+  }
+  or(decoder) {
+    return or(this, decoder);
+  }
+};
+var ComposedDecoder = class {
+  decoders;
+  constructor(decoders) {
+    this.decoders = decoders;
+  }
+  or(decoder) {
+    return or(this, decoder);
+  }
+  decode(input) {
+    const prefix = input[0];
+    const decoder = this.decoders[prefix];
+    if (decoder != null) {
+      return decoder.decode(input);
+    } else {
+      throw RangeError(`Unable to decode multibase string ${JSON.stringify(input)}, only inputs prefixed with ${Object.keys(this.decoders)} are supported`);
+    }
+  }
+};
+function or(left, right) {
+  return new ComposedDecoder({
+    ...left.decoders ?? { [left.prefix]: left },
+    ...right.decoders ?? { [right.prefix]: right }
+  });
+}
+var Codec = class {
+  name;
+  prefix;
+  baseEncode;
+  baseDecode;
+  encoder;
+  decoder;
+  constructor(name, prefix, baseEncode, baseDecode) {
+    this.name = name;
+    this.prefix = prefix;
+    this.baseEncode = baseEncode;
+    this.baseDecode = baseDecode;
+    this.encoder = new Encoder(name, prefix, baseEncode);
+    this.decoder = new Decoder(name, prefix, baseDecode);
+  }
+  encode(input) {
+    return this.encoder.encode(input);
+  }
+  decode(input) {
+    return this.decoder.decode(input);
+  }
+};
+function from({ name, prefix, encode: encode5, decode: decode9 }) {
+  return new Codec(name, prefix, encode5, decode9);
+}
+function baseX({ name, prefix, alphabet }) {
+  const { encode: encode5, decode: decode9 } = base_x_default(alphabet, name);
+  return from({
+    prefix,
+    name,
+    encode: encode5,
+    decode: (text) => coerce(decode9(text))
+  });
+}
+function decode4(string, alphabet, bitsPerChar, name) {
+  const codes = {};
+  for (let i = 0; i < alphabet.length; ++i) {
+    codes[alphabet[i]] = i;
+  }
+  let end = string.length;
+  while (string[end - 1] === "=") {
+    --end;
+  }
+  const out = new Uint8Array(end * bitsPerChar / 8 | 0);
+  let bits = 0;
+  let buffer = 0;
+  let written = 0;
+  for (let i = 0; i < end; ++i) {
+    const value = codes[string[i]];
+    if (value === void 0) {
+      throw new SyntaxError(`Non-${name} character`);
+    }
+    buffer = buffer << bitsPerChar | value;
+    bits += bitsPerChar;
+    if (bits >= 8) {
+      bits -= 8;
+      out[written++] = 255 & buffer >> bits;
+    }
+  }
+  if (bits >= bitsPerChar || (255 & buffer << 8 - bits) !== 0) {
+    throw new SyntaxError("Unexpected end of data");
+  }
+  return out;
+}
+function encode2(data, alphabet, bitsPerChar) {
+  const pad = alphabet[alphabet.length - 1] === "=";
+  const mask = (1 << bitsPerChar) - 1;
+  let out = "";
+  let bits = 0;
+  let buffer = 0;
+  for (let i = 0; i < data.length; ++i) {
+    buffer = buffer << 8 | data[i];
+    bits += 8;
+    while (bits > bitsPerChar) {
+      bits -= bitsPerChar;
+      out += alphabet[mask & buffer >> bits];
+    }
+  }
+  if (bits !== 0) {
+    out += alphabet[mask & buffer << bitsPerChar - bits];
+  }
+  if (pad) {
+    while ((out.length * bitsPerChar & 7) !== 0) {
+      out += "=";
+    }
+  }
+  return out;
+}
+function rfc4648({ name, prefix, bitsPerChar, alphabet }) {
+  return from({
+    prefix,
+    name,
+    encode(input) {
+      return encode2(input, alphabet, bitsPerChar);
+    },
+    decode(input) {
+      return decode4(input, alphabet, bitsPerChar, name);
+    }
+  });
+}
+
+// ../../../node_modules/.pnpm/multiformats@13.3.1/node_modules/multiformats/dist/src/bases/base32.js
+var base32 = rfc4648({
+  prefix: "b",
+  name: "base32",
+  alphabet: "abcdefghijklmnopqrstuvwxyz234567",
+  bitsPerChar: 5
+});
+var base32upper = rfc4648({
+  prefix: "B",
+  name: "base32upper",
+  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567",
+  bitsPerChar: 5
+});
+var base32pad = rfc4648({
+  prefix: "c",
+  name: "base32pad",
+  alphabet: "abcdefghijklmnopqrstuvwxyz234567=",
+  bitsPerChar: 5
+});
+var base32padupper = rfc4648({
+  prefix: "C",
+  name: "base32padupper",
+  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=",
+  bitsPerChar: 5
+});
+var base32hex = rfc4648({
+  prefix: "v",
+  name: "base32hex",
+  alphabet: "0123456789abcdefghijklmnopqrstuv",
+  bitsPerChar: 5
+});
+var base32hexupper = rfc4648({
+  prefix: "V",
+  name: "base32hexupper",
+  alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV",
+  bitsPerChar: 5
+});
+var base32hexpad = rfc4648({
+  prefix: "t",
+  name: "base32hexpad",
+  alphabet: "0123456789abcdefghijklmnopqrstuv=",
+  bitsPerChar: 5
+});
+var base32hexpadupper = rfc4648({
+  prefix: "T",
+  name: "base32hexpadupper",
+  alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV=",
+  bitsPerChar: 5
+});
+var base32z = rfc4648({
+  prefix: "h",
+  name: "base32z",
+  alphabet: "ybndrfg8ejkmcpqxot1uwisza345h769",
+  bitsPerChar: 5
+});
+
+// ../../../node_modules/.pnpm/multiformats@13.3.1/node_modules/multiformats/dist/src/bases/base36.js
+var base36 = baseX({
+  prefix: "k",
+  name: "base36",
+  alphabet: "0123456789abcdefghijklmnopqrstuvwxyz"
+});
+var base36upper = baseX({
+  prefix: "K",
+  name: "base36upper",
+  alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+});
+
+// ../../../node_modules/.pnpm/multiformats@13.3.1/node_modules/multiformats/dist/src/bases/base58.js
+var base58btc = baseX({
+  name: "base58btc",
+  prefix: "z",
+  alphabet: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+});
+var base58flickr = baseX({
+  name: "base58flickr",
+  prefix: "Z",
+  alphabet: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"
+});
+
+// ../../../node_modules/.pnpm/multiformats@13.3.1/node_modules/multiformats/dist/src/vendor/varint.js
+var encode_1 = encode3;
+var MSB = 128;
+var REST = 127;
+var MSBALL = ~REST;
+var INT = Math.pow(2, 31);
+function encode3(num, out, offset) {
+  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;
+}
+var decode5 = read;
+var MSB$1 = 128;
+var REST$1 = 127;
+function read(buf, offset) {
+  var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf.length;
+  do {
+    if (counter >= l) {
+      read.bytes = 0;
+      throw new RangeError("Could not decode varint");
+    }
+    b = buf[counter++];
+    res += shift < 28 ? (b & REST$1) << shift : (b & REST$1) * Math.pow(2, shift);
+    shift += 7;
+  } while (b >= MSB$1);
+  read.bytes = counter - offset;
+  return res;
+}
+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);
+var length = 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;
+};
+var varint = {
+  encode: encode_1,
+  decode: decode5,
+  encodingLength: length
+};
+var _brrp_varint = varint;
+var varint_default = _brrp_varint;
+
+// ../../../node_modules/.pnpm/multiformats@13.3.1/node_modules/multiformats/dist/src/varint.js
+function decode6(data, offset = 0) {
+  const code = varint_default.decode(data, offset);
+  return [code, varint_default.decode.bytes];
+}
+function encodeTo(int, target, offset = 0) {
+  varint_default.encode(int, target, offset);
+  return target;
+}
+function encodingLength(int) {
+  return varint_default.encodingLength(int);
+}
+
+// ../../../node_modules/.pnpm/multiformats@13.3.1/node_modules/multiformats/dist/src/hashes/digest.js
+function create(code, digest) {
+  const size = digest.byteLength;
+  const sizeOffset = encodingLength(code);
+  const digestOffset = sizeOffset + encodingLength(size);
+  const bytes = new Uint8Array(digestOffset + size);
+  encodeTo(code, bytes, 0);
+  encodeTo(size, bytes, sizeOffset);
+  bytes.set(digest, digestOffset);
+  return new Digest(code, size, digest, bytes);
+}
+function decode7(multihash) {
+  const bytes = coerce(multihash);
+  const [code, sizeOffset] = decode6(bytes);
+  const [size, digestOffset] = decode6(bytes.subarray(sizeOffset));
+  const digest = bytes.subarray(sizeOffset + digestOffset);
+  if (digest.byteLength !== size) {
+    throw new Error("Incorrect length");
+  }
+  return new Digest(code, size, digest, bytes);
+}
+function equals2(a, b) {
+  if (a === b) {
+    return true;
+  } else {
+    const data = b;
+    return a.code === data.code && a.size === data.size && data.bytes instanceof Uint8Array && equals(a.bytes, data.bytes);
+  }
+}
+var Digest = class {
+  code;
+  size;
+  digest;
+  bytes;
+  /**
+   * Creates a multihash digest.
+   */
+  constructor(code, size, digest, bytes) {
+    this.code = code;
+    this.size = size;
+    this.digest = digest;
+    this.bytes = bytes;
+  }
+};
+
+// ../../../node_modules/.pnpm/multiformats@13.3.1/node_modules/multiformats/dist/src/cid.js
+function format(link, base2) {
+  const { bytes, version } = link;
+  switch (version) {
+    case 0:
+      return toStringV0(bytes, baseCache(link), base2 ?? base58btc.encoder);
+    default:
+      return toStringV1(bytes, baseCache(link), base2 ?? base32.encoder);
+  }
+}
+var cache = /* @__PURE__ */ new WeakMap();
+function baseCache(cid) {
+  const baseCache2 = cache.get(cid);
+  if (baseCache2 == null) {
+    const baseCache3 = /* @__PURE__ */ new Map();
+    cache.set(cid, baseCache3);
+    return baseCache3;
+  }
+  return baseCache2;
+}
+var CID2 = class _CID {
+  code;
+  version;
+  multihash;
+  bytes;
+  "/";
+  /**
+   * @param version - Version of the CID
+   * @param code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
+   * @param multihash - (Multi)hash of the of the content.
+   */
+  constructor(version, code, multihash, bytes) {
+    this.code = code;
+    this.version = version;
+    this.multihash = multihash;
+    this.bytes = bytes;
+    this["/"] = bytes;
+  }
+  /**
+   * Signalling `cid.asCID === cid` has been replaced with `cid['/'] === cid.bytes`
+   * please either use `CID.asCID(cid)` or switch to new signalling mechanism
+   *
+   * @deprecated
+   */
+  get asCID() {
+    return this;
+  }
+  // ArrayBufferView
+  get byteOffset() {
+    return this.bytes.byteOffset;
+  }
+  // ArrayBufferView
+  get byteLength() {
+    return this.bytes.byteLength;
+  }
+  toV0() {
+    switch (this.version) {
+      case 0: {
+        return this;
+      }
+      case 1: {
+        const { code, multihash } = this;
+        if (code !== DAG_PB_CODE) {
+          throw new Error("Cannot convert a non dag-pb CID to CIDv0");
+        }
+        if (multihash.code !== SHA_256_CODE) {
+          throw new Error("Cannot convert non sha2-256 multihash CID to CIDv0");
+        }
+        return _CID.createV0(multihash);
+      }
+      default: {
+        throw Error(`Can not convert CID version ${this.version} to version 0. This is a bug please report`);
+      }
+    }
+  }
+  toV1() {
+    switch (this.version) {
+      case 0: {
+        const { code, digest } = this.multihash;
+        const multihash = create(code, digest);
+        return _CID.createV1(this.code, multihash);
+      }
+      case 1: {
+        return this;
+      }
+      default: {
+        throw Error(`Can not convert CID version ${this.version} to version 1. This is a bug please report`);
+      }
+    }
+  }
+  equals(other) {
+    return _CID.equals(this, other);
+  }
+  static equals(self, other) {
+    const unknown = other;
+    return unknown != null && self.code === unknown.code && self.version === unknown.version && equals2(self.multihash, unknown.multihash);
+  }
+  toString(base2) {
+    return format(this, base2);
+  }
+  toJSON() {
+    return { "/": format(this) };
+  }
+  link() {
+    return this;
+  }
+  [Symbol.toStringTag] = "CID";
+  // Legacy
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return `CID(${this.toString()})`;
+  }
+  /**
+   * Takes any input `value` and returns a `CID` instance if it was
+   * a `CID` otherwise returns `null`. If `value` is instanceof `CID`
+   * it will return value back. If `value` is not instance of this CID
+   * class, but is compatible CID it will return new instance of this
+   * `CID` class. Otherwise returns null.
+   *
+   * This allows two different incompatible versions of CID library to
+   * co-exist and interop as long as binary interface is compatible.
+   */
+  static asCID(input) {
+    if (input == null) {
+      return null;
+    }
+    const value = input;
+    if (value instanceof _CID) {
+      return value;
+    } else if (value["/"] != null && value["/"] === value.bytes || value.asCID === value) {
+      const { version, code, multihash, bytes } = value;
+      return new _CID(version, code, multihash, bytes ?? encodeCID(version, code, multihash.bytes));
+    } else if (value[cidSymbol] === true) {
+      const { version, multihash, code } = value;
+      const digest = decode7(multihash);
+      return _CID.create(version, code, digest);
+    } else {
+      return null;
+    }
+  }
+  /**
+   * @param version - Version of the CID
+   * @param code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
+   * @param digest - (Multi)hash of the of the content.
+   */
+  static create(version, code, digest) {
+    if (typeof code !== "number") {
+      throw new Error("String codecs are no longer supported");
+    }
+    if (!(digest.bytes instanceof Uint8Array)) {
+      throw new Error("Invalid digest");
+    }
+    switch (version) {
+      case 0: {
+        if (code !== DAG_PB_CODE) {
+          throw new Error(`Version 0 CID must use dag-pb (code: ${DAG_PB_CODE}) block encoding`);
+        } else {
+          return new _CID(version, code, digest, digest.bytes);
+        }
+      }
+      case 1: {
+        const bytes = encodeCID(version, code, digest.bytes);
+        return new _CID(version, code, digest, bytes);
+      }
+      default: {
+        throw new Error("Invalid version");
+      }
+    }
+  }
+  /**
+   * Simplified version of `create` for CIDv0.
+   */
+  static createV0(digest) {
+    return _CID.create(0, DAG_PB_CODE, digest);
+  }
+  /**
+   * Simplified version of `create` for CIDv1.
+   *
+   * @param code - Content encoding format code.
+   * @param digest - Multihash of the content.
+   */
+  static createV1(code, digest) {
+    return _CID.create(1, code, digest);
+  }
+  /**
+   * Decoded a CID from its binary representation. The byte array must contain
+   * only the CID with no additional bytes.
+   *
+   * An error will be thrown if the bytes provided do not contain a valid
+   * binary representation of a CID.
+   */
+  static decode(bytes) {
+    const [cid, remainder] = _CID.decodeFirst(bytes);
+    if (remainder.length !== 0) {
+      throw new Error("Incorrect length");
+    }
+    return cid;
+  }
+  /**
+   * Decoded a CID from its binary representation at the beginning of a byte
+   * array.
+   *
+   * Returns an array with the first element containing the CID and the second
+   * element containing the remainder of the original byte array. The remainder
+   * will be a zero-length byte array if the provided bytes only contained a
+   * binary CID representation.
+   */
+  static decodeFirst(bytes) {
+    const specs = _CID.inspectBytes(bytes);
+    const prefixSize = specs.size - specs.multihashSize;
+    const multihashBytes = coerce(bytes.subarray(prefixSize, prefixSize + specs.multihashSize));
+    if (multihashBytes.byteLength !== specs.multihashSize) {
+      throw new Error("Incorrect length");
+    }
+    const digestBytes = multihashBytes.subarray(specs.multihashSize - specs.digestSize);
+    const digest = new Digest(specs.multihashCode, specs.digestSize, digestBytes, multihashBytes);
+    const cid = specs.version === 0 ? _CID.createV0(digest) : _CID.createV1(specs.codec, digest);
+    return [cid, bytes.subarray(specs.size)];
+  }
+  /**
+   * Inspect the initial bytes of a CID to determine its properties.
+   *
+   * Involves decoding up to 4 varints. Typically this will require only 4 to 6
+   * bytes but for larger multicodec code values and larger multihash digest
+   * lengths these varints can be quite large. It is recommended that at least
+   * 10 bytes be made available in the `initialBytes` argument for a complete
+   * inspection.
+   */
+  static inspectBytes(initialBytes) {
+    let offset = 0;
+    const next = () => {
+      const [i, length2] = decode6(initialBytes.subarray(offset));
+      offset += length2;
+      return i;
+    };
+    let version = next();
+    let codec = DAG_PB_CODE;
+    if (version === 18) {
+      version = 0;
+      offset = 0;
+    } else {
+      codec = next();
+    }
+    if (version !== 0 && version !== 1) {
+      throw new RangeError(`Invalid CID version ${version}`);
+    }
+    const prefixSize = offset;
+    const multihashCode = next();
+    const digestSize = next();
+    const size = offset + digestSize;
+    const multihashSize = size - prefixSize;
+    return { version, codec, multihashCode, digestSize, multihashSize, size };
+  }
+  /**
+   * Takes cid in a string representation and creates an instance. If `base`
+   * decoder is not provided will use a default from the configuration. It will
+   * throw an error if encoding of the CID is not compatible with supplied (or
+   * a default decoder).
+   */
+  static parse(source, base2) {
+    const [prefix, bytes] = parseCIDtoBytes(source, base2);
+    const cid = _CID.decode(bytes);
+    if (cid.version === 0 && source[0] !== "Q") {
+      throw Error("Version 0 CID string must not include multibase prefix");
+    }
+    baseCache(cid).set(prefix, source);
+    return cid;
+  }
+};
+function parseCIDtoBytes(source, base2) {
+  switch (source[0]) {
+    case "Q": {
+      const decoder = base2 ?? base58btc;
+      return [
+        base58btc.prefix,
+        decoder.decode(`${base58btc.prefix}${source}`)
+      ];
+    }
+    case base58btc.prefix: {
+      const decoder = base2 ?? base58btc;
+      return [base58btc.prefix, decoder.decode(source)];
+    }
+    case base32.prefix: {
+      const decoder = base2 ?? base32;
+      return [base32.prefix, decoder.decode(source)];
+    }
+    case base36.prefix: {
+      const decoder = base2 ?? base36;
+      return [base36.prefix, decoder.decode(source)];
+    }
+    default: {
+      if (base2 == null) {
+        throw Error("To parse non base32, base36 or base58btc encoded CID multibase decoder must be provided");
+      }
+      return [source[0], base2.decode(source)];
+    }
+  }
+}
+function toStringV0(bytes, cache2, base2) {
+  const { prefix } = base2;
+  if (prefix !== base58btc.prefix) {
+    throw Error(`Cannot string encode V0 in ${base2.name} encoding`);
+  }
+  const cid = cache2.get(prefix);
+  if (cid == null) {
+    const cid2 = base2.encode(bytes).slice(1);
+    cache2.set(prefix, cid2);
+    return cid2;
+  } else {
+    return cid;
+  }
+}
+function toStringV1(bytes, cache2, base2) {
+  const { prefix } = base2;
+  const cid = cache2.get(prefix);
+  if (cid == null) {
+    const cid2 = base2.encode(bytes);
+    cache2.set(prefix, cid2);
+    return cid2;
+  } else {
+    return cid;
+  }
+}
+var DAG_PB_CODE = 112;
+var SHA_256_CODE = 18;
+function encodeCID(version, code, multihash) {
+  const codeOffset = encodingLength(version);
+  const hashOffset = codeOffset + encodingLength(code);
+  const bytes = new Uint8Array(hashOffset + multihash.byteLength);
+  encodeTo(version, bytes, 0);
+  encodeTo(code, bytes, codeOffset);
+  bytes.set(multihash, hashOffset);
+  return bytes;
+}
+var cidSymbol = Symbol.for("@ipld/js-cid/CID");
+
 // ../../../node_modules/.pnpm/@ipld+dag-cbor@9.1.0/node_modules/@ipld/dag-cbor/src/index.js
 var CID_CBOR_TAG = 42;
 function cidEncoder(obj) {
   if (obj.asCID !== obj && obj["/"] !== obj.bytes) {
     return null;
   }
-  const cid = CID.asCID(obj);
+  const cid = CID2.asCID(obj);
   if (!cid) {
     return null;
   }
@@ -164,7 +1029,7 @@ 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));
+  return CID2.decode(bytes.subarray(1));
 }
 var _decodeOptions = {
   allowIndefinite: false,
@@ -185,11 +1050,11 @@ var decodeOptions = {
   ..._decodeOptions,
   tags: _decodeOptions.tags.slice()
 };
-var encode2 = (node) => encode(node, _encodeOptions);
-var decode4 = (data) => decode(data, _decodeOptions);
+var encode4 = (node) => encode(node, _encodeOptions);
+var decode8 = (data) => decode(data, _decodeOptions);
 
 // ../../../node_modules/.pnpm/@ipld+car@5.2.6/node_modules/@ipld/car/src/decoder-common.js
-var import_varint = __toESM(require_varint(), 1);
+var import_varint2 = __toESM(require_varint(), 1);
 var CIDV0_BYTES = {
   SHA2_256: 18,
   LENGTH: 32,
@@ -203,10 +1068,10 @@ function decodeVarint(bytes, seeker) {
   if (!bytes.length) {
     throw new Error("Unexpected end of data");
   }
-  const i = import_varint.default.decode(bytes);
+  const i = import_varint2.default.decode(bytes);
   seeker.seek(
     /** @type {number} */
-    import_varint.default.decode.bytes
+    import_varint2.default.decode.bytes
   );
   return i;
 }
@@ -227,17 +1092,17 @@ function decodeV2Header(bytes) {
   return header;
 }
 function getMultihashLength(bytes) {
-  import_varint.default.decode(bytes);
+  import_varint2.default.decode(bytes);
   const codeLength = (
     /** @type {number} */
-    import_varint.default.decode.bytes
+    import_varint2.default.decode.bytes
   );
-  const length = import_varint.default.decode(bytes.subarray(import_varint.default.decode.bytes));
+  const length2 = import_varint2.default.decode(bytes.subarray(import_varint2.default.decode.bytes));
   const lengthLength = (
     /** @type {number} */
-    import_varint.default.decode.bytes
+    import_varint2.default.decode.bytes
   );
-  const mhLength = codeLength + lengthLength + length;
+  const mhLength = codeLength + lengthLength + length2;
   return mhLength;
 }
 
@@ -467,7 +1332,7 @@ var CarV1HeaderOrV2Pragma = {
 var cborEncoders = makeCborEncoders();
 
 // ../../../node_modules/.pnpm/@ipld+car@5.2.6/node_modules/@ipld/car/src/buffer-writer.js
-var import_varint2 = __toESM(require_varint(), 1);
+var import_varint3 = __toESM(require_varint(), 1);
 var headerPreludeTokens = [
   new Token(Type.map, 2),
   new Token(Type.string, "version"),
@@ -478,12 +1343,12 @@ var CID_TAG = new Token(Type.tag, 42);
 
 // ../../../node_modules/.pnpm/@ipld+car@5.2.6/node_modules/@ipld/car/src/decoder.js
 async function readHeader(reader, strictVersion) {
-  const length = decodeVarint(await reader.upTo(8), reader);
-  if (length === 0) {
+  const length2 = decodeVarint(await reader.upTo(8), reader);
+  if (length2 === 0) {
     throw new Error("Invalid CAR header (zero length)");
   }
-  const header = await reader.exactly(length, true);
-  const block = decode4(header);
+  const header = await reader.exactly(length2, true);
+  const block = decode8(header);
   if (CarV1HeaderOrV2Pragma.toTyped(block) === void 0) {
     throw new Error("Invalid CAR header format");
   }
@@ -522,14 +1387,14 @@ async function readCid(reader) {
 }
 async function readBlockHead(reader) {
   const start = reader.pos;
-  let length = decodeVarint(await reader.upTo(8), reader);
-  if (length === 0) {
+  let length2 = decodeVarint(await reader.upTo(8), reader);
+  if (length2 === 0) {
     throw new Error("Invalid CAR section (zero length)");
   }
-  length += reader.pos - start;
+  length2 += reader.pos - start;
   const cid = await readCid(reader);
-  const blockLength = length - Number(reader.pos - start);
-  return { cid, length, blockLength };
+  const blockLength = length2 - Number(reader.pos - start);
+  return { cid, length: length2, blockLength };
 }
 async function readBlock(reader) {
   const { cid, blockLength } = await readBlockHead(reader);
@@ -538,8 +1403,8 @@ async function readBlock(reader) {
 }
 async function readBlockIndex(reader) {
   const offset = reader.pos;
-  const { cid, length, blockLength } = await readBlockHead(reader);
-  const index = { cid, length, blockLength, offset, blockOffset: reader.pos };
+  const { cid, length: length2, blockLength } = await readBlockHead(reader);
+  const index = { cid, length: length2, blockLength, offset, blockOffset: reader.pos };
   reader.seek(index.blockLength);
   return index;
 }
@@ -571,22 +1436,22 @@ function createDecoder(reader) {
 function bytesReader(bytes) {
   let pos = 0;
   return {
-    async upTo(length) {
-      const out = bytes.subarray(pos, pos + Math.min(length, bytes.length - pos));
+    async upTo(length2) {
+      const out = bytes.subarray(pos, pos + Math.min(length2, bytes.length - pos));
       return out;
     },
-    async exactly(length, seek = false) {
-      if (length > bytes.length - pos) {
+    async exactly(length2, seek = false) {
+      if (length2 > bytes.length - pos) {
         throw new Error("Unexpected end of data");
       }
-      const out = bytes.subarray(pos, pos + length);
+      const out = bytes.subarray(pos, pos + length2);
       if (seek) {
-        pos += length;
+        pos += length2;
       }
       return out;
     },
-    seek(length) {
-      pos += length;
+    seek(length2) {
+      pos += length2;
     },
     get pos() {
       return pos;
@@ -598,10 +1463,10 @@ function chunkReader(readChunk) {
   let have = 0;
   let offset = 0;
   let currentChunk = new Uint8Array(0);
-  const read = async (length) => {
+  const read2 = async (length2) => {
     have = currentChunk.length - offset;
     const bufa = [currentChunk.subarray(offset)];
-    while (have < length) {
+    while (have < length2) {
       const chunk = await readChunk();
       if (chunk == null) {
         break;
@@ -624,29 +1489,29 @@ function chunkReader(readChunk) {
     offset = 0;
   };
   return {
-    async upTo(length) {
-      if (currentChunk.length - offset < length) {
-        await read(length);
+    async upTo(length2) {
+      if (currentChunk.length - offset < length2) {
+        await read2(length2);
       }
-      return currentChunk.subarray(offset, offset + Math.min(currentChunk.length - offset, length));
+      return currentChunk.subarray(offset, offset + Math.min(currentChunk.length - offset, length2));
     },
-    async exactly(length, seek = false) {
-      if (currentChunk.length - offset < length) {
-        await read(length);
+    async exactly(length2, seek = false) {
+      if (currentChunk.length - offset < length2) {
+        await read2(length2);
       }
-      if (currentChunk.length - offset < length) {
+      if (currentChunk.length - offset < length2) {
         throw new Error("Unexpected end of data");
       }
-      const out = currentChunk.subarray(offset, offset + length);
+      const out = currentChunk.subarray(offset, offset + length2);
       if (seek) {
-        pos += length;
-        offset += length;
+        pos += length2;
+        offset += length2;
       }
       return out;
     },
-    seek(length) {
-      pos += length;
-      offset += length;
+    seek(length2) {
+      pos += length2;
+      offset += length2;
     },
     get pos() {
       return pos;
@@ -667,26 +1532,26 @@ function asyncIterableReader(asyncIterable) {
 function limitReader(reader, byteLimit) {
   let bytesRead = 0;
   return {
-    async upTo(length) {
-      let bytes = await reader.upTo(length);
+    async upTo(length2) {
+      let bytes = await reader.upTo(length2);
       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);
+    async exactly(length2, seek = false) {
+      const bytes = await reader.exactly(length2, seek);
       if (bytes.length + bytesRead > byteLimit) {
         throw new Error("Unexpected end of data");
       }
       if (seek) {
-        bytesRead += length;
+        bytesRead += length2;
       }
       return bytes;
     },
-    seek(length) {
-      bytesRead += length;
-      reader.seek(length);
+    seek(length2) {
+      bytesRead += length2;
+      reader.seek(length2);
     },
     get pos() {
       return reader.pos;
@@ -842,10 +1707,10 @@ async function decodeReaderComplete(reader) {
 }
 
 // ../../../node_modules/.pnpm/@ipld+car@5.2.6/node_modules/@ipld/car/src/encoder.js
-var import_varint3 = __toESM(require_varint(), 1);
+var import_varint4 = __toESM(require_varint(), 1);
 function createHeader(roots) {
-  const headerBytes = encode2({ version: 1, roots });
-  const varintBytes = import_varint3.default.encode(headerBytes.length);
+  const headerBytes = encode4({ version: 1, roots });
+  const varintBytes = import_varint4.default.encode(headerBytes.length);
   const header = new Uint8Array(varintBytes.length + headerBytes.length);
   header.set(varintBytes, 0);
   header.set(headerBytes, varintBytes.length);
@@ -867,7 +1732,7 @@ function createEncoder(writer) {
      */
     async writeBlock(block) {
       const { cid, bytes } = block;
-      await writer.write(new Uint8Array(import_varint3.default.encode(cid.bytes.length + bytes.length)));
+      await writer.write(new Uint8Array(import_varint4.default.encode(cid.bytes.length + bytes.length)));
       await writer.write(cid.bytes);
       if (bytes.length) {
         await writer.write(bytes);
@@ -885,7 +1750,7 @@ function createEncoder(writer) {
 // ../../../node_modules/.pnpm/@ipld+car@5.2.6/node_modules/@ipld/car/src/iterator-channel.js
 function noop() {
 }
-function create() {
+function create2() {
   const chunkQueue = [];
   let drainer = null;
   let drainerResolver = noop;
@@ -1094,7 +1959,7 @@ var CarWriterOut = class {
   }
 };
 function encodeWriter() {
-  const iw = create();
+  const iw = create2();
   const { writer, iterator } = iw;
   const encoder = createEncoder(writer);
   return { encoder, iterator };
@@ -1121,24 +1986,133 @@ function toRoots(roots) {
   return _roots;
 }
 
-// src/pubsub/pub-pull.ts
-var { WARN, LOG, DEBUG, VERBOSE, ERROR } = E.setup(E.DEBUG);
-function integratePub({ targetThread, agentHash, subID, pubData }) {
-  const newLogs = pubData.thread.applogs.filter((log) => !targetThread.hasApplog(log, false));
-  LOG(`[integratePub] integrating ${newLogs.length} logs`, { targetThread, subID, pubData });
-  let toInsert = newLogs;
-  if (subID) {
-    toInsert = toInsert.concat(ensureTsPvAndFinalizeApplog(
-      { en: subID, at: "subscription/cid", vl: pubData.cid.toString(), ag: agentHash },
-      targetThread
-    ));
-  }
-  targetThread.insertRaw(toInsert);
-  return newLogs;
+// src/ipfs/car.ts
+var { WARN, LOG, DEBUG, VERBOSE, ERROR } = E.setup(E.INFO);
+async function decodePubFromCar(car) {
+  const decoded = await getBlocksOfCar(car);
+  return await decodePubFromBlocks(decoded);
+}
+async function decodePubFromBlocks({ rootCID, blockStore }, recursionTrace = []) {
+  if (!rootCID || !blockStore) {
+    throw ERROR("Empty roots/blocks", { rootCID, blockStore });
+  }
+  const root = await getDecodedBlock(blockStore, rootCID);
+  let pubLogsArray;
+  let applogsCID = null;
+  let info = null;
+  VERBOSE(`[decodePubFromBlocks] root:`, rootCID.toString(), root, { blockStore });
+  if (!root)
+    throw ERROR("root not found in blockStore", { blockStore, rootCID });
+  if (root?.info) {
+    applogsCID = root.applogs;
+    const applogsBlock = await getDecodedBlock(blockStore, applogsCID);
+    pubLogsArray = await unchunkApplogsBlock(applogsBlock, blockStore);
+    info = await getDecodedBlock(blockStore, root.info);
+    DEBUG(`new format - infoLogs`, info.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 CID)
+      applog.pv = applog.pv.toV1().toString();
+    return {
+      ...applog,
+      cid: cid.toV1().toString()
+    };
+  };
+  let applogs;
+  applogs = await Promise.all(pubLogsArray.map(resolveLogFromCidLink));
+  if (root.prev) {
+    if (areCidsEqual(root.prev, rootCID) || containsCid(recursionTrace, root.prev)) {
+      throw ERROR(`[pubFromBlocks] pub chain has a loop`, { rootCID, prev: root.prev, recursionTrace });
+    }
+    applogs.push(...(await decodePubFromBlocks({ rootCID: root.prev, blockStore }, [...recursionTrace, rootCID])).applogs);
+  }
+  const result = {
+    cid: rootCID,
+    info: {
+      ...info,
+      logs: await Promise.all(info.logs.map(resolveLogFromCidLink))
+    },
+    applogsCID,
+    applogs
+  };
+  DEBUG("[decodePubFromBlocks] result:", result, { rootCID: rootCID.toString(), root, blockStore, applogs, info });
+  return result;
+}
+async function getBlocksOfCar(car) {
+  const rootsFromCar = await car.getRoots();
+  const roots = rootsFromCar.map((c) => (typeof c.toV1 === "function" ? c : CID.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 : CID.decode(cidFromCarblocks.bytes);
+    VERBOSE({ cidFromCarblocks, cid });
+    blocks.set(cid.toV1().toString(), bytes);
+  }
+  if (roots.length !== 1) {
+    WARN("Unexpected roots count:", roots);
+  }
+  return {
+    rootCID: CID.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 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/pub-push.ts
-var { WARN: WARN2, LOG: LOG2, DEBUG: DEBUG2, VERBOSE: VERBOSE2, ERROR: ERROR2 } = E.setup(E.DEBUG);
+var { WARN: WARN2, LOG: LOG2, DEBUG: DEBUG2, VERBOSE: VERBOSE2, ERROR: ERROR2 } = E.setup(E.INFO);
 async function preparePubForPush(agent, appThread, threadToPublish, publication, prevPubCID) {
   let logsToPublish = getLogsFromThread(threadToPublish);
   DEBUG2(`[preparePubForPush] Collected ${logsToPublish.length} logs :`, {
@@ -1176,7 +2150,7 @@ async function preparePubForPush(agent, appThread, threadToPublish, publication,
     if (!sharedKey || !sharedKeyMap) {
       throw ERROR2("sharedAgents but no Keys/Map", { sharedAgents, sharedKeyMap, sharedKey });
     }
-    LOG2("encrypting", { sharedAgents, sharedKeyMap });
+    VERBOSE2("encrypting", { sharedAgents, sharedKeyMap });
     for (const [eachAgent, eachEncKey] of Array.from(sharedKeyMap.entries())) {
       VERBOSE2.force("adding key", { eachAgent, eachEncKey });
       agentSharedKeyLogs.push({
@@ -1199,7 +2173,13 @@ async function preparePubForPush(agent, appThread, threadToPublish, publication,
   } else {
     maybeEncryptedApplogs = logsToPublish;
   }
-  DEBUG2.force("adding all agent info and pubAtoms", { publication, agent, logsToPublish, threadToPublish, agentSharedKeyLogs });
+  DEBUG2("adding all agent info and pubAtoms", {
+    publication,
+    agent,
+    logsToPublish,
+    // threadToPublish, - very verbose
+    agentSharedKeyLogs
+  });
   const infoLogs = [
     ...rollingFilter(lastWriteWins(appThread), {
       // TODO: use static filter for performance
@@ -1221,7 +2201,7 @@ async function preparePubForPush(agent, appThread, threadToPublish, publication,
   if (!infologsToEncode.length) {
     throw ERROR2("no valid infologs", { agent, maybeEncryptedApplogs, infoLogs, applogsToEncode, infologsToEncode, prevPubCID });
   }
-  const encodedPub = encodePubAsCar(agent, applogsToEncode, infologsToEncode, prevPubCID);
+  const encodedPub = await encodePubAsCar(agent, applogsToEncode, infologsToEncode, prevPubCID);
   DEBUG2("inPreparePubForPush", { encodedPub });
   return encodedPub;
 }
@@ -1315,143 +2295,13 @@ async function encodeApplogsAsIPLD(applogs) {
   return { cids, encodedApplogs };
 }
 
-// src/pubsub/pubsub-types.ts
-function isPublication(obj) {
-  return obj?.pk !== void 0 && obj?.lastPush !== void 0;
-}
-function isSubscription(obj) {
-  return obj?.lastPull !== void 0;
-}
-function agentToShortHash(agentString) {
-  return cyrb53hash(agentString, 31, 7);
-}
-
-// src/ipfs/car.ts
-var { WARN: WARN3, LOG: LOG3, DEBUG: DEBUG3, VERBOSE: VERBOSE3, ERROR: ERROR3 } = E.setup(E.DEBUG);
-async function decodePubFromCar(car) {
-  const decoded = await getBlocksOfCar(car);
-  return await decodePubFromBlocks(decoded);
-}
-async function decodePubFromBlocks({ rootCID, blockStore }, recursionTrace = []) {
-  if (!rootCID || !blockStore) {
-    throw ERROR3("Empty roots/blocks", { rootCID, blockStore });
-  }
-  const root = await getDecodedBlock(blockStore, rootCID);
-  let pubLogsArray;
-  let applogsCID = null;
-  let info = null;
-  VERBOSE3(`[decodePubFromBlocks] root:`, rootCID.toString(), root, { blockStore });
-  if (!root)
-    throw ERROR3("root not found in blockStore", { blockStore, rootCID });
-  if (root?.info) {
-    applogsCID = root.applogs;
-    const applogsBlock = await getDecodedBlock(blockStore, applogsCID);
-    pubLogsArray = await unchunkApplogsBlock(applogsBlock, blockStore);
-    info = await getDecodedBlock(blockStore, root.info);
-    DEBUG3(`new format - infoLogs`, info.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) {
-      ERROR3(`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 CID)
-      applog.pv = applog.pv.toV1().toString();
-    return {
-      ...applog,
-      cid: cid.toV1().toString()
-    };
-  };
-  let applogs;
-  applogs = await Promise.all(pubLogsArray.map(resolveLogFromCidLink));
-  if (root.prev) {
-    if (areCidsEqual(root.prev, rootCID) || containsCid(recursionTrace, root.prev)) {
-      throw ERROR3(`[pubFromBlocks] pub chain has a loop`, { rootCID, prev: root.prev, recursionTrace });
-    }
-    applogs.push(...(await decodePubFromBlocks({ rootCID: root.prev, blockStore }, [...recursionTrace, rootCID])).applogs);
-  }
-  const result = {
-    cid: rootCID,
-    info: {
-      ...info,
-      logs: await Promise.all(info.logs.map(resolveLogFromCidLink))
-    },
-    applogsCID,
-    applogs
-  };
-  DEBUG3("[decodePubFromBlocks] result:", result, { rootCID: rootCID.toString(), root, blockStore, applogs, info });
-  return result;
-}
-async function getBlocksOfCar(car) {
-  const rootsFromCar = await car.getRoots();
-  const roots = rootsFromCar.map((c) => (typeof c.toV1 === "function" ? c : CID.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 : CID.decode(cidFromCarblocks.bytes);
-    VERBOSE3({ cidFromCarblocks, cid });
-    blocks.set(cid.toV1().toString(), bytes);
-  }
-  if (roots.length !== 1) {
-    WARN3("Unexpected roots count:", roots);
-  }
-  return {
-    rootCID: CID.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) {
-      WARN3("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]);
-  VERBOSE3(`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 streamReaderToIterable(bodyReader) {
-  return async function* () {
-    while (true) {
-      const { done, value } = await bodyReader.read();
-      VERBOSE3(`[car] chunk`, { done, value });
-      if (done) {
-        break;
-      }
-      yield value;
-    }
-  }();
-}
-
 export {
+  preparePubForPush,
+  encodePubAsCar,
+  chunkApplogs,
+  unchunkApplogsBlock,
+  isPubBlockChunks,
+  encodeApplogsAsCar,
   decodePubFromCar,
   decodePubFromBlocks,
   getBlocksOfCar,
@@ -1459,16 +2309,6 @@ export {
   makeCarOut,
   makeCarBlob,
   carFromBlob,
-  streamReaderToIterable,
-  integratePub,
-  preparePubForPush,
-  encodePubAsCar,
-  chunkApplogs,
-  unchunkApplogsBlock,
-  isPubBlockChunks,
-  encodeApplogsAsCar,
-  isPublication,
-  isSubscription,
-  agentToShortHash
+  streamReaderToIterable
 };
-//# sourceMappingURL=chunk-BLAIQY2K.min.js.map
+//# sourceMappingURL=chunk-C75X52ZX.min.js.map