@wovin/core 0.0.0-ciao-mobx-955482e8

package/dist/chunk-CY4NLISM.js

@@ -0,0 +1,144 @@
+import {
+  unchunkApplogsBlock
+} from "./chunk-O43W7UW6.js";
+import {
+  areCidsEqual,
+  removeDuplicateAppLogs
+} from "./chunk-XIQSYEV3.js";
+
+// src/retrieve/update-thread.ts
+import * as dagJson from "@ipld/dag-json";
+import { Logger } from "besonders-logger";
+import { CID } from "multiformats/cid";
+var { WARN, LOG, DEBUG, VERBOSE, ERROR } = Logger.setup(Logger.INFO);
+function withBlockCache(source, store) {
+  return {
+    get: (cid) => store.get(cid),
+    async *getDag(cid) {
+      for await (const block of source.getDag(cid)) {
+        await store.put(block.cid, block.bytes);
+        yield block;
+      }
+    }
+  };
+}
+function createMemoryBlockStore() {
+  const blocks = /* @__PURE__ */ new Map();
+  return {
+    get(cid) {
+      return blocks.get(cid.toV1().toString());
+    },
+    put(cid, bytes) {
+      blocks.set(cid.toV1().toString(), bytes);
+    }
+  };
+}
+async function getDecodedBlock(blockStore, cid) {
+  const bytes = blockStore.get(cid);
+  if (!bytes) return null;
+  return dagJson.decode(bytes);
+}
+async function updateThreadFromSnapshot(thread, cid, retriever, options) {
+  const { excludeSnapshotCID, stopAtCounter, maxDepth = 100 } = options ?? {};
+  DEBUG("[updateThreadFromSnapshot] starting from", cid.toString(), {
+    excludeSnapshotCID: excludeSnapshotCID?.toString(),
+    stopAtCounter,
+    maxDepth
+  });
+  const blockStore = createMemoryBlockStore();
+  const visited = /* @__PURE__ */ new Set();
+  let currentCID = cid;
+  let snapshotCount = 0;
+  const allApplogs = [];
+  let minCounter = Infinity;
+  let maxCounter = -Infinity;
+  let lastCounter;
+  while (currentCID && snapshotCount < maxDepth) {
+    const cidStr = currentCID.toString();
+    if (visited.has(cidStr)) {
+      throw ERROR("[updateThreadFromSnapshot] snapshot chain has a loop", {
+        currentCID: cidStr,
+        visited: [...visited]
+      });
+    }
+    visited.add(cidStr);
+    if (excludeSnapshotCID && areCidsEqual(currentCID, excludeSnapshotCID)) {
+      DEBUG("[updateThreadFromSnapshot] reached excludeSnapshotCID, stopping", excludeSnapshotCID.toString());
+      break;
+    }
+    DEBUG("[updateThreadFromSnapshot] fetching root block", cidStr);
+    const rootBytes = await retriever.get(currentCID);
+    blockStore.put(currentCID, rootBytes);
+    const root = dagJson.decode(rootBytes);
+    if (typeof root.prevCounter === "number") {
+      minCounter = Math.min(minCounter, root.prevCounter);
+      maxCounter = Math.max(maxCounter, root.prevCounter);
+      if (lastCounter !== void 0 && root.prevCounter !== lastCounter - 1) {
+        WARN("[updateThreadFromSnapshot] counter gap detected", {
+          expected: lastCounter - 1,
+          got: root.prevCounter
+        });
+      }
+      lastCounter = root.prevCounter;
+    }
+    if (stopAtCounter !== void 0 && typeof root.prevCounter === "number" && root.prevCounter <= stopAtCounter) {
+      DEBUG("[updateThreadFromSnapshot] reached stopAtCounter", { stopAtCounter, prevCounter: root.prevCounter });
+      break;
+    }
+    DEBUG("[updateThreadFromSnapshot] fetching applogs", root.applogs.toString());
+    for await (const { cid: blockCid, bytes } of retriever.getDag(root.applogs)) {
+      blockStore.put(blockCid, bytes);
+    }
+    DEBUG("[updateThreadFromSnapshot] fetching info", root.info.toString());
+    for await (const { cid: blockCid, bytes } of retriever.getDag(root.info)) {
+      blockStore.put(blockCid, bytes);
+    }
+    const applogsBlock = await getDecodedBlock(blockStore, root.applogs);
+    if (!applogsBlock) {
+      throw ERROR("[updateThreadFromSnapshot] applogs block not found", { cid: root.applogs.toString() });
+    }
+    const applogCIDs = await unchunkApplogsBlock(applogsBlock, {
+      get: async (cid2) => blockStore.get(cid2)
+    });
+    for (const applogCID of applogCIDs) {
+      const applog = await getDecodedBlock(blockStore, applogCID);
+      if (!applog) {
+        WARN("[updateThreadFromSnapshot] applog not found:", applogCID.toString());
+        continue;
+      }
+      if (applog.pv instanceof CID) {
+        applog.pv = applog.pv.toV1().toString();
+      }
+      allApplogs.push({
+        ...applog,
+        cid: applogCID.toV1().toString()
+      });
+    }
+    snapshotCount++;
+    currentCID = root.prev;
+  }
+  DEBUG("[updateThreadFromSnapshot] fetched", {
+    snapshotCount,
+    applogCount: allApplogs.length,
+    rootCID: cid.toString()
+  });
+  const deduplicated = removeDuplicateAppLogs(allApplogs, "cleanup");
+  const inserted = thread.insertMissing(deduplicated, false);
+  DEBUG("[updateThreadFromSnapshot] inserted", {
+    insertedCount: inserted.length,
+    duplicateCount: deduplicated.length - inserted.length
+  });
+  return {
+    cid,
+    applogs: deduplicated,
+    insertedCount: inserted.length,
+    snapshotCount,
+    counterRange: minCounter !== Infinity ? { minCounter, maxCounter } : void 0
+  };
+}
+
+export {
+  withBlockCache,
+  updateThreadFromSnapshot
+};
+//# sourceMappingURL=chunk-CY4NLISM.js.map

