bulletin-deploy 0.7.8 → 0.7.9-rc.1

package/dist/bug-report.js

@@ -9,10 +9,10 @@ import {
   offerBugReport,
   scrubSecrets,
   setDeployContext
-} from "./chunk-BTAGLNZY.js";
-import "./chunk-ZTUUEMII.js";
-import "./chunk-R7SSZDXQ.js";
-import "./chunk-KRL6D3YY.js";
+} from "./chunk-RUEFJ32K.js";
+import "./chunk-XBONIEIK.js";
+import "./chunk-ULIUVP7W.js";
+import "./chunk-ODXESRRQ.js";
 import "./chunk-QGM4M3NI.js";
 export {
   buildCliFlagsSummary,

package/dist/{chunk-KRL6D3YY.js → chunk-ODXESRRQ.js}

@@ -6,7 +6,7 @@ import * as path from "path";
 // package.json
 var package_default = {
   name: "bulletin-deploy",
-  version: "0.7.8",
+  version: "0.7.9-rc.1",
   private: false,
   repository: {
     type: "git",

package/dist/{chunk-BTAGLNZY.js → chunk-RUEFJ32K.js}

@@ -2,11 +2,11 @@ import {
   classifyErrorArea,
   isInteractive,
   promptYesNo
-} from "./chunk-ZTUUEMII.js";
+} from "./chunk-XBONIEIK.js";
 import {
   VERSION,
   getCurrentSentryTraceId
-} from "./chunk-R7SSZDXQ.js";
+} from "./chunk-ULIUVP7W.js";
 
 // src/bug-report.ts
 import { execSync, execFileSync } from "child_process";

package/dist/{chunk-RUY7MR2M.js → chunk-RWITW7YV.js}

@@ -1,6 +1,6 @@
 import {
   setDeployContext
-} from "./chunk-BTAGLNZY.js";
+} from "./chunk-RUEFJ32K.js";
 import {
   DotNS,
   TX_TIMEOUT_MS,
@@ -8,7 +8,7 @@ import {
   parseDomainName,
   popStatusName,
   verifyNonceAdvanced
-} from "./chunk-4HGXZ225.js";
+} from "./chunk-YIMJSLP2.js";
 import {
   MirrorSkipped,
   mirrorToGitHubPages,
@@ -27,7 +27,7 @@ import {
   truncateAddress,
   withDeploySpan,
   withSpan
-} from "./chunk-R7SSZDXQ.js";
+} from "./chunk-ULIUVP7W.js";
 import {
   merkleizeJS
 } from "./chunk-B7GUYYAN.js";

package/dist/{chunk-R7SSZDXQ.js → chunk-ULIUVP7W.js}

@@ -1,7 +1,7 @@
 import {
   package_default,
   writeRunState
-} from "./chunk-KRL6D3YY.js";
+} from "./chunk-ODXESRRQ.js";
 
 // src/memory-report.ts
 import * as fs2 from "fs";

package/dist/{chunk-ZTUUEMII.js → chunk-XBONIEIK.js}

@@ -1,6 +1,6 @@
 import {
   VERSION
-} from "./chunk-R7SSZDXQ.js";
+} from "./chunk-ULIUVP7W.js";
 
 // src/version-check.ts
 import { execSync, execFileSync } from "child_process";

package/dist/{chunk-4HGXZ225.js → chunk-YIMJSLP2.js}

@@ -2,13 +2,14 @@ import {
   captureWarning,
   setDeployAttribute,
   withSpan
-} from "./chunk-R7SSZDXQ.js";
+} from "./chunk-ULIUVP7W.js";
 import {
   isTestnetSpecName
 } from "./chunk-RP4YJYNB.js";
 
 // src/dotns.ts
 import { spawn } from "child_process";
+import crypto from "crypto";
 import { readFileSync } from "fs";
 import { dirname, join } from "path";
 import { createClient, Enum } from "polkadot-api";
