bulletin-deploy 0.7.14 → 0.7.15

package/dist/index.js

@@ -1,15 +1,39 @@
 import {
-  deploy
-} from "./chunk-3ILZFC4E.js";
+  deploy,
+  merkleizeJS,
+  merkleizeWithStableOrder
+} from "./chunk-VQHM3R6N.js";
+import {
+  computeStats,
+  renderSummary,
+  telemetryAttributes
+} from "./chunk-MJTQOXBC.js";
+import {
+  finaliseEmbeddedManifest,
+  writeEmbeddedManifestPlaceholder
+} from "./chunk-KOSF5FDO.js";
+import {
+  fetchPreviousManifest
+} from "./chunk-5MRZ3V4A.js";
+import {
+  MANIFEST_DIR,
+  MANIFEST_FILENAME,
+  MANIFEST_PATH,
+  MANIFEST_VERSION,
+  classifyFile,
+  isVolatilePath,
+  parseManifest
+} from "./chunk-S7EM5VMW.js";
+import "./chunk-AQUBKPSF.js";
+import "./chunk-NE5MN2M2.js";
 import {
-  merkleizeJS
-} from "./chunk-B7GUYYAN.js";
-import "./chunk-3RNYFSU7.js";
-import "./chunk-6YJ46BN2.js";
+  probeChunks
+} from "./chunk-Y2OSXJIZ.js";
+import "./chunk-C2TS5MER.js";
 import {
   DotNS,
   parseDomainName
-} from "./chunk-LM5U3XDV.js";
+} from "./chunk-5TW653QP.js";
 import {
   bootstrapPool,
   derivePoolAccounts,
@@ -17,10 +41,7 @@ import {
   fetchPoolAuthorizations,
   selectAccount
 } from "./chunk-VOEFHED3.js";
-import "./chunk-2VYG7NXN.js";
-import "./chunk-ZOC4GITL.js";
-import "./chunk-HOTQDYHD.js";
-import "./chunk-4AP5ZFNV.js";
+import "./chunk-KMRYJR4E.js";
 import {
   VERSION,
   loadRunState,
@@ -30,24 +51,42 @@ import {
   shouldSkipStaleWarning,
   stateFilePath,
   writeRunState
-} from "./chunk-N7YE5ZN3.js";
+} from "./chunk-ZGU6FOLO.js";
+import "./chunk-2VYG7NXN.js";
+import "./chunk-ZOC4GITL.js";
+import "./chunk-HOTQDYHD.js";
 import "./chunk-QGM4M3NI.js";
 export {
   DotNS,
+  MANIFEST_DIR,
+  MANIFEST_FILENAME,
+  MANIFEST_PATH,
+  MANIFEST_VERSION,
   VERSION,
   bootstrapPool,
+  classifyFile,
+  computeStats,
   deploy,
   derivePoolAccounts,
   ensureAuthorized,
   fetchPoolAuthorizations,
+  fetchPreviousManifest,
+  finaliseEmbeddedManifest,
+  isVolatilePath,
   loadRunState,
   merkleizeJS,
+  merkleizeWithStableOrder,
   parseDomainName,
+  parseManifest,
   probablyOomRssMb,
+  probeChunks,
+  renderSummary,
   resolveStateDir,
   selectAccount,
   shouldShowOomHint,
   shouldSkipStaleWarning,
   stateFilePath,
+  telemetryAttributes,
+  writeEmbeddedManifestPlaceholder,
   writeRunState
 };

package/dist/manifest-embed.d.ts

@@ -0,0 +1,18 @@
+import { ManifestFileEntry, ManifestChunkEntry } from './manifest.js';
+
+interface PlaceholderInput {
+    version: number;
+    previousContenthash: string | null;
+    deployedAt: string;
+    framework: string | null;
+}
+interface FinaliseInput extends PlaceholderInput {
+    files: Record<string, ManifestFileEntry>;
+    stableBlockOrder: string[];
+    blocks: string[];
+    chunks: Record<string, ManifestChunkEntry>;
+}
+declare function writeEmbeddedManifestPlaceholder(buildDir: string, data: PlaceholderInput): void;
+declare function finaliseEmbeddedManifest(buildDir: string, data: FinaliseInput): void;
+
+export { finaliseEmbeddedManifest, writeEmbeddedManifestPlaceholder };

package/dist/manifest-embed.js

@@ -0,0 +1,10 @@
+import {
+  finaliseEmbeddedManifest,
+  writeEmbeddedManifestPlaceholder
+} from "./chunk-KOSF5FDO.js";
+import "./chunk-S7EM5VMW.js";
+import "./chunk-QGM4M3NI.js";
+export {
+  finaliseEmbeddedManifest,
+  writeEmbeddedManifestPlaceholder
+};

package/dist/manifest-fetch.d.ts

@@ -0,0 +1,26 @@
+import { EmbeddedManifest } from './manifest.js';
+
+declare const DEFAULT_GATEWAY = "https://paseo-ipfs.polkadot.io";
+declare const DEFAULT_TIMEOUT_MS = 5000;
+type FetchOutcome = {
+    source: "embedded";
+    manifest: EmbeddedManifest;
+    attempts: number;
+    bytesDownloaded?: number;
+} | {
+    source: "heuristic_fallback";
+    reason: string;
+    attempts: number;
+    bytesDownloaded?: number;
+} | {
+    source: "none";
+};
+interface FetchOptions {
+    gateway?: string;
+    gateways?: string[];
+    timeoutMs?: number;
+}
+declare function fetchPreviousManifest(prevContenthash: string | null, options?: FetchOptions): Promise<FetchOutcome>;
+declare function extractManifestFromCar(carBytes: Uint8Array): Promise<Uint8Array | null>;
+
+export { DEFAULT_GATEWAY, DEFAULT_TIMEOUT_MS, type FetchOptions, type FetchOutcome, extractManifestFromCar, fetchPreviousManifest };

package/dist/manifest-fetch.js

@@ -0,0 +1,14 @@
+import {
+  DEFAULT_GATEWAY,
+  DEFAULT_TIMEOUT_MS,
+  extractManifestFromCar,
+  fetchPreviousManifest
+} from "./chunk-5MRZ3V4A.js";
+import "./chunk-S7EM5VMW.js";
+import "./chunk-QGM4M3NI.js";
+export {
+  DEFAULT_GATEWAY,
+  DEFAULT_TIMEOUT_MS,
+  extractManifestFromCar,
+  fetchPreviousManifest
+};

package/dist/manifest-roundtrip.d.ts

@@ -0,0 +1,15 @@
+interface RoundtripOptions {
+    gateway: string;
+    budgetMs?: number;
+    pollIntervalMs?: number;
+    perRequestTimeoutMs?: number;
+}
+declare function fetchManifestRoundtrip(cid: string, options: RoundtripOptions): Promise<{
+    ok: true;
+    manifestBytes: Uint8Array;
+} | {
+    ok: false;
+    reason: string;
+}>;
+
+export { type RoundtripOptions, fetchManifestRoundtrip };

package/dist/manifest-roundtrip.js

@@ -0,0 +1,56 @@
+import {
+  extractManifestFromCar
+} from "./chunk-5MRZ3V4A.js";
+import "./chunk-S7EM5VMW.js";
+import "./chunk-QGM4M3NI.js";
+
+// src/manifest-roundtrip.ts
+async function fetchManifestRoundtrip(cid, options) {
+  const gateway = options.gateway.replace(/\/$/, "");
+  const budget = options.budgetMs ?? 3e4;
+  const poll = options.pollIntervalMs ?? 2e3;
+  const perReq = options.perRequestTimeoutMs ?? 1e4;
+  const start = Date.now();
+  let lastReason = "no attempts";
+  while (Date.now() - start < budget) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), perReq);
+    let res;
+    try {
+      res = await fetch(`${gateway}/ipfs/${cid}`, { signal: ctrl.signal });
+    } catch (e) {
+      lastReason = `network: ${e?.message ?? e}`;
+      clearTimeout(timer);
+      await sleep(poll);
+      continue;
+    } finally {
+      clearTimeout(timer);
+    }
+    if (res.status === 404 || res.status === 504) {
+      lastReason = `gateway HTTP ${res.status}`;
+      await sleep(poll);
+      continue;
+    }
+    if (res.status !== 200) {
+      lastReason = `gateway HTTP ${res.status}`;
+      await sleep(poll);
+      continue;
+    }
+    const buf = await res.arrayBuffer();
+    const carBytes = new Uint8Array(buf);
+    const manifestBytes = await extractManifestFromCar(carBytes);
+    if (!manifestBytes) {
+      lastReason = "manifest not in deployed DAG";
+      await sleep(poll);
+      continue;
+    }
+    return { ok: true, manifestBytes };
+  }
+  return { ok: false, reason: `roundtrip budget exhausted: ${lastReason}` };
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+export {
+  fetchManifestRoundtrip
+};

