bulletin-deploy 0.7.3 → 0.7.4

package/dist/{chunk-EPNPPAMS.js → chunk-SVKCVNXD.js}

@@ -1,13 +1,14 @@
 import {
   setDeployContext
-} from "./chunk-4EQERQRG.js";
+} from "./chunk-YYULF2JX.js";
 import {
   DotNS,
   TX_TIMEOUT_MS,
   fetchNonce,
   parseDomainName,
-  popStatusName
-} from "./chunk-M3H3F4FY.js";
+  popStatusName,
+  verifyNonceAdvanced
+} from "./chunk-YREZFNCC.js";
 import {
   MirrorSkipped,
   mirrorToGitHubPages,
@@ -26,7 +27,7 @@ import {
   truncateAddress,
   withDeploySpan,
   withSpan
-} from "./chunk-BYIVK52G.js";
+} from "./chunk-DHQ3JGF4.js";
 import {
   merkleizeJS
 } from "./chunk-B7GUYYAN.js";
@@ -48,7 +49,7 @@ import { sha256 } from "@noble/hashes/sha256";
 import { blake2b } from "@noble/hashes/blake2b";
 import { createClient as createPolkadotClient, Enum } from "polkadot-api";
 import { Binary } from "@polkadot-api/substrate-bindings";
-import { getWsProvider } from "polkadot-api/ws-provider";
+import { getWsProvider, WsEvent } from "polkadot-api/ws-provider";
 import { withPolkadotSdkCompat } from "polkadot-api/polkadot-sdk-compat";
 import { CID } from "multiformats/cid";
 import { create as createMultihash } from "multiformats/hashes/digest";
@@ -75,12 +76,23 @@ function friendlyChainError(msg) {
 }
 var DEFAULT_BULLETIN_RPC = "wss://paseo-bulletin-rpc.polkadot.io";
 var DEFAULT_POOL_SIZE = 10;
-var BULLETIN_RPC = DEFAULT_BULLETIN_RPC;
+var BULLETIN_ENDPOINTS = [DEFAULT_BULLETIN_RPC];
 var POOL_SIZE = DEFAULT_POOL_SIZE;
+var _deployRpcFailedOver = false;
+function makeBulletinStatusHandler(primary) {
+  return (s) => {
+    if (s.type === WsEvent.CONNECTED && s.uri !== primary) {
+      _deployRpcFailedOver = true;
+      setDeployAttribute("deploy.rpc.failed_over", "true");
+      captureWarning("Bulletin RPC failover", { from: primary, to: s.uri });
+    }
+  };
+}
 var CHUNK_SIZE = 2 * 1024 * 1024;
 var MAX_FILE_SIZE = 8 * 1024 * 1024;
 var MAX_RECONNECTIONS = parseInt(process.env.BULLETIN_MAX_RECONNECTIONS ?? "3", 10);
 var CHUNK_TIMEOUT_MS = parseInt(process.env.BULLETIN_CHUNK_TIMEOUT_MS ?? "180000", 10);
+var CHUNK_MORTALITY_PERIOD = 16;
 var RETRY_BASE_DELAY_MS = 2e3;
 var RETRY_MAX_DELAY_MS = 15e3;
 var WS_HEARTBEAT_TIMEOUT_MS = 3e5;
