bulletin-deploy 0.6.16 → 0.7.0

package/dist/{chunk-LF3XAUCI.js → chunk-Q42TQHNL.js}

@@ -1,3 +1,9 @@
+// src/memory-report.ts
+import * as fs2 from "fs";
+import * as os from "os";
+import * as path2 from "path";
+import * as v8 from "v8";
+
 // src/telemetry.ts
 import { execSync } from "child_process";
 import { createHash } from "crypto";
@@ -7,7 +13,7 @@ import * as path from "path";
 // package.json
 var package_default = {
   name: "bulletin-deploy",
-  version: "0.6.16",
+  version: "0.7.0",
   private: false,
   repository: {
     type: "git",
@@ -31,11 +37,10 @@ var package_default = {
   },
   files: [
     "dist",
-    "bin",
-    "cdm.json"
+    "bin"
   ],
   scripts: {
-    build: "tsup src/index.ts src/deploy.ts src/dotns.ts src/pool.ts src/telemetry.ts src/merkle.ts src/gh-pages-mirror.ts src/version-check.ts src/bug-report.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 --format esm --dts --clean --target node22",
     prepare: "npm run build",
     test: "npm run build && node --test test/test.js test/pool.test.js test/helpers/e2e-helpers.test.js",
     "test:e2e": "npm run build && node --test test/e2e.test.js",
@@ -45,7 +50,6 @@ var package_default = {
     benchmark: "npm run build && node benchmark.js"
   },
   dependencies: {
-    "@dotdm/cdm": "^0.5.1",
     "@ipld/car": "^5.4.3",
     "@ipld/dag-pb": "^4.1.3",
     "@noble/hashes": "^1.7.2",
@@ -244,11 +248,51 @@ async function withSpan(op, description, attributes, fn) {
     }
   });
 }
+var memoryPeak = null;
+var deployRootSpan = null;
+var stageSamples = {};
+var reportContext = {};
+function toMb(bytes) {
+  return Math.round(bytes / 1024 / 1024 * 100) / 100;
+}
+function sampleMemory(stage) {
+  if (!Sentry) return;
+  const m = process.memoryUsage();
+  const active = Sentry.getActiveSpan();
+  if (process.env.BULLETIN_DEPLOY_MEM_DEBUG) {
+    console.error(`[sampleMemory] stage=${stage} active=${active ? active.description ?? active.name ?? "?" : "null"} rss=${toMb(m.rss)}MB`);
+  }
+  if (active) {
+    active.setAttribute(`mem.${stage}.rss_mb`, String(toMb(m.rss)));
+    active.setAttribute(`mem.${stage}.heap_used_mb`, String(toMb(m.heapUsed)));
+    active.setAttribute(`mem.${stage}.external_mb`, String(toMb(m.external)));
+    active.setAttribute(`mem.${stage}.array_buffers_mb`, String(toMb(m.arrayBuffers)));
+  }
+  stageSamples[stage] = sampleFromBytes(m);
+  if (memoryPeak) {
+    if (m.rss > memoryPeak.rss) memoryPeak.rss = m.rss;
+    if (m.heapUsed > memoryPeak.heapUsed) memoryPeak.heapUsed = m.heapUsed;
+    if (m.external > memoryPeak.external) memoryPeak.external = m.external;
+    if (m.arrayBuffers > memoryPeak.arrayBuffers) memoryPeak.arrayBuffers = m.arrayBuffers;
+    if (deployRootSpan) {
+      deployRootSpan.setAttribute("deploy.mem.peak_rss_mb", String(toMb(memoryPeak.rss)));
+      deployRootSpan.setAttribute("deploy.mem.peak_heap_used_mb", String(toMb(memoryPeak.heapUsed)));
+      deployRootSpan.setAttribute("deploy.mem.peak_external_mb", String(toMb(memoryPeak.external)));
+      deployRootSpan.setAttribute("deploy.mem.peak_array_buffers_mb", String(toMb(memoryPeak.arrayBuffers)));
+    }
+  }
+}
 async function withDeploySpan(domain, fn) {
   if (!Sentry) return fn();
   const attrs = { ...getDeployAttributes(domain), "deploy.domain": domain };
+  const m0 = process.memoryUsage();
+  memoryPeak = { rss: m0.rss, heapUsed: m0.heapUsed, external: m0.external, arrayBuffers: m0.arrayBuffers };
+  stageSamples = {};
+  reportContext = {};
+  const deployStartMs = Date.now();
   try {
     return await Sentry.startSpan({ op: "deploy", name: `deploy ${domain}`, attributes: attrs }, async (span) => {
+      deployRootSpan = span;
       Sentry.setTags({
         "deploy.repo": attrs["deploy.repo"],
         "deploy.branch": attrs["deploy.branch"],
@@ -269,12 +313,53 @@ async function withDeploySpan(domain, fn) {
           span.setStatus({ code: 2, message: "internal_error" });
         }
         throw error;
+      } finally {
+        sampleMemory("end");
+        if (memoryPeak) {
+          const report = maybeWriteMemoryReport({
+            peak: sampleFromBytes(memoryPeak),
+            stages: stageSamples,
+            deploy: {
+              domain,
+              repo: attrs["deploy.repo"],
+              deployTag: attrs["deploy.tag"],
+              durationMs: Date.now() - deployStartMs,
+              sentryTraceId: span.spanContext?.().traceId,
+              ...reportContext
+            },
+            outputDir: reportContext.outputDir,
+            onSentryAttach: (r) => {
+              try {
+                Sentry.captureMessage(`deploy memory threshold crossed (${r.threshold.peakRssMb} MB)`, {
+                  level: "warning",
+                  tags: { "deploy.mem.report": "1" },
+                  extra: { memoryReport: r }
+                });
+              } catch {
+              }
+            }
+          });
+          if (report.status === "written") {
+            span.setAttribute("deploy.mem.report_written", "true");
+            span.setAttribute("deploy.mem.report_path", report.path);
+            console.log(`
+   High memory usage detected (peak ${report.peakRssMb} MB, threshold ${report.thresholdMb} MB).`);
+            console.log(`   Diagnostic report written to ${report.path}`);
+          }
+        }
       }
     });
   } finally {
+    memoryPeak = null;
+    deployRootSpan = null;
+    stageSamples = {};
+    reportContext = {};
     await Sentry.flush(5e3);
   }
 }
+function setDeployReportContext(patch) {
+  reportContext = { ...reportContext, ...patch };
+}
 function setDeployAttribute(key, value) {
   if (!Sentry) return;
   const span = Sentry.getActiveSpan();
@@ -299,7 +384,108 @@ async function flush() {
   await Sentry.flush(5e3);
 }
 
+// src/memory-report.ts
+var DEFAULT_THRESHOLD_MB = 1500;
+function toMb2(bytes) {
+  return Math.round(bytes / 1024 / 1024 * 100) / 100;
+}
+function countByType(items) {
+  const counts = {};
+  for (const item of items) {
+    const name = item?.constructor?.name ?? "Unknown";
+    counts[name] = (counts[name] ?? 0) + 1;
+  }
+  return counts;
+}
+function readActiveHandles() {
+  const proc = process;
+  const handles = typeof proc._getActiveHandles === "function" ? proc._getActiveHandles() : [];
+  return countByType(handles);
+}
+function readActiveRequests() {
+  const proc = process;
+  const reqs = typeof proc._getActiveRequests === "function" ? proc._getActiveRequests() : [];
+  return countByType(reqs);
+}
+function readPolkadotApiVersion() {
+  try {
+    const candidates = [
+      path2.join(process.cwd(), "node_modules/polkadot-api/package.json"),
+      path2.join(process.cwd(), "../node_modules/polkadot-api/package.json")
+    ];
+    for (const p of candidates) {
+      if (fs2.existsSync(p)) {
+        const pkg = JSON.parse(fs2.readFileSync(p, "utf-8"));
+        return typeof pkg.version === "string" ? pkg.version : void 0;
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+function buildMemoryReport(input) {
+  return {
+    schemaVersion: 1,
+    toolVersion: VERSION,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    threshold: { thresholdMb: input.thresholdMb, peakRssMb: input.peak.rssMb },
+    deploy: input.deploy,
+    memory: { peak: input.peak, stages: input.stages },
+    v8: {
+      heapStatistics: v8.getHeapStatistics(),
+      heapSpaceStatistics: v8.getHeapSpaceStatistics()
+    },
+    runtime: {
+      nodeVersion: process.version,
+      platform: process.platform,
+      arch: process.arch,
+      totalMemMb: Math.round(os.totalmem() / 1024 / 1024),
+      freeMemMb: Math.round(os.freemem() / 1024 / 1024),
+      cpuCount: os.cpus().length,
+      activeHandlesByType: readActiveHandles(),
+      activeRequestsByType: readActiveRequests()
+    },
+    polkadotApi: { version: readPolkadotApiVersion() }
+  };
+}
+function maybeWriteMemoryReport(input) {
+  const thresholdMb = input.thresholdMbOverride ?? (process.env.BULLETIN_DEPLOY_MEM_REPORT_THRESHOLD_MB ? Number(process.env.BULLETIN_DEPLOY_MEM_REPORT_THRESHOLD_MB) : DEFAULT_THRESHOLD_MB);
+  const peakRssMb = input.peak.rssMb;
+  if (process.env.BULLETIN_DEPLOY_MEM_REPORT === "0") {
+    return { status: "disabled", thresholdMb, peakRssMb };
+  }
+  if (!Number.isFinite(thresholdMb) || peakRssMb < thresholdMb) {
+    return { status: "below-threshold", thresholdMb, peakRssMb };
+  }
+  const isInternal = input.isInternal ?? isInternalContext;
+  if (!isInternal()) {
+    return { status: "not-internal", thresholdMb, peakRssMb };
+  }
+  const report = buildMemoryReport({
+    thresholdMb,
+    peak: input.peak,
+    stages: input.stages,
+    deploy: input.deploy
+  });
+  const outDir = input.outputDir ?? process.cwd();
+  const filePath = path2.join(outDir, ".bulletin-memory-report.json");
+  const write = input.writeFile ?? ((p, c) => fs2.writeFileSync(p, c));
+  try {
+    write(filePath, JSON.stringify(report, null, 2));
+  } catch {
+  }
+  if (input.onSentryAttach) input.onSentryAttach(report);
+  return { status: "written", thresholdMb, peakRssMb, path: filePath };
+}
+function sampleFromBytes(m) {
+  return { rssMb: toMb2(m.rss), heapUsedMb: toMb2(m.heapUsed), externalMb: toMb2(m.external), arrayBuffersMb: toMb2(m.arrayBuffers) };
+}
+
 export {
+  DEFAULT_THRESHOLD_MB,
+  buildMemoryReport,
+  maybeWriteMemoryReport,
+  sampleFromBytes,
   VERSION,
   isInternalContextFromSignals,
   isInternalContext,
@@ -314,7 +500,9 @@ export {
   getDeployAttributes,
   isExpectedError,
   withSpan,
+  sampleMemory,
   withDeploySpan,
+  setDeployReportContext,
   setDeployAttribute,
   setDeploySentryTag,
   captureWarning,

package/dist/deploy.d.ts

@@ -50,13 +50,27 @@ declare function merkleize(directoryPath: string, outputCarPath: string): Promis
     carPath: string;
     cid: string;
 }>;
-declare function storeDirectory(directoryPath: string, provider?: ExistingProvider, password?: string, jsMerkle?: boolean): Promise<{
+declare function computeStorageCid(chunks: Uint8Array[]): string;
+interface StoreDirectoryOptions {
+    provider?: ExistingProvider;
+    password?: string;
+    jsMerkle?: boolean;
+    /**
+     * Fires exactly once, right after the CAR has been merkleized + encrypted
+     * and the final storage CID is known, but BEFORE the chunk upload to
+     * Bulletin starts. Use to kick off parallel side-effects (e.g. the
+     * gh-pages mirror) that can run concurrently with the slow upload. The
+     * returned promise is awaited at the end of the deploy; errors are passed
+     * through to the caller so they can decide fatal / non-fatal policy.
+     */
+    onCarReady?: (carBytes: Uint8Array, storageCid: string) => Promise<void> | void;
+}
+declare function storeDirectory(directoryPath: string, providerOrOptions?: ExistingProvider | StoreDirectoryOptions, password?: string, jsMerkle?: boolean): Promise<{
     storageCid: string;
     ipfsCid: string;
     carBytes: Uint8Array;
 }>;
 interface DeployOptions {
-    playground?: boolean;
     mnemonic?: string;
     /** Optional derivation path applied to the mnemonic (e.g. "//deploy/3"). Defaults to "" (root key). */
     derivationPath?: string;
@@ -89,4 +103,4 @@ interface DeployOptions {
 declare function estimateUploadBytes(content: DeployContent): Promise<number | null>;
 declare function deploy(content: DeployContent, domainName?: string | null, options?: DeployOptions): Promise<DeployResult>;
 
-export { 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, EXIT_CODE_NO_RETRY, NonRetryableError, chunk, createCID, deploy, deriveRootSigner, encodeContenthash, encryptContent, estimateUploadBytes, friendlyChainError, hasIPFS, isConnectionError, merkleize, storeChunkedContent, storeDirectory, storeFile };
+export { 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, EXIT_CODE_NO_RETRY, NonRetryableError, type StoreDirectoryOptions, chunk, computeStorageCid, createCID, deploy, deriveRootSigner, encodeContenthash, encryptContent, estimateUploadBytes, friendlyChainError, hasIPFS, isConnectionError, merkleize, storeChunkedContent, storeDirectory, storeFile };

package/dist/deploy.js

@@ -10,6 +10,7 @@ import {
   EXIT_CODE_NO_RETRY,
   NonRetryableError,
   chunk,
+  computeStorageCid,
   createCID,
   deploy,
   deriveRootSigner,
@@ -23,12 +24,12 @@ import {
   storeChunkedContent,
   storeDirectory,
   storeFile
-} from "./chunk-K7TA53E2.js";
-import "./chunk-3C7PWPPG.js";
-import "./chunk-UZVOH3HB.js";
-import "./chunk-QILGABSF.js";
+} from "./chunk-G3YCSH44.js";
+import "./chunk-OCOCVZQV.js";
+import "./chunk-2Q2WSKFD.js";
+import "./chunk-Q42TQHNL.js";
+import "./chunk-B7GUYYAN.js";
 import "./chunk-JHNW2EKY.js";
-import "./chunk-LF3XAUCI.js";
 import "./chunk-QGM4M3NI.js";
 export {
   DEFAULT_BULLETIN_RPC,
@@ -42,6 +43,7 @@ export {
   EXIT_CODE_NO_RETRY,
   NonRetryableError,
   chunk,
+  computeStorageCid,
   createCID,
   deploy,
   deriveRootSigner,

package/dist/dotns.js

@@ -29,9 +29,9 @@ import {
   simulateUserStatus,
   stripTrailingDigits,
   validateDomainLabel
-} from "./chunk-3C7PWPPG.js";
+} from "./chunk-OCOCVZQV.js";
+import "./chunk-Q42TQHNL.js";
 import "./chunk-JHNW2EKY.js";
-import "./chunk-LF3XAUCI.js";
 import "./chunk-QGM4M3NI.js";
 export {
   CONNECTION_TIMEOUT_MS,

package/dist/gh-pages-mirror.d.ts

@@ -34,6 +34,30 @@ interface MirrorManifest {
 declare class MirrorSkipped extends Error {
     constructor(reason: string);
 }
+interface FreshnessPollResult {
+    verified: boolean;
+    attempts: number;
+    durationMs: number;
+    lastCid: string | null;
+    lastStatus: number;
+}
+/**
+ * Poll the mirror's manifest URL until its `cid` field equals the expected
+ * value. Pages is CDN-backed — a fresh commit may return HTTP 200 for
+ * several seconds to a few minutes while Fastly still serves stale bytes,
+ * so we can't just 200-check. Matching the manifest CID proves the edge
+ * has picked up the current deploy; the sibling .car URL is then guaranteed
+ * fresh for the same commit.
+ *
+ * Non-fatal to the deploy — returns `{ verified: false }` if the poll times
+ * out so the caller can log a warning without aborting a deploy whose
+ * on-chain state is already good.
+ */
+declare function pollMirrorFreshness(mirrorUrl: string, expectedCid: string, opts?: {
+    timeoutMs?: number;
+    intervalMs?: number;
+    fetchFn?: typeof fetch;
+}): Promise<FreshnessPollResult>;
 declare function parseGitRemoteUrl(url: string): {
     owner: string;
     repo: string;
@@ -48,4 +72,4 @@ declare function mirrorUrl(owner: string, repo: string, domainFilename: string):
 declare function buildManifest(input: Omit<MirrorInput, "carBytes" | "repoPath" | "githubToken">): MirrorManifest;
 declare function mirrorToGitHubPages(input: MirrorInput): Promise<MirrorResult>;
 
-export { GH_PAGES_MIRROR_BRANCH, GH_PAGES_MIRROR_DIR, GH_PAGES_MIRROR_MAX_BYTES, type MirrorInput, type MirrorManifest, type MirrorResult, MirrorSkipped, buildManifest, mirrorToGitHubPages, mirrorUrl, normalizeDomainFilename, parseGitRemoteUrl, resolveOwnerRepo, resolveSourceCommit };
+export { type FreshnessPollResult, GH_PAGES_MIRROR_BRANCH, GH_PAGES_MIRROR_DIR, GH_PAGES_MIRROR_MAX_BYTES, type MirrorInput, type MirrorManifest, type MirrorResult, MirrorSkipped, buildManifest, mirrorToGitHubPages, mirrorUrl, normalizeDomainFilename, parseGitRemoteUrl, pollMirrorFreshness, resolveOwnerRepo, resolveSourceCommit };

package/dist/gh-pages-mirror.js

@@ -8,9 +8,10 @@ import {
   mirrorUrl,
   normalizeDomainFilename,
   parseGitRemoteUrl,
+  pollMirrorFreshness,
   resolveOwnerRepo,
   resolveSourceCommit
-} from "./chunk-UZVOH3HB.js";
+} from "./chunk-2Q2WSKFD.js";
 import "./chunk-QGM4M3NI.js";
 export {
   GH_PAGES_MIRROR_BRANCH,
@@ -22,6 +23,7 @@ export {
   mirrorUrl,
   normalizeDomainFilename,
   parseGitRemoteUrl,
+  pollMirrorFreshness,
   resolveOwnerRepo,
   resolveSourceCommit
 };

package/dist/index.js

@@ -1,13 +1,14 @@
 import {
   deploy
-} from "./chunk-K7TA53E2.js";
+} from "./chunk-G3YCSH44.js";
 import {
   DotNS
-} from "./chunk-3C7PWPPG.js";
-import "./chunk-UZVOH3HB.js";
+} from "./chunk-OCOCVZQV.js";
+import "./chunk-2Q2WSKFD.js";
+import "./chunk-Q42TQHNL.js";
 import {
   merkleizeJS
-} from "./chunk-QILGABSF.js";
+} from "./chunk-B7GUYYAN.js";
 import {
   bootstrapPool,
   derivePoolAccounts,
@@ -15,7 +16,6 @@ import {
   fetchPoolAuthorizations,
   selectAccount
 } from "./chunk-JHNW2EKY.js";
-import "./chunk-LF3XAUCI.js";
 import "./chunk-QGM4M3NI.js";
 export {
   DotNS,

package/dist/memory-report.d.ts

@@ -0,0 +1,93 @@
+import * as v8 from 'node:v8';
+
+declare const DEFAULT_THRESHOLD_MB = 1500;
+interface MemorySampleMb {
+    rssMb: number;
+    heapUsedMb: number;
+    externalMb: number;
+    arrayBuffersMb: number;
+}
+interface DeployContextForReport {
+    /** Sanitized domain label (sanitizeBranch equivalent). No dots. */
+    domain?: string;
+    /** Sanitized repo slug. Matches what the deploy span already carries. */
+    repo?: string;
+    deployTag?: string;
+    deployMode?: "pool" | "direct" | "external";
+    jsMerkle?: boolean;
+    chunkCount?: number;
+    carBytes?: number;
+    reconnects?: number;
+    durationMs?: number;
+    sentryTraceId?: string;
+}
+interface MemoryReport {
+    schemaVersion: 1;
+    toolVersion: string;
+    generatedAt: string;
+    threshold: {
+        thresholdMb: number;
+        peakRssMb: number;
+    };
+    deploy: DeployContextForReport;
+    memory: {
+        peak: MemorySampleMb;
+        stages: Record<string, MemorySampleMb>;
+    };
+    v8: {
+        heapStatistics: ReturnType<typeof v8.getHeapStatistics>;
+        heapSpaceStatistics: ReturnType<typeof v8.getHeapSpaceStatistics>;
+    };
+    runtime: {
+        nodeVersion: string;
+        platform: string;
+        arch: string;
+        totalMemMb: number;
+        freeMemMb: number;
+        cpuCount: number;
+        activeHandlesByType: Record<string, number>;
+        activeRequestsByType: Record<string, number>;
+    };
+    polkadotApi?: {
+        version?: string;
+        clientsCreated?: number;
+    };
+}
+declare function buildMemoryReport(input: {
+    thresholdMb: number;
+    peak: MemorySampleMb;
+    stages: Record<string, MemorySampleMb>;
+    deploy: DeployContextForReport;
+}): MemoryReport;
+interface MaybeWriteMemoryReportInput {
+    peak: MemorySampleMb;
+    stages: Record<string, MemorySampleMb>;
+    deploy: DeployContextForReport;
+    /** Where to write the report file. Usually the build directory. */
+    outputDir?: string;
+    /** Override the default 1500 MB threshold (BULLETIN_DEPLOY_MEM_REPORT_THRESHOLD_MB). */
+    thresholdMbOverride?: number;
+    /** Hook for tests — defaults to isInternalContext(). */
+    isInternal?: () => boolean;
+    /** Hook for tests — defaults to real fs writes. */
+    writeFile?: (path: string, content: string) => void;
+    /** Hook for tests — receives the report when it would be attached to Sentry. */
+    onSentryAttach?: (report: MemoryReport) => void;
+}
+interface MemoryReportResult {
+    /** Why the report did/didn't fire. Useful for tests and CLI logging. */
+    status: "disabled" | "below-threshold" | "not-internal" | "written";
+    thresholdMb: number;
+    peakRssMb: number;
+    path?: string;
+}
+declare function maybeWriteMemoryReport(input: MaybeWriteMemoryReportInput): MemoryReportResult;
+/** Convert a MemorySample with raw byte fields into the MB-shaped sample. */
+declare function sampleFromBytes(m: {
+    rss: number;
+    heapUsed: number;
+    external: number;
+    arrayBuffers: number;
+}): MemorySampleMb;
+
+export { DEFAULT_THRESHOLD_MB, type DeployContextForReport, type MaybeWriteMemoryReportInput, type MemoryReport, type MemoryReportResult, type MemorySampleMb, buildMemoryReport, maybeWriteMemoryReport, sampleFromBytes };

package/dist/memory-report.js

@@ -0,0 +1,13 @@
+import {
+  DEFAULT_THRESHOLD_MB,
+  buildMemoryReport,
+  maybeWriteMemoryReport,
+  sampleFromBytes
+} from "./chunk-Q42TQHNL.js";
+import "./chunk-QGM4M3NI.js";
+export {
+  DEFAULT_THRESHOLD_MB,
+  buildMemoryReport,
+  maybeWriteMemoryReport,
+  sampleFromBytes
+};

package/dist/merkle.js

@@ -1,6 +1,6 @@
 import {
   merkleizeJS
-} from "./chunk-QILGABSF.js";
+} from "./chunk-B7GUYYAN.js";
 import "./chunk-QGM4M3NI.js";
 export {
   merkleizeJS

package/dist/telemetry.d.ts

@@ -1,3 +1,6 @@
+import { DeployContextForReport } from './memory-report.js';
+import 'node:v8';
+
 declare const VERSION: string;
 interface InternalContextSignals {
     githubRepository?: string;
@@ -17,10 +20,14 @@ declare function resolveRunnerType(): string;
 declare function getDeployAttributes(domain: string): Record<string, string | number | boolean | undefined>;
 declare function isExpectedError(msg: string): boolean;
 declare function withSpan<T>(op: string, description: string, attributes: Record<string, string | number | boolean | undefined>, fn: () => T | Promise<T>): Promise<T>;
+declare function sampleMemory(stage: string): void;
 declare function withDeploySpan<T>(domain: string, fn: () => T | Promise<T>): Promise<T>;
+declare function setDeployReportContext(patch: Partial<DeployContextForReport> & {
+    outputDir?: string;
+}): void;
 declare function setDeployAttribute(key: string, value: string | number | boolean): void;
 declare function setDeploySentryTag(key: string, value: string): void;
 declare function captureWarning(message: string, context?: Record<string, unknown>): void;
 declare function flush(): Promise<void>;
 
-export { type InternalContextSignals, VERSION, captureWarning, flush, getDeployAttributes, initTelemetry, isExpectedError, isInternalContext, isInternalContextFromSignals, resolveRepo, resolveRunner, resolveRunnerType, sanitizeBranch, sanitizeRepo, scrubPaths, setDeployAttribute, setDeploySentryTag, truncateAddress, withDeploySpan, withSpan };
+export { type InternalContextSignals, VERSION, captureWarning, flush, getDeployAttributes, initTelemetry, isExpectedError, isInternalContext, isInternalContextFromSignals, resolveRepo, resolveRunner, resolveRunnerType, sampleMemory, sanitizeBranch, sanitizeRepo, scrubPaths, setDeployAttribute, setDeployReportContext, setDeploySentryTag, truncateAddress, withDeploySpan, withSpan };

package/dist/telemetry.js

@@ -10,15 +10,17 @@ import {
   resolveRepo,
   resolveRunner,
   resolveRunnerType,
+  sampleMemory,
   sanitizeBranch,
   sanitizeRepo,
   scrubPaths,
   setDeployAttribute,
+  setDeployReportContext,
   setDeploySentryTag,
   truncateAddress,
   withDeploySpan,
   withSpan
-} from "./chunk-LF3XAUCI.js";
+} from "./chunk-Q42TQHNL.js";
 import "./chunk-QGM4M3NI.js";
 export {
   VERSION,
@@ -32,10 +34,12 @@ export {
   resolveRepo,
   resolveRunner,
   resolveRunnerType,
+  sampleMemory,
   sanitizeBranch,
   sanitizeRepo,
   scrubPaths,
   setDeployAttribute,
+  setDeployReportContext,
   setDeploySentryTag,
   truncateAddress,
   withDeploySpan,

package/dist/version-check.js

@@ -8,8 +8,8 @@ import {
   isPreReleaseVersion,
   preReleaseWarning,
   promptYesNo
-} from "./chunk-BGLOVKHX.js";
-import "./chunk-LF3XAUCI.js";
+} from "./chunk-PA3AS7QR.js";
+import "./chunk-Q42TQHNL.js";
 import "./chunk-QGM4M3NI.js";
 export {
   assessVersion,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bulletin-deploy",
-  "version": "0.6.16",
+  "version": "0.7.0",
   "private": false,
   "repository": {
     "type": "git",
@@ -24,11 +24,10 @@
   },
   "files": [
     "dist",
-    "bin",
-    "cdm.json"
+    "bin"
   ],
   "scripts": {
-    "build": "tsup src/index.ts src/deploy.ts src/dotns.ts src/pool.ts src/telemetry.ts src/merkle.ts src/gh-pages-mirror.ts src/version-check.ts src/bug-report.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 --format esm --dts --clean --target node22",
     "prepare": "npm run build",
     "test": "npm run build && node --test test/test.js test/pool.test.js test/helpers/e2e-helpers.test.js",
     "test:e2e": "npm run build && node --test test/e2e.test.js",
@@ -38,7 +37,6 @@
     "benchmark": "npm run build && node benchmark.js"
   },
   "dependencies": {
-    "@dotdm/cdm": "^0.5.1",
     "@ipld/car": "^5.4.3",
     "@ipld/dag-pb": "^4.1.3",
     "@noble/hashes": "^1.7.2",