bulletin-deploy 0.7.14 → 0.7.15

package/dist/{chunk-3ILZFC4E.js → chunk-VQHM3R6N.js}

@@ -1,9 +1,30 @@
 import {
-  merkleizeJS
-} from "./chunk-B7GUYYAN.js";
+  computeStats,
+  renderSummary,
+  telemetryAttributes
+} from "./chunk-MJTQOXBC.js";
+import {
+  finaliseEmbeddedManifest,
+  writeEmbeddedManifestPlaceholder
+} from "./chunk-KOSF5FDO.js";
+import {
+  DEFAULT_GATEWAY,
+  fetchPreviousManifest
+} from "./chunk-5MRZ3V4A.js";
+import {
+  MANIFEST_PATH,
+  MANIFEST_VERSION,
+  classifyFile
+} from "./chunk-S7EM5VMW.js";
 import {
   setDeployContext
-} from "./chunk-3RNYFSU7.js";
+} from "./chunk-AQUBKPSF.js";
+import {
+  probeChunks
+} from "./chunk-Y2OSXJIZ.js";
+import {
+  packSection
+} from "./chunk-C2TS5MER.js";
 import {
   DotNS,
   TX_TIMEOUT_MS,
@@ -11,7 +32,7 @@ import {
   parseDomainName,
   popStatusName,
   verifyNonceAdvanced
-} from "./chunk-LM5U3XDV.js";
+} from "./chunk-5TW653QP.js";
 import {
   derivePoolAccounts,
   detectTestnet,
@@ -20,19 +41,6 @@ import {
   selectAccount,
   topUpBy
 } from "./chunk-VOEFHED3.js";
-import {
-  DEFAULT_ENV_ID,
-  loadEnvironments,
-  resolveEndpoints
-} from "./chunk-2VYG7NXN.js";
-import {
-  NonRetryableError
-} from "./chunk-ZOC4GITL.js";
-import {
-  MirrorSkipped,
-  mirrorToGitHubPages,
-  pollMirrorFreshness
-} from "./chunk-HOTQDYHD.js";
 import {
   VERSION,
   captureWarning,
@@ -46,7 +54,31 @@ import {
   truncateAddress,
   withDeploySpan,
   withSpan
-} from "./chunk-4AP5ZFNV.js";
+} from "./chunk-KMRYJR4E.js";
+import {
+  DEFAULT_ENV_ID,
+  loadEnvironments,
+  resolveEndpoints
+} from "./chunk-2VYG7NXN.js";
+import {
+  NonRetryableError
+} from "./chunk-ZOC4GITL.js";
+import {
+  MirrorSkipped,
+  mirrorToGitHubPages,
+  pollMirrorFreshness
+} from "./chunk-HOTQDYHD.js";
+
+// src/merkle.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import { execSync as execSync2 } from "child_process";
+import { importer } from "ipfs-unixfs-importer";
+import { CarReader } from "@ipld/car/reader";
+import { CarWriter } from "@ipld/car/writer";
+import { CID as CID2 } from "multiformats/cid";
+import * as dagPB2 from "@ipld/dag-pb";
+import { UnixFS as UnixFS2 } from "ipfs-unixfs";
 
 // src/deploy.ts
 import { Buffer } from "buffer";
@@ -121,11 +153,11 @@ function isConnectionError(error) {
   return /heartbeat timeout|WS halt|Unable to connect|ChainHead disjointed/i.test(msg);
 }
 var CID_CONFIG = { version: 1, codec: 85, hashCode: 18, hashLength: 32 };
-function deriveRootSigner(mnemonic, path2 = "") {
+function deriveRootSigner(mnemonic, path3 = "") {
   const entropy = mnemonicToEntropy(mnemonic);
   const miniSecret = entropyToMiniSecret(entropy);
   const derive = sr25519CreateDerive(miniSecret);
-  const keyPair = derive(path2);
+  const keyPair = derive(path3);
   const signer = getPolkadotSigner(keyPair.publicKey, "Sr25519", keyPair.sign);
   return { signer, ss58: ss58Address(keyPair.publicKey) };
 }
@@ -341,7 +373,19 @@ async function storeFile(contentBytes, { client: existingClient, unsafeApi: exis
     throw e;
   }
 }
-async function storeChunkedContent(chunks, { client: existingClient, unsafeApi: existingApi, signer: existingSigner, ss58: existingSS58, reconnect, fetchNonce: fetchNonceOverride } = {}) {
+function assignDenseNonces(stored, startNonce) {
+  const nonces = /* @__PURE__ */ new Map();
+  let counter = 0;
+  for (let i = 0; i < stored.length; i++) {
+    if (stored[i] === null) {
+      nonces.set(i, startNonce + counter);
+      counter++;
+    }
+  }
+  return nonces;
+}
+var __assignDenseNoncesForTest = assignDenseNonces;
+async function storeChunkedContent(chunks, { client: existingClient, unsafeApi: existingApi, signer: existingSigner, ss58: existingSS58, reconnect, fetchNonce: fetchNonceOverride, skipCids, probeFailedCids, gateway: providerGateway } = {}) {
   const _fetchNonce = fetchNonceOverride ?? fetchNonce;
   console.log(`
    Chunks: ${chunks.length}`);
@@ -441,7 +485,18 @@ async function storeChunkedContent(chunks, { client: existingClient, unsafeApi:
     console.log(`
    Submitting ${chunks.length} chunks in batches of up to ${BATCH_SIZE_INITIAL}...`);
     const stored = new Array(chunks.length).fill(null);
-    const assignedNonces = /* @__PURE__ */ new Map();
+    if (skipCids && skipCids.size > 0) {
+      let skippedCount = 0;
+      for (let i = 0; i < chunks.length; i++) {
+        const cid = createCID(chunks[i], CID_CONFIG.codec, 18);
+        if (skipCids.has(cid.toString())) {
+          stored[i] = { cid, len: chunks[i].length, viaFallback: true };
+          skippedCount++;
+        }
+      }
+      if (skippedCount > 0) console.log(`   Skipping ${skippedCount} already-present chunks (gateway probe)`);
+    }
+    const assignedNonces = assignDenseNonces(stored, startNonce);
     let b = 0;
     while (b < chunks.length) {
       if (wsHaltDetected && reconnect && reconnectionsUsed < MAX_RECONNECTIONS) {
@@ -464,9 +519,6 @@ async function storeChunkedContent(chunks, { client: existingClient, unsafeApi:
       }
       const batchPromises = batchChunks.map((chunkData, j) => {
         const i = batchIndices[j];
-        if (!assignedNonces.has(i)) {
-          assignedNonces.set(i, startNonce + i);
-        }
         const nonce = assignedNonces.get(i);
         console.log(`   [${i + 1}/${chunks.length}] ${(chunkData.length / 1024 / 1024).toFixed(2)} MB (nonce: ${nonce})`);
         return storeChunk(unsafeApi, signer, chunkData, nonce, ss58, { fetchNonce: fetchNonceOverride });
@@ -497,6 +549,13 @@ async function storeChunkedContent(chunks, { client: existingClient, unsafeApi:
         }
       }
       for (const fail of failures) {
+        const failCid = createCID(fail.chunkData, CID_CONFIG.codec, 18);
+        if (probeFailedCids && probeFailedCids.has(failCid.toString()) && fail.error?.message?.includes("isValid:false")) {
+          console.log(`   Chunk ${fail.index + 1}: isValid:false but CID was probe-failed \u2014 treating as already on chain`);
+          captureWarning("isValid:false treated as success (probe-failed backstop)", { chunkIndex: fail.index + 1, cid: failCid.toString() });
+          stored[fail.index] = { cid: failCid, len: fail.chunkData.length, viaFallback: true };
+          continue;
+        }
         captureWarning("Chunk upload failed, retrying", { chunkIndex: fail.index + 1, maxRetries: MAX_CHUNK_RETRIES, error: fail.error?.message?.slice(0, 200) });
         let retried = false;
         for (let attempt = 1; attempt <= MAX_CHUNK_RETRIES; attempt++) {
@@ -529,6 +588,14 @@ async function storeChunkedContent(chunks, { client: existingClient, unsafeApi:
             retried = true;
             break;
           } catch (e) {
+            if (probeFailedCids && probeFailedCids.has(failCid.toString()) && e?.message?.includes("isValid:false")) {
+              console.log(`   Chunk ${fail.index + 1}: retry isValid:false but CID was probe-failed \u2014 treating as already on chain`);
+              captureWarning("isValid:false retry treated as success (probe-failed backstop)", { chunkIndex: fail.index + 1, cid: failCid.toString(), attempt });
+              stored[fail.index] = { cid: failCid, len: fail.chunkData.length, viaFallback: true };
+              assignedNonces.delete(fail.index);
+              retried = true;
+              break;
+            }
             captureWarning("Chunk retry failed", { chunkIndex: fail.index + 1, attempt, maxRetries: MAX_CHUNK_RETRIES, error: e.message?.slice(0, 200) });
             console.log(`   Retry ${attempt} failed: ${e.message?.slice(0, 80)}`);
             if (isConnectionError(e) && reconnect && reconnectionsUsed < MAX_RECONNECTIONS) {
@@ -561,12 +628,48 @@ async function storeChunkedContent(chunks, { client: existingClient, unsafeApi:
       }
     }
     console.log(`   All ${chunks.length} chunks verified \u2713`);
+    const fallbackStored = verifiedStored.filter((c) => c.viaFallback === true);
+    let tier2Verified = 0;
+    let tier2Inconclusive = 0;
+    if (fallbackStored.length > 0) {
+      console.log(`   Re-probing ${fallbackStored.length} via-fallback chunk(s) via chain (issue #269)...`);
+      const fallbackCids = fallbackStored.map((c) => c.cid.toString());
+      const verifyStart = Date.now();
+      const verifyResults = await probeChunks(fallbackCids, { client });
+      const missingCids = [];
+      for (const r of verifyResults) {
+        if (r.present === false) {
+          missingCids.push(r.cid);
+        } else if (r.present === null) {
+          captureWarning("Post-upload chain re-probe failed (inconclusive)", { cid: r.cid, failureReason: r.failureReason });
+          tier2Inconclusive++;
+        } else {
+          tier2Verified++;
+        }
+      }
+      if (missingCids.length > 0) {
+        const preview = missingCids.slice(0, 5).join(", ");
+        const suffix = missingCids.length > 5 ? `, ...and ${missingCids.length - 5} more` : "";
+        throw new Error(
+          `Pre-flight chunk verification failed: ${missingCids.length} chunk(s) marked stored but absent from chain. Missing CIDs: ${preview}${suffix}. Re-run the deploy.`
+        );
+      }
+      const verifyMs = Date.now() - verifyStart;
+      console.log(`   \u2713 All ${fallbackStored.length} via-fallback chunk(s) confirmed present on chain (${verifyMs}ms)`);
+    }
     console.log(`   Building DAG-PB...`);
     const fileData = new UnixFS({ type: "file", blockSizes: verifiedStored.map((c) => BigInt(c.len)) });
     const dagNode = dagPB.prepare({ Data: fileData.marshal(), Links: verifiedStored.map((c) => ({ Name: "", Tsize: c.len, Hash: c.cid })) });
     const dagBytes = dagPB.encode(dagNode);
     const hashCode = 18;
     const rootCid = createCID(dagBytes, 112, hashCode);
+    const rssBeforeRootMb = Math.round(process.memoryUsage().rss / 1024 / 1024);
+    if (rssBeforeRootMb > 2048) {
+      captureWarning("high RSS before root node store \u2014 OOM risk", {
+        rss_mb: rssBeforeRootMb,
+        chunks: chunks.length
+      });
+    }
     const MAX_ROOT_RETRIES = 3;
     let result;
     for (let rootAttempt = 1; rootAttempt <= MAX_ROOT_RETRIES; rootAttempt++) {
@@ -596,7 +699,7 @@ async function storeChunkedContent(chunks, { client: existingClient, unsafeApi:
       }
     }
     if (ownsClient) client.destroy();
-    return result;
+    return { storageCid: result, tier2Verified, tier2Inconclusive, tier2Fallback: fallbackStored.length };
   } catch (e) {
     if (ownsClient) client.destroy();
     throw e;
@@ -702,7 +805,7 @@ async function storeDirectory(directoryPath, providerOrOptions = {}, password, j
     sampleMemory("chunk_upload_start");
     const r = await storeChunkedContent(carChunks, provider);
     sampleMemory("chunk_upload_end");
-    return r;
+    return r.storageCid;
   });
   if (storageCid !== predictedStorageCid) {
     captureWarning("computeStorageCid drift vs storeChunkedContent", {
@@ -712,6 +815,286 @@ async function storeDirectory(directoryPath, providerOrOptions = {}, password, j
   }
   return { storageCid, ipfsCid, carBytes: carContent };
 }
+async function readPreviousContenthashSafe(dotns, domainName) {
+  try {
+    const hex = await dotns.getContenthash(domainName);
+    if (!hex || hex === "0x") return null;
+    const bytes = Buffer.from(hex.slice(2), "hex");
+    if (bytes[0] !== 227 || bytes.length < 4) return null;
+    return CID.decode(bytes.slice(2)).toString();
+  } catch {
+    return null;
+  }
+}
+function buildFilesMap(buildDir, fileCids = /* @__PURE__ */ new Map()) {
+  const map = {};
+  function walk(dir, prefix = "") {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    entries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+    for (const entry of entries) {
+      const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+      const abs = path.join(dir, entry.name);
+      if (entry.isDirectory()) walk(abs, rel);
+      else if (entry.isFile()) {
+        if (rel === MANIFEST_PATH) continue;
+        const fileCid = fileCids.get(rel) ?? "";
+        let size = 0;
+        try {
+          size = fs.statSync(abs).size;
+        } catch {
+        }
+        const type = classifyFile(rel, { fileCid: fileCid || void 0 });
+        map[rel] = { cid: fileCid, type, size };
+      }
+    }
+  }
+  walk(buildDir);
+  return map;
+}
+async function readRetentionPeriodBlocks(unsafeApi) {
+  try {
+    const rp = await unsafeApi.query.TransactionStorage.RetentionPeriod.getValue();
+    return Number(rp);
+  } catch {
+    return 0;
+  }
+}
+function detectFramework(directoryPath) {
+  if (fs.existsSync(path.join(directoryPath, "_next"))) return "next";
+  if (fs.existsSync(path.join(directoryPath, "assets"))) return "vite";
+  return null;
+}
+var SIZE_WARN_BYTES = 50 * 1024 * 1024;
+var SIZE_ABORT_BYTES = 500 * 1024 * 1024;
+function checkDeploySize(carBytes, opts) {
+  if (carBytes >= SIZE_ABORT_BYTES && !opts.allowLargeDeploy) {
+    return { kind: "abort", message: `deploy exceeds 500 MiB (${(carBytes / 1024 / 1024).toFixed(1)} MiB). Re-run with --allow-large-deploy if intentional.` };
+  }
+  if (carBytes >= SIZE_WARN_BYTES) {
+    return { kind: "warn", message: `deploy exceeds 50 MiB (${(carBytes / 1024 / 1024).toFixed(1)} MiB). Continuing.` };
+  }
+  return { kind: "ok" };
+}
+function resolveReproducibleTimestamp(source) {
+  if (source === "commit") {
+    try {
+      const out = execSync("git log -1 --format=%cI", { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+      const d2 = new Date(out);
+      if (Number.isNaN(d2.getTime())) throw new Error("invalid git committer date");
+      return d2.toISOString();
+    } catch (e) {
+      throw new Error(`--reproducible=commit failed: ${e?.message ?? e}. Provide --reproducible=<ISO8601> instead.`);
+    }
+  }
+  if (source.startsWith("epoch:")) {
+    const n = Number(source.slice("epoch:".length));
+    if (!Number.isFinite(n)) throw new Error(`--reproducible=epoch:N requires a number; got ${source}`);
+    return new Date(n * 1e3).toISOString();
+  }
+  const d = new Date(source);
+  if (Number.isNaN(d.getTime())) throw new Error(`--reproducible=<source>: '${source}' is not a recognised timestamp`);
+  return d.toISOString();
+}
+function preWarmGateway(chunkCids, gateways) {
+  for (const cid of chunkCids) {
+    for (const gw of gateways) {
+      const url = `${gw.replace(/\/$/, "")}/ipfs/${cid}`;
+      fetch(url, { method: "HEAD" }).catch(() => {
+      });
+    }
+  }
+}
+async function storeDirectoryV2(directoryPath, opts = {}) {
+  if (opts.password) return storeDirectory(directoryPath, opts);
+  const provider = opts.provider ?? {};
+  const prevContenthash = opts.previousContenthash ?? null;
+  const gateway = opts.gateway ?? DEFAULT_GATEWAY;
+  const dirBasename = path.basename(directoryPath);
+  sampleMemory("storage_start");
+  const fetched = await fetchPreviousManifest(prevContenthash, { gateway });
+  const prevManifest = fetched.source === "embedded" ? fetched.manifest : null;
+  console.log(`   Manifest fetch: ${fetched.source}${fetched.source !== "none" ? ` (${fetched.attempts} attempt${fetched.attempts === 1 ? "" : "s"})` : ""}`);
+  const deployedAt = opts.reproducibleSource ? resolveReproducibleTimestamp(opts.reproducibleSource) : (/* @__PURE__ */ new Date()).toISOString();
+  writeEmbeddedManifestPlaceholder(directoryPath, {
+    version: MANIFEST_VERSION,
+    previousContenthash: prevContenthash,
+    deployedAt,
+    framework: null
+  });
+  let useKubo;
+  if (opts.jsMerkle === true) {
+    useKubo = false;
+  } else if (opts.jsMerkle === false) {
+    if (!hasIPFS()) {
+      throw new Error("jsMerkle:false requires the ipfs binary on PATH; install from https://docs.ipfs.tech/install/ or omit --js-merkle to fall back to JS.");
+    }
+    useKubo = true;
+  } else {
+    useKubo = hasIPFS();
+  }
+  const phaseA = await withSpan("deploy.merkleize", `1a. merkleize (${useKubo ? "kubo" : "js"}, stable)`, { "deploy.directory": dirBasename, "deploy.merkle": useKubo ? "kubo" : "js" }, async () => {
+    const r = await merkleizeWithStableOrder(directoryPath, prevManifest?.stableBlockOrder, { useKubo });
+    sampleMemory("merkleize_end");
+    return r;
+  });
+  const carChunksA = phaseA.chunks;
+  const carChunkCidsA = phaseA.chunkCids;
+  const probe = carChunkCidsA.length > 0 ? await withSpan("deploy.chain-probe", "2. chain probe", { "deploy.probe.total": carChunkCidsA.length }, () => probeChunks(carChunkCidsA, { client: provider.client })) : [];
+  const skipCids = /* @__PURE__ */ new Set();
+  const probeFailedCidsA = /* @__PURE__ */ new Set();
+  let bytesSkipped = 0;
+  for (let i = 0; i < probe.length; i++) {
+    if (probe[i].present === true) {
+      skipCids.add(carChunkCidsA[i]);
+      bytesSkipped += carChunksA[i].length;
+    } else if (probe[i].present === null) {
+      probeFailedCidsA.add(carChunkCidsA[i]);
+    }
+  }
+  const probePresent = probe.filter((p) => p.present === true).length;
+  const probeAbsent = probe.filter((p) => p.present === false).length;
+  const probeFailedAll = probe.filter((p) => p.present === null);
+  setDeployAttribute("deploy.probe.present", probePresent);
+  setDeployAttribute("deploy.probe.absent", probeAbsent);
+  setDeployAttribute("deploy.probe.failed", probeFailedAll.length);
+  setDeployAttribute("deploy.probe.failed_rpc", probeFailedAll.filter((r) => r.failureReason === "rpc_error").length);
+  setDeployAttribute("deploy.probe.failed_decode", probeFailedAll.filter((r) => r.failureReason === "decode_error").length);
+  setDeployAttribute("deploy.probe.failed_metadata", probeFailedAll.filter((r) => r.failureReason === "metadata_error").length);
+  console.log(`   Probe: ${probe.length} chunks \u2192 ${probePresent} present, ${probeAbsent} absent, ${probeFailedAll.length} probe-failed`);
+  setDeployReportContext({
+    jsMerkle: true,
+    chunkCount: carChunksA.length,
+    carBytes: phaseA.carBytes.length,
+    outputDir: path.dirname(directoryPath)
+  });
+  setDeployContext({
+    chunkCount: carChunksA.length,
+    totalSize: `${(phaseA.carBytes.length / 1024 / 1024).toFixed(2)} MB`
+  });
+  const carMbA = String(Math.round(phaseA.carBytes.length / 1024 / 1024 * 100) / 100);
+  await withSpan("deploy.chunk-upload", "1b. chunk-upload (phase A)", {
+    "deploy.chunks.total": carChunksA.length,
+    "deploy.chunks.skipped": skipCids.size,
+    "deploy.car.bytes": phaseA.carBytes.length,
+    "deploy.car.mb": carMbA
+  }, async () => {
+    sampleMemory("chunk_upload_start");
+    await storeChunkedContent(carChunksA, { ...provider, gateway, skipCids, probeFailedCids: probeFailedCidsA });
+    sampleMemory("chunk_upload_end");
+  });
+  const phaseAKnownPresent = new Set(carChunkCidsA);
+  const filesMap = buildFilesMap(directoryPath, phaseA.fileCids);
+  const blocksList = [...phaseA.blocks.keys()];
+  const chunksMap = {};
+  for (let i = 0; i < phaseA.section1ChunkCids.length; i++) {
+    const cid = phaseA.section1ChunkCids[i];
+    const probedIdx = phaseA.chunkCids.indexOf(cid);
+    const probeOutcome = probedIdx >= 0 ? probe[probedIdx] : void 0;
+    const inheritFrom = prevManifest?.chunks?.[cid];
+    let deployedAtForChunk;
+    if (probeOutcome?.present === true && inheritFrom) {
+      deployedAtForChunk = inheritFrom.deployed_at;
+    } else if (probeOutcome?.present === null && inheritFrom) {
+      deployedAtForChunk = inheritFrom.deployed_at;
+    } else {
+      deployedAtForChunk = deployedAt;
+    }
+    const sizeBytes = phaseA.chunks[probedIdx]?.length ?? 0;
+    const probeEntry = probeOutcome?.present === true ? { block: probeOutcome.block, index: probeOutcome.index } : {};
+    chunksMap[cid] = { size: sizeBytes, deployed_at: deployedAtForChunk, ...probeEntry };
+  }
+  finaliseEmbeddedManifest(directoryPath, {
+    version: MANIFEST_VERSION,
+    previousContenthash: prevContenthash,
+    deployedAt,
+    framework: detectFramework(directoryPath),
+    files: filesMap,
+    stableBlockOrder: phaseA.stableOrder,
+    blocks: blocksList,
+    chunks: chunksMap
+  });
+  const phaseB = await withSpan("deploy.merkleize", "1c. merkleize (js, finalise)", { "deploy.directory": dirBasename }, async () => {
+    const r = await merkleizeWithStableOrder(directoryPath, phaseA.stableOrder, { useKubo });
+    sampleMemory("merkleize_finalise_end");
+    return r;
+  });
+  const sizeDecision = checkDeploySize(phaseB.carBytes.length, { allowLargeDeploy: opts.allowLargeDeploy });
+  if (sizeDecision.kind === "abort") throw new Error(sizeDecision.message);
+  if (sizeDecision.kind === "warn") console.warn(`   \u26A0 ${sizeDecision.message}`);
+  const dumpPath = process.env.BULLETIN_DEPLOY_DUMP_CAR ?? path.join(path.dirname(directoryPath), `${path.basename(directoryPath)}.bulletin.car`);
+  fs.writeFileSync(dumpPath, phaseB.carBytes);
+  console.log(`   Pre-upload CAR saved to ${dumpPath} (${(phaseB.carBytes.length / 1024 / 1024).toFixed(2)} MB)`);
+  const carChunksB = phaseB.chunks;
+  const carChunkCidsB = phaseB.chunkCids;
+  const skipCidsB = new Set(phaseAKnownPresent);
+  const predictedStorageCid = computeStorageCid(carChunksB);
+  if (opts.onCarReady) await opts.onCarReady(phaseB.carBytes, predictedStorageCid);
+  const carMbB = String(Math.round(phaseB.carBytes.length / 1024 / 1024 * 100) / 100);
+  const newPhaseBChunks = carChunkCidsB.filter((c) => !skipCidsB.has(c)).length;
+  const phaseBResult = await withSpan("deploy.chunk-upload", "1d. chunk-upload (phase B)", {
+    "deploy.chunks.total": carChunksB.length,
+    "deploy.chunks.phase_b_new": newPhaseBChunks,
+    "deploy.car.bytes": phaseB.carBytes.length,
+    "deploy.car.mb": carMbB
+  }, async () => {
+    sampleMemory("chunk_upload_b_start");
+    const r = await storeChunkedContent(carChunksB, { ...provider, gateway, skipCids: skipCidsB, probeFailedCids: probeFailedCidsA });
+    sampleMemory("chunk_upload_b_end");
+    return r;
+  });
+  const storageCid = phaseBResult.storageCid;
+  if (storageCid !== predictedStorageCid) {
+    captureWarning("computeStorageCid drift vs storeChunkedContent (v2)", {
+      predicted: predictedStorageCid,
+      uploaded: storageCid
+    });
+  }
+  const newlyUploadedCids = carChunkCidsB.filter((c) => !skipCidsB.has(c));
+  if (newlyUploadedCids.length > 0) {
+    preWarmGateway(newlyUploadedCids, [gateway]);
+  }
+  const retentionPeriodBlocks = await readRetentionPeriodBlocks(provider.unsafeApi);
+  const framework = detectFramework(directoryPath);
+  const filesStableCount = [...phaseA.fileCids.entries()].filter(([p, cid]) => {
+    if (p === MANIFEST_PATH) return false;
+    return classifyFile(p, { prevManifest, fileCid: cid, framework }) === "stable";
+  }).length;
+  const filesTotalCount = phaseA.fileCids.size - (phaseA.fileCids.has(MANIFEST_PATH) ? 1 : 0);
+  let bytesUploadedB = 0;
+  let bytesSkippedB = 0;
+  for (let i = 0; i < phaseB.chunks.length; i++) {
+    const len = phaseB.chunks[i].length;
+    if (skipCidsB.has(phaseB.chunkCids[i])) bytesSkippedB += len;
+    else bytesUploadedB += len;
+  }
+  const stats = computeStats({
+    manifestSource: fetched.source,
+    manifestFetchAttempts: fetched.source === "none" ? 0 : fetched.attempts ?? 0,
+    manifestBytes: fetched.source === "embedded" ? fetched.bytesDownloaded ?? 0 : 0,
+    framework,
+    filesTotal: filesTotalCount,
+    filesStable: filesStableCount,
+    filesVolatile: filesTotalCount - filesStableCount,
+    probeResults: probe,
+    prevChunks: prevManifest?.chunks ?? {},
+    retentionPeriodBlocks,
+    bytesSkipped: bytesSkippedB,
+    bytesUploaded: bytesUploadedB,
+    chunksTotal: phaseB.chunks.length,
+    chunksUploaded: phaseB.chunks.length - skipCidsB.size,
+    chunksSkipped: skipCidsB.size,
+    carBytes: phaseB.carBytes.length,
+    sectionSizes: phaseB.sectionSizes,
+    tier2VerifiedCount: phaseBResult.tier2Verified,
+    tier2InconclusiveCount: phaseBResult.tier2Inconclusive,
+    tier2FallbackCount: phaseBResult.tier2Fallback
+  });
+  for (const [k, v] of Object.entries(telemetryAttributes(stats))) {
+    setDeployAttribute(k, v);
+  }
+  console.log("\n" + renderSummary(stats));
+  return { storageCid, ipfsCid: phaseB.cid, carBytes: phaseB.carBytes };
+}
 function resolveDotnsConnectOptions(options, assetHubEndpoints) {
   const tail = assetHubEndpoints && assetHubEndpoints.length > 0 ? { assetHubEndpoints } : {};
   if (options.signer && options.signerAddress) {
@@ -798,6 +1181,7 @@ async function deploy(content, domainName = null, options = {}) {
     let provider;
     const reconnect = options.mnemonic ? () => getDirectProvider(options.mnemonic, options.derivationPath) : () => getProvider();
     let dotnsPreflight = null;
+    let previousContenthashCid = null;
     try {
       console.log("\n" + "=".repeat(60));
       console.log("Preflight");
@@ -815,6 +1199,7 @@ async function deploy(content, domainName = null, options = {}) {
               );
             }
           }
+          previousContenthashCid = await readPreviousContenthashSafe(preflight, parsed.fullName);
         } finally {
           preflight.disconnect();
         }
@@ -822,6 +1207,7 @@ async function deploy(content, domainName = null, options = {}) {
       } else {
         try {
           dotnsPreflight = await preflight.preflight(name);
+          previousContenthashCid = await readPreviousContenthashSafe(preflight, name);
         } finally {
           preflight.disconnect();
         }
@@ -877,7 +1263,7 @@ async function deploy(content, domainName = null, options = {}) {
             console.log(`   Encrypted: ${(encrypted.length / 1024).toFixed(1)} KB`);
             contentChunks = chunk(encrypted);
           }
-          cid = await storeChunkedContent(contentChunks, providerWithReconnect);
+          cid = (await storeChunkedContent(contentChunks, providerWithReconnect)).storageCid;
         } else if (typeof content === "string") {
           const contentPath = path.resolve(content);
           if (!fs.existsSync(contentPath)) throw new Error(`Path not found: ${contentPath}`);
@@ -886,10 +1272,16 @@ async function deploy(content, domainName = null, options = {}) {
             console.log(`
    Mode: Directory`);
             console.log(`   Path: ${contentPath}`);
-            const { storageCid: sCid, ipfsCid: iCid } = await storeDirectory(contentPath, {
+            if (previousContenthashCid) console.log(`   Incremental: previous contenthash ${previousContenthashCid}`);
+            else console.log(`   Incremental: first deploy (no previous contenthash)`);
+            const storeFn = options.password ? storeDirectory : storeDirectoryV2;
+            const { storageCid: sCid, ipfsCid: iCid } = await storeFn(contentPath, {
               provider: providerWithReconnect,
               password: options.password,
               jsMerkle: options.jsMerkle,
+              previousContenthash: previousContenthashCid,
+              allowLargeDeploy: options.allowLargeDeploy,
+              reproducibleSource: options.reproducibleSource,
               onCarReady: (carBytes, predictedCid) => {
                 if (options.ghPagesMirror) {
                   mirrorPromise = mirrorToGitHubPages({
@@ -917,7 +1309,7 @@ async function deploy(content, domainName = null, options = {}) {
             }
             if (fileContent.length > MAX_FILE_SIZE) {
               console.log(`   Exceeds 8MB, chunking...`);
-              cid = await storeChunkedContent(chunk(fileContent), providerWithReconnect);
+              cid = (await storeChunkedContent(chunk(fileContent), providerWithReconnect)).storageCid;
             } else {
               cid = await storeFile(fileContent, providerWithReconnect);
             }
@@ -933,7 +1325,7 @@ async function deploy(content, domainName = null, options = {}) {
           }
           if (bytesContent.length > MAX_FILE_SIZE) {
             console.log(`   Exceeds 8MB, chunking...`);
-            cid = await storeChunkedContent(chunk(bytesContent), providerWithReconnect);
+            cid = (await storeChunkedContent(chunk(bytesContent), providerWithReconnect)).storageCid;
           } else {
             cid = await storeFile(bytesContent, providerWithReconnect);
           }
@@ -1033,7 +1425,383 @@ async function deploy(content, domainName = null, options = {}) {
   });
 }
 
+// src/merkle.ts
+var CidPreservingBlockstore = class {
+  data = /* @__PURE__ */ new Map();
+  async put(cid, bytes) {
+    this.data.set(cid.toString(), { cid, bytes });
+    return cid;
+  }
+  *all() {
+    yield* this.data.values();
+  }
+  clear() {
+    this.data.clear();
+  }
+};
+function* walkDirectoryLazy(dirPath, prefix = "") {
+  let dirents;
+  try {
+    dirents = fs2.readdirSync(dirPath, { withFileTypes: true });
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") throw new Error(`Directory not found: ${dirPath}`);
+    if (code === "ENOTDIR") throw new Error(`Not a directory: ${dirPath}`);
+    throw err;
+  }
+  dirents.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+  for (const entry of dirents) {
+    const fullPath = path2.join(dirPath, entry.name);
+    const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      yield* walkDirectoryLazy(fullPath, relativePath);
+    } else if (entry.isFile()) {
+      yield { path: relativePath, absolutePath: fullPath };
+    }
+  }
+}
+async function collectBytes(iter) {
+  const parts = [];
+  let totalLength = 0;
+  for await (const chunk2 of iter) {
+    parts.push(chunk2);
+    totalLength += chunk2.length;
+  }
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    result.set(part, offset);
+    offset += part.length;
+    parts[i] = void 0;
+  }
+  return result;
+}
+function walkFileBlocks(rootCidStr, blocks) {
+  const fileBlocks = /* @__PURE__ */ new Map();
+  const fileCids = /* @__PURE__ */ new Map();
+  const rootBlockCids = [];
+  const subdirCids = [];
+  const subdirSeen = /* @__PURE__ */ new Set();
+  walkNode(rootCidStr, "", "", blocks, fileBlocks, fileCids, rootBlockCids, subdirCids, subdirSeen, true);
+  return { fileBlocks, fileCids, rootBlockCids, subdirCids };
+}
+function walkNode(cidStr, pathSoFar, fullDirPath, blocks, fileBlocks, fileCids, intermediates, subdirCids, subdirSeen, isRoot) {
+  const cid = CID2.parse(cidStr);
+  if (cid.code === 85) {
+    if (pathSoFar) {
+      fileBlocks.set(pathSoFar, [cidStr]);
+      fileCids.set(pathSoFar, cidStr);
+    }
+    return;
+  }
+  if (cid.code !== 112) {
+    if (pathSoFar) {
+      fileBlocks.set(pathSoFar, [cidStr]);
+      fileCids.set(pathSoFar, cidStr);
+    }
+    return;
+  }
+  const bytes = blocks.get(cidStr);
+  if (!bytes) throw new Error(`block ${cidStr} not in block source`);
+  intermediates.push(cidStr);
+  const node = dagPB2.decode(bytes);
+  let unixfs;
+  if (node.Data) {
+    try {
+      unixfs = UnixFS2.unmarshal(node.Data);
+    } catch {
+      unixfs = void 0;
+    }
+  }
+  if (unixfs && unixfs.isDirectory()) {
+    if (!isRoot && !subdirSeen.has(cidStr)) {
+      subdirCids.push(cidStr);
+      subdirSeen.add(cidStr);
+    }
+    for (const link of node.Links ?? []) {
+      const childName = link.Name ?? "";
+      const childCid = link.Hash.toString();
+      const childPath = pathSoFar ? `${pathSoFar}/${childName}` : childName;
+      walkNode(childCid, childPath, childPath, blocks, fileBlocks, fileCids, intermediates, subdirCids, subdirSeen, false);
+    }
+  } else {
+    const fileBlockList = [cidStr];
+    for (const link of node.Links ?? []) {
+      collectFileBlocks(link.Hash.toString(), blocks, fileBlockList);
+    }
+    if (pathSoFar) {
+      fileBlocks.set(pathSoFar, fileBlockList);
+      fileCids.set(pathSoFar, cidStr);
+    }
+  }
+}
+function collectFileBlocks(cidStr, blocks, fileBlockList) {
+  const cid = CID2.parse(cidStr);
+  if (cid.code === 85) {
+    fileBlockList.push(cidStr);
+    return;
+  }
+  if (cid.code !== 112) {
+    fileBlockList.push(cidStr);
+    return;
+  }
+  fileBlockList.push(cidStr);
+  const bytes = blocks.get(cidStr);
+  if (!bytes) return;
+  const node = dagPB2.decode(bytes);
+  for (const link of node.Links ?? []) {
+    collectFileBlocks(link.Hash.toString(), blocks, fileBlockList);
+  }
+}
+async function merkleizeJSBackend(directoryPath) {
+  const blockstore = new CidPreservingBlockstore();
+  const source = (function* () {
+    for (const file of walkDirectoryLazy(directoryPath)) {
+      yield {
+        path: file.path,
+        content: (async function* () {
+          yield fs2.readFileSync(file.absolutePath);
+        })()
+      };
+    }
+  })();
+  let rootCid;
+  for await (const entry of importer(source, blockstore, {
+    cidVersion: 1,
+    rawLeaves: true,
+    wrapWithDirectory: true
+  })) {
+    rootCid = entry.cid;
+  }
+  if (!rootCid) throw new Error("Merkleization produced no root CID");
+  const blocks = /* @__PURE__ */ new Map();
+  for (const { cid, bytes } of blockstore.all()) {
+    blocks.set(cid.toString(), bytes);
+  }
+  blockstore.clear();
+  const { fileBlocks, fileCids, rootBlockCids, subdirCids } = walkFileBlocks(rootCid.toString(), blocks);
+  return { rootCid: rootCid.toString(), blocks, fileBlocks, fileCids, rootBlockCids, subdirCids };
+}
+async function merkleizeKuboBackend(directoryPath) {
+  const carPath = path2.join(path2.dirname(directoryPath), `${path2.basename(directoryPath)}.car`);
+  const cidStr = execSync2(
+    `ipfs add -Q -r --cid-version=1 --raw-leaves --pin=false "${directoryPath}"`,
+    { encoding: "utf-8" }
+  ).trim();
+  execSync2(`ipfs dag export ${cidStr} > "${carPath}"`);
+  const carBytes = fs2.readFileSync(carPath);
+  const reader = await CarReader.fromBytes(carBytes);
+  const blocks = /* @__PURE__ */ new Map();
+  for await (const { cid, bytes } of reader.blocks()) {
+    blocks.set(cid.toString(), bytes);
+  }
+  const { fileBlocks, fileCids, rootBlockCids, subdirCids } = walkFileBlocks(cidStr, blocks);
+  return { rootCid: cidStr, blocks, fileBlocks, fileCids, rootBlockCids, subdirCids };
+}
+async function merkleizeBackend(directoryPath, useKubo) {
+  if (useKubo) {
+    console.log(`   Merkleizing (Kubo): ${directoryPath}`);
+    return merkleizeKuboBackend(directoryPath);
+  }
+  console.log(`   Merkleizing (JS): ${directoryPath}`);
+  return merkleizeJSBackend(directoryPath);
+}
+function encodeCarFrame(cid, payload) {
+  const cidBytes = cid.bytes;
+  const innerLen = cidBytes.length + payload.length;
+  const lenBytes = encodeVarint(innerLen);
+  const out = new Uint8Array(lenBytes.length + cidBytes.length + payload.length);
+  out.set(lenBytes, 0);
+  out.set(cidBytes, lenBytes.length);
+  out.set(payload, lenBytes.length + cidBytes.length);
+  return out;
+}
+function encodeVarint(n) {
+  const out = [];
+  while (n > 127) {
+    out.push(n & 127 | 128);
+    n >>>= 7;
+  }
+  out.push(n & 127);
+  return new Uint8Array(out);
+}
+function concatBytes(parts) {
+  let total = 0;
+  for (const p of parts) total += p.length;
+  const out = new Uint8Array(total);
+  let off = 0;
+  for (const p of parts) {
+    out.set(p, off);
+    off += p.length;
+  }
+  return out;
+}
+async function encodeCarHeader(root) {
+  const { writer, out } = CarWriter.create([root]);
+  const headerPromise = collectBytes(out);
+  await writer.close();
+  return await headerPromise;
+}
+function frameBlockCid(frame) {
+  let offset = 0;
+  while (offset < frame.length && frame[offset] & 128) offset++;
+  offset++;
+  const [cid] = CID2.decodeFirst(frame.slice(offset));
+  return cid.toString();
+}
+async function buildOrderedCar(options) {
+  const { output, prevStableOrder = [] } = options;
+  const clsFn = options.classifyFn ?? ((p) => classifyFile(p));
+  const MANIFEST_PATH_LITERAL = ".bulletin-deploy/manifest.json";
+  const stableFiles = [];
+  const volatileFiles = [];
+  for (const [filePath, fileBlockCids] of output.fileBlocks) {
+    if (filePath === MANIFEST_PATH_LITERAL) continue;
+    const fileCid = output.fileCids.get(filePath);
+    const frames = [];
+    for (const blockCid of fileBlockCids) {
+      const blockBytes = output.blocks.get(blockCid);
+      if (!blockBytes) throw new Error(`buildOrderedCar: block ${blockCid} missing`);
+      frames.push(encodeCarFrame(CID2.parse(blockCid), blockBytes));
+    }
+    const size = frames.reduce((s, b) => s + b.length, 0);
+    const cls = clsFn(filePath, fileCid);
+    (cls === "stable" ? stableFiles : volatileFiles).push({ path: filePath, fileCid, blocks: frames, size });
+  }
+  const fileByCid = new Map(stableFiles.map((f) => [f.fileCid, f]));
+  const placed = /* @__PURE__ */ new Set();
+  const section1Files = [];
+  for (const cid of prevStableOrder) {
+    const f = fileByCid.get(cid);
+    if (f && !placed.has(cid)) {
+      section1Files.push(f);
+      placed.add(cid);
+    }
+  }
+  const newStable = stableFiles.filter((f) => !placed.has(f.fileCid));
+  newStable.sort(
+    (a, b) => b.size - a.size || (a.fileCid < b.fileCid ? -1 : a.fileCid > b.fileCid ? 1 : 0)
+  );
+  for (const f of newStable) section1Files.push(f);
+  volatileFiles.sort(
+    (a, b) => b.size - a.size || (a.fileCid < b.fileCid ? -1 : a.fileCid > b.fileCid ? 1 : 0)
+  );
+  const rootCidParsed = CID2.parse(output.rootCid);
+  const headerBytes = await encodeCarHeader(rootCidParsed);
+  const section0Frames = [headerBytes];
+  const manifestBlockCids = output.fileBlocks.get(MANIFEST_PATH_LITERAL) ?? [];
+  if (manifestBlockCids.length > 0) {
+    for (const blockCid of manifestBlockCids) {
+      const blockBytes = output.blocks.get(blockCid);
+      if (!blockBytes) throw new Error(`buildOrderedCar: manifest block ${blockCid} missing`);
+      section0Frames.push(encodeCarFrame(CID2.parse(blockCid), blockBytes));
+    }
+  }
+  const section0Bytes = concatBytes(section0Frames);
+  const rootDirBytes = output.blocks.get(output.rootCid);
+  if (!rootDirBytes) throw new Error(`buildOrderedCar: root block ${output.rootCid} missing`);
+  const section2LeadFrames = [encodeCarFrame(rootCidParsed, rootDirBytes)];
+  for (const cid of output.subdirCids) {
+    const bytes = output.blocks.get(cid);
+    if (!bytes) continue;
+    section2LeadFrames.push(encodeCarFrame(CID2.parse(cid), bytes));
+  }
+  const section1SectionFiles = section1Files.map((f) => ({ blocks: f.blocks }));
+  const section2SectionFiles = [
+    { blocks: section2LeadFrames },
+    ...volatileFiles.map((f) => ({ blocks: f.blocks }))
+  ];
+  const section1Chunks = packSection(section1SectionFiles);
+  const section2Chunks = packSection(section2SectionFiles);
+  const section0Chunks = section0Bytes.length > 0 ? [section0Bytes] : [];
+  const allChunks = [...section0Chunks, ...section1Chunks, ...section2Chunks];
+  const carBytes = concatBytes(allChunks);
+  const chunkCids = allChunks.map((b) => createCID(b).toString());
+  const section1ChunkCids = section1Chunks.map((b) => createCID(b).toString());
+  const blockOrder = [];
+  const collectFrameCids = (frames) => {
+    for (const frame of frames) {
+      if (frame === headerBytes) continue;
+      try {
+        blockOrder.push(frameBlockCid(frame));
+      } catch {
+      }
+    }
+  };
+  collectFrameCids(section0Frames);
+  for (const f of section1Files) collectFrameCids(f.blocks);
+  collectFrameCids(section2LeadFrames);
+  for (const f of volatileFiles) collectFrameCids(f.blocks);
+  const stableOrder = section1Files.map((f) => f.fileCid);
+  const s1Bytes = section1Chunks.reduce((s, b) => s + b.length, 0);
+  const s2Bytes = section2Chunks.reduce((s, b) => s + b.length, 0);
+  console.log(
+    `   CAR (3-section): ${(carBytes.length / 1024 / 1024).toFixed(2)} MB (s0=${section0Bytes.length}B s1=${s1Bytes}B s2=${s2Bytes}B), ${allChunks.length} chunks (${section0Chunks.length}+${section1Chunks.length}+${section2Chunks.length})`
+  );
+  return {
+    carBytes,
+    cid: output.rootCid,
+    blockOrder,
+    stableOrder,
+    chunks: allChunks,
+    chunkCids,
+    section1ChunkCids,
+    sectionSizes: {
+      section0: section0Bytes.length,
+      section1: s1Bytes,
+      section2: s2Bytes
+    },
+    blocks: output.blocks,
+    fileCids: output.fileCids
+  };
+}
+async function merkleizeWithStableOrder(directoryPath, prevStableOrder, options) {
+  const useKubo = options?.useKubo ?? false;
+  const output = await merkleizeBackend(directoryPath, useKubo);
+  return buildOrderedCar({ output, classifyFn: options?.classifyFn, prevStableOrder });
+}
+async function merkleizeJS(directoryPath) {
+  console.log(`   Merkleizing (JS): ${directoryPath}`);
+  const blockstore = new CidPreservingBlockstore();
+  const source = (function* () {
+    for (const file of walkDirectoryLazy(directoryPath)) {
+      yield {
+        path: file.path,
+        content: (async function* () {
+          yield fs2.readFileSync(file.absolutePath);
+        })()
+      };
+    }
+  })();
+  let rootCid;
+  for await (const entry of importer(source, blockstore, {
+    cidVersion: 1,
+    rawLeaves: true,
+    wrapWithDirectory: true
+  })) {
+    rootCid = entry.cid;
+  }
+  if (!rootCid) throw new Error("Merkleization produced no root CID");
+  const { writer, out } = CarWriter.create([rootCid]);
+  const collectPromise = collectBytes(out);
+  for (const { cid, bytes } of blockstore.all()) {
+    await writer.put({ cid, bytes });
+  }
+  await writer.close();
+  const carBytes = await collectPromise;
+  blockstore.clear();
+  console.log(`   CAR (JS): ${(carBytes.length / 1024 / 1024).toFixed(2)} MB`);
+  return { carBytes, cid: rootCid.toString() };
+}
+
 export {
+  merkleizeJSBackend,
+  merkleizeKuboBackend,
+  merkleizeBackend,
+  buildOrderedCar,
+  merkleizeWithStableOrder,
+  merkleizeJS,
   friendlyChainError,
   DEFAULT_BULLETIN_RPC,
   DEFAULT_POOL_SIZE,
@@ -1052,12 +1820,18 @@ export {
   ENCRYPT_PBKDF2_ITERATIONS,
   encryptContent,
   storeFile,
+  __assignDenseNoncesForTest,
   storeChunkedContent,
   chunk,
   hasIPFS,
   merkleize,
   computeStorageCid,
   storeDirectory,
+  buildFilesMap,
+  detectFramework,
+  checkDeploySize,
+  resolveReproducibleTimestamp,
+  storeDirectoryV2,
   resolveDotnsConnectOptions,
   estimateUploadBytes,
   deploy