@parity/product-deploy 0.7.28-rc.0

package/dist/chunk-MFTODIIT.js

@@ -0,0 +1,725 @@
+import {
+  package_default,
+  writeRunState
+} from "./chunk-KJH2T5TQ.js";
+
+// 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";
+import * as fs from "fs";
+import * as path from "path";
+var VERSION = package_default.version;
+var DOTNS_BACKEND = "contract";
+var DOTNS_POP_SOURCE = "personhood-precompile";
+var DEFAULT_DSN = "https://e021c025d79c4c3ade2862a11f13c40b@o4511059872841728.ingest.de.sentry.io/4511093597405264";
+var INTERNAL_ORG_RE = /^(paritytech|w3f|polkadot-fellows)\//i;
+var PARITY_HOST_APPS = /* @__PURE__ */ new Set(["playground-cli"]);
+function extractRepoSlug(url) {
+  return url.replace(/.*github\.com[:/]/, "").replace(/\.git$/, "");
+}
+function tryGitRemote() {
+  try {
+    return extractRepoSlug(execSync("git remote get-url origin", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim());
+  } catch {
+    return void 0;
+  }
+}
+function isInternalContextFromSignals(signals) {
+  if (INTERNAL_ORG_RE.test(signals.githubRepository ?? "")) return true;
+  if (signals.runnerName?.startsWith("parity-")) return true;
+  if (signals.gitRemote && INTERNAL_ORG_RE.test(signals.gitRemote)) return true;
+  if (signals.hostApp && PARITY_HOST_APPS.has(signals.hostApp)) return true;
+  return false;
+}
+function isInternalContext() {
+  return isInternalContextFromSignals({
+    githubRepository: process.env.GITHUB_REPOSITORY,
+    runnerName: process.env.RUNNER_NAME,
+    gitRemote: tryGitRemote(),
+    hostApp: process.env.BULLETIN_DEPLOY_HOST_APP
+  });
+}
+var OPT_OUT = process.env.BULLETIN_DEPLOY_TELEMETRY === "0";
+var OPT_IN = process.env.BULLETIN_DEPLOY_TELEMETRY === "1";
+var DISABLED = OPT_OUT || !OPT_IN && !isInternalContext();
+var CONVENTIONAL_BRANCH_PREFIXES = /* @__PURE__ */ new Set([
+  "fix",
+  "feat",
+  "chore",
+  "docs",
+  "test",
+  "refactor",
+  "release",
+  "bump",
+  "perf",
+  "style",
+  "ci",
+  "build",
+  "revert"
+]);
+function scrubPaths(msg) {
+  if (!msg) return msg;
+  return msg.replace(/\/Users\/[^\/\s"'`]+/g, "/Users/<redacted>").replace(/\/home\/[^\/\s"'`]+/g, "/home/<redacted>");
+}
+function truncateAddress(ss58) {
+  if (!ss58) return ss58;
+  return ss58.length > 8 ? `${ss58.slice(0, 8)}\u2026` : ss58;
+}
+function sanitizeBranch(name) {
+  if (!name) return name;
+  const slash = name.indexOf("/");
+  if (slash === -1) return name;
+  const prefix = name.slice(0, slash).toLowerCase();
+  if (CONVENTIONAL_BRANCH_PREFIXES.has(prefix)) return name;
+  return name.slice(slash + 1);
+}
+function sanitizeRepo(slug) {
+  if (!slug) return slug;
+  if (INTERNAL_ORG_RE.test(slug)) return slug;
+  const slash = slug.indexOf("/");
+  if (slash === -1) {
+    return `ext/${createHash("sha256").update(slug).digest("hex").slice(0, 12)}`;
+  }
+  const org = slug.slice(0, slash);
+  const repo = slug.slice(slash + 1);
+  return `${org}/${createHash("sha256").update(repo).digest("hex").slice(0, 12)}`;
+}
+var Sentry = null;
+if (!DISABLED) {
+  try {
+    Sentry = await import("@sentry/node");
+  } catch {
+  }
+}
+var runStateActive = false;
+var relaunchOomHintShown = false;
+function setRunStateActive(v) {
+  runStateActive = v;
+}
+function markRelaunchOomHintShown() {
+  relaunchOomHintShown = true;
+}
+async function closeTelemetry(timeoutMs) {
+  if (!Sentry) return;
+  try {
+    await Sentry.close(timeoutMs);
+  } catch {
+  }
+}
+function initTelemetry() {
+  if (!Sentry) return;
+  if (process.env.BULLETIN_DEPLOY_USE_AMBIENT_SENTRY === "1") {
+    return;
+  }
+  Sentry.init({
+    dsn: process.env.SENTRY_DSN || DEFAULT_DSN,
+    release: `${package_default.name}@${VERSION}`,
+    tracesSampleRate: 1,
+    environment: process.env.CI ? "ci" : "local",
+    // Sentry Node SDK captures os.hostname() by default, which leaks personal
+    // machine names (e.g. "Mac.fritz.box"). Override to something anonymous.
+    serverName: process.env.CI ? process.env.RUNNER_NAME ?? "ci" : "local",
+    beforeSend(event) {
+      if (event.server_name) event.server_name = process.env.CI ? process.env.RUNNER_NAME ?? "ci" : "local";
+      if (event.message) event.message = scrubPaths(event.message);
+      for (const ex of event.exception?.values ?? []) {
+        if (ex.value) ex.value = scrubPaths(ex.value);
+      }
+      for (const bc of event.breadcrumbs ?? []) {
+        if (bc.message) bc.message = scrubPaths(bc.message);
+      }
+      return event;
+    },
+    beforeSendTransaction(event) {
+      const spans = event.spans ?? [];
+      for (const span of spans) {
+        const attrs = span.data;
+        if (!attrs) continue;
+        for (const k of Object.keys(attrs)) {
+          const v = attrs[k];
+          if (typeof v === "string") attrs[k] = scrubPaths(v);
+        }
+      }
+      return event;
+    }
+  });
+  Sentry.setTag("bulletin-deploy.version", VERSION);
+  Sentry.setContext("bulletin-deploy", {
+    version: VERSION,
+    release: `${package_default.name}@${VERSION}`,
+    node: process.version
+  });
+}
+function tryPackageJsonRepo() {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(process.cwd(), "package.json"), "utf-8"));
+    const repo = typeof pkg.repository === "string" ? pkg.repository : pkg.repository?.url;
+    if (repo) return extractRepoSlug(repo);
+  } catch {
+  }
+  return void 0;
+}
+function resolveRepo(domain) {
+  return process.env.GITHUB_REPOSITORY || tryGitRemote() || tryPackageJsonRepo() || domain || "unknown";
+}
+function tryGitBranch() {
+  try {
+    return execSync("git rev-parse --abbrev-ref HEAD", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+  } catch {
+    return "unknown";
+  }
+}
+function resolveRunner() {
+  if (!process.env.CI) return "local";
+  if (process.env.RUNNER_NAME?.startsWith("parity-")) return process.env.RUNNER_NAME;
+  return process.env.RUNNER_NAME || "unknown";
+}
+function resolveRunnerType() {
+  if (!process.env.CI) return "local";
+  if (process.env.RUNNER_NAME?.startsWith("parity-")) return "self-hosted";
+  return "github-hosted";
+}
+function getDeployAttributes(domain) {
+  const hostApp = process.env.BULLETIN_DEPLOY_HOST_APP;
+  const attrs = {
+    "deploy.repo": sanitizeRepo(resolveRepo(domain)),
+    "deploy.branch": sanitizeBranch(process.env.GITHUB_HEAD_REF || process.env.GITHUB_REF_NAME || tryGitBranch()),
+    "deploy.source": process.env.CI ? "ci" : "local",
+    "deploy.pr": process.env.GITHUB_PR_NUMBER || void 0,
+    "deploy.tool_version": VERSION,
+    "deploy.runner": resolveRunner(),
+    "deploy.runner_type": resolveRunnerType(),
+    // Seed "false" so successful spans form the %SAD denominator; the catch block and
+    // captureWarning flip it to "true" on friction.
+    "deploy.sad": "false",
+    // Same ratio-denominator reasoning as deploy.sad above, but for the
+    // %EXPECTED-refusal metric: catch block flips to "true" when the error
+    // matches isExpectedError (user-facing product rule, not tool friction).
+    "deploy.expected": "false",
+    // Seed "false" so every span carries the attribute (boolean-both-values rule).
+    // Flipped to "true" by getWsProvider's onStatusChanged when papi connects to a
+    // non-primary endpoint, and flushed again in deploy()'s finally block.
+    "deploy.rpc.failed_over": "false",
+    // DotNS preflight balance gate. Seeded "false" so successful spans form the
+    // denominator for "% of deploys hitting the floor" and "% recovered via
+    // testnet auto-top-up" metrics. Flipped by gateOnFeeBalance.
+    "deploy.dotns.signer_below_floor": "false",
+    "deploy.dotns.toppedup": "false",
+    // Seeded "hash" so spans missing an explicit set (non-DotNS deploys) group
+    // cleanly in the "hash" bucket.
+    "deploy.dotns.tx_resolution_kind": "hash",
+    // Seeded "false" so every span carries the attribute for ratio queries.
+    // Flipped by deploy.ts storage phase when content is encrypted.
+    "deploy.encrypted": "false",
+    // Flipped by deploy.ts after parseDomainName resolves isSubdomain.
+    "deploy.subdomain": "false",
+    // Flipped by deploy.ts after readPreviousContenthashSafe when a prior CID is found.
+    "deploy.incremental": "false",
+    // Seeded "false" so every span carries the attribute for ratio queries.
+    // Flipped to "true" by storeDirectoryV2 when the Phase A root node is already on-chain.
+    "deploy.storage.phase_a.root_already_onchain": "false",
+    // Seeded 0 so every span carries the attribute; incremented by storeDirectoryV2
+    // for each Phase B chunk confirmed present on-chain (probe hit → skip re-upload).
+    "deploy.storage.phase_b.probe_hit_count": 0,
+    "deploy.phase_a.chunks_uploaded": 0,
+    "deploy.probe.finality_miss_count": 0,
+    "deploy.probe.finality_miss_reupload_count": 0,
+    "deploy.pool.eligible_count": 0,
+    // Nonce-advance collision probe counters. Seeded to 0 so every span carries
+    // the attribute for ratio queries even when no collision is detected.
+    "deploy.pool.nonce_collision_count": 0,
+    "deploy.pool.nonce_collision_missing": 0,
+    "deploy.pool.nonce_collision_reupload_count": 0,
+    // Manifest-aware Phase A trust: count of section-1 CIDs trusted from prev manifest.
+    "deploy.phase_a.chunks_trusted": 0,
+    // Manifest fetch outcome. Seeded so every span carries the attributes even when
+    // fetchPreviousManifest is never reached (first deploy, early error, non-incremental
+    // path). "none" + "0" form the denominator for ratio queries:
+    // count_if(deploy.manifest.fetch_source, "heuristic_fallback") / count().
+    // Both string-valued per @sentry/node EAP numeric-attribute caveat.
+    "deploy.manifest.fetch_source": "none",
+    "deploy.manifest.fetch_attempts": "0",
+    "deploy.manifest.bytes_downloaded": "0",
+    // Bulletin storage upload chain receipt (root-node tx, or last chunk when root skipped).
+    // Empty-string default so every span carries the attribute for filter queries.
+    "bulletin.upload.tx_hash": "",
+    "bulletin.upload.block_hash": "",
+    "bulletin.upload.block_number": 0,
+    // DotNS setContenthash chain receipt.
+    "deploy.contenthash.tx": "",
+    "deploy.contenthash.block": 0,
+    "deploy.contenthash.block_hash": "",
+    // DotNS register chain receipt (fresh registrations only).
+    "deploy.register.tx": "",
+    "deploy.register.block": 0,
+    "deploy.register.block_hash": "",
+    // DotNS setSubnodeOwner chain receipt (subdomain registrations only).
+    "deploy.subnode.tx": "",
+    "deploy.subnode.block": 0,
+    "deploy.subnode.block_hash": ""
+  };
+  if (hostApp) attrs["deploy.host_app"] = hostApp;
+  const hostAppVersion = process.env.BULLETIN_DEPLOY_HOST_APP_VERSION;
+  if (hostAppVersion) attrs["deploy.host_app_version"] = hostAppVersion;
+  attrs["deploy.dotns_backend"] = DOTNS_BACKEND;
+  attrs["deploy.dotns_pop_source"] = DOTNS_POP_SOURCE;
+  return attrs;
+}
+function isExpectedError(msg) {
+  return /personhood|owned by|owner mismatch|reserved for original|invalid domain label|not authorized for bulletin|insufficient balance|insufficient funds|quota exhausted|insufficient .* authorization|bip39 mnemonic|ipfs cli not installed|base name is \d+ chars|NameNotAvailable|name must be lowercase/i.test(msg);
+}
+function classifyDeployError(msg) {
+  if (isExpectedError(msg)) return "user";
+  if (/chunk.*failed after.*retr|tx dropped from best chain|timed out after \d+s waiting for block|Contract reverted|Contract execution would revert|dotns register failed|All promises were rejected|"type"\s*:\s*"Invalid"|Commitment still too new|not finalised after \d+s|chain may have (dropped|evicted)|ReviveApi.*timed out/i.test(msg)) return "environment";
+  if (/javascript heap out of memory|allocation failed.*heap|External signer mode is not supported with dotns-cli/i.test(msg)) return "internal";
+  return "unknown";
+}
+function classifySadReason(message) {
+  if (/process terminated: SIG/i.test(message)) return "killed";
+  if (/memory threshold/i.test(message)) return "memory";
+  if (/spektr injection|account map failed/i.test(message)) return "signer";
+  if (/chunk upload failed|chunk retry failed/i.test(message)) return "chain_storage";
+  if (/websocket connection lost|rpc.*endpoint failed|rpc failover/i.test(message)) return "rpc";
+  return "other";
+}
+function computeDeployOutcome(errorCategory, isSad, sadReason) {
+  if (errorCategory === "user") return "user_error";
+  if (errorCategory === "environment") return "env_error";
+  if (errorCategory === "internal") return "internal_error";
+  if (errorCategory === "unknown") return "unknown_error";
+  if (isSad) return `sad_${sadReason}`;
+  return "clean";
+}
+var ERROR_KIND_RULES = [
+  [/Contract reverted|Contract execution would revert|revert(?:ed|ing)?\s*\(flags=[0-9]+\)/i, "contract-revert"],
+  [/timed out after \d+s waiting for block|Transaction not included after \d+s|Transaction did not settle within/i, "chain-timeout"],
+  [/\bstale\b.*nonce|nonce.*\bstale\b|"type"\s*:\s*"(?:Future|Stale)"|Invalid::Future|tx rejected by pool/i, "nonce-stale"],
+  [/heartbeat timeout|WS halt|Unable to connect|ChainHead disjointed|websocket.*closed|socket closed|disconnect/i, "connection"],
+  [/requires ProofOfPersonhoodFull,\s*but this signer is NoStatus/i, "naming.pop_required"],
+  [/Domain\s+\S+\.dot\s+is already owned by\s+0x[a-fA-F0-9]+/i, "naming.already_owned"],
+  [/Cannot deploy\s+[\w.-]+\.dot:\s*parent\s+[\w.-]+\.dot\s+is owned by/i, "naming.subdomain_orphan"],
+  [/Post-deploy verification failed for .+: on-chain contenthash is /i, "verify.contenthash_mismatch"],
+  [/Deploy verification failed:\s*DAG-PB root.+not finalised/i, "verify.dagpb_not_finalised"],
+  [/Retry budget exhausted:.*recovery attempts/i, "network.recovery_exhausted"],
+  [/ReviveApi\.\w+ timed out after \d+ms/i, "chain.api_timeout"],
+  [/^INVARIANT FAILED:/i, "tool.invariant"]
+];
+function classifyErrorKind(msg) {
+  for (const [re, kind] of ERROR_KIND_RULES) {
+    if (re.test(msg)) return kind;
+  }
+  return "unknown";
+}
+function sanitizeErrorMessage(msg) {
+  return scrubPaths(msg.slice(0, 500));
+}
+function analyseErrorPattern(msg) {
+  const tags = [];
+  const len = msg.length;
+  if (len < 50) tags.push("len:lt50");
+  else if (len < 100) tags.push("len:50-99");
+  else if (len < 200) tags.push("len:100-199");
+  else if (len < 500) tags.push("len:200-499");
+  else tags.push("len:gte500");
+  if (/[a-z]+:\/\/[^\s:/?#]+:[^\s@/?#]+@/i.test(msg)) tags.push("url-userinfo");
+  const longHexRuns = (msg.match(/[0-9a-fA-F]{40,}/g) ?? []).filter((h) => !h.toLowerCase().startsWith("e30") && h.length !== 40);
+  if (longHexRuns.length > 0) tags.push(`long-hex:${Math.min(longHexRuns.length, 9)}`);
+  const b64ish = msg.match(/[A-Za-z0-9+/=]{30,}/g) ?? [];
+  if (b64ish.some((s) => /[A-Z]/.test(s) && /[a-z]/.test(s) && /[0-9]/.test(s))) tags.push("base64ish");
+  if (/\b[A-Za-z0-9_-]{6,}\.[A-Za-z0-9_-]{6,}\.[A-Za-z0-9_-]{6,}\b/.test(msg)) tags.push("jwt-shape");
+  const evmCount = (msg.match(/0x[a-fA-F0-9]{40}\b/g) ?? []).length;
+  if (evmCount > 0) tags.push(`evm:${Math.min(evmCount, 9)}`);
+  if (/\b[1-9A-HJ-NP-Za-km-z]{46,49}\b/.test(msg)) tags.push("ss58-shape");
+  if (/(?:\b[a-z]{3,8}\s){11,23}\b[a-z]{3,8}\b/.test(msg)) tags.push("mnemonic-shape");
+  return tags.join(",");
+}
+async function withSpan(op, description, attributes, fn) {
+  if (!Sentry) return fn();
+  return Sentry.startSpan({ op, name: description, attributes }, async (span) => {
+    try {
+      return await fn();
+    } catch (error) {
+      const msg = error.message ?? String(error);
+      span.setAttribute("error.message", msg);
+      span.setAttribute("deploy.error_kind", classifyErrorKind(msg));
+      span.setAttribute("deploy.error_message", sanitizeErrorMessage(msg));
+      span.setAttribute("deploy.error_pattern_signature", analyseErrorPattern(msg));
+      span.setStatus({ code: 2, message: "internal_error" });
+      throw error;
+    }
+  });
+}
+var memoryPeak = null;
+var deployRootSpan = null;
+var stageSamples = {};
+var reportContext = {};
+var currentErrorCategory = null;
+var currentDeploySad = false;
+var currentSadReason = "other";
+var currentSadReasonPriority = 0;
+var SAD_REASON_PRIORITY = {
+  killed: 5,
+  memory: 4,
+  signer: 3,
+  chain_storage: 2,
+  rpc: 1,
+  other: 0
+};
+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_bytes`, m.rss);
+    active.setAttribute(`mem.${stage}.heap_used_bytes`, m.heapUsed);
+    active.setAttribute(`mem.${stage}.external_bytes`, m.external);
+    active.setAttribute(`mem.${stage}.array_buffers_bytes`, 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_bytes", memoryPeak.rss);
+      deployRootSpan.setAttribute("deploy.mem.peak_heap_used_bytes", memoryPeak.heapUsed);
+      deployRootSpan.setAttribute("deploy.mem.peak_external_bytes", memoryPeak.external);
+      deployRootSpan.setAttribute("deploy.mem.peak_array_buffers_bytes", memoryPeak.arrayBuffers);
+    }
+  }
+  if (runStateActive && memoryPeak) {
+    try {
+      writeRunState({ lastPeakRssMb: toMb(memoryPeak.rss), lastStage: stage });
+    } catch {
+    }
+  }
+}
+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 = {};
+  currentErrorCategory = null;
+  currentDeploySad = false;
+  currentSadReason = "other";
+  currentSadReasonPriority = 0;
+  const deployStartMs = Date.now();
+  try {
+    return await Sentry.startSpan({ op: "deploy", name: `deploy ${domain}`, attributes: attrs }, async (span) => {
+      deployRootSpan = span;
+      span.setAttribute("deploy.tool_version", VERSION);
+      if (relaunchOomHintShown) {
+        span.setAttribute("deploy.relaunch.oom_hint_shown", "true");
+      }
+      const tagsToSet = {
+        "deploy.repo": attrs["deploy.repo"],
+        "deploy.branch": attrs["deploy.branch"],
+        "deploy.domain": domain,
+        "deploy.source": attrs["deploy.source"],
+        "deploy.tool_version": VERSION,
+        "deploy.runner_type": resolveRunnerType(),
+        "deploy.host_app": attrs["deploy.host_app"] ?? ""
+      };
+      if (!tagsToSet["deploy.host_app"]) delete tagsToSet["deploy.host_app"];
+      Sentry.setTags(tagsToSet);
+      try {
+        const result = await fn();
+        span.setAttribute("deploy.status", "ok");
+        return result;
+      } catch (error) {
+        const msg = error.message ?? String(error);
+        span.setAttribute("deploy.status", "error");
+        span.setAttribute("deploy.error", msg.slice(0, 500));
+        const errorCategory = classifyDeployError(msg);
+        span.setAttribute("deploy.error_category", errorCategory);
+        span.setAttribute("deploy.error_kind", classifyErrorKind(msg));
+        span.setAttribute("deploy.error_message", sanitizeErrorMessage(msg));
+        span.setAttribute("deploy.error_pattern_signature", analyseErrorPattern(msg));
+        currentErrorCategory = errorCategory;
+        const isExpected = isExpectedError(msg);
+        span.setAttribute("deploy.expected", isExpected ? "true" : "false");
+        span.setAttribute("deploy.sad", isExpected ? "false" : "true");
+        if (!isExpected) {
+          span.setStatus({ code: 2, message: "internal_error" });
+        }
+        throw error;
+      } finally {
+        sampleMemory("end");
+        span.setAttribute(
+          "deploy.outcome",
+          computeDeployOutcome(currentErrorCategory, currentDeploySad, currentSadReason)
+        );
+        if (memoryPeak) {
+          try {
+            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}`);
+            }
+          } catch (e) {
+            captureWarning("maybeWriteMemoryReport threw", {
+              error: e?.message?.slice(0, 200)
+            });
+          }
+        }
+      }
+    });
+  } finally {
+    memoryPeak = null;
+    deployRootSpan = null;
+    stageSamples = {};
+    reportContext = {};
+    currentErrorCategory = null;
+    currentDeploySad = false;
+    currentSadReason = "other";
+    currentSadReasonPriority = 0;
+    try {
+      await Sentry.flush(5e3);
+    } catch {
+    }
+  }
+}
+function setDeployReportContext(patch) {
+  reportContext = { ...reportContext, ...patch };
+}
+function setDeployAttribute(key, value) {
+  if (!deployRootSpan) return;
+  deployRootSpan.setAttribute(key, value);
+}
+function __setDeployRootSpanForTest(span) {
+  deployRootSpan = span;
+}
+function __setSentryForTest(stub) {
+  const prev = Sentry;
+  Sentry = stub;
+  return prev;
+}
+function getCurrentSentryTraceId() {
+  if (!Sentry) return void 0;
+  const span = Sentry.getActiveSpan();
+  if (!span) return void 0;
+  return span.spanContext?.().traceId;
+}
+function setDeploySentryTag(key, value) {
+  if (!Sentry) return;
+  Sentry.setTag(key, value);
+}
+function captureWarning(message, context) {
+  if (!Sentry) return;
+  try {
+    Sentry.addBreadcrumb({ level: "warning", message, data: context });
+    Sentry.captureMessage(message, { level: "warning", extra: context });
+    if (deployRootSpan) deployRootSpan.setAttribute("deploy.sad", "true");
+    const reason = classifySadReason(message);
+    const priority = SAD_REASON_PRIORITY[reason] ?? 0;
+    if (priority >= currentSadReasonPriority) {
+      currentSadReason = reason;
+      currentSadReasonPriority = priority;
+    }
+    currentDeploySad = true;
+  } catch {
+  }
+}
+async function flush() {
+  if (!Sentry) return;
+  try {
+    await Sentry.flush(5e3);
+  } catch {
+  }
+}
+
+// src/memory-report.ts
+function isBunRuntime() {
+  return typeof globalThis.Bun !== "undefined" || typeof process.versions.bun === "string";
+}
+var DEFAULT_THRESHOLD_MB = 800;
+function toMb2(bytes) {
+  return Math.round(bytes / 1024 / 1024 * 100) / 100;
+}
+function safeHeap(f) {
+  try {
+    return f();
+  } catch {
+    return void 0;
+  }
+}
+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;
+  return safeHeap(() => {
+    const handles = typeof proc._getActiveHandles === "function" ? proc._getActiveHandles() : [];
+    return countByType(handles);
+  }) ?? {};
+}
+function readActiveRequests() {
+  const proc = process;
+  return safeHeap(() => {
+    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: safeHeap(() => v8.getHeapStatistics()),
+      heapSpaceStatistics: safeHeap(() => 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 (isBunRuntime()) {
+    return { status: "unsupported-runtime", 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 {
+  isBunRuntime,
+  DEFAULT_THRESHOLD_MB,
+  safeHeap,
+  buildMemoryReport,
+  maybeWriteMemoryReport,
+  sampleFromBytes,
+  VERSION,
+  isInternalContextFromSignals,
+  isInternalContext,
+  scrubPaths,
+  truncateAddress,
+  sanitizeBranch,
+  sanitizeRepo,
+  setRunStateActive,
+  markRelaunchOomHintShown,
+  closeTelemetry,
+  initTelemetry,
+  resolveRepo,
+  resolveRunner,
+  resolveRunnerType,
+  getDeployAttributes,
+  isExpectedError,
+  classifyDeployError,
+  classifySadReason,
+  computeDeployOutcome,
+  classifyErrorKind,
+  sanitizeErrorMessage,
+  analyseErrorPattern,
+  withSpan,
+  sampleMemory,
+  withDeploySpan,
+  setDeployReportContext,
+  setDeployAttribute,
+  __setDeployRootSpanForTest,
+  __setSentryForTest,
+  getCurrentSentryTraceId,
+  setDeploySentryTag,
+  captureWarning,
+  flush
+};