package/dist/manifest.d.ts

@@ -0,0 +1,44 @@
+declare const MANIFEST_VERSION = 3;
+declare const MANIFEST_DIR = ".bulletin-deploy";
+declare const MANIFEST_FILENAME = "manifest.json";
+declare const MANIFEST_PATH = ".bulletin-deploy/manifest.json";
+type FileType = "stable" | "volatile";
+interface ManifestFileEntry {
+    cid: string;
+    type: FileType;
+    size?: number;
+}
+interface ManifestChunkEntry {
+    size: number;
+    deployed_at: string;
+    block?: number;
+    index?: number;
+}
+interface EmbeddedManifest {
+    version: number;
+    previous_contenthash: string | null;
+    deployed_at: string;
+    framework: string | null;
+    files: Record<string, ManifestFileEntry>;
+    stableBlockOrder: string[];
+    blocks: string[];
+    chunks: Record<string, ManifestChunkEntry>;
+}
+declare function isVolatilePath(p: string): boolean;
+type ClassifyContext = {
+    prevManifest?: EmbeddedManifest | null;
+    framework?: string | null;
+    fileCid?: string;
+};
+declare function classifyFileHeuristic(filePath: string, framework?: string | null): FileType;
+declare function classifyFile(filePath: string, ctx?: ClassifyContext): FileType;
+type ParseResult = {
+    ok: true;
+    manifest: EmbeddedManifest;
+} | {
+    ok: false;
+    error: string;
+};
+declare function parseManifest(raw: string): ParseResult;
+
+export { type ClassifyContext, type EmbeddedManifest, type FileType, MANIFEST_DIR, MANIFEST_FILENAME, MANIFEST_PATH, MANIFEST_VERSION, type ManifestChunkEntry, type ManifestFileEntry, type ParseResult, classifyFile, classifyFileHeuristic, isVolatilePath, parseManifest };

