@wovin/core 0.0.9-RC3 → 0.0.10

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

@@ -1,14 +1,30 @@
+import {
+  keepTruthy
+} from "./chunk-QPGEBDMJ.min.js";
+import {
+  lastWriteWins
+} from "./chunk-4432UCLM.min.js";
 import {
   CID,
-  Logger,
+  E,
   Token,
   Type,
+  areCidsEqual,
+  containsCid,
+  cyrb53hash,
   decode,
   decode2,
   decode3,
   encode,
-  makeCborEncoders
-} from "./chunk-PG6EJTCU.min.js";
+  encodeBlockOriginal,
+  ensureTsPvAndFinalizeApplog,
+  getLogsFromThread,
+  makeCborEncoders,
+  prepareForPub,
+  rollingFilter,
+  src_exports,
+  wrapper_default
+} from "./chunk-ITYJ7DMX.min.js";
 import {
   __commonJS,
   __toESM
@@ -101,7 +117,7 @@ var require_varint = __commonJS({
   }
 });
 
-// ../../../node_modules/.pnpm/@ipld+dag-cbor@9.0.6/node_modules/@ipld/dag-cbor/src/index.js
+// ../../../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) {
@@ -130,7 +146,7 @@ function numberEncoder(num) {
   }
   return null;
 }
