bulletin-deploy 0.7.14 → 0.7.15

package/dist/chunk-Y2OSXJIZ.js

@@ -0,0 +1,177 @@
+import {
+  captureWarning
+} from "./chunk-KMRYJR4E.js";
+
+// src/chunk-probe.ts
+import { Twox128, Blake2128Concat, decAnyMetadata, unifyMetadata } from "@polkadot-api/substrate-bindings";
+import { CID } from "multiformats/cid";
+var ChainProbeMetadataError = class extends Error {
+  constructor(msg) {
+    super(msg);
+    this.name = "ChainProbeMetadataError";
+  }
+};
+var ChainProbeCrossValidationError = class extends Error {
+  constructor(msg) {
+    super(msg);
+    this.name = "ChainProbeCrossValidationError";
+  }
+};
+var _enc = new TextEncoder();
+var MAX_BLOCK = 2 ** 30;
+var MAX_TX_INDEX = 512;
+var DEFAULT_BATCH_SIZE = 500;
+var _metadataChecked = false;
+var _crossValidated = false;
+var _sentryBatchCount = 0;
+function buildStorageKey(contentHashBytes) {
+  const parts = [
+    Twox128(_enc.encode("TransactionStorage")),
+    Twox128(_enc.encode("TransactionByContentHash")),
+    Blake2128Concat(contentHashBytes)
+  ];
+  const total = parts.reduce((s, p) => s + p.length, 0);
+  const key = new Uint8Array(total);
+  let offset = 0;
+  for (const p of parts) {
+    key.set(p, offset);
+    offset += p.length;
+  }
+  return "0x" + Buffer.from(key).toString("hex");
+}
+function cidToContentHash(cidStr) {
+  return CID.parse(cidStr).multihash.digest;
+}
+function hexToBytes(hex) {
+  return Buffer.from(hex.replace(/^0x/, ""), "hex");
+}
+function _decodeStorageValue(hex) {
+  if (!hex || hex === "0x" || hex === "0x00") return null;
+  const bytes = hexToBytes(hex);
+  if (bytes.length < 8) return null;
+  const block = bytes.readUInt32LE(0);
+  const index = bytes.readUInt32LE(4);
+  if (block <= 0 || block >= MAX_BLOCK || index >= MAX_TX_INDEX) return null;
+  return { block, index };
+}
+async function ensureMetadataChecked(client) {
+  if (_metadataChecked) return;
+  const metaHex = await client._request("state_getMetadata", []);
+  const decoded = decAnyMetadata(hexToBytes(metaHex));
+  const unified = unifyMetadata(decoded);
+  const pallet = unified.pallets?.find((p) => p.name === "TransactionStorage");
+  if (!pallet) throw new ChainProbeMetadataError("TransactionStorage pallet not found in runtime metadata");
+  const item = pallet.storage?.items?.find((e) => e.name === "TransactionByContentHash");
+  if (!item) throw new ChainProbeMetadataError("TransactionByContentHash entry not found in TransactionStorage");
+  if (item.type?.tag !== "map") {
+    throw new ChainProbeMetadataError(
+      `TransactionByContentHash storage type is '${item.type?.tag}', expected 'map'`
+    );
+  }
+  const hasher = item.type.value?.hashers?.[0]?.tag;
+  if (hasher !== "Blake2128Concat") {
+    throw new ChainProbeMetadataError(
+      `TransactionByContentHash key hasher is '${hasher}', expected 'Blake2128Concat'. Update key construction in chunk-probe.ts.`
+    );
+  }
+  _metadataChecked = true;
+}
+async function crossValidateFirstHit(client, cid, block, index, contentHashBytes) {
+  if (_crossValidated) return;
+  _crossValidated = true;
+  try {
+    const blockBuf = Buffer.alloc(4);
+    blockBuf.writeUInt32LE(block, 0);
+    const txKey = "0x" + Buffer.from([
+      ...Twox128(_enc.encode("TransactionStorage")),
+      ...Twox128(_enc.encode("Transactions")),
+      ...Blake2128Concat(blockBuf)
+    ]).toString("hex");
+    const result = await client._request("state_queryStorageAt", [[txKey]]);
+    const hex = result[0]?.changes?.[0]?.[1];
+    if (!hex) {
+      captureWarning("chunk-probe cross-validate: Transactions[block] absent (non-fatal)", { cid, block, index });
+      return;
+    }
+    const haystack = hexToBytes(hex);
+    const needle = Buffer.from(contentHashBytes);
+    if (!haystack.includes(needle)) {
+      throw new ChainProbeCrossValidationError(
+        `Cross-validation failed: content hash for CID ${cid} not found in Transactions[${block}]. Key construction may be wrong. Run tools/chain-probe-key-probe.mjs to diagnose.`
+      );
+    }
+  } catch (e) {
+    if (e instanceof ChainProbeCrossValidationError) throw e;
+    captureWarning("chunk-probe cross-validate RPC error (non-fatal)", { cid, error: String(e).slice(0, 200) });
+  }
+}
+async function probeChunks(cids, options) {
+  if (cids.length === 0) return [];
+  const { client, batchSize = DEFAULT_BATCH_SIZE } = options;
+  try {
+    await ensureMetadataChecked(client);
+  } catch (e) {
+    if (e instanceof ChainProbeMetadataError) throw e;
+    return cids.map((cid) => ({ cid, present: null, failureReason: "metadata_error" }));
+  }
+  const results = new Array(cids.length);
+  for (let start = 0; start < cids.length; start += batchSize) {
+    const batchCids = cids.slice(start, start + batchSize);
+    const batchDigests = batchCids.map(cidToContentHash);
+    const batchKeys = batchDigests.map(buildStorageKey);
+    let changes;
+    try {
+      const rpcResult = await client._request("state_queryStorageAt", [batchKeys]);
+      changes = rpcResult[0]?.changes ?? [];
+    } catch {
+      for (let i = 0; i < batchCids.length; i++) {
+        results[start + i] = { cid: batchCids[i], present: null, failureReason: "rpc_error" };
+      }
+      continue;
+    }
+    const keyToValue = new Map(changes);
+    for (let i = 0; i < batchCids.length; i++) {
+      const cid = batchCids[i];
+      const key = batchKeys[i];
+      const rawValue = keyToValue.get(key) ?? null;
+      if (!rawValue) {
+        results[start + i] = { cid, present: false };
+        continue;
+      }
+      const decoded = _decodeStorageValue(rawValue);
+      if (!decoded) {
+        if (_sentryBatchCount < 3) {
+          captureWarning("chunk-probe decode failed (out-of-range or short value)", {
+            cid,
+            raw_hex: rawValue.slice(0, 64)
+          });
+        }
+        results[start + i] = { cid, present: null, failureReason: "decode_error" };
+        continue;
+      }
+      results[start + i] = { cid, present: true, block: decoded.block, index: decoded.index };
+      if (!_crossValidated) {
+        await crossValidateFirstHit(client, cid, decoded.block, decoded.index, batchDigests[i]);
+      }
+    }
+    if (_sentryBatchCount < 3) _sentryBatchCount++;
+  }
+  return results;
+}
+function _resetProbeSession() {
+  _metadataChecked = false;
+  _crossValidated = false;
+  _sentryBatchCount = 0;
+}
+function _bypassMetadataCheckForTest() {
+  _metadataChecked = true;
+}
+
+export {
+  ChainProbeMetadataError,
+  ChainProbeCrossValidationError,
+  _decodeStorageValue,
+  probeChunks,
+  _resetProbeSession,
+  _bypassMetadataCheckForTest
+};