package/dist/manifest.js

@@ -0,0 +1,21 @@
+import {
+  MANIFEST_DIR,
+  MANIFEST_FILENAME,
+  MANIFEST_PATH,
+  MANIFEST_VERSION,
+  classifyFile,
+  classifyFileHeuristic,
+  isVolatilePath,
+  parseManifest
+} from "./chunk-S7EM5VMW.js";
+import "./chunk-QGM4M3NI.js";
+export {
+  MANIFEST_DIR,
+  MANIFEST_FILENAME,
+  MANIFEST_PATH,
+  MANIFEST_VERSION,
+  classifyFile,
+  classifyFileHeuristic,
+  isVolatilePath,
+  parseManifest
+};

package/dist/memory-report.js

@@ -5,8 +5,8 @@ import {
   maybeWriteMemoryReport,
   safeHeap,
   sampleFromBytes
-} from "./chunk-4AP5ZFNV.js";
-import "./chunk-N7YE5ZN3.js";
+} from "./chunk-KMRYJR4E.js";
+import "./chunk-ZGU6FOLO.js";
 import "./chunk-QGM4M3NI.js";
 export {
   DEFAULT_THRESHOLD_MB,

package/dist/merkle.d.ts

@@ -2,6 +2,43 @@ interface MerkleizeResult {
     carBytes: Uint8Array;
     cid: string;
 }
+interface MerkleizeStableResult extends MerkleizeResult {
+    blockOrder: string[];
+    stableOrder: string[];
+    chunks: Uint8Array[];
+    chunkCids: string[];
+    section1ChunkCids: string[];
+    sectionSizes: {
+        section0: number;
+        section1: number;
+        section2: number;
+    };
+    /** All DAG blocks from the merkleize backend: cid → block bytes. */
+    blocks: Map<string, Uint8Array>;
+    /** File path → user-facing CID (leaf for single-block, dag-pb root for multi-block). */
+    fileCids: Map<string, string>;
+}
+interface MerkleizeOutput {
+    rootCid: string;
+    blocks: Map<string, Uint8Array>;
+    fileBlocks: Map<string, string[]>;
+    fileCids: Map<string, string>;
+    rootBlockCids: string[];
+    subdirCids: string[];
+}
+declare function merkleizeJSBackend(directoryPath: string): Promise<MerkleizeOutput>;
+declare function merkleizeKuboBackend(directoryPath: string): Promise<MerkleizeOutput>;
+declare function merkleizeBackend(directoryPath: string, useKubo: boolean): Promise<MerkleizeOutput>;
+interface BuildOrderedCarOptions {
+    output: MerkleizeOutput;
+    classifyFn?: (filePath: string, fileCid?: string) => "stable" | "volatile";
+    prevStableOrder?: string[];
+}
+declare function buildOrderedCar(options: BuildOrderedCarOptions): Promise<MerkleizeStableResult>;
+declare function merkleizeWithStableOrder(directoryPath: string, prevStableOrder?: string[], options?: {
+    useKubo?: boolean;
+    classifyFn?: (filePath: string) => "stable" | "volatile";
+}): Promise<MerkleizeStableResult>;
 declare function merkleizeJS(directoryPath: string): Promise<MerkleizeResult>;
 
-export { type MerkleizeResult, merkleizeJS };
+export { type BuildOrderedCarOptions, type MerkleizeOutput, type MerkleizeResult, type MerkleizeStableResult, buildOrderedCar, merkleizeBackend, merkleizeJS, merkleizeJSBackend, merkleizeKuboBackend, merkleizeWithStableOrder };

package/dist/merkle.js

@@ -1,7 +1,32 @@
 import {
-  merkleizeJS
-} from "./chunk-B7GUYYAN.js";
+  buildOrderedCar,
+  merkleizeBackend,
+  merkleizeJS,
+  merkleizeJSBackend,
+  merkleizeKuboBackend,
+  merkleizeWithStableOrder
+} 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 "./chunk-ZOC4GITL.js";
+import "./chunk-HOTQDYHD.js";
 import "./chunk-QGM4M3NI.js";
 export {
-  merkleizeJS
+  buildOrderedCar,
+  merkleizeBackend,
+  merkleizeJS,
+  merkleizeJSBackend,
+  merkleizeKuboBackend,
+  merkleizeWithStableOrder
 };