@@ -22,6 +23,7 @@ import {
   decodeFunctionResult,
   keccak256,
   toBytes,
+  formatEther,
   isAddress,
   bytesToHex,
   isHex,
@@ -143,12 +145,36 @@ var ProofOfPersonhoodStatus = {
   ProofOfPersonhoodFull: 2,
   Reserved: 3
 };
+var DOTNS_REGISTRAR_CONTROLLER_ABI = [
+  { inputs: [{ name: "registration", type: "tuple", components: [{ name: "label", type: "string" }, { name: "owner", type: "address" }, { name: "secret", type: "bytes32" }, { name: "reserved", type: "bool" }] }], name: "makeCommitment", outputs: [{ name: "", type: "bytes32" }], stateMutability: "view", type: "function" },
+  { inputs: [{ name: "commitment", type: "bytes32" }], name: "commit", outputs: [], stateMutability: "nonpayable", type: "function" },
+  { inputs: [], name: "minCommitmentAge", outputs: [{ name: "", type: "uint256" }], stateMutability: "view", type: "function" },
+  { inputs: [{ name: "commitment", type: "bytes32" }], name: "commitments", outputs: [{ name: "", type: "uint256" }], stateMutability: "view", type: "function" },
+  { inputs: [{ name: "registration", type: "tuple", components: [{ name: "label", type: "string" }, { name: "owner", type: "address" }, { name: "secret", type: "bytes32" }, { name: "reserved", type: "bool" }] }], name: "register", outputs: [], stateMutability: "payable", type: "function" }
+];
+var DOTNS_REGISTRAR_ABI = [
+  { inputs: [{ name: "tokenId", type: "uint256" }], name: "ownerOf", outputs: [{ name: "", type: "address" }], stateMutability: "view", type: "function" }
+];
 var POP_RULES_ABI = [
+  { inputs: [{ name: "name", type: "string" }], name: "classifyName", outputs: [{ name: "requirement", type: "uint8" }, { name: "message", type: "string" }], stateMutability: "pure", type: "function" },
+  { inputs: [{ name: "name", type: "string" }], name: "price", outputs: [{ name: "", type: "uint256" }], stateMutability: "view", type: "function" },
+  { inputs: [{ name: "", type: "address" }], name: "userPopStatus", outputs: [{ name: "", type: "uint8" }], stateMutability: "view", type: "function" },
+  { inputs: [{ name: "status", type: "uint8" }], name: "setUserPopStatus", outputs: [], stateMutability: "nonpayable", type: "function" },
   { inputs: [{ name: "name", type: "string" }], name: "isBaseNameReserved", outputs: [{ name: "isReserved", type: "bool" }, { name: "reservationOwner", type: "address" }, { name: "expiryTimestamp", type: "uint64" }], stateMutability: "view", type: "function" }
 ];
 var DOTNS_REGISTRY_ABI = [
+  { inputs: [{ name: "record", type: "tuple", components: [{ name: "parentNode", type: "bytes32" }, { name: "subLabel", type: "string" }, { name: "parentLabel", type: "string" }, { name: "owner", type: "address" }] }], name: "setSubnodeOwner", outputs: [{ name: "subnode", type: "bytes32" }], stateMutability: "nonpayable", type: "function" },
+  { inputs: [{ name: "node", type: "bytes32" }, { name: "newResolver", type: "address" }], name: "setResolver", outputs: [], stateMutability: "nonpayable", type: "function" },
   { inputs: [{ name: "node", type: "bytes32" }], name: "owner", outputs: [{ name: "", type: "address" }], stateMutability: "view", type: "function" }
 ];
+var DOTNS_CONTENT_RESOLVER_ABI = [
+  { inputs: [{ name: "node", type: "bytes32" }, { name: "hash", type: "bytes" }], name: "setContenthash", outputs: [], stateMutability: "nonpayable", type: "function" },
+  { inputs: [{ name: "node", type: "bytes32" }], name: "contenthash", outputs: [{ name: "", type: "bytes" }], stateMutability: "view", type: "function" }
+];
+var DOTNS_TEXT_RESOLVER_ABI = [
+  { inputs: [{ name: "node", type: "bytes32" }, { name: "key", type: "string" }, { name: "value", type: "string" }], name: "setText", outputs: [], stateMutability: "nonpayable", type: "function" },
+  { inputs: [{ name: "node", type: "bytes32" }, { name: "key", type: "string" }], name: "text", outputs: [{ name: "", type: "string" }], stateMutability: "view", type: "function" }
+];
 function convertToHexString(value) {
   if (!value) return "0x";
   if (typeof value?.asHex === "function") return value.asHex();
@@ -359,6 +385,11 @@ var ReviveClientWrapper = class _ReviveClientWrapper {
     const isErr = !ok || didRevert || !!err || (typeof successFlag === "boolean" ? !successFlag : false);
     return { gasConsumed, gasRequired, storageDeposit: { value: storageDepositValue }, result: { isOk, isErr, value: { data: ok ? returnData : "0x", flags: ok ? flags : 1n } } };
   }
+  async estimateGasForCall(originSubstrateAddress, contractAddress, value, encodedData) {
+    const result = await this.performDryRunCall(originSubstrateAddress, contractAddress, value, encodedData);
+    if (!result.result.isOk) return { success: false, gasConsumed: result.gasConsumed, storageDeposit: result.storageDeposit.value, gasRequired: result.gasRequired, revertData: result.result.value.data, revertFlags: result.result.value.flags };
+    return { success: true, gasConsumed: result.gasConsumed, storageDeposit: result.storageDeposit.value, gasRequired: result.gasRequired };
+  }
   async checkIfAccountMapped(substrateAddress) {
     try {
       const evmAddress = await this.getEvmAddress(substrateAddress);
@@ -369,6 +400,151 @@ var ReviveClientWrapper = class _ReviveClientWrapper {
       return false;
     }
   }
+  async ensureAccountMapped(substrateAddress, signer) {
+    if (isAddress(substrateAddress)) throw new Error("ensureAccountMapped requires SS58 Substrate address, not EVM H160 address");
+    if (this.mappedAccounts.has(substrateAddress)) return;
+    const isMapped = await this.checkIfAccountMapped(substrateAddress);
+    if (isMapped) {
+      this.mappedAccounts.add(substrateAddress);
+      return;
+    }
+    try {
+      await this.signAndSubmitWithRetry(() => this.client.tx.Revive.map_account(), signer, () => {
+      }, "Revive.map_account");
+      this.mappedAccounts.add(substrateAddress);
+    } catch (error) {
+      const errorMessage = error?.message || String(error);
+      if (errorMessage.includes("AccountAlreadyMapped")) {
+        this.mappedAccounts.add(substrateAddress);
+        return;
+      }
+      throw error;
+    }
+  }
+  signAndSubmitExtrinsic(extrinsic, signer, statusCallback, opts = {}) {
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      let deadlinePoller = null;
+      let sub;
+      const finish = (fn) => (...args) => {
+        if (!settled) {
+          settled = true;
+          if (deadlinePoller) clearInterval(deadlinePoller);
+          try {
+            sub?.unsubscribe();
+          } catch {
+          }
+          fn(...args);
+        }
+      };
+      const startWallClockMs = Date.now();
+      let startChainTimeMs = null;
+      deadlinePoller = setInterval(async () => {
+        if (settled) return;
+        try {
+          if (opts.nonceFallback) {
+            const nonce = await verifyNonceAdvanced(opts.nonceFallback.rpcs, opts.nonceFallback.senderSS58, opts.nonceFallback.expectedNonce);
+            if (nonce.advanced) {
+              statusCallback("included");
+              finish(resolve)(`nonce-advanced:${nonce.witnessRpc}`);
+              return;
+            }
+          }
+          if (Date.now() - startWallClockMs > TX_WALL_CLOCK_CEILING_MS) {
+            statusCallback("failed");
+            finish(reject)(new Error(`Transaction did not settle within ${TX_WALL_CLOCK_CEILING_MS / 1e3}s wall-clock (chain may be stalled)`));
+            return;
+          }
+          const chainNowMs = Number(await this.client.query.Timestamp.Now.getValue());
+          if (startChainTimeMs === null) startChainTimeMs = chainNowMs;
+          const chainElapsedMs = chainNowMs - startChainTimeMs;
+          if (chainElapsedMs > TX_CHAIN_TIME_BUDGET_MS) {
+            statusCallback("failed");
+            finish(reject)(new Error(`Transaction not included after ${Math.floor(chainElapsedMs / 1e3)}s of chain progress (budget=${TX_CHAIN_TIME_BUDGET_MS / 1e3}s)`));
+          }
+        } catch {
+        }
+      }, 6e3);
+      try {
+        sub = extrinsic.signSubmitAndWatch(signer, { mortality: { mortal: true, period: 256 } }).subscribe({
+          next: (event) => {
+            const transactionHash = event.txHash?.toString();
+            switch (event.type) {
+              case "signed":
+                statusCallback("signing");
+                break;
+              case "broadcasted":
+                statusCallback("broadcasting");
+                break;
+              case "txBestBlocksState":
+                if (event.found) statusCallback("included");
+                break;
+              case "finalized":
+                if (event.dispatchError || event.ok === false) {
+                  statusCallback("failed");
+                  finish(reject)(new Error(`Transaction failed: ${event.dispatchError?.toString?.() ?? "dispatch error"}`));
+                  return;
+                }
+                statusCallback("finalized");
+                finish(resolve)(transactionHash);
+                return;
+              case "invalid":
+              case "dropped":
+                statusCallback("failed");
+                finish(reject)(new Error(`Transaction ${event.type}`));
+                return;
+            }
+          },
+          error: (error) => {
+            statusCallback("failed");
+            finish(reject)(error);
+          },
+          complete: () => {
+            if (settled) return;
+            statusCallback("failed");
+            finish(reject)(new Error("transaction subscription closed before finalization"));
+          }
+        });
+      } catch (error) {
+        statusCallback("failed");
+        finish(reject)(error);
+      }
+    });
+  }
+  async signAndSubmitWithRetry(buildExtrinsic, signer, statusCallback, label, opts = {}) {
+    let lastError;
+    for (let attempt = 1; attempt <= DOTNS_TX_MAX_ATTEMPTS; attempt++) {
+      try {
+        return await this.signAndSubmitExtrinsic(buildExtrinsic(), signer, statusCallback, opts);
+      } catch (e) {
+        lastError = e;
+        const decision = classifyTxRetryDecision(e);
+        if (decision === "abort" || attempt === DOTNS_TX_MAX_ATTEMPTS) break;
+        const short = (e?.message ?? String(e)).slice(0, 80);
+        console.log(`   ${label}: attempt ${attempt}/${DOTNS_TX_MAX_ATTEMPTS} failed (${short}), retrying...`);
+      }
+    }
+    throw lastError instanceof Error ? lastError : new Error(String(lastError));
+  }
+  async submitTransaction(contractAddress, value, encodedData, signerSubstrateAddress, signer, statusCallback, { rpcs, useNoncePolling }) {
+    await this.ensureAccountMapped(signerSubstrateAddress, signer);
+    const gasEstimate = await this.estimateGasForCall(signerSubstrateAddress, contractAddress, value, encodedData);
+    if (!gasEstimate.success) throw new Error(`Contract execution would revert: ${gasEstimate.revertData ?? "0x"}`);
+    const weightLimit = { proof_size: gasEstimate.gasRequired.proofSize, ref_time: gasEstimate.gasRequired.referenceTime };
+    const minimumStorageDeposit = 2000000000000n;
+    let storageDepositLimit = gasEstimate.storageDeposit === 0n ? minimumStorageDeposit : gasEstimate.storageDeposit * 120n / 100n;
+    if (storageDepositLimit < minimumStorageDeposit) storageDepositLimit = minimumStorageDeposit;
+    const buildExtrinsic = () => this.client.tx.Revive.call({ dest: Binary.fromHex(contractAddress), value, weight_limit: weightLimit, storage_deposit_limit: storageDepositLimit, data: Binary.fromHex(encodedData) });
+    let nonceFallback;
+    if (useNoncePolling) {
+      try {
+        const nonce = await fetchNonce(rpcs, signerSubstrateAddress);
+        nonceFallback = { rpcs, senderSS58: signerSubstrateAddress, expectedNonce: nonce };
+      } catch {
+      }
+    }
+    return await this.signAndSubmitWithRetry(buildExtrinsic, signer, statusCallback, "Revive.call", { nonceFallback });
+  }
 };
 async function runDotnsCli(argv, env) {
   return new Promise((resolve, reject) => {
@@ -438,6 +614,7 @@ var DotNS = class {
   // Stored credentials for CLI subprocess calls. Never logged or exposed.
   _mnemonic = null;
   _keyUri = null;
+  _usesExternalSigner = false;
   constructor() {
     this.client = null;
     this.clientWrapper = null;
@@ -448,27 +625,33 @@ var DotNS = class {
     this.connected = false;
   }
   async connect(options = {}) {
-    if (options.signer || options.signerAddress) {
-      throw new Error("External signer mode is not supported with dotns-cli subprocess \u2014 tracked as a follow-up (#158 regression notice)");
-    }
     const rpc = options.rpc || process.env.DOTNS_RPC || RPC_ENDPOINTS[0];
     this.rpc = rpc;
-    const mnemonicArg = options.mnemonic || process.env.DOTNS_MNEMONIC || process.env.MNEMONIC;
-    const keyUriArg = options.keyUri || process.env.DOTNS_KEY_URI;
-    const source = keyUriArg || mnemonicArg || DEFAULT_MNEMONIC;
-    const isKeyUri = Boolean(keyUriArg);
-    this._keyUri = isKeyUri ? source : null;
-    this._mnemonic = isKeyUri ? null : source;
-    if (options.derivationPath && !isKeyUri && this._mnemonic) {
-      this._keyUri = `${this._mnemonic}${options.derivationPath}`;
+    this._usesExternalSigner = Boolean(options.signer && options.signerAddress);
+    let authEnv = {};
+    if (this._usesExternalSigner) {
+      this._keyUri = null;
       this._mnemonic = null;
+      this.signer = options.signer;
+      this.substrateAddress = options.signerAddress;
+    } else {
+      const mnemonicArg = options.mnemonic || process.env.DOTNS_MNEMONIC || process.env.MNEMONIC;
+      const keyUriArg = options.keyUri || process.env.DOTNS_KEY_URI;
+      const source = keyUriArg || mnemonicArg || DEFAULT_MNEMONIC;
+      const isKeyUri = Boolean(keyUriArg);
+      this._keyUri = isKeyUri ? source : null;
+      this._mnemonic = isKeyUri ? null : source;
+      if (options.derivationPath && !isKeyUri && this._mnemonic) {
+        this._keyUri = `${this._mnemonic}${options.derivationPath}`;
+        this._mnemonic = null;
+      }
+      authEnv = buildAuthEnv({ mnemonic: this._mnemonic ?? void 0, keyUri: this._keyUri ?? void 0 });
+      await cryptoWaitReady();
+      const keyring = new Keyring({ type: "sr25519" });
+      const account = this._keyUri ? keyring.addFromUri(this._keyUri) : keyring.addFromMnemonic(source);
+      this.signer = getPolkadotSigner(account.publicKey, "Sr25519", async (input) => account.sign(input));
+      this.substrateAddress = account.address;
     }
-    const authEnv = buildAuthEnv({ mnemonic: this._mnemonic ?? void 0, keyUri: this._keyUri ?? void 0 });
-    await cryptoWaitReady();
-    const keyring = new Keyring({ type: "sr25519" });
-    const account = this._keyUri ? keyring.addFromUri(this._keyUri) : keyring.addFromMnemonic(source);
-    this.signer = getPolkadotSigner(account.publicKey, "Sr25519", async (input) => account.sign(input));
-    this.substrateAddress = account.address;
     console.log(`   SS58 Address: ${this.substrateAddress}`);
     try {
       this.client = createClient(getWsProvider(rpc, { heartbeatTimeout: WS_HEARTBEAT_TIMEOUT_MS }));
@@ -485,22 +668,26 @@ var DotNS = class {
     }
     if (!await this.clientWrapper.checkIfAccountMapped(this.substrateAddress)) {
       console.log(`   Mapping account on Asset Hub Revive...`);
-      try {
-        await runDotnsCli(["account", "map", ...rpcFlag(rpc)], authEnv);
-      } catch (e) {
-        captureWarning("account map failed during connect (will rely on chain confirmation)", { error: e.message?.slice(0, 200) });
-      }
-      const mappingDeadline = Date.now() + 15e3;
-      let mappingConfirmed = false;
-      while (Date.now() < mappingDeadline) {
-        if (await this.clientWrapper.checkIfAccountMapped(this.substrateAddress)) {
-          mappingConfirmed = true;
-          break;
+      if (this._usesExternalSigner) {
+        await this.clientWrapper.ensureAccountMapped(this.substrateAddress, this.signer);
+      } else {
+        try {
+          await runDotnsCli(["account", "map", ...rpcFlag(rpc)], authEnv);
+        } catch (e) {
+          captureWarning("account map failed during connect (will rely on chain confirmation)", { error: e.message?.slice(0, 200) });
+        }
+        const mappingDeadline = Date.now() + 15e3;
+        let mappingConfirmed = false;
+        while (Date.now() < mappingDeadline) {
+          if (await this.clientWrapper.checkIfAccountMapped(this.substrateAddress)) {
+            mappingConfirmed = true;
+            break;
+          }
+          await new Promise((r) => setTimeout(r, 1500));
+        }
+        if (!mappingConfirmed) {
+          throw new Error(`Account mapping did not take effect on-chain for ${this.substrateAddress}. The map_account tx may have been dropped or hit a dispatch error \u2014 check the signer's balance for existential deposit + fees.`);
         }
-        await new Promise((r) => setTimeout(r, 1500));
-      }
-      if (!mappingConfirmed) {
-        throw new Error(`Account mapping did not take effect on-chain for ${this.substrateAddress}. The map_account tx may have been dropped or hit a dispatch error \u2014 check the signer's balance for existential deposit + fees.`);
       }
     }
     console.log(`   Account: mapped`);
@@ -673,9 +860,31 @@ var DotNS = class {
     }
     return decodeFunctionResult({ abi: contractAbi, functionName, data: callResult.result.value.data });
   }
+  async contractTransaction(contractAddress, value, contractAbi, functionName, args = [], statusCallback = () => {
+  }, { useNoncePolling } = {}) {
+    this.ensureConnected();
+    if (!this.clientWrapper) throw new Error("contractTransaction: polkadot-api client not available");
+    const encodedCallData = encodeFunctionData({ abi: contractAbi, functionName, args });
+    const rpcs = this.rpc ? [this.rpc, ...RPC_ENDPOINTS.filter((ep) => ep !== this.rpc)] : RPC_ENDPOINTS;
+    return await withTimeout(
+      this.clientWrapper.submitTransaction(contractAddress, value, encodedCallData, this.substrateAddress, this.signer, statusCallback, { rpcs, useNoncePolling }),
+      OPERATION_TIMEOUT_MS,
+      functionName
+    );
+  }
   async checkOwnership(label, ownerAddress = null) {
     this.ensureConnected();
     const checkAddress = (ownerAddress || this.evmAddress).toLowerCase();
+    if (this._usesExternalSigner) {
+      const tokenId = computeDomainTokenId(label);
+      try {
+        const owner = await withTimeout(this.contractCall(CONTRACTS.DOTNS_REGISTRAR, DOTNS_REGISTRAR_ABI, "ownerOf", [tokenId]), 3e4, "ownerOf");
+        const owned = owner.toLowerCase() === checkAddress;
+        return { owned, owner };
+      } catch {
+        return { owned: false, owner: null };
+      }
+    }
     try {
       const result = await runDotnsCli(
         ["lookup", "owner-of", label, "--json", ...rpcFlag(this.rpc)]
@@ -690,6 +899,11 @@ var DotNS = class {
   }
   async getUserPopStatus(ownerAddress = null) {
     this.ensureConnected();
+    if (this._usesExternalSigner) {
+      const checkAddress = ownerAddress || this.evmAddress;
+      const result = await withTimeout(this.contractCall(CONTRACTS.POP_RULES, POP_RULES_ABI, "userPopStatus", [checkAddress]), 3e4, "userPopStatus");
+      return typeof result === "bigint" ? Number(result) : result;
+    }
     if (ownerAddress && ownerAddress.toLowerCase() !== (this.evmAddress ?? "").toLowerCase()) {
       if (!this.clientWrapper) return 0;
       return 0;
@@ -719,6 +933,11 @@ var DotNS = class {
       return;
     }
     console.log(`   Setting PoP status to ${desiredStatusName}...`);
+    if (this._usesExternalSigner) {
+      const txHash = await this.contractTransaction(CONTRACTS.POP_RULES, 0n, POP_RULES_ABI, "setUserPopStatus", [status], (s) => console.log(`      ${s}`));
+      console.log(`   Tx: ${txHash}`);
+      return;
+    }
     const statusStr = desiredStatusName.replace("ProofOfPersonhood", "").toLowerCase() || "none";
     const authEnv = buildAuthEnv({ mnemonic: this._mnemonic ?? void 0, keyUri: this._keyUri ?? void 0 });
     const result = await runDotnsCli(
@@ -745,6 +964,18 @@ var DotNS = class {
       this.ensureConnected();
       console.log(`
    Registering subdomain ${sublabel}.${parentLabel}.dot...`);
+      if (this._usesExternalSigner) {
+        const parentNode = namehash(`${parentLabel}.dot`);
+        const subnodeRecord = { parentNode, subLabel: sublabel, parentLabel, owner: this.evmAddress };
+        const txHash = await this.contractTransaction(CONTRACTS.DOTNS_REGISTRY, 0n, DOTNS_REGISTRY_ABI, "setSubnodeOwner", [subnodeRecord], (s) => console.log(`      ${s}`), { useNoncePolling: true });
+        console.log(`   Tx: ${txHash}`);
+        console.log(`   Setting resolver...`);
+        const subnodeNode = namehash(`${sublabel}.${parentLabel}.dot`);
+        const resolverTxHash = await this.contractTransaction(CONTRACTS.DOTNS_REGISTRY, 0n, DOTNS_REGISTRY_ABI, "setResolver", [subnodeNode, CONTRACTS.DOTNS_CONTENT_RESOLVER], (s) => console.log(`      ${s}`), { useNoncePolling: true });
+        console.log(`   Tx: ${resolverTxHash}`);
+        console.log(`   Subdomain registered!`);
+        return { sublabel, parentLabel, owner: this.evmAddress };
+      }
       const authEnv = buildAuthEnv({ mnemonic: this._mnemonic ?? void 0, keyUri: this._keyUri ?? void 0 });
       const result = await runDotnsCli(
         ["register", "subname", "-n", sublabel, "-p", parentLabel, "--json", ...rpcFlag(this.rpc)],
@@ -768,6 +999,32 @@ var DotNS = class {
       }
       if (!ipfsCid) throw new Error(`setContenthash: cannot decode contenthash ${contenthashHex} to an IPFS CID`);
       console.log(`   Setting contenthash: ${ipfsCid}`);
+      if (this._usesExternalSigner) {
+        const txHash = await this.contractTransaction(CONTRACTS.DOTNS_CONTENT_RESOLVER, 0n, DOTNS_CONTENT_RESOLVER_ABI, "setContenthash", [node, contenthashHex], (s) => console.log(`      ${s}`), { useNoncePolling: true });
+        console.log(`   Tx: ${txHash}`);
+        const expected = contenthashHex.toLowerCase();
+        const MAX_CHAIN_WAIT_SECONDS = 90;
+        const POLL_INTERVAL_MS = 2e3;
+        const startChainMs = Number(await this.clientWrapper.client.query.Timestamp.Now.getValue());
+        let onChain = "0x";
+        while (true) {
+          onChain = (await this.getContenthash(domainName) || "0x").toLowerCase();
+          if (onChain === expected) break;
+          const nowChainMs = Number(await this.clientWrapper.client.query.Timestamp.Now.getValue());
+          const chainElapsed = (nowChainMs - startChainMs) / 1e3;
+          if (chainElapsed >= MAX_CHAIN_WAIT_SECONDS) break;
+          console.log(`   Awaiting finalization (chain time +${Math.floor(chainElapsed)}s / ${MAX_CHAIN_WAIT_SECONDS}s)...`);
+          await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+        }
+        if (onChain !== expected) {
+          throw new Error(
+            `Post-deploy verification failed for ${domainName}.dot: on-chain contenthash is ${onChain}, not the ${expected} we just wrote. The setContenthash tx may have silently failed, or another party overwrote the domain. Re-run the deploy to retry.`
+          );
+        }
+        console.log(`   Verified on-chain: ${ipfsCid}
+`);
+        return { node };
+      }
       const authEnv = buildAuthEnv({ mnemonic: this._mnemonic ?? void 0, keyUri: this._keyUri ?? void 0 });
       const setResult = await runDotnsCli(
         ["content", "set", domainName, ipfsCid, "--json", ...rpcFlag(this.rpc)],
@@ -792,6 +1049,20 @@ var DotNS = class {
     return withSpan("deploy.dotns.set-text", `2c. set-text ${key}`, {}, async () => {
       this.ensureConnected();
       console.log(`   Setting text[${key}]: ${value}`);
+      if (this._usesExternalSigner) {
+        const node = namehash(`${domainName}.dot`);
+        const txHash = await this.contractTransaction(CONTRACTS.DOTNS_RESOLVER, 0n, DOTNS_TEXT_RESOLVER_ABI, "setText", [node, key, value], (s) => console.log(`      ${s}`), { useNoncePolling: true });
+        console.log(`   Tx: ${txHash}`);
+        const onChain2 = await withTimeout(this.contractCall(CONTRACTS.DOTNS_RESOLVER, DOTNS_TEXT_RESOLVER_ABI, "text", [node, key]), 3e4, "text");
+        if ((onChain2 ?? "") !== value) {
+          throw new Error(
+            `Post-set verification failed for text[${key}] on ${domainName}.dot: on-chain value is ${JSON.stringify(onChain2 ?? "")}, not ${JSON.stringify(value)} we just wrote. The setText tx may have silently failed, or another writer overwrote the record.`
+          );
+        }
+        console.log(`   Verified text[${key}]: ${onChain2}
+`);
+        return { value, txHash };
+      }
       const authEnv = buildAuthEnv({ mnemonic: this._mnemonic ?? void 0, keyUri: this._keyUri ?? void 0 });
       const setResult = await _cli(
         ["text", "set", domainName, key, value, "--json", ...rpcFlag(this.rpc)],
@@ -814,11 +1085,155 @@ var DotNS = class {
   }
   async getContenthash(domainName) {
     this.ensureConnected();
+    if (this._usesExternalSigner) {
+      const node = namehash(`${domainName}.dot`);
+      const result2 = await withTimeout(
+        this.contractCall(CONTRACTS.DOTNS_CONTENT_RESOLVER, DOTNS_CONTENT_RESOLVER_ABI, "contenthash", [node]),
+        3e4,
+        "contenthash"
+      );
+      return typeof result2 === "string" ? result2 : result2?.toString?.() ?? String(result2);
+    }
     const result = await runDotnsCli(
       ["content", "view", domainName, "--json", ...rpcFlag(this.rpc)]
     );
     return result.contenthash ?? "0x";
   }
+  async classifyName(label) {
+    this.ensureConnected();
+    if (!this._usesExternalSigner) {
+      const classification = classifyDotnsLabel(label);
+      return { requiredStatus: classification.status, message: classification.message };
+    }
+    console.log(`
+   Classifying name via PopOracle...`);
+    const result = await withTimeout(this.contractCall(CONTRACTS.POP_RULES, POP_RULES_ABI, "classifyName", [label]), 3e4, "classifyName");
+    const requiredStatus = typeof result[0] === "bigint" ? Number(result[0]) : result[0];
+    const message = result[1];
+    console.log(`   Required status: ${popStatusName(requiredStatus)}`);
+    console.log(`   Message: ${message}`);
+    return { requiredStatus, message };
+  }
+  async ensureNotRegistered(label) {
+    this.ensureConnected();
+    console.log(`
+   Checking availability of ${label}.dot...`);
+    const tokenId = computeDomainTokenId(label);
+    try {
+      const owner = await withTimeout(this.contractCall(CONTRACTS.DOTNS_REGISTRAR, DOTNS_REGISTRAR_ABI, "ownerOf", [tokenId]), 3e4, "Availability check");
+      if (owner !== zeroAddress) throw new Error(`Domain ${label}.dot already owned by ${owner}`);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (errorMessage.includes("already owned")) throw error;
+    }
+    console.log(`   ${label}.dot is available`);
+  }
+  async generateCommitment(label, includeReverse = false) {
+    this.ensureConnected();
+    console.log(`
+   Generating commitment hash...`);
+    label = validateDomainLabel(label);
+    const secret = `0x${crypto.randomBytes(32).toString("hex")}`;
+    const registration = { label, owner: this.evmAddress, secret, reserved: includeReverse };
+    const commitment = await withTimeout(this.contractCall(CONTRACTS.DOTNS_REGISTRAR_CONTROLLER, DOTNS_REGISTRAR_CONTROLLER_ABI, "makeCommitment", [registration]), 3e4, "Commitment generation");
+    console.log(`   Commitment: ${commitment}`);
+    return { commitment, registration };
+  }
+  async submitCommitment(commitment) {
+    this.ensureConnected();
+    console.log(`
+   Submitting commitment...`);
+    const txHash = await this.contractTransaction(CONTRACTS.DOTNS_REGISTRAR_CONTROLLER, 0n, DOTNS_REGISTRAR_CONTROLLER_ABI, "commit", [commitment], (s) => console.log(`      ${s}`));
+    console.log(`   Tx: ${txHash}`);
+    console.log(`   Committed at: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  }
+  async waitForCommitmentAge(commitment) {
+    this.ensureConnected();
+    const POLL_TIMEOUT_MS = 9e4;
+    const POLL_INTERVAL_MS = 3e3;
+    console.log(`
+   Reading minimum commitment age...`);
+    const [minimumAge, initialCommitTimestamp] = await Promise.all([
+      withTimeout(this.contractCall(CONTRACTS.DOTNS_REGISTRAR_CONTROLLER, DOTNS_REGISTRAR_CONTROLLER_ABI, "minCommitmentAge", []), 3e4, "minCommitmentAge"),
+      withTimeout(this.contractCall(CONTRACTS.DOTNS_REGISTRAR_CONTROLLER, DOTNS_REGISTRAR_CONTROLLER_ABI, "commitments", [commitment]), 3e4, "commitments")
+    ]);
+    const minimumAgeSeconds = typeof minimumAge === "bigint" ? Number(minimumAge) : minimumAge;
+    const commitTimestamp = typeof initialCommitTimestamp === "bigint" ? Number(initialCommitTimestamp) : initialCommitTimestamp;
+    if (commitTimestamp === 0) {
+      throw new Error("Commitment not found on-chain. It may not have been included in a block yet.");
+    }
+    console.log(`   Minimum commitment age: ${minimumAgeSeconds}s`);
+    console.log(`   Commitment stored on-chain (timestamp: ${commitTimestamp})`);
+    console.log(`   Waiting for on-chain block.timestamp > ${commitTimestamp + minimumAgeSeconds}...`);
+    const pollDeadline = Date.now() + POLL_TIMEOUT_MS;
+    while (Date.now() < pollDeadline) {
+      const nowMs = await this.clientWrapper.client.query.Timestamp.Now.getValue();
+      const chainNowSeconds = Math.floor(Number(nowMs) / 1e3);
+      if (isCommitmentMature(chainNowSeconds, commitTimestamp, minimumAgeSeconds)) {
+        console.log(`   Commitment age requirement met (chain.now=${chainNowSeconds}, target>${commitTimestamp + minimumAgeSeconds})`);
+        return;
+      }
+      const remaining = Math.ceil((pollDeadline - Date.now()) / 1e3);
+      console.log(`   Chain time ${chainNowSeconds}, waiting for > ${commitTimestamp + minimumAgeSeconds} (${remaining}s left)...`);
+      await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+    }
+    throw new Error(`Commitment still too new after ${POLL_TIMEOUT_MS / 1e3}s of polling chain time. The chain may be stalled.`);
+  }
+  async getPriceAndValidate(label) {
+    this.ensureConnected();
+    console.log(`
+   Checking price and eligibility...`);
+    label = validateDomainLabel(label);
+    const baseName = stripTrailingDigits(label);
+    const reservationInfo = await withTimeout(this.contractCall(CONTRACTS.POP_RULES, POP_RULES_ABI, "isBaseNameReserved", [baseName]), 3e4, "isBaseNameReserved");
+    const [isReserved, reservationOwner] = reservationInfo;
+    if (isReserved && reservationOwner.toLowerCase() !== this.evmAddress.toLowerCase()) throw new Error("Base name reserved for original Lite registrant");
+    const classificationResult = await withTimeout(this.contractCall(CONTRACTS.POP_RULES, POP_RULES_ABI, "classifyName", [label]), 3e4, "classifyName");
+    const requiredStatus = typeof classificationResult[0] === "bigint" ? Number(classificationResult[0]) : classificationResult[0];
+    const message = classificationResult[1];
+    const userStatus = await this.getUserPopStatus();
+    if (requiredStatus === ProofOfPersonhoodStatus.Reserved) throw new Error(message);
+    if (requiredStatus === ProofOfPersonhoodStatus.ProofOfPersonhoodFull) {
+      if (userStatus !== ProofOfPersonhoodStatus.ProofOfPersonhoodFull) throw new Error("Requires Full Personhood verification");
+    } else if (requiredStatus === ProofOfPersonhoodStatus.ProofOfPersonhoodLite) {
+      if (userStatus !== ProofOfPersonhoodStatus.ProofOfPersonhoodLite && userStatus !== ProofOfPersonhoodStatus.ProofOfPersonhoodFull) throw new Error("Requires Personhood Lite verification");
+    } else {
+      const trailingDigitCount = countTrailingDigits(label);
+      if (trailingDigitCount === 0 || userStatus === ProofOfPersonhoodStatus.ProofOfPersonhoodLite) {
+        throw new Error("Personhood Lite cannot register base names \u2014 this name class requires a Full or NoStatus signer");
+      }
+    }
+    const priceRaw = await withTimeout(this.contractCall(CONTRACTS.POP_RULES, POP_RULES_ABI, "price", [label]), 3e4, "price");
+    const priceWei = typeof priceRaw === "bigint" ? priceRaw : BigInt(priceRaw);
+    console.log(`   Required status: ${popStatusName(requiredStatus)}`);
+    console.log(`   User status: ${popStatusName(userStatus)}`);
+    console.log(`   Price: ${formatEther(priceWei)} PAS`);
+    return { priceWei, requiredStatus, userStatus, message };
+  }
+  async finalizeRegistration(registration, priceWei) {
+    this.ensureConnected();
+    console.log(`
+   Finalizing registration for ${registration.label}.dot...`);
+    const bufferedPaymentWei = priceWei * 110n / 100n;
+    const bufferedPaymentNative = convertWeiToNative(bufferedPaymentWei);
+    console.log(`   Oracle price: ${formatEther(priceWei)} PAS`);
+    console.log(`   Paying: ${formatEther(bufferedPaymentWei)} PAS`);
+    const txHash = await this.contractTransaction(CONTRACTS.DOTNS_REGISTRAR_CONTROLLER, bufferedPaymentNative, DOTNS_REGISTRAR_CONTROLLER_ABI, "register", [registration], (s) => console.log(`      ${s}`));
+    console.log(`   Tx: ${txHash}`);
+  }
+  async verifyOwnership(label) {
+    this.ensureConnected();
+    console.log(`
+   Verifying ownership...`);
+    const tokenId = computeDomainTokenId(label);
+    const actualOwner = await withTimeout(this.contractCall(CONTRACTS.DOTNS_REGISTRAR, DOTNS_REGISTRAR_ABI, "ownerOf", [tokenId]), 3e4, "ownerOf");
+    if (actualOwner.toLowerCase() !== this.evmAddress.toLowerCase()) {
+      console.log(`   Expected: ${this.evmAddress}`);
+      console.log(`   Actual: ${actualOwner}`);
+      throw new Error(`Owner mismatch for ${label}.dot`);
+    }
+    console.log(`   Owner: ${actualOwner}`);
+  }
   // View-only readiness check. Runs every chain read needed to predict whether
   // `register(label)` will succeed, so the caller can fail-fast BEFORE the
   // Bulletin chunk upload. Never writes to chain. See issue #100.
@@ -1018,6 +1433,43 @@ var DotNS = class {
       }
       const explicitStatus = options.status || process.env.DOTNS_STATUS;
       const reverse = options.reverse ?? (process.env.DOTNS_REVERSE ?? "false").toLowerCase() === "true";
+      if (this._usesExternalSigner) {
+        const [classification] = await Promise.all([
+          this.classifyName(label),
+          this.ensureNotRegistered(label)
+        ]);
+        const requiredStatus = classification.requiredStatus;
+        if (requiredStatus === ProofOfPersonhoodStatus.Reserved) {
+          throw new Error(classification.message);
+        }
+        const initialUserStatus = await this.getUserPopStatus();
+        const isTestnet = await this.isTestnet();
+        const explicitStatusNum = explicitStatus ? parseProofOfPersonhoodStatus(explicitStatus) : void 0;
+        const targetUserStatus = simulateUserStatus(initialUserStatus, requiredStatus, { explicitStatus: explicitStatusNum, isTestnet });
+        if (!canRegister(requiredStatus, targetUserStatus, countTrailingDigits(label))) {
+          throw new Error(
+            `This label classifies as ${popStatusName(requiredStatus)}; the registrar will reject this signer (PopRules.priceWithCheck). Remediations: use a signer with Full PoP, or pick a shorter base name (6-8 chars + trailing 00) that classifies as PopLite.`
+          );
+        }
+        if (targetUserStatus !== initialUserStatus && targetUserStatus !== ProofOfPersonhoodStatus.NoStatus) {
+          await this.setUserPopStatus(targetUserStatus);
+          const userStatus = await this.getUserPopStatus();
+          if (userStatus !== targetUserStatus) {
+            throw new Error(
+              "setUserPopStatus did not land as expected (wanted " + targetUserStatus + ", got " + userStatus + "). Check RPC connectivity and POP_RULES contract."
+            );
+          }
+        }
+        const { commitment, registration } = await this.generateCommitment(label, reverse);
+        await withSpan("deploy.dotns.submit-commitment", "2a-i. submit-commitment", {}, () => this.submitCommitment(commitment));
+        await withSpan("deploy.dotns.wait-commitment-age", "2a-ii. wait-commitment-age", {}, () => this.waitForCommitmentAge(commitment));
+        const pricing = await withSpan("deploy.dotns.price-validation", "2a-iii. price-validation", {}, () => this.getPriceAndValidate(label));
+        await withSpan("deploy.dotns.finalize-registration", "2a-iv. finalize-registration", {}, () => this.finalizeRegistration(registration, pricing.priceWei));
+        await this.verifyOwnership(label);
+        console.log(`
+   Registration complete!`);
+        return { label, owner: this.evmAddress };
+      }
       const statusArgs = explicitStatus ? ["-s", explicitStatus] : [];
       const reverseArgs = reverse ? ["-r"] : [];
       console.log(`
@@ -1066,6 +1518,7 @@ var DotNS = class {
     }
     this._mnemonic = null;
     this._keyUri = null;
+    this._usesExternalSigner = false;
   }
 };
 var dotns = new DotNS();

package/dist/deploy.js

@@ -26,13 +26,13 @@ import {
   storeChunkedContent,
   storeDirectory,
   storeFile
-} from "./chunk-RUY7MR2M.js";
-import "./chunk-BTAGLNZY.js";
-import "./chunk-ZTUUEMII.js";
-import "./chunk-4HGXZ225.js";
+} from "./chunk-RWITW7YV.js";
+import "./chunk-RUEFJ32K.js";
+import "./chunk-XBONIEIK.js";
+import "./chunk-YIMJSLP2.js";
 import "./chunk-HOTQDYHD.js";
-import "./chunk-R7SSZDXQ.js";
-import "./chunk-KRL6D3YY.js";
+import "./chunk-ULIUVP7W.js";
+import "./chunk-ODXESRRQ.js";
 import "./chunk-B7GUYYAN.js";
 import "./chunk-RP4YJYNB.js";
 import "./chunk-QGM4M3NI.js";

package/dist/dotns.d.ts

@@ -124,7 +124,27 @@ declare class ReviveClientWrapper {
     constructor(client: any);
     getEvmAddress(substrateAddress: string): Promise<string>;
     performDryRunCall(originSubstrateAddress: string, contractAddress: string, value: bigint, encodedData: string): Promise<any>;
+    estimateGasForCall(originSubstrateAddress: string, contractAddress: string, value: bigint, encodedData: string): Promise<any>;
     checkIfAccountMapped(substrateAddress: string): Promise<boolean>;
+    ensureAccountMapped(substrateAddress: string, signer: PolkadotSigner): Promise<void>;
+    signAndSubmitExtrinsic(extrinsic: any, signer: PolkadotSigner, statusCallback: (status: string) => void, opts?: {
+        nonceFallback?: {
+            rpcs: string[];
+            senderSS58: string;
+            expectedNonce: number;
+        };
+    }): Promise<string>;
+    signAndSubmitWithRetry(buildExtrinsic: () => any, signer: PolkadotSigner, statusCallback: (status: string) => void, label: string, opts?: {
+        nonceFallback?: {
+            rpcs: string[];
+            senderSS58: string;
+            expectedNonce: number;
+        };
+    }): Promise<string>;
+    submitTransaction(contractAddress: string, value: bigint, encodedData: string, signerSubstrateAddress: string, signer: PolkadotSigner, statusCallback: (status: string) => void, { rpcs, useNoncePolling }: {
+        rpcs: string[];
+        useNoncePolling?: boolean;
+    }): Promise<string>;
 }
 declare function runDotnsCli(argv: string[], env?: Record<string, string>): Promise<unknown>;
 declare class DotNS {
@@ -137,6 +157,7 @@ declare class DotNS {
     connected: boolean;
     private _mnemonic;
     private _keyUri;
+    private _usesExternalSigner;
     constructor();
     connect(options?: DotNSConnectOptions): Promise<this>;
     ensureConnected(): void;
@@ -149,6 +170,9 @@ declare class DotNS {
     } | null>;
     private submitTransfer;
     contractCall(contractAddress: string, contractAbi: readonly any[], functionName: string, args?: any[]): Promise<any>;
+    contractTransaction(contractAddress: string, value: bigint, contractAbi: readonly any[], functionName: string, args?: any[], statusCallback?: (status: string) => void, { useNoncePolling }?: {
+        useNoncePolling?: boolean;
+    }): Promise<string>;
     checkOwnership(label: string, ownerAddress?: string | null): Promise<OwnershipResult>;
     getUserPopStatus(ownerAddress?: string | null): Promise<number>;
     setUserPopStatus(status: number): Promise<void>;
@@ -166,6 +190,20 @@ declare class DotNS {
         txHash: string;
     }>;
     getContenthash(domainName: string): Promise<string>;
+    classifyName(label: string): Promise<{
+        requiredStatus: number;
+        message: string;
+    }>;
+    ensureNotRegistered(label: string): Promise<void>;
+    generateCommitment(label: string, includeReverse?: boolean): Promise<{
+        commitment: any;
+        registration: any;
+    }>;
+    submitCommitment(commitment: any): Promise<void>;
+    waitForCommitmentAge(commitment: any): Promise<void>;
+    getPriceAndValidate(label: string): Promise<PriceValidationResult>;
+    finalizeRegistration(registration: any, priceWei: bigint): Promise<void>;
+    verifyOwnership(label: string): Promise<void>;
     preflight(label: string, explicitStatusOverride?: string): Promise<DotnsPreflightResult>;
     private gateOnFeeBalance;
     register(label: string, options?: DotNSConnectOptions & {

package/dist/dotns.js

@@ -35,9 +35,9 @@ import {
   stripTrailingDigits,
   validateDomainLabel,
   verifyNonceAdvanced
-} from "./chunk-4HGXZ225.js";
-import "./chunk-R7SSZDXQ.js";
-import "./chunk-KRL6D3YY.js";
+} from "./chunk-YIMJSLP2.js";
+import "./chunk-ULIUVP7W.js";
+import "./chunk-ODXESRRQ.js";
 import "./chunk-RP4YJYNB.js";
 import "./chunk-QGM4M3NI.js";
 export {

package/dist/index.js

@@ -1,14 +1,14 @@
 import {
   deploy
-} from "./chunk-RUY7MR2M.js";
-import "./chunk-BTAGLNZY.js";
-import "./chunk-ZTUUEMII.js";
+} from "./chunk-RWITW7YV.js";
+import "./chunk-RUEFJ32K.js";
+import "./chunk-XBONIEIK.js";
 import {
   DotNS,
   parseDomainName
-} from "./chunk-4HGXZ225.js";
+} from "./chunk-YIMJSLP2.js";
 import "./chunk-HOTQDYHD.js";
-import "./chunk-R7SSZDXQ.js";
+import "./chunk-ULIUVP7W.js";
 import {
   VERSION,
   loadRunState,
@@ -18,7 +18,7 @@ import {
   shouldSkipStaleWarning,
   stateFilePath,
   writeRunState
-} from "./chunk-KRL6D3YY.js";
+} from "./chunk-ODXESRRQ.js";
 import {
   merkleizeJS
 } from "./chunk-B7GUYYAN.js";

package/dist/memory-report.js

@@ -5,8 +5,8 @@ import {
   maybeWriteMemoryReport,
   safeHeap,
   sampleFromBytes
-} from "./chunk-R7SSZDXQ.js";
-import "./chunk-KRL6D3YY.js";
+} from "./chunk-ULIUVP7W.js";
+import "./chunk-ODXESRRQ.js";
 import "./chunk-QGM4M3NI.js";
 export {
   DEFAULT_THRESHOLD_MB,

package/dist/run-state.js

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

package/dist/telemetry.js

@@ -24,8 +24,8 @@ import {
   truncateAddress,
   withDeploySpan,
   withSpan
-} from "./chunk-R7SSZDXQ.js";
-import "./chunk-KRL6D3YY.js";
+} from "./chunk-ULIUVP7W.js";
+import "./chunk-ODXESRRQ.js";
 import "./chunk-QGM4M3NI.js";
 export {
   VERSION,

package/dist/version-check.js

@@ -8,9 +8,9 @@ import {
   isPreReleaseVersion,
   preReleaseWarning,
   promptYesNo
-} from "./chunk-ZTUUEMII.js";
-import "./chunk-R7SSZDXQ.js";
-import "./chunk-KRL6D3YY.js";
+} from "./chunk-XBONIEIK.js";
+import "./chunk-ULIUVP7W.js";
+import "./chunk-ODXESRRQ.js";
 import "./chunk-QGM4M3NI.js";
 export {
   assessVersion,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bulletin-deploy",
-  "version": "0.7.8",
+  "version": "0.7.9-rc.1",
   "private": false,
   "repository": {
     "type": "git",