package/dist/{chunk-N7YE5ZN3.js → chunk-ZGU6FOLO.js}

@@ -6,7 +6,7 @@ import * as path from "path";
 // package.json
 var package_default = {
   name: "bulletin-deploy",
-  version: "0.7.14",
+  version: "0.7.15",
   private: false,
   repository: {
     type: "git",
@@ -37,7 +37,7 @@ var package_default = {
   ],
   scripts: {
     prebuild: "node scripts/refresh-environments.mjs",
-    build: "tsup src/index.ts src/deploy.ts src/dotns.ts src/pool.ts src/telemetry.ts src/memory-report.ts src/merkle.ts src/gh-pages-mirror.ts src/version-check.ts src/bug-report.ts src/run-state.ts src/environments.ts src/errors.ts --format esm --dts --clean --target node22",
+    build: "tsup src/index.ts src/deploy.ts src/dotns.ts src/pool.ts src/telemetry.ts src/memory-report.ts src/merkle.ts src/gh-pages-mirror.ts src/version-check.ts src/bug-report.ts src/run-state.ts src/environments.ts src/errors.ts src/manifest.ts src/chunk-probe.ts src/manifest-embed.ts src/manifest-fetch.ts src/manifest-roundtrip.ts src/incremental-stats.ts src/chunker.ts --format esm --dts --clean --target node22",
     "refresh-environments": "node scripts/refresh-environments.mjs",
     prepare: "npm run build",
     test: "npm run build && node --test test/test.js test/cli-help.test.js test/helpers/e2e-helpers.test.js test/environments.test.js",

package/dist/chunk-probe.d.ts

@@ -0,0 +1,36 @@
+type ChunkProbeFailureReason = "rpc_error" | "decode_error" | "metadata_error";
+type ChunkProbeResult = {
+    cid: string;
+    present: false;
+} | {
+    cid: string;
+    present: true;
+    block: number;
+    index: number;
+} | {
+    cid: string;
+    present: null;
+    failureReason: ChunkProbeFailureReason;
+};
+interface ChainProbeOptions {
+    client: any;
+    batchSize?: number;
+}
+declare class ChainProbeMetadataError extends Error {
+    constructor(msg: string);
+}
+declare class ChainProbeCrossValidationError extends Error {
+    constructor(msg: string);
+}
+/** Exported for unit testing. */
+declare function _decodeStorageValue(hex: string | null | undefined): {
+    block: number;
+    index: number;
+} | null;
+declare function probeChunks(cids: string[], options: ChainProbeOptions): Promise<ChunkProbeResult[]>;
+/** Reset session-level caches. Used in tests only. */
+declare function _resetProbeSession(): void;
+/** Pre-set metadataChecked so tests don't need a real metadata RPC mock. Used in tests only. */
+declare function _bypassMetadataCheckForTest(): void;
+
+export { ChainProbeCrossValidationError, ChainProbeMetadataError, type ChainProbeOptions, type ChunkProbeFailureReason, type ChunkProbeResult, _bypassMetadataCheckForTest, _decodeStorageValue, _resetProbeSession, probeChunks };

package/dist/chunk-probe.js

@@ -0,0 +1,19 @@
+import {
+  ChainProbeCrossValidationError,
+  ChainProbeMetadataError,
+  _bypassMetadataCheckForTest,
+  _decodeStorageValue,
+  _resetProbeSession,
+  probeChunks
+} from "./chunk-Y2OSXJIZ.js";
+import "./chunk-KMRYJR4E.js";
+import "./chunk-ZGU6FOLO.js";
+import "./chunk-QGM4M3NI.js";
+export {
+  ChainProbeCrossValidationError,
+  ChainProbeMetadataError,
+  _bypassMetadataCheckForTest,
+  _decodeStorageValue,
+  _resetProbeSession,
+  probeChunks
+};

package/dist/chunker.d.ts

@@ -0,0 +1,8 @@
+declare const CHUNK_SIZE_TARGET: number;
+declare const CHUNK_SIZE_MAX: number;
+interface SectionFile {
+    blocks: Uint8Array[];
+}
+declare function packSection(files: SectionFile[]): Uint8Array[];
+
+export { CHUNK_SIZE_MAX, CHUNK_SIZE_TARGET, type SectionFile, packSection };

package/dist/chunker.js

@@ -0,0 +1,11 @@
+import {
+  CHUNK_SIZE_MAX,
+  CHUNK_SIZE_TARGET,
+  packSection
+} from "./chunk-C2TS5MER.js";
+import "./chunk-QGM4M3NI.js";
+export {
+  CHUNK_SIZE_MAX,
+  CHUNK_SIZE_TARGET,
+  packSection
+};

package/dist/deploy.d.ts

@@ -1,4 +1,5 @@
 import { CID } from 'multiformats/cid';
+import { ManifestFileEntry } from './manifest.js';
 import { PolkadotSigner } from 'polkadot-api';
 export { EXIT_CODE_NO_RETRY, NonRetryableError } from './errors.js';
 
@@ -24,6 +25,14 @@ interface ExistingProvider {
     ss58?: string;
     reconnect?: () => Promise<ProviderResult>;
     fetchNonce?: (rpc: string | string[], ss58: string) => Promise<number>;
+    skipCids?: Set<string>;
+    probeFailedCids?: Set<string>;
+    gateway?: string;
+}
+interface StoredChunk {
+    cid: CID;
+    len: number;
+    viaFallback?: boolean;
 }
 declare const DEFAULT_BULLETIN_RPC = "wss://paseo-bulletin-rpc.polkadot.io";
 declare const DEFAULT_POOL_SIZE = 10;
@@ -45,7 +54,21 @@ declare const ENCRYPT_KEY_LEN = 32;
 declare const ENCRYPT_PBKDF2_ITERATIONS = 100000;
 declare function encryptContent(data: Uint8Array, password: string): Promise<Uint8Array>;
 declare function storeFile(contentBytes: Uint8Array, { client: existingClient, unsafeApi: existingApi, signer: existingSigner }?: ExistingProvider): Promise<string>;
-declare function storeChunkedContent(chunks: Uint8Array[], { client: existingClient, unsafeApi: existingApi, signer: existingSigner, ss58: existingSS58, reconnect, fetchNonce: fetchNonceOverride }?: ExistingProvider): Promise<string>;
+/**
+ * Pre-compute dense nonces for chunks that need submission.
+ * Chunks where stored[i] !== null are already on chain (skipped via skipCids or
+ * prior reconnect logic) and consume zero nonce slots.
+ * Exported under a test-only alias so unit tests can verify the dense property
+ * without touching the real chain.
+ */
+declare function assignDenseNonces(stored: (StoredChunk | null)[], startNonce: number): Map<number, number>;
+declare const __assignDenseNoncesForTest: typeof assignDenseNonces;
+declare function storeChunkedContent(chunks: Uint8Array[], { client: existingClient, unsafeApi: existingApi, signer: existingSigner, ss58: existingSS58, reconnect, fetchNonce: fetchNonceOverride, skipCids, probeFailedCids, gateway: providerGateway }?: ExistingProvider): Promise<{
+    storageCid: string;
+    tier2Verified: number;
+    tier2Inconclusive: number;
+    tier2Fallback: number;
+}>;
 declare function chunk(data: Uint8Array, size?: number): Uint8Array[];
 declare function hasIPFS(): boolean;
 declare function merkleize(directoryPath: string, outputCarPath: string): Promise<{
@@ -66,12 +89,52 @@ interface StoreDirectoryOptions {
      * through to the caller so they can decide fatal / non-fatal policy.
      */
     onCarReady?: (carBytes: Uint8Array, storageCid: string) => Promise<void> | void;
+    /**
+     * v2 incremental upload: contenthash from the previous deploy of this
+     * domain (the IPFS CID, not the e3-prefixed bytes). The new flow fetches
+     * this CID's embedded manifest via the gateway, classifies files,
+     * probes chunks for presence, and skips re-uploading any chunk already
+     * stored on chain. Pass null (or omit) for first-deploy behaviour.
+     * Encrypted deploys (password set) bypass the incremental path because
+     * encryption breaks chunk-level dedup.
+     */
+    previousContenthash?: string | null;
+    /** Override gateway URL for manifest fetch + chunk probes. */
+    gateway?: string;
+    /** Skip the 500 MiB abort guard and allow oversized deploys. */
+    allowLargeDeploy?: boolean;
+    /**
+     * Pin the `deployedAt` timestamp for byte-identical rebuilds.
+     * Values: "commit" (git committer date), "epoch:<N>" (Unix epoch seconds),
+     * or any ISO 8601 string. Omit for a live wall-clock timestamp.
+     */
+    reproducibleSource?: string;
 }
 declare function storeDirectory(directoryPath: string, providerOrOptions?: ExistingProvider | StoreDirectoryOptions, password?: string, jsMerkle?: boolean): Promise<{
     storageCid: string;
     ipfsCid: string;
     carBytes: Uint8Array;
 }>;
+declare function buildFilesMap(buildDir: string, fileCids?: Map<string, string>): Record<string, ManifestFileEntry>;
+declare function detectFramework(directoryPath: string): string | null;
+type SizeDecision = {
+    kind: "ok";
+} | {
+    kind: "warn";
+    message: string;
+} | {
+    kind: "abort";
+    message: string;
+};
+declare function checkDeploySize(carBytes: number, opts: {
+    allowLargeDeploy?: boolean;
+}): SizeDecision;
+declare function resolveReproducibleTimestamp(source: string): string;
+declare function storeDirectoryV2(directoryPath: string, opts?: StoreDirectoryOptions): Promise<{
+    storageCid: string;
+    ipfsCid: string;
+    carBytes: Uint8Array;
+}>;
 interface DeployOptions {
     mnemonic?: string;
     /** Optional derivation path applied to the mnemonic (e.g. "//deploy/3"). Defaults to "" (root key). */
@@ -105,6 +168,14 @@ interface DeployOptions {
     name?: string;
     /** When set, writes the "description" text record. ≤100 chars recommended for host-app cards. */
     description?: string;
+    /** Skip the 500 MiB abort guard and allow oversized deploys. */
+    allowLargeDeploy?: boolean;
+    /**
+     * Pin the `deployedAt` timestamp for byte-identical rebuilds.
+     * Values: "commit" (git committer date), "epoch:<N>" (Unix epoch seconds),
+     * or any ISO 8601 string. Omit for a live wall-clock timestamp.
+     */
+    reproducibleSource?: string;
     /**
      * Environment id from environments.json (e.g. "paseo-next", "paseo-review").
      * Drives both the bulletin RPC and the asset-hub RPC. Defaults to
@@ -131,4 +202,4 @@ declare function resolveDotnsConnectOptions(options: Pick<DeployOptions, "mnemon
 declare function estimateUploadBytes(content: DeployContent): Promise<number | null>;
 declare function deploy(content: DeployContent, domainName?: string | null, options?: DeployOptions): Promise<DeployResult>;
 
-export { CHUNK_MORTALITY_PERIOD, DEFAULT_BULLETIN_RPC, DEFAULT_POOL_SIZE, type DeployContent, type DeployOptions, type DeployResult, ENCRYPT_KEY_LEN, ENCRYPT_MAGIC, ENCRYPT_NONCE_LEN, ENCRYPT_PBKDF2_ITERATIONS, ENCRYPT_SALT_LEN, ENCRYPT_TAG_LEN, type StoreDirectoryOptions, chunk, computeStorageCid, createCID, deploy, deriveRootSigner, encodeContenthash, encryptContent, estimateUploadBytes, friendlyChainError, hasIPFS, isConnectionError, merkleize, resolveDotnsConnectOptions, retryBudgetExhausted, setWsHaltCallback, storeChunkedContent, storeDirectory, storeFile };
+export { CHUNK_MORTALITY_PERIOD, DEFAULT_BULLETIN_RPC, DEFAULT_POOL_SIZE, type DeployContent, type DeployOptions, type DeployResult, ENCRYPT_KEY_LEN, ENCRYPT_MAGIC, ENCRYPT_NONCE_LEN, ENCRYPT_PBKDF2_ITERATIONS, ENCRYPT_SALT_LEN, ENCRYPT_TAG_LEN, type SizeDecision, type StoreDirectoryOptions, __assignDenseNoncesForTest, buildFilesMap, checkDeploySize, chunk, computeStorageCid, createCID, deploy, deriveRootSigner, detectFramework, encodeContenthash, encryptContent, estimateUploadBytes, friendlyChainError, hasIPFS, isConnectionError, merkleize, resolveDotnsConnectOptions, resolveReproducibleTimestamp, retryBudgetExhausted, setWsHaltCallback, storeChunkedContent, storeDirectory, storeDirectoryV2, storeFile };

package/dist/deploy.js

@@ -8,11 +8,15 @@ import {
   ENCRYPT_PBKDF2_ITERATIONS,
   ENCRYPT_SALT_LEN,
   ENCRYPT_TAG_LEN,
+  __assignDenseNoncesForTest,
+  buildFilesMap,
+  checkDeploySize,
   chunk,
   computeStorageCid,
   createCID,
   deploy,
   deriveRootSigner,
+  detectFramework,
   encodeContenthash,
   encryptContent,
   estimateUploadBytes,
@@ -21,25 +25,32 @@ import {
   isConnectionError,
   merkleize,
   resolveDotnsConnectOptions,
+  resolveReproducibleTimestamp,
   retryBudgetExhausted,
   setWsHaltCallback,
   storeChunkedContent,
   storeDirectory,
+  storeDirectoryV2,
   storeFile
-} from "./chunk-3ILZFC4E.js";
-import "./chunk-B7GUYYAN.js";
-import "./chunk-3RNYFSU7.js";
-import "./chunk-6YJ46BN2.js";
-import "./chunk-LM5U3XDV.js";
+} from "./chunk-VQHM3R6N.js";
+import "./chunk-MJTQOXBC.js";
+import "./chunk-KOSF5FDO.js";
+import "./chunk-5MRZ3V4A.js";
+import "./chunk-S7EM5VMW.js";
+import "./chunk-AQUBKPSF.js";
+import "./chunk-NE5MN2M2.js";
+import "./chunk-Y2OSXJIZ.js";
+import "./chunk-C2TS5MER.js";
+import "./chunk-5TW653QP.js";
 import "./chunk-VOEFHED3.js";
+import "./chunk-KMRYJR4E.js";
+import "./chunk-ZGU6FOLO.js";
 import "./chunk-2VYG7NXN.js";
 import {
   EXIT_CODE_NO_RETRY,
   NonRetryableError
 } from "./chunk-ZOC4GITL.js";
 import "./chunk-HOTQDYHD.js";
-import "./chunk-4AP5ZFNV.js";
-import "./chunk-N7YE5ZN3.js";
 import "./chunk-QGM4M3NI.js";
 export {
   CHUNK_MORTALITY_PERIOD,
@@ -53,11 +64,15 @@ export {
   ENCRYPT_TAG_LEN,
   EXIT_CODE_NO_RETRY,
   NonRetryableError,
+  __assignDenseNoncesForTest,
+  buildFilesMap,
+  checkDeploySize,
   chunk,
   computeStorageCid,
   createCID,
   deploy,
   deriveRootSigner,
+  detectFramework,
   encodeContenthash,
   encryptContent,
   estimateUploadBytes,
@@ -66,9 +81,11 @@ export {
   isConnectionError,
   merkleize,
   resolveDotnsConnectOptions,
+  resolveReproducibleTimestamp,
   retryBudgetExhausted,
   setWsHaltCallback,
   storeChunkedContent,
   storeDirectory,
+  storeDirectoryV2,
   storeFile
 };

package/dist/dotns.js

@@ -36,10 +36,10 @@ import {
   stripTrailingDigits,
   validateDomainLabel,
   verifyNonceAdvanced
-} from "./chunk-LM5U3XDV.js";
+} from "./chunk-5TW653QP.js";
 import "./chunk-VOEFHED3.js";
-import "./chunk-4AP5ZFNV.js";
-import "./chunk-N7YE5ZN3.js";
+import "./chunk-KMRYJR4E.js";
+import "./chunk-ZGU6FOLO.js";
 import "./chunk-QGM4M3NI.js";
 export {
   CONNECTION_TIMEOUT_MS,

package/dist/incremental-stats.d.ts

@@ -0,0 +1,65 @@
+import { ChunkProbeResult } from './chunk-probe.js';
+import { ManifestChunkEntry } from './manifest.js';
+
+interface IncrementalStats {
+    manifestSource: "embedded" | "heuristic_fallback" | "none";
+    manifestFetchAttempts: number;
+    manifestBytes: number;
+    framework: string | null;
+    filesTotal: number;
+    filesStable: number;
+    filesVolatile: number;
+    probedTotal: number;
+    probePresent: number;
+    probeAbsent: number;
+    probeFailed: number;
+    probeFailedRpc: number;
+    probeFailedDecode: number;
+    probeFailedMetadata: number;
+    recycledCids: number;
+    retentionPeriodBlocks: number;
+    bytesSkipped: number;
+    bytesUploaded: number;
+    chunksTotal: number;
+    chunksUploaded: number;
+    chunksSkipped: number;
+    carBytes: number;
+    section0Bytes: number;
+    section1Bytes: number;
+    section2Bytes: number;
+    estimatedSecondsSaved: number;
+    tier2VerifiedCount: number;
+    tier2InconclusiveCount: number;
+    tier2FallbackCount: number;
+}
+interface ComputeStatsInput {
+    manifestSource: IncrementalStats["manifestSource"];
+    manifestFetchAttempts: number;
+    manifestBytes?: number;
+    framework: string | null;
+    filesTotal: number;
+    filesStable: number;
+    filesVolatile: number;
+    probeResults: ChunkProbeResult[];
+    prevChunks: Record<string, ManifestChunkEntry>;
+    retentionPeriodBlocks: number;
+    bytesSkipped: number;
+    bytesUploaded: number;
+    chunksTotal: number;
+    chunksUploaded: number;
+    chunksSkipped: number;
+    carBytes: number;
+    sectionSizes: {
+        section0: number;
+        section1: number;
+        section2: number;
+    };
+    tier2VerifiedCount: number;
+    tier2InconclusiveCount: number;
+    tier2FallbackCount: number;
+}
+declare function computeStats(input: ComputeStatsInput): IncrementalStats;
+declare function telemetryAttributes(s: IncrementalStats): Record<string, string>;
+declare function renderSummary(s: IncrementalStats): string;
+
+export { type ComputeStatsInput, type IncrementalStats, computeStats, renderSummary, telemetryAttributes };

package/dist/incremental-stats.js

@@ -0,0 +1,11 @@
+import {
+  computeStats,
+  renderSummary,
+  telemetryAttributes
+} from "./chunk-MJTQOXBC.js";
+import "./chunk-QGM4M3NI.js";
+export {
+  computeStats,
+  renderSummary,
+  telemetryAttributes
+};

package/dist/index.d.ts

@@ -1,7 +1,12 @@
 export { DeployContent, DeployOptions, DeployResult, deploy } from './deploy.js';
 export { PoolAccount, PoolAuthorization, bootstrapPool, derivePoolAccounts, ensureAuthorized, fetchPoolAuthorizations, selectAccount } from './pool.js';
 export { DotNS, DotNSConnectOptions, OwnershipResult, ParsedDomainName, PriceValidationResult, parseDomainName } from './dotns.js';
-export { MerkleizeResult, merkleizeJS } from './merkle.js';
+export { MerkleizeResult, MerkleizeStableResult, merkleizeJS, merkleizeWithStableOrder } from './merkle.js';
+export { EmbeddedManifest, FileType, MANIFEST_DIR, MANIFEST_FILENAME, MANIFEST_PATH, MANIFEST_VERSION, ManifestFileEntry, ParseResult, classifyFile, isVolatilePath, parseManifest } from './manifest.js';
+export { ChainProbeOptions, ChunkProbeResult, probeChunks } from './chunk-probe.js';
+export { finaliseEmbeddedManifest, writeEmbeddedManifestPlaceholder } from './manifest-embed.js';
+export { FetchOptions, FetchOutcome, fetchPreviousManifest } from './manifest-fetch.js';
+export { ComputeStatsInput, IncrementalStats, computeStats, renderSummary, telemetryAttributes } from './incremental-stats.js';
 export { RunState, RunStatus, VERSION, loadRunState, probablyOomRssMb, resolveStateDir, shouldShowOomHint, shouldSkipStaleWarning, stateFilePath, writeRunState } from './run-state.js';
 import 'multiformats/cid';
 import 'polkadot-api';