package/dist/chunk-CY4NLISM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/retrieve/update-thread.ts"],"sourcesContent":["import { CarReader } from '@ipld/car'\nimport * as dagJson from '@ipld/dag-json'\nimport { Logger } from 'besonders-logger'\nimport { CID } from 'multiformats/cid'\nimport type { Applog } from '../applog/datom-types.ts'\nimport { removeDuplicateAppLogs } from '../applog/applog-utils.ts'\nimport type { SnapRootBlock, SnapBlockLogsOrChunks } from '../pubsub/pubsub-types.ts'\nimport { unchunkApplogsBlock } from '../pubsub/snap-push.ts'\nimport { areCidsEqual } from '../ipfs/ipfs-utils.ts'\nimport type { WriteableThread } from '../thread/writeable.ts'\nimport type { BlockStore } from '../blockstore/index.ts'\n\nconst { WARN, LOG, DEBUG, VERBOSE, ERROR } = Logger.setup(Logger.INFO) // eslint-disable-line no-unused-vars\n\n/**\n * Block retrieval abstraction - fetch or get blocks.\n * Implemented by gateway retriever or local blockstore.\n */\nexport interface BlockRetriever {\n\t/** Get single block by CID */\n\tget(cid: CID): Promise<Uint8Array>\n\t/** Get all blocks in DAG rooted at CID (for applogs/info sub-DAGs) */\n\tgetDag(cid: CID): AsyncIterable<{ cid: CID; bytes: Uint8Array }>\n}\n\n/**\n * Wrap a BlockRetriever so fetched blocks flow through a BlockStore.\n * - get: delegates to store.get() (which handles local-first / remote fallback)\n * - getDag: streams from source, puts each block into store\n */\nexport function withBlockCache(\n\tsource: BlockRetriever,\n\tstore: BlockStore,\n): BlockRetriever {\n\treturn {\n\t\tget: (cid) => store.get(cid),\n\t\tasync *getDag(cid) {\n\t\t\tfor await (const block of source.getDag(cid)) {\n\t\t\t\tawait store.put(block.cid, block.bytes)\n\t\t\t\tyield block\n\t\t\t}\n\t\t},\n\t}\n}\n\n/**\n * Options for updateThreadFromSnapshot\n */\nexport interface UpdateOptions {\n\t/** CID of last included snapshot - exclude this and older snapshots */\n\texcludeSnapshotCID?: CID\n\t/** Stop when we reach this counter (walking backwards) */\n\tstopAtCounter?: number\n\t/** Maximum number of snapshots to traverse (default: 100) */\n\tmaxDepth?: number\n}\n\n/**\n * Result from updateThreadFromSnapshot\n */\nexport interface UpdateResult {\n\t/** Root CID that was fetched */\n\tcid: CID\n\t/** All applogs decoded from the chain */\n\tapplogs: Applog[]\n\t/** Count of applogs actually inserted (not duplicates) */\n\tinsertedCount: number\n\t/** Number of snapshots traversed */\n\tsnapshotCount: number\n\t/** Counter range encountered (min/max) */\n\tcounterRange?: { minCounter: number; maxCounter: number }\n}\n\n/**\n * Simple in-memory block store used during snapshot chain fetch.\n */\ninterface MemoryBlockStore {\n\tget(cid: CID): Uint8Array | undefined\n\tput(cid: CID, bytes: Uint8Array): void\n}\n\nfunction createMemoryBlockStore(): MemoryBlockStore {\n\tconst blocks = new Map<string, Uint8Array>()\n\treturn {\n\t\tget(cid: CID) {\n\t\t\treturn blocks.get(cid.toV1().toString())\n\t\t},\n\t\tput(cid: CID, bytes: Uint8Array) {\n\t\t\tblocks.set(cid.toV1().toString(), bytes)\n\t\t},\n\t}\n}\n\nasync function getDecodedBlock<T>(blockStore: MemoryBlockStore, cid: CID): Promise<T | null> {\n\tconst bytes = blockStore.get(cid)\n\tif (!bytes) return null\n\treturn dagJson.decode(bytes) as T\n}\n\n/**\n * Fetch snapshot chain from CID using a BlockRetriever, decode applogs, insert into thread.\n * Stops before excludeSnapshotCID if provided (incremental update).\n *\n * @param thread - WriteableThread to insert applogs into\n * @param cid - Root CID of the snapshot to start from\n * @param retriever - BlockRetriever for fetching blocks\n * @param options - Optional configuration\n * @returns UpdateResult with applogs and counts\n */\nexport async function updateThreadFromSnapshot(\n\tthread: WriteableThread,\n\tcid: CID,\n\tretriever: BlockRetriever,\n\toptions?: UpdateOptions\n): Promise<UpdateResult> {\n\tconst { excludeSnapshotCID, stopAtCounter, maxDepth = 100 } = options ?? {}\n\n\tDEBUG('[updateThreadFromSnapshot] starting from', cid.toString(), {\n\t\texcludeSnapshotCID: excludeSnapshotCID?.toString(),\n\t\tstopAtCounter,\n\t\tmaxDepth,\n\t})\n\n\tconst blockStore = createMemoryBlockStore()\n\tconst visited = new Set<string>()\n\tlet currentCID: CID | undefined = cid\n\tlet snapshotCount = 0\n\tconst allApplogs: Applog[] = []\n\tlet minCounter = Infinity\n\tlet maxCounter = -Infinity\n\tlet lastCounter: number | undefined\n\n\twhile (currentCID && snapshotCount < maxDepth) {\n\t\tconst cidStr = currentCID.toString()\n\n\t\t// Loop detection\n\t\tif (visited.has(cidStr)) {\n\t\t\tthrow ERROR('[updateThreadFromSnapshot] snapshot chain has a loop', {\n\t\t\t\tcurrentCID: cidStr,\n\t\t\t\tvisited: [...visited],\n\t\t\t})\n\t\t}\n\t\tvisited.add(cidStr)\n\n\t\t// Check stop condition BEFORE fetching content\n\t\tif (excludeSnapshotCID && areCidsEqual(currentCID, excludeSnapshotCID)) {\n\t\t\tDEBUG('[updateThreadFromSnapshot] reached excludeSnapshotCID, stopping', excludeSnapshotCID.toString())\n\t\t\tbreak\n\t\t}\n\n\t\t// 1. Fetch root block\n\t\tDEBUG('[updateThreadFromSnapshot] fetching root block', cidStr)\n\t\tconst rootBytes = await retriever.get(currentCID)\n\t\tblockStore.put(currentCID, rootBytes)\n\n\t\t// Parse root to get applogs, info, prev CIDs\n\t\tconst root = dagJson.decode(rootBytes) as SnapRootBlock\n\n\t\t// Track counter range and validate sequentiality\n\t\tif (typeof root.prevCounter === 'number') {\n\t\t\tminCounter = Math.min(minCounter, root.prevCounter)\n\t\t\tmaxCounter = Math.max(maxCounter, root.prevCounter)\n\n\t\t\t// Validate sequentiality (walking backwards, counter should decrease)\n\t\t\tif (lastCounter !== undefined && root.prevCounter !== lastCounter - 1) {\n\t\t\t\tWARN('[updateThreadFromSnapshot] counter gap detected', {\n\t\t\t\t\texpected: lastCounter - 1,\n\t\t\t\t\tgot: root.prevCounter,\n\t\t\t\t})\n\t\t\t}\n\t\t\tlastCounter = root.prevCounter\n\t\t}\n\n\t\t// Stop condition based on counter\n\t\tif (stopAtCounter !== undefined && typeof root.prevCounter === 'number' && root.prevCounter <= stopAtCounter) {\n\t\t\tDEBUG('[updateThreadFromSnapshot] reached stopAtCounter', { stopAtCounter, prevCounter: root.prevCounter })\n\t\t\tbreak\n\t\t}\n\n\t\t// 2. Fetch applogs DAG\n\t\tDEBUG('[updateThreadFromSnapshot] fetching applogs', root.applogs.toString())\n\t\tfor await (const { cid: blockCid, bytes } of retriever.getDag(root.applogs)) {\n\t\t\tblockStore.put(blockCid, bytes)\n\t\t}\n\n\t\t// 3. Fetch info DAG\n\t\tDEBUG('[updateThreadFromSnapshot] fetching info', root.info.toString())\n\t\tfor await (const { cid: blockCid, bytes } of retriever.getDag(root.info)) {\n\t\t\tblockStore.put(blockCid, bytes)\n\t\t}\n\n\t\t// Decode applogs from this snapshot\n\t\tconst applogsBlock = await getDecodedBlock<SnapBlockLogsOrChunks>(blockStore, root.applogs)\n\t\tif (!applogsBlock) {\n\t\t\tthrow ERROR('[updateThreadFromSnapshot] applogs block not found', { cid: root.applogs.toString() })\n\t\t}\n\n\t\t// Use the unchunk helper which handles both chunked and non-chunked formats\n\t\tconst applogCIDs = await unchunkApplogsBlock(applogsBlock, {\n\t\t\tget: async (cid: CID) => blockStore.get(cid)!,\n\t\t})\n\n\t\t// Resolve each applog CID to actual applog data\n\t\tfor (const applogCID of applogCIDs) {\n\t\t\tconst applog = await getDecodedBlock<Applog>(blockStore, applogCID)\n\t\t\tif (!applog) {\n\t\t\t\tWARN('[updateThreadFromSnapshot] applog not found:', applogCID.toString())\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\t// Normalize pv field if it's a CID instance\n\t\t\tif ((applog.pv as any) instanceof CID) {\n\t\t\t\tapplog.pv = (applog.pv as any as CID).toV1().toString()\n\t\t\t}\n\t\t\tallApplogs.push({\n\t\t\t\t...applog,\n\t\t\t\tcid: applogCID.toV1().toString(),\n\t\t\t})\n\t\t}\n\n\t\tsnapshotCount++\n\t\tcurrentCID = root.prev // Move to previous snapshot\n\t}\n\n\tDEBUG('[updateThreadFromSnapshot] fetched', {\n\t\tsnapshotCount,\n\t\tapplogCount: allApplogs.length,\n\t\trootCID: cid.toString(),\n\t})\n\n\t// Deduplicate applogs (in case of overlapping snapshots)\n\tconst deduplicated = removeDuplicateAppLogs(allApplogs, 'cleanup')\n\n\t// Insert into thread\n\tconst inserted = thread.insertMissing(deduplicated, false)\n\n\tDEBUG('[updateThreadFromSnapshot] inserted', {\n\t\tinsertedCount: inserted.length,\n\t\tduplicateCount: deduplicated.length - inserted.length,\n\t})\n\n\treturn {\n\t\tcid,\n\t\tapplogs: deduplicated,\n\t\tinsertedCount: inserted.length,\n\t\tsnapshotCount,\n\t\tcounterRange: minCounter !== Infinity ? { minCounter, maxCounter } : undefined,\n\t}\n}\n"],"mappings":"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","names":["cid"]}