@@ -147,8 +159,12 @@ function toHashingEnum(mhCode) {
   }
 }
 async function getProvider() {
-  console.log(`   Connecting to Bulletin: ${BULLETIN_RPC}`);
-  const client = createPolkadotClient(withPolkadotSdkCompat(getWsProvider(BULLETIN_RPC, { heartbeatTimeout: WS_HEARTBEAT_TIMEOUT_MS })));
+  const primary = BULLETIN_ENDPOINTS[0];
+  console.log(`   Connecting to Bulletin: ${primary}`);
+  const client = createPolkadotClient(withPolkadotSdkCompat(getWsProvider(
+    BULLETIN_ENDPOINTS,
+    { heartbeatTimeout: WS_HEARTBEAT_TIMEOUT_MS, onStatusChanged: makeBulletinStatusHandler(primary) }
+  )));
   const unsafeApi = client.getUnsafeApi();
   try {
     await cryptoWaitReady();
@@ -159,10 +175,10 @@ async function getProvider() {
     if (!selected) {
       const best = authorizations.reduce((a, b) => a.transactions > b.transactions ? a : b);
       console.log(`   All pool accounts low on capacity, auto-authorizing account ${best.index}...`);
-      await ensureAuthorized(unsafeApi, best.address, BULLETIN_RPC, `pool account ${best.index}`);
+      await ensureAuthorized(unsafeApi, best.address, BULLETIN_ENDPOINTS[0], `pool account ${best.index}`);
       selected = best;
     } else {
-      await ensureAuthorized(unsafeApi, selected.address, BULLETIN_RPC, `pool account ${selected.index}`);
+      await ensureAuthorized(unsafeApi, selected.address, BULLETIN_ENDPOINTS[0], `pool account ${selected.index}`);
     }
     console.log(`   Using pool account ${selected.index}: ${selected.address}`);
     setDeployAttribute("deploy.signer.mode", "pool");
@@ -175,8 +191,12 @@ async function getProvider() {
   }
 }
 async function getDirectProvider(mnemonic, derivationPath = "") {
-  console.log(`   Connecting to Bulletin: ${BULLETIN_RPC}`);
-  const client = createPolkadotClient(withPolkadotSdkCompat(getWsProvider(BULLETIN_RPC, { heartbeatTimeout: WS_HEARTBEAT_TIMEOUT_MS })));
+  const primary = BULLETIN_ENDPOINTS[0];
+  console.log(`   Connecting to Bulletin: ${primary}`);
+  const client = createPolkadotClient(withPolkadotSdkCompat(getWsProvider(
+    BULLETIN_ENDPOINTS,
+    { heartbeatTimeout: WS_HEARTBEAT_TIMEOUT_MS, onStatusChanged: makeBulletinStatusHandler(primary) }
+  )));
   const unsafeApi = client.getUnsafeApi();
   const { signer, ss58 } = deriveRootSigner(mnemonic, derivationPath);
   console.log(`   Using direct signer: ${ss58}${derivationPath ? ` (path: ${derivationPath})` : ""}`);
@@ -195,8 +215,9 @@ async function getDirectProvider(mnemonic, derivationPath = "") {
   return { client, unsafeApi, signer, ss58 };
 }
 var MAX_BEST_CHAIN_DROPS = 5;
-function watchTransaction(tx, signer, txOpts, onSuccess, { label = "transaction", rpc, senderSS58, expectedNonce, timeoutMs } = {}) {
+function watchTransaction(tx, signer, txOpts, onSuccess, { label = "transaction", rpc, senderSS58, expectedNonce, timeoutMs, fetchNonce: fetchNonceOverride } = {}) {
   const timeout = timeoutMs ?? TX_TIMEOUT_MS;
+  const _fetchNonce = fetchNonceOverride ?? fetchNonce;
   return new Promise((resolve2, reject) => {
     let settled = false;
     let sub;
@@ -211,14 +232,15 @@ function watchTransaction(tx, signer, txOpts, onSuccess, { label = "transaction"
       }
       fn(...args);
     };
-    const tryNonceFallback = async () => {
+    const tryNonceFallback = async (subscriptionErrored) => {
       if (!rpc || !senderSS58 || expectedNonce == null) return false;
       try {
-        const currentNonce = await fetchNonce(rpc, senderSS58);
+        const endpoints = Array.isArray(rpc) ? rpc : [rpc];
+        const verified = await verifyNonceAdvanced(endpoints, senderSS58, expectedNonce);
         if (settled) return true;
-        if (currentNonce > expectedNonce) {
-          console.log(`      ${label}: nonce advanced (${expectedNonce} -> ${currentNonce}), tx was included`);
-          settle(resolve2)({ value: onSuccess(), viaFallback: true });
+        if (verified.advanced) {
+          console.log(`      ${label}: nonce advanced past ${expectedNonce} (witnessed by ${verified.witnessRpc}), tx was included`);
+          settle(resolve2)({ value: onSuccess(), viaFallback: true, subscriptionError: subscriptionErrored });
           return true;
         }
       } catch (e) {
@@ -229,7 +251,7 @@ function watchTransaction(tx, signer, txOpts, onSuccess, { label = "transaction"
     };
     const timer = setTimeout(async () => {
       if (settled) return;
-      if (await tryNonceFallback()) return;
+      if (await tryNonceFallback(false)) return;
       settle(reject)(new Error(`${label} timed out after ${timeout / 1e3}s waiting for block confirmation`));
     }, timeout);
     sub = tx.signSubmitAndWatch(signer, txOpts).subscribe({
@@ -237,7 +259,7 @@ function watchTransaction(tx, signer, txOpts, onSuccess, { label = "transaction"
         if (event.type === "txBestBlocksState") {
           if (event.found) {
             if (event.ok) {
-              settle(resolve2)({ value: onSuccess(event), viaFallback: false });
+              settle(resolve2)({ value: onSuccess(event), viaFallback: false, subscriptionError: false });
             } else {
               settle(reject)(new Error(`${label} dispatch error`));
             }
@@ -245,7 +267,7 @@ function watchTransaction(tx, signer, txOpts, onSuccess, { label = "transaction"
             dropCount++;
             if (dropCount >= MAX_BEST_CHAIN_DROPS) {
               console.log(`      ${label}: tx dropped ${dropCount} times, checking nonce...`);
-              if (await tryNonceFallback()) return;
+              if (await tryNonceFallback(true)) return;
               settle(reject)(new Error(`${label} tx dropped from best chain ${dropCount} times`));
             } else {
               console.log(`      ${label}: tx dropped from best chain (${dropCount}/${MAX_BEST_CHAIN_DROPS}), waiting...`);
@@ -260,16 +282,16 @@ function watchTransaction(tx, signer, txOpts, onSuccess, { label = "transaction"
     });
   });
 }
-async function storeChunk(unsafeApi, signer, chunkBytes, nonce, ss58) {
+async function storeChunk(unsafeApi, signer, chunkBytes, nonce, ss58, opts = {}) {
   const hashCode = 18;
   const cid = createCID(chunkBytes, CID_CONFIG.codec, hashCode);
   const tx = unsafeApi.tx.TransactionStorage.store_with_cid_config({ cid: { codec: BigInt(CID_CONFIG.codec), hashing: toHashingEnum(hashCode) }, data: Binary.fromBytes(chunkBytes) });
-  const txOpts = { mortality: { mortal: true, period: 256 }, nonce };
-  const { value, viaFallback } = await watchTransaction(tx, signer, txOpts, () => {
+  const txOpts = { mortality: { mortal: true, period: CHUNK_MORTALITY_PERIOD }, nonce };
+  const { value, viaFallback, subscriptionError } = await watchTransaction(tx, signer, txOpts, () => {
     console.log(`      CID: ${cid.toString()}`);
     return { cid, len: chunkBytes.length };
-  }, { label: `chunk(nonce:${nonce})`, rpc: BULLETIN_RPC, senderSS58: ss58, expectedNonce: nonce, timeoutMs: CHUNK_TIMEOUT_MS });
-  return { ...value, viaFallback };
+  }, { label: `chunk(nonce:${nonce})`, rpc: BULLETIN_ENDPOINTS, senderSS58: ss58, expectedNonce: nonce, timeoutMs: CHUNK_TIMEOUT_MS, fetchNonce: opts.fetchNonce });
+  return { ...value, viaFallback, subscriptionError };
 }
 async function storeFile(contentBytes, { client: existingClient, unsafeApi: existingApi, signer: existingSigner } = {}) {
   console.log(`
@@ -305,7 +327,8 @@ async function storeFile(contentBytes, { client: existingClient, unsafeApi: exis
     throw e;
   }
 }
-async function storeChunkedContent(chunks, { client: existingClient, unsafeApi: existingApi, signer: existingSigner, ss58: existingSS58, reconnect } = {}) {
+async function storeChunkedContent(chunks, { client: existingClient, unsafeApi: existingApi, signer: existingSigner, ss58: existingSS58, reconnect, fetchNonce: fetchNonceOverride } = {}) {
+  const _fetchNonce = fetchNonceOverride ?? fetchNonce;
   console.log(`
    Chunks: ${chunks.length}`);
   const totalBytes = chunks.reduce((s, c) => s + c.length, 0);
@@ -337,7 +360,7 @@ async function storeChunkedContent(chunks, { client: existingClient, unsafeApi:
    Account has insufficient authorization for this upload (need ${requiredTxs} txs / ${(totalBytes / 1e6).toFixed(1)}MB, have ${txsRemaining} txs / ${Number(bytesRemaining) / 1e6}MB)`);
     console.log(`   Attempting to re-authorize with Alice...`);
     try {
-      await ensureAuthorized(unsafeApi, ss58, BULLETIN_RPC, void 0, { txs: requiredTxs, bytes: requiredBytes });
+      await ensureAuthorized(unsafeApi, ss58, BULLETIN_ENDPOINTS[0], void 0, { txs: requiredTxs, bytes: requiredBytes });
       console.log(`   Re-authorization successful`);
     } catch (e) {
       throw new NonRetryableError(`Account ${ss58} has insufficient Bulletin authorization quota and auto-authorization via Alice failed (${e.message}). Authorize the account on-chain.`);
@@ -368,7 +391,7 @@ async function storeChunkedContent(chunks, { client: existingClient, unsafeApi:
     sampleMemory(`reconnect_${reconnectionsUsed}_after`);
   }
   try {
-    let startNonce = await fetchNonce(BULLETIN_RPC, ss58);
+    let startNonce = await _fetchNonce(BULLETIN_ENDPOINTS, ss58);
     console.log(`   Starting nonce: ${startNonce}`);
     const BATCH_SIZE = 2;
     const MAX_CHUNK_RETRIES = 3;
@@ -394,7 +417,7 @@ async function storeChunkedContent(chunks, { client: existingClient, unsafeApi:
         }
         const nonce = assignedNonces.get(i);
         console.log(`   [${i + 1}/${chunks.length}] ${(chunkData.length / 1024 / 1024).toFixed(2)} MB (nonce: ${nonce})`);
-        return storeChunk(unsafeApi, signer, chunkData, nonce, ss58);
+        return storeChunk(unsafeApi, signer, chunkData, nonce, ss58, { fetchNonce: fetchNonceOverride });
       });
       const results = await Promise.allSettled(batchPromises);
       results.forEach((r, j) => {
@@ -404,11 +427,11 @@ async function storeChunkedContent(chunks, { client: existingClient, unsafeApi:
         }
       });
       const failures = results.map((r, j) => r.status === "rejected" ? { index: batchIndices[j], chunkData: batchChunks[j], error: r.reason } : null).filter(Boolean);
-      const succeededViaFallback = results.some((r) => r.status === "fulfilled" && r.value.viaFallback);
-      const needsReconnect = failures.some((f) => isConnectionError(f.error)) || succeededViaFallback;
+      const subscriptionErrored = results.some((r) => r.status === "fulfilled" && r.value.subscriptionError);
+      const needsReconnect = failures.some((f) => isConnectionError(f.error)) || subscriptionErrored;
       if (needsReconnect && reconnect && reconnectionsUsed < MAX_RECONNECTIONS) {
         await doReconnect();
-        const currentNonce = await fetchNonce(BULLETIN_RPC, ss58);
+        const currentNonce = await _fetchNonce(BULLETIN_ENDPOINTS, ss58);
         for (const idx of batchIndices) {
           const chunkNonce = assignedNonces.get(idx);
           if (chunkNonce !== void 0 && chunkNonce < currentNonce && stored[idx] === null) {
@@ -439,7 +462,7 @@ async function storeChunkedContent(chunks, { client: existingClient, unsafeApi:
             }
           }
           try {
-            const currentNonce = await fetchNonce(BULLETIN_RPC, ss58);
+            const currentNonce = await _fetchNonce(BULLETIN_ENDPOINTS, ss58);
             const originalNonce = assignedNonces.get(fail.index);
             if (originalNonce !== void 0 && originalNonce < currentNonce) {
               console.log(`   Chunk ${fail.index + 1}: nonce ${originalNonce} consumed (current=${currentNonce}), treating as included`);
@@ -449,7 +472,7 @@ async function storeChunkedContent(chunks, { client: existingClient, unsafeApi:
               break;
             }
             const retryNonce = originalNonce ?? currentNonce;
-            const result2 = await storeChunk(unsafeApi, signer, fail.chunkData, retryNonce, ss58);
+            const result2 = await storeChunk(unsafeApi, signer, fail.chunkData, retryNonce, ss58, { fetchNonce: fetchNonceOverride });
             stored[fail.index] = result2;
             assignedNonces.delete(fail.index);
             retried = true;
@@ -495,7 +518,7 @@ async function storeChunkedContent(chunks, { client: existingClient, unsafeApi:
     const MAX_ROOT_RETRIES = 3;
     let result;
     for (let rootAttempt = 1; rootAttempt <= MAX_ROOT_RETRIES; rootAttempt++) {
-      const rootNonce = await fetchNonce(BULLETIN_RPC, ss58);
+      const rootNonce = await _fetchNonce(BULLETIN_ENDPOINTS, ss58);
       console.log(`   Storing root node (nonce: ${rootNonce})...`);
       const rootTx = unsafeApi.tx.TransactionStorage.store_with_cid_config({ cid: { codec: BigInt(112), hashing: toHashingEnum(hashCode) }, data: Binary.fromBytes(dagBytes) });
       const rootTxOpts = { mortality: { mortal: true, period: 256 }, nonce: rootNonce };
@@ -504,9 +527,9 @@ async function storeChunkedContent(chunks, { client: existingClient, unsafeApi:
           console.log(`   Root CID: ${rootCid.toString()}
 `);
           return rootCid.toString();
-        }, { label: "root-node", rpc: BULLETIN_RPC, senderSS58: ss58, expectedNonce: rootNonce, timeoutMs: CHUNK_TIMEOUT_MS });
+        }, { label: "root-node", rpc: BULLETIN_ENDPOINTS, senderSS58: ss58, expectedNonce: rootNonce, timeoutMs: CHUNK_TIMEOUT_MS, fetchNonce: fetchNonceOverride });
         result = watchResult.value;
-        if (watchResult.viaFallback && reconnect && reconnectionsUsed < MAX_RECONNECTIONS) {
+        if (watchResult.subscriptionError && reconnect && reconnectionsUsed < MAX_RECONNECTIONS) {
           await doReconnect();
         }
         break;
@@ -665,7 +688,9 @@ async function estimateUploadBytes(content) {
   }
 }
 async function deploy(content, domainName = null, options = {}) {
-  BULLETIN_RPC = options.rpc ?? process.env.BULLETIN_RPC ?? DEFAULT_BULLETIN_RPC;
+  const userRpc = options.rpc ?? process.env.BULLETIN_RPC;
+  BULLETIN_ENDPOINTS = userRpc ? [userRpc, ...[DEFAULT_BULLETIN_RPC].filter((e) => e !== userRpc)] : [DEFAULT_BULLETIN_RPC];
+  _deployRpcFailedOver = false;
   POOL_SIZE = options.poolSize ?? parseInt(process.env.BULLETIN_POOL_SIZE ?? String(DEFAULT_POOL_SIZE), 10);
   initTelemetry();
   const randomSuffix = Math.floor(Math.random() * 100).toString().padStart(2, "0");
@@ -762,7 +787,7 @@ async function deploy(content, domainName = null, options = {}) {
         const uploadBytes = Math.ceil(estimated * 1.2);
         const chunksNeeded = Math.max(1, Math.ceil(uploadBytes / CHUNK_SIZE));
         const needs = { txs: BigInt(chunksNeeded + 2), bytes: BigInt(uploadBytes) };
-        await topUpBy(provider.ss58, BULLETIN_RPC, needs, "uploader");
+        await topUpBy(provider.ss58, BULLETIN_ENDPOINTS[0], needs, "uploader");
       }
       console.log("\n" + "=".repeat(60));
       console.log("Storage");
@@ -808,7 +833,7 @@ async function deploy(content, domainName = null, options = {}) {
                     carBytes,
                     cid: predictedCid,
                     toolVersion: VERSION,
-                    bulletinRpc: options.rpc ?? process.env.BULLETIN_RPC ?? DEFAULT_BULLETIN_RPC,
+                    bulletinRpc: BULLETIN_ENDPOINTS[0],
                     encrypted: Boolean(options.password)
                   }).catch((err) => err instanceof Error ? err : new Error(String(err)));
                 }
@@ -939,6 +964,7 @@ async function deploy(content, domainName = null, options = {}) {
       console.log("\n" + "=".repeat(60) + "\n");
       return { domainName: name, fullDomain: `${name}.dot`, cid, ipfsCid };
     } finally {
+      if (_deployRpcFailedOver) setDeployAttribute("deploy.rpc.failed_over", "true");
       provider?.client.destroy();
     }
   });
@@ -950,6 +976,7 @@ export {
   friendlyChainError,
   DEFAULT_BULLETIN_RPC,
   DEFAULT_POOL_SIZE,
+  CHUNK_MORTALITY_PERIOD,
   isConnectionError,
   deriveRootSigner,
   createCID,

package/dist/chunk-UJP2PZGU.js

@@ -0,0 +1,155 @@
+// src/run-state.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+
+// package.json
+var package_default = {
+  name: "bulletin-deploy",
+  version: "0.7.4",
+  private: false,
+  repository: {
+    type: "git",
+    url: "https://github.com/paritytech/bulletin-deploy.git"
+  },
+  publishConfig: {
+    registry: "https://registry.npmjs.org",
+    access: "public"
+  },
+  type: "module",
+  main: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  bin: {
+    "bulletin-deploy": "./bin/bulletin-deploy"
+  },
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js"
+    }
+  },
+  files: [
+    "dist",
+    "bin"
+  ],
+  scripts: {
+    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 --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",
+    "test:e2e:smoke": "bash scripts/e2e-pass.sh smoke",
+    "test:e2e:pr": "bash scripts/e2e-pass.sh pr",
+    "test:e2e:nightly": "bash scripts/e2e-pass.sh nightly",
+    benchmark: "npm run build && node benchmark.js"
+  },
+  dependencies: {
+    "@ipld/car": "^5.4.3",
+    "@ipld/dag-pb": "^4.1.3",
+    "@noble/hashes": "^1.7.2",
+    "@parity/dotns-cli": "0.5.6",
+    "@polkadot-api/substrate-bindings": "^0.16.5",
+    "@polkadot-labs/hdkd": "^0.0.25",
+    "@polkadot-labs/hdkd-helpers": "^0.0.26",
+    "@polkadot/keyring": "^13.0.0",
+    "@polkadot/util-crypto": "^13.0.0",
+    "@sentry/node": "^9.14.0",
+    "ipfs-unixfs": "^11.2.0",
+    "ipfs-unixfs-importer": "^16.1.4",
+    multiformats: "^13.4.1",
+    "polkadot-api": "^1.23.1",
+    viem: "^2.30.5"
+  },
+  devDependencies: {
+    "@types/node": "^22.0.0",
+    tsup: "^8.5.0",
+    typescript: "^5.9.3"
+  },
+  minimumVersion: "0.5.6",
+  engines: {
+    node: ">=22"
+  }
+};
+
+// src/run-state.ts
+var VERSION = package_default.version;
+function resolveStateDir() {
+  if (process.platform === "darwin") {
+    return path.join(os.homedir(), "Library", "Application Support", "bulletin-deploy");
+  }
+  if (process.platform === "win32") {
+    const base2 = process.env.LOCALAPPDATA ?? path.join(os.homedir(), "AppData", "Local");
+    return path.join(base2, "bulletin-deploy");
+  }
+  const base = process.env.XDG_STATE_HOME && process.env.XDG_STATE_HOME.length > 0 ? process.env.XDG_STATE_HOME : path.join(os.homedir(), ".local", "state");
+  return path.join(base, "bulletin-deploy");
+}
+function stateFilePath() {
+  return path.join(resolveStateDir(), "last-run.json");
+}
+function loadRunState() {
+  try {
+    const raw = fs.readFileSync(stateFilePath(), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function writeRunState(patch) {
+  try {
+    const dir = resolveStateDir();
+    fs.mkdirSync(dir, { recursive: true });
+    const file = stateFilePath();
+    let existing = {};
+    try {
+      const raw = fs.readFileSync(file, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object") existing = parsed;
+    } catch {
+    }
+    const merged = { ...existing, ...patch };
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(merged), { encoding: "utf-8" });
+    fs.renameSync(tmp, file);
+  } catch {
+  }
+}
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    const code = err.code;
+    if (code === "EPERM") return true;
+    return false;
+  }
+}
+function shouldSkipStaleWarning(prev) {
+  if (prev.pid && isPidAlive(prev.pid)) return true;
+  if (prev.toolVersion !== VERSION) return true;
+  return false;
+}
+function probablyOomRssMb(override) {
+  if (typeof override === "number" && Number.isFinite(override)) return override;
+  const env = process.env.BULLETIN_DEPLOY_OOM_HINT_RSS_MB;
+  const parsed = env != null ? Number(env) : NaN;
+  if (Number.isFinite(parsed) && parsed > 0) return parsed;
+  return 1800;
+}
+function shouldShowOomHint(prev) {
+  if (prev.lastPeakRssMb == null) return false;
+  return prev.lastPeakRssMb >= probablyOomRssMb();
+}
+
+export {
+  package_default,
+  VERSION,
+  resolveStateDir,
+  stateFilePath,
+  loadRunState,
+  writeRunState,
+  shouldSkipStaleWarning,
+  probablyOomRssMb,
+  shouldShowOomHint
+};