package/dist/run-state.js

@@ -7,7 +7,7 @@ import {
   shouldSkipStaleWarning,
   stateFilePath,
   writeRunState
-} from "./chunk-N7YE5ZN3.js";
+} from "./chunk-ZGU6FOLO.js";
 import "./chunk-QGM4M3NI.js";
 export {
   VERSION,

package/dist/telemetry.js

@@ -27,8 +27,8 @@ import {
   truncateAddress,
   withDeploySpan,
   withSpan
-} from "./chunk-4AP5ZFNV.js";
-import "./chunk-N7YE5ZN3.js";
+} from "./chunk-KMRYJR4E.js";
+import "./chunk-ZGU6FOLO.js";
 import "./chunk-QGM4M3NI.js";
 export {
   VERSION,

package/dist/version-check.js

@@ -8,9 +8,9 @@ import {
   isPreReleaseVersion,
   preReleaseWarning,
   promptYesNo
-} from "./chunk-6YJ46BN2.js";
-import "./chunk-4AP5ZFNV.js";
-import "./chunk-N7YE5ZN3.js";
+} from "./chunk-NE5MN2M2.js";
+import "./chunk-KMRYJR4E.js";
+import "./chunk-ZGU6FOLO.js";
 import "./chunk-QGM4M3NI.js";
 export {
   assessVersion,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bulletin-deploy",
-  "version": "0.7.14",
+  "version": "0.7.15",
   "private": false,
   "repository": {
     "type": "git",
@@ -31,7 +31,7 @@
   ],
   "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-B7GUYYAN.js

@@ -1,94 +0,0 @@
-// src/merkle.ts
-import * as fs from "fs";
-import * as path from "path";
-import { importer } from "ipfs-unixfs-importer";
-import { CarWriter } from "@ipld/car/writer";
-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 = fs.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;
-  }
-  for (const entry of dirents) {
-    const fullPath = path.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 chunk of iter) {
-    parts.push(chunk);
-    totalLength += chunk.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;
-}
-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 fs.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 {
-  merkleizeJS
-};