package/dist/chunk-E46VTKTZ.js

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-E46VTKTZ.js.map

package/dist/chunk-E46VTKTZ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-O43W7UW6.js

@@ -0,0 +1,434 @@
+import {
+  keepTruthy
+} from "./chunk-YDAKBU6Q.js";
+import {
+  lastWriteWins
+} from "./chunk-ZXCJRYD7.js";
+import {
+  areCidsEqual,
+  encodeBlockOriginal,
+  ensureTsPvAndFinalizeApplog,
+  getLogsFromThread,
+  prepareForPub,
+  rollingFilter
+} from "./chunk-XIQSYEV3.js";
+
+// src/pubsub/snap-push.ts
+import * as dagJson2 from "@ipld/dag-json";
+import { Logger as Logger2 } from "besonders-logger";
+import stringify from "safe-stable-stringify";
+
+// src/ipfs/car.ts
+import { CarReader, CarWriter } from "@ipld/car";
+import * as dagJson from "@ipld/dag-json";
+import { Logger } from "besonders-logger";
+import { CID } from "multiformats";
+var { WARN, LOG, DEBUG, VERBOSE, ERROR } = Logger.setup(Logger.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 CID) 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 CID) 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 : 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 dagJson.decode(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 CID) 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 = dagJson.decode(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 } = Logger2.setup(Logger2.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 = stringify(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: dagJson2 });
+  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-O43W7UW6.js.map