-var encodeOptions = {
+var _encodeOptions = {
   float64: true,
   typeEncoders: {
     Object: cidEncoder,
@@ -138,13 +154,19 @@ var encodeOptions = {
     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 = {
+var _decodeOptions = {
   allowIndefinite: false,
   coerceUndefinedToNull: true,
   allowNaN: false,
@@ -158,11 +180,15 @@ var decodeOptions = {
   /** @type {import('cborg').TagDecoder[]} */
   tags: []
 };
-decodeOptions.tags[CID_CBOR_TAG] = cidDecoder;
-var encode2 = (node) => encode(node, encodeOptions);
-var decode4 = (data) => decode(data, decodeOptions);
+_decodeOptions.tags[CID_CBOR_TAG] = cidDecoder;
+var decodeOptions = {
+  ..._decodeOptions,
+  tags: _decodeOptions.tags.slice()
+};
+var encode2 = (node) => encode(node, _encodeOptions);
+var decode4 = (data) => decode(data, _decodeOptions);
 
-// ../../../node_modules/.pnpm/@ipld+car@5.2.4/node_modules/@ipld/car/src/decoder-common.js
+// ../../../node_modules/.pnpm/@ipld+car@5.2.6/node_modules/@ipld/car/src/decoder-common.js
 var import_varint = __toESM(require_varint(), 1);
 var CIDV0_BYTES = {
   SHA2_256: 18,
@@ -215,7 +241,7 @@ function getMultihashLength(bytes) {
   return mhLength;
 }
 
-// ../../../node_modules/.pnpm/@ipld+car@5.2.4/node_modules/@ipld/car/src/header-validator.js
+// ../../../node_modules/.pnpm/@ipld+car@5.2.6/node_modules/@ipld/car/src/header-validator.js
 var Kinds = {
   Null: (
     /** @returns {undefined|null} */
@@ -437,10 +463,10 @@ var CarV1HeaderOrV2Pragma = {
   toRepresentation: Reprs.CarV1HeaderOrV2Pragma
 };
 
-// ../../../node_modules/.pnpm/cborg@4.0.5/node_modules/cborg/lib/length.js
+// ../../../node_modules/.pnpm/cborg@4.0.9/node_modules/cborg/lib/length.js
 var cborEncoders = makeCborEncoders();
 
-// ../../../node_modules/.pnpm/@ipld+car@5.2.4/node_modules/@ipld/car/src/buffer-writer.js
+// ../../../node_modules/.pnpm/@ipld+car@5.2.6/node_modules/@ipld/car/src/buffer-writer.js
 var import_varint2 = __toESM(require_varint(), 1);
 var headerPreludeTokens = [
   new Token(Type.map, 2),
@@ -450,7 +476,7 @@ var headerPreludeTokens = [
 ];
 var CID_TAG = new Token(Type.tag, 42);
 
-// ../../../node_modules/.pnpm/@ipld+car@5.2.4/node_modules/@ipld/car/src/decoder.js
+// ../../../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) {
@@ -668,83 +694,7 @@ function limitReader(reader, byteLimit) {
   };
 }
 
-// ../../../node_modules/.pnpm/@ipld+car@5.2.4/node_modules/@ipld/car/src/indexer.js
-var CarIndexer = class {
-  /**
-   * @param {number} version
-   * @param {CID[]} roots
-   * @param {AsyncGenerator<BlockIndex>} iterator
-   */
-  constructor(version, roots, iterator) {
-    this._version = version;
-    this._roots = roots;
-    this._iterator = iterator;
-  }
-  get version() {
-    return this._version;
-  }
-  /**
-   * Get the list of roots defined by the CAR referenced by this indexer. May be
-   * zero or more `CID`s.
-   *
-   * @function
-   * @memberof CarIndexer
-   * @instance
-   * @async
-   * @returns {Promise<CID[]>}
-   */
-  async getRoots() {
-    return this._roots;
-  }
-  /**
-   * @returns {AsyncIterator<BlockIndex>}
-   */
-  [Symbol.asyncIterator]() {
-    return this._iterator;
-  }
-  /**
-   * Instantiate a {@link CarIndexer} from a `Uint8Array` blob. Only the header
-   * is decoded initially, the remainder is processed and emitted via the
-   * iterator as it is consumed.
-   *
-   * @async
-   * @static
-   * @memberof CarIndexer
-   * @param {Uint8Array} bytes
-   * @returns {Promise<CarIndexer>}
-   */
-  static async fromBytes(bytes) {
-    if (!(bytes instanceof Uint8Array)) {
-      throw new TypeError("fromBytes() requires a Uint8Array");
-    }
-    return decodeIndexerComplete(bytesReader(bytes));
-  }
-  /**
-   * Instantiate a {@link CarIndexer} 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).
-   * is decoded initially, the remainder is processed and emitted via the
-   * iterator as it is consumed.
-   *
-   * @async
-   * @static
-   * @memberof CarIndexer
-   * @param {AsyncIterable<Uint8Array>} asyncIterable
-   * @returns {Promise<CarIndexer>}
-   */
-  static async fromIterable(asyncIterable) {
-    if (!asyncIterable || !(typeof asyncIterable[Symbol.asyncIterator] === "function")) {
-      throw new TypeError("fromIterable() requires an async iterable");
-    }
-    return decodeIndexerComplete(asyncIterableReader(asyncIterable));
-  }
-};
-async function decodeIndexerComplete(reader) {
-  const decoder = createDecoder(reader);
-  const { version, roots } = await decoder.header();
-  return new CarIndexer(version, roots, decoder.blocksIndex());
-}
-
-// ../../../node_modules/.pnpm/@ipld+car@5.2.4/node_modules/@ipld/car/src/reader-browser.js
+// ../../../node_modules/.pnpm/@ipld+car@5.2.6/node_modules/@ipld/car/src/reader-browser.js
 var CarReader = class {
   /**
    * @constructs CarReader
@@ -891,174 +841,7 @@ async function decodeReaderComplete(reader) {
   return new CarReader(header, blocks);
 }
 
-// ../../../node_modules/.pnpm/@ipld+car@5.2.4/node_modules/@ipld/car/src/iterator.js
-var CarIteratorBase = class {
-  /**
-   * @param {number} version
-   * @param {CID[]} roots
-   * @param {AsyncIterable<Block>|void} iterable
-   */
-  constructor(version, roots, iterable) {
-    this._version = version;
-    this._roots = roots;
-    this._iterable = iterable;
-    this._decoded = false;
-  }
-  get version() {
-    return this._version;
-  }
-  /**
-   * @returns {Promise<CID[]>}
-   */
-  async getRoots() {
-    return this._roots;
-  }
-};
-var CarBlockIterator = class _CarBlockIterator extends CarIteratorBase {
-  // inherited method
-  /**
-   * Get the list of roots defined by the CAR referenced by this iterator. May be
-   * zero or more `CID`s.
-   *
-   * @function getRoots
-   * @memberof CarBlockIterator
-   * @instance
-   * @async
-   * @returns {Promise<CID[]>}
-   */
-  /**
-   * @returns {AsyncIterator<Block>}
-   */
-  [Symbol.asyncIterator]() {
-    if (this._decoded) {
-      throw new Error("Cannot decode more than once");
-    }
-    if (!this._iterable) {
-      throw new Error("Block iterable not found");
-    }
-    this._decoded = true;
-    return this._iterable[Symbol.asyncIterator]();
-  }
-  /**
-   * Instantiate a {@link CarBlockIterator} from a `Uint8Array` blob. Rather
-   * than decoding the entire byte array prior to returning the iterator, as in
-   * {@link CarReader.fromBytes}, only the header is decoded and the remainder
-   * of the CAR is parsed as the `Block`s as yielded.
-   *
-   * @async
-   * @static
-   * @memberof CarBlockIterator
-   * @param {Uint8Array} bytes
-   * @returns {Promise<CarBlockIterator>}
-   */
-  static async fromBytes(bytes) {
-    const { version, roots, iterator } = await fromBytes2(bytes);
-    return new _CarBlockIterator(version, roots, iterator);
-  }
-  /**
-   * Instantiate a {@link CarBlockIterator} 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).
-   * Rather than decoding the entire byte array prior to returning the iterator,
-   * as in {@link CarReader.fromIterable}, only the header is decoded and the
-   * remainder of the CAR is parsed as the `Block`s as yielded.
-   *
-   * @async
-   * @static
-   * @param {AsyncIterable<Uint8Array>} asyncIterable
-   * @returns {Promise<CarBlockIterator>}
-   */
-  static async fromIterable(asyncIterable) {
-    const { version, roots, iterator } = await fromIterable(asyncIterable);
-    return new _CarBlockIterator(version, roots, iterator);
-  }
-};
-var CarCIDIterator = class _CarCIDIterator extends CarIteratorBase {
-  // inherited method
-  /**
-   * Get the list of roots defined by the CAR referenced by this iterator. May be
-   * zero or more `CID`s.
-   *
-   * @function getRoots
-   * @memberof CarCIDIterator
-   * @instance
-   * @async
-   * @returns {Promise<CID[]>}
-   */
-  /**
-   * @returns {AsyncIterator<CID>}
-   */
-  [Symbol.asyncIterator]() {
-    if (this._decoded) {
-      throw new Error("Cannot decode more than once");
-    }
-    if (!this._iterable) {
-      throw new Error("Block iterable not found");
-    }
-    this._decoded = true;
-    const iterable = this._iterable[Symbol.asyncIterator]();
-    return {
-      async next() {
-        const next = await iterable.next();
-        if (next.done) {
-          return next;
-        }
-        return { done: false, value: next.value.cid };
-      }
-    };
-  }
-  /**
-   * Instantiate a {@link CarCIDIterator} from a `Uint8Array` blob. Rather
-   * than decoding the entire byte array prior to returning the iterator, as in
-   * {@link CarReader.fromBytes}, only the header is decoded and the remainder
-   * of the CAR is parsed as the `CID`s as yielded.
-   *
-   * @async
-   * @static
-   * @memberof CarCIDIterator
-   * @param {Uint8Array} bytes
-   * @returns {Promise<CarCIDIterator>}
-   */
-  static async fromBytes(bytes) {
-    const { version, roots, iterator } = await fromBytes2(bytes);
-    return new _CarCIDIterator(version, roots, iterator);
-  }
-  /**
-   * Instantiate a {@link CarCIDIterator} 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).
-   * Rather than decoding the entire byte array prior to returning the iterator,
-   * as in {@link CarReader.fromIterable}, only the header is decoded and the
-   * remainder of the CAR is parsed as the `CID`s as yielded.
-   *
-   * @async
-   * @static
-   * @memberof CarCIDIterator
-   * @param {AsyncIterable<Uint8Array>} asyncIterable
-   * @returns {Promise<CarCIDIterator>}
-   */
-  static async fromIterable(asyncIterable) {
-    const { version, roots, iterator } = await fromIterable(asyncIterable);
-    return new _CarCIDIterator(version, roots, iterator);
-  }
-};
-async function fromBytes2(bytes) {
-  if (!(bytes instanceof Uint8Array)) {
-    throw new TypeError("fromBytes() requires a Uint8Array");
-  }
-  return decodeIterator(bytesReader(bytes));
-}
-async function fromIterable(asyncIterable) {
-  if (!asyncIterable || !(typeof asyncIterable[Symbol.asyncIterator] === "function")) {
-    throw new TypeError("fromIterable() requires an async iterable");
-  }
-  return decodeIterator(asyncIterableReader(asyncIterable));
-}
-async function decodeIterator(reader) {
-  const decoder = createDecoder(reader);
-  const { version, roots } = await decoder.header();
-  return { version, roots, iterator: decoder.blocks() };
-}
-
-// ../../../node_modules/.pnpm/@ipld+car@5.2.4/node_modules/@ipld/car/src/encoder.js
+// ../../../node_modules/.pnpm/@ipld+car@5.2.6/node_modules/@ipld/car/src/encoder.js
 var import_varint3 = __toESM(require_varint(), 1);
 function createHeader(roots) {
   const headerBytes = encode2({ version: 1, roots });
@@ -1099,7 +882,7 @@ function createEncoder(writer) {
   };
 }
 
-// ../../../node_modules/.pnpm/@ipld+car@5.2.4/node_modules/@ipld/car/src/iterator-channel.js
+// ../../../node_modules/.pnpm/@ipld+car@5.2.6/node_modules/@ipld/car/src/iterator-channel.js
 function noop() {
 }
 function create() {
@@ -1168,7 +951,7 @@ function create() {
   return { writer, iterator };
 }
 
-// ../../../node_modules/.pnpm/@ipld+car@5.2.4/node_modules/@ipld/car/src/writer-browser.js
+// ../../../node_modules/.pnpm/@ipld+car@5.2.6/node_modules/@ipld/car/src/writer-browser.js
 var CarWriter = class _CarWriter {
   /**
    * @param {CID[]} roots
@@ -1338,54 +1121,307 @@ function toRoots(roots) {
   return _roots;
 }
 
-// src/ipfs/car.ts
-var { WARN, LOG, DEBUG, VERBOSE, ERROR } = Logger.setup(Logger.INFO);
-async function decodeCarToApplogs(car) {
-  const { roots, blocks } = await decodeCar(car);
-  if (!roots || !blocks) {
-    throw ERROR("decodeCar is funky", { roots, blocks });
+// 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
+    ));
   }
-  if (roots.length !== 1) {
-    WARN("Unexpected roots count:", roots);
+  targetThread.insertRaw(toInsert);
+  return newLogs;
+}
+
+// src/pubsub/pub-push.ts
+var { WARN: WARN2, LOG: LOG2, DEBUG: DEBUG2, VERBOSE: VERBOSE2, ERROR: ERROR2 } = E.setup(E.DEBUG);
+async function preparePubForPush(agent, appThread, threadToPublish, publication, prevPubCID) {
+  let logsToPublish = getLogsFromThread(threadToPublish);
+  DEBUG2(`[preparePubForPush] Collected ${logsToPublish.length} logs :`, {
+    logsToPublish,
+    threadOrLogsCount: threadToPublish.nameAndSizeUntracked || `[${threadToPublish.length}]`
+  });
+  const { sharedAgents, sharedKeyMap, sharedKey, pubCounter } = publication ?? {};
+  const getExistingOrNewLog = (thread, publication2, ag, at, vl) => {
+    let logInQuestion = rollingFilter(lastWriteWins(thread), { en: publication2.id, at }).latestLog;
+    if (!logInQuestion && vl !== void 0) {
+      logInQuestion = ensureTsPvAndFinalizeApplog({ ag, en: publication2.id, at, vl }, thread);
+    }
+    return logInQuestion;
+  };
+  const pubNameLog = getExistingOrNewLog(appThread, publication, agent.ag, "pub/name", publication.name);
+  const pubCounterLog = getExistingOrNewLog(appThread, publication, agent.ag, "pub/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 });
+    }
+    LOG2("encrypting", { sharedAgents, sharedKeyMap });
+    for (const [eachAgent, eachEncKey] of Array.from(sharedKeyMap.entries())) {
+      VERBOSE2.force("adding key", { eachAgent, eachEncKey });
+      agentSharedKeyLogs.push({
+        ag: agent.ag,
+        en: eachAgent,
+        at: "pub/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.force("[crypto] encrypting ", { eachLog, sharedKey });
+      const encPayload = await encryptApplog(eachLog, sharedKey);
+      DEBUG2.force("[crypto] encrypted ", { eachLog, encPayload, sharedKey });
+      encryptedApplogs.push({ enc: encPayload });
+    }
+    maybeEncryptedApplogs = encryptedApplogs;
+  } else {
+    maybeEncryptedApplogs = logsToPublish;
+  }
+  DEBUG2.force("adding all agent info and pubAtoms", { publication, agent, logsToPublish, threadToPublish, agentSharedKeyLogs });
+  const infoLogs = [
+    ...rollingFilter(lastWriteWins(appThread), {
+      // TODO: use static filter for performance
+      en: agent.ag,
+      at: ["agent/ecdh", "agent/jwkd", "agent/appAgent"]
+    }).applogs,
+    ...pubNameLog ? [pubNameLog] : [],
+    ...pubCounterLog ? [pubCounterLog] : [],
+    ...agentSharedKeyLogs
+  ];
+  DEBUG2(`[preparePubForPush] info logs:`, infoLogs);
+  if (!infoLogs.find(({ at }) => at === "agent/appAgent"))
+    throw ERROR2(`[preparePubForPush] 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, prevPubCID });
   }
-  const root = blocks.get(roots[0]);
-  let applogArr;
-  DEBUG(`root:`, root, { blocks });
-  if (root.info) {
-    applogArr = blocks.get(root.applogs.toString()).logs;
-    DEBUG(`new format - infoLogs`, blocks.get(root.info.toString()));
+  if (!infologsToEncode.length) {
+    throw ERROR2("no valid infologs", { agent, maybeEncryptedApplogs, infoLogs, applogsToEncode, infologsToEncode, prevPubCID });
+  }
+  const encodedPub = encodePubAsCar(agent, applogsToEncode, infologsToEncode, prevPubCID);
+  DEBUG2("inPreparePubForPush", { encodedPub });
+  return encodedPub;
+}
+async function encodePubAsCar(agent, applogs, infoLogs, prevPubCID) {
+  DEBUG2(`[encodePubAsCar] encoding`, { agent, applogs, infoLogs });
+  const { cids: infoLogCids, encodedApplogs: encodedInfoLogs } = await encodeApplogsAsIPLD(infoLogs);
+  const { cids: applogCids, encodedApplogs } = await encodeApplogsAsIPLD(applogs);
+  const blocks = [...encodedApplogs, ...encodedInfoLogs];
+  const infoLogsWrap = await encodeBlockOriginal({ logs: infoLogCids });
+  blocks.push(infoLogsWrap);
+  const { rootCID: chunkRootCID, blocks: chunkBlocks } = await chunkApplogs(applogCids);
+  blocks.push(...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: prevPubCID
+  };
+  DEBUG2("[encodePubAsCar] encoding root", { root, logCids: applogCids, infoLogCids });
+  const encodedRoot = await encodeBlockOriginal(root);
+  blocks.push(encodedRoot);
+  DEBUG2("[encodePubAsCar] => 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 (isPubBlockChunks(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 {
-    applogArr = root.applogs;
+    return block.logs;
   }
-  let applogs;
-  applogs = applogArr.map((cidOrLink) => {
-    const cid = cidOrLink.toV1 ? cidOrLink.toV1().toString() : cidOrLink["/"];
-    const applog = blocks.get(cid);
+}
+function isPubBlockChunks(block) {
+  return block.chunks;
+}
+async function encodeApplogsAsCar(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("[encodeApplogsAsCar] encoded root", { cids, encodedRoot });
+  return await makeCarBlob(encodedRoot.cid, [encodedRoot, ...encodedApplogs]);
+}
+async function encodeApplogsAsIPLD(applogs) {
+  DEBUG2.force({ applogs });
+  const validApplogs = applogs.filter((eachLog) => !!eachLog);
+  DEBUG2.force({ 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.force("[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 };
+}
+
+// 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) {
-      ERROR(`Could not find applog CID in Car file:`, cid, { root, blocks });
-      throw new Error(`Could not find applog CID in Car file: ${cid.toString()}`);
+      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: cid.toV1().toString()
     };
-  });
-  DEBUG("Decoded car logs:", root, { roots, blocks, applogs });
-  return { applogs };
+  };
+  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 decodeCar(car) {
-  const roots = (await car.getRoots()).map((c) => c.toV1().toString());
+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, bytes } of car.blocks()) {
-    blocks.set(cid.toV1().toString(), decode3(bytes));
+  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 { roots, blocks };
+  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 });
+  VERBOSE3(`Writing ${blocks.length} blocks to CAR`, { roots, blocks });
   blocks.forEach((b) => writer.put(b));
   writer.close();
   return out;
@@ -1406,6 +1442,7 @@ function streamReaderToIterable(bodyReader) {
   return async function* () {
     while (true) {
       const { done, value } = await bodyReader.read();
+      VERBOSE3(`[car] chunk`, { done, value });
       if (done) {
         break;
       }
@@ -1415,11 +1452,23 @@ function streamReaderToIterable(bodyReader) {
 }
 
 export {
-  decodeCarToApplogs,
-  decodeCar,
+  decodePubFromCar,
+  decodePubFromBlocks,
+  getBlocksOfCar,
+  getDecodedBlock,
   makeCarOut,
   makeCarBlob,
   carFromBlob,
-  streamReaderToIterable
+  streamReaderToIterable,
+  integratePub,
+  preparePubForPush,
+  encodePubAsCar,
+  chunkApplogs,
+  unchunkApplogsBlock,
+  isPubBlockChunks,
+  encodeApplogsAsCar,
+  isPublication,
+  isSubscription,
+  agentToShortHash
 };
-//# sourceMappingURL=chunk-RMPMFLPZ.min.js.map
+//# sourceMappingURL=chunk-BLAIQY2K.min.js.map