bulletin-deploy 0.5.5 → 0.5.6

package/bin/bulletin-deploy

@@ -39,14 +39,17 @@ try {
   if (flags.bootstrap) {
     const rpc = process.env.BULLETIN_RPC || "wss://paseo-bulletin-rpc.polkadot.io";
     const poolSize = parseInt(process.env.BULLETIN_POOL_SIZE || "10", 10);
-    await bootstrapPool(rpc, poolSize);
+    await bootstrapPool(rpc, poolSize, flags.mnemonic);
   } else {
     const [buildDir, domain] = positional;
     if (!buildDir) { console.error("Error: build directory required"); process.exit(1); }
     if (!domain) { console.error("Error: domain required (e.g. my-app.dot)"); process.exit(1); }
     if (!fs.existsSync(buildDir)) { console.error(`Error: ${buildDir} does not exist`); process.exit(1); }
 
-    const result = await deploy(buildDir, domain, { playground: flags.playground });
+    const result = await deploy(buildDir, domain, {
+      playground: flags.playground,
+      mnemonic: flags.mnemonic,
+    });
 
     const output = process.env.GITHUB_OUTPUT;
     if (output) {

package/dist/{chunk-2RURGSQW.js → chunk-4ZPXQDUZ.js}

@@ -56,6 +56,9 @@ function getDeployAttributes(domain) {
     "deploy.pr": process.env.GITHUB_PR_NUMBER || void 0
   };
 }
+function isExpectedError(msg) {
+  return /personhood|owned by|owner mismatch|reserved for original|invalid domain label|not authorized for bulletin/i.test(msg);
+}
 async function withSpan(op, description, attributes, fn) {
   if (!Sentry) return fn();
   return Sentry.startSpan({ op, name: description, attributes }, async (span) => {
@@ -63,9 +66,7 @@ async function withSpan(op, description, attributes, fn) {
       return await fn();
     } catch (error) {
       span.setAttribute("error.message", error.message);
-      Sentry.setTag("deploy.phase", op);
-      Sentry.captureException(error);
-      error._sentryCaptured = true;
+      span.setStatus({ code: 2, message: "internal_error" });
       throw error;
     }
   });
@@ -84,11 +85,12 @@ async function withDeploySpan(domain, fn) {
       try {
         return await fn();
       } catch (error) {
+        const msg = error.message;
         span.setAttribute("deploy.status", "error");
-        span.setAttribute("deploy.error", error.message);
-        if (!error._sentryCaptured) {
-          Sentry.setTag("deploy.phase", "deploy");
-          Sentry.captureException(error);
+        span.setAttribute("deploy.error", msg);
+        const isExpected = isExpectedError(msg);
+        if (!isExpected) {
+          span.setStatus({ code: 2, message: "internal_error" });
         }
         throw error;
       }
@@ -118,6 +120,7 @@ async function flush() {
 export {
   initTelemetry,
   resolveRepo,
+  isExpectedError,
   withSpan,
   withDeploySpan,
   setDeployAttribute,

package/dist/{chunk-RS62TJNH.js → chunk-CXNOJQNX.js}

@@ -3,7 +3,7 @@ import {
   DotNS,
   TX_TIMEOUT_MS,
   fetchNonce
-} from "./chunk-WQ74BM5S.js";
+} from "./chunk-YTCA5JTA.js";
 import {
   derivePoolAccounts,
   ensureAuthorized,
@@ -16,7 +16,7 @@ import {
   setDeployAttribute,
   withDeploySpan,
   withSpan
-} from "./chunk-2RURGSQW.js";
+} from "./chunk-4ZPXQDUZ.js";
 
 // src/deploy.ts
 import { Buffer } from "buffer";
@@ -26,7 +26,7 @@ import { fileURLToPath } from "url";
 import { execSync } from "child_process";
 import { sha256 } from "@noble/hashes/sha256";
 import { blake2b } from "@noble/hashes/blake2b";
-import { createClient as createPolkadotClient } from "polkadot-api";
+import { createClient as createPolkadotClient, Enum } from "polkadot-api";
 import { Binary } from "@polkadot-api/substrate-bindings";
 import { getWsProvider } from "polkadot-api/ws-provider";
 import { withPolkadotSdkCompat } from "polkadot-api/polkadot-sdk-compat";
@@ -43,7 +43,6 @@ import { sr25519CreateDerive } from "@polkadot-labs/hdkd";
 import { mnemonicToEntropy, entropyToMiniSecret, ss58Address } from "@polkadot-labs/hdkd-helpers";
 var BULLETIN_RPC = process.env.BULLETIN_RPC || "wss://paseo-bulletin-rpc.polkadot.io";
 var POOL_SIZE = parseInt(process.env.BULLETIN_POOL_SIZE || "10", 10);
-var POOL_MNEMONIC = process.env.BULLETIN_POOL_MNEMONIC || void 0;
 var CHUNK_SIZE = 1 * 1024 * 1024;
 var MAX_FILE_SIZE = 8 * 1024 * 1024;
 var CID_CONFIG = { version: 1, codec: 85, hashCode: 18, hashLength: 32 };
@@ -60,15 +59,18 @@ function getGitRemoteUrl() {
     return null;
   }
 }
-function getRegistrySigner() {
-  const mnemonic = process.env.DOTNS_MNEMONIC || process.env.MNEMONIC || DEFAULT_MNEMONIC;
+function deriveRootSigner(mnemonic) {
   const entropy = mnemonicToEntropy(mnemonic);
   const miniSecret = entropyToMiniSecret(entropy);
   const derive = sr25519CreateDerive(miniSecret);
   const keyPair = derive("");
   const signer = getPolkadotSigner(keyPair.publicKey, "Sr25519", keyPair.sign);
-  const origin = ss58Address(keyPair.publicKey);
-  return { signer, origin };
+  return { signer, ss58: ss58Address(keyPair.publicKey) };
+}
+function getRegistrySigner(explicitMnemonic) {
+  const mnemonic = explicitMnemonic || process.env.DOTNS_MNEMONIC || process.env.MNEMONIC || DEFAULT_MNEMONIC;
+  const { signer, ss58 } = deriveRootSigner(mnemonic);
+  return { signer, origin: ss58 };
 }
 function createCID(data, codec = CID_CONFIG.codec, hashCode = CID_CONFIG.hashCode) {
   let hash;
@@ -103,7 +105,8 @@ async function getProvider() {
   const client = createPolkadotClient(withPolkadotSdkCompat(getWsProvider(BULLETIN_RPC)));
   const unsafeApi = client.getUnsafeApi();
   await cryptoWaitReady();
-  const poolAccounts = derivePoolAccounts(POOL_SIZE, POOL_MNEMONIC);
+  const poolMnemonic = process.env.BULLETIN_POOL_MNEMONIC || void 0;
+  const poolAccounts = derivePoolAccounts(POOL_SIZE, poolMnemonic);
   const authorizations = await fetchPoolAuthorizations(unsafeApi, poolAccounts);
   let selected = selectAccount(authorizations);
   if (!selected) {
@@ -115,10 +118,31 @@ async function getProvider() {
     await ensureAuthorized(unsafeApi, selected, BULLETIN_RPC);
   }
   console.log(`   Using pool account ${selected.index}: ${selected.address}`);
+  setDeployAttribute("deploy.signer.mode", "pool");
   setDeployAttribute("deploy.pool.account", selected.address);
   setDeployAttribute("deploy.pool.index", selected.index);
   return { client, unsafeApi, signer: selected.signer, ss58: selected.address };
 }
+async function getDirectProvider(mnemonic) {
+  console.log(`   Connecting to Bulletin: ${BULLETIN_RPC}`);
+  const client = createPolkadotClient(withPolkadotSdkCompat(getWsProvider(BULLETIN_RPC)));
+  const unsafeApi = client.getUnsafeApi();
+  const { signer, ss58 } = deriveRootSigner(mnemonic);
+  console.log(`   Using direct signer: ${ss58}`);
+  const auth = await unsafeApi.query.TransactionStorage.Authorizations.getValue(
+    Enum("Account", ss58)
+  );
+  const txsRemaining = auth ? BigInt(auth.extent.transactions) : 0n;
+  const bytesRemaining = auth ? auth.extent.bytes : 0n;
+  if (txsRemaining === 0n && bytesRemaining === 0n) {
+    client.destroy();
+    throw new Error(`Account ${ss58} is not authorized for Bulletin storage. Run 'bulletin-deploy --bootstrap --mnemonic "..."' or authorize the account on-chain first.`);
+  }
+  console.log(`   Authorization: ${txsRemaining} txs, ${Number(bytesRemaining) / 1e6}MB remaining`);
+  setDeployAttribute("deploy.signer.mode", "direct");
+  setDeployAttribute("deploy.signer.address", ss58);
+  return { client, unsafeApi, signer, ss58 };
+}
 function watchTransaction(tx, signer, txOpts, onSuccess, { label = "transaction", rpc, senderSS58, expectedNonce } = {}) {
   return new Promise((resolve2, reject) => {
     let settled = false;
@@ -348,7 +372,7 @@ async function merkleize(directoryPath, outputCarPath) {
   console.log(`   CAR: ${(size / 1024 / 1024).toFixed(2)} MB`);
   return { carPath: outputCarPath, cid };
 }
-async function storeDirectory(directoryPath) {
+async function storeDirectory(directoryPath, provider = {}) {
   const carPath = path.join(path.dirname(directoryPath), `${path.basename(directoryPath)}.car`);
   const { cid: ipfsCid } = await withSpan("deploy.merkleize", "1a. merkleize", { "deploy.directory": directoryPath }, async () => {
     return merkleize(directoryPath, carPath);
@@ -356,7 +380,7 @@ async function storeDirectory(directoryPath) {
   const carBuffer = fs.readFileSync(carPath);
   const carChunks = chunk(carBuffer, CHUNK_SIZE);
   const storageCid = await withSpan("deploy.chunk-upload", "1b. chunk-upload", { "deploy.chunks.total": carChunks.length, "deploy.car.bytes": carBuffer.length }, async () => {
-    return storeChunkedContent(carChunks);
+    return storeChunkedContent(carChunks, provider);
   });
   return { storageCid, ipfsCid };
 }
@@ -372,133 +396,139 @@ async function deploy(content, domainName = null, options = {}) {
     console.log("=".repeat(60));
     console.log(`   Domain: ${name}.dot`);
     if (typeof content === "string") console.log(`   Build dir: ${path.resolve(content)}`);
-    console.log("\n" + "=".repeat(60));
-    console.log("Storage");
-    console.log("=".repeat(60));
-    await withSpan("deploy.storage", "1. storage", {}, async () => {
-      if (process.env.IPFS_CID) {
-        cid = process.env.IPFS_CID;
-        ipfsCid = cid;
-        console.log(`
+    const provider = options.mnemonic ? await getDirectProvider(options.mnemonic) : await getProvider();
+    try {
+      console.log("\n" + "=".repeat(60));
+      console.log("Storage");
+      console.log("=".repeat(60));
+      await withSpan("deploy.storage", "1. storage", {}, async () => {
+        if (process.env.IPFS_CID) {
+          cid = process.env.IPFS_CID;
+          ipfsCid = cid;
+          console.log(`
    Using CID: ${cid}`);
-      } else if (Array.isArray(content)) {
-        console.log(`
-   Mode: Multi-chunk (${content.length} chunks)`);
-        cid = await storeChunkedContent(content);
-      } else if (typeof content === "string") {
-        const contentPath = path.resolve(content);
-        if (!fs.existsSync(contentPath)) throw new Error(`Path not found: ${contentPath}`);
-        const stats = fs.statSync(contentPath);
-        if (stats.isDirectory()) {
+        } else if (Array.isArray(content)) {
           console.log(`
+   Mode: Multi-chunk (${content.length} chunks)`);
+          cid = await storeChunkedContent(content, provider);
+        } else if (typeof content === "string") {
+          const contentPath = path.resolve(content);
+          if (!fs.existsSync(contentPath)) throw new Error(`Path not found: ${contentPath}`);
+          const stats = fs.statSync(contentPath);
+          if (stats.isDirectory()) {
+            console.log(`
    Mode: Directory`);
-          console.log(`   Path: ${contentPath}`);
-          const result = await storeDirectory(contentPath);
-          cid = result.storageCid;
-          ipfsCid = result.ipfsCid;
-        } else {
-          console.log(`
+            console.log(`   Path: ${contentPath}`);
+            const result = await storeDirectory(contentPath, provider);
+            cid = result.storageCid;
+            ipfsCid = result.ipfsCid;
+          } else {
+            console.log(`
    Mode: File`);
-          console.log(`   Path: ${contentPath}`);
-          const fileContent = fs.readFileSync(contentPath);
-          if (fileContent.length > MAX_FILE_SIZE) {
+            console.log(`   Path: ${contentPath}`);
+            const fileContent = fs.readFileSync(contentPath);
+            if (fileContent.length > MAX_FILE_SIZE) {
+              console.log(`   Exceeds 8MB, chunking...`);
+              cid = await storeChunkedContent(chunk(fileContent), provider);
+            } else {
+              cid = await storeFile(new Uint8Array(fileContent), provider);
+            }
+          }
+        } else if (content instanceof Uint8Array) {
+          console.log(`
+   Mode: Bytes`);
+          if (content.length > MAX_FILE_SIZE) {
             console.log(`   Exceeds 8MB, chunking...`);
-            cid = await storeChunkedContent(chunk(fileContent));
+            cid = await storeChunkedContent(chunk(content), provider);
           } else {
-            cid = await storeFile(new Uint8Array(fileContent));
+            cid = await storeFile(content, provider);
           }
-        }
-      } else if (content instanceof Uint8Array) {
-        console.log(`
-   Mode: Bytes`);
-        if (content.length > MAX_FILE_SIZE) {
-          console.log(`   Exceeds 8MB, chunking...`);
-          cid = await storeChunkedContent(chunk(content));
         } else {
-          cid = await storeFile(content);
+          throw new Error("Invalid content: must be path, Uint8Array, or Array<Uint8Array>");
         }
-      } else {
-        throw new Error("Invalid content: must be path, Uint8Array, or Array<Uint8Array>");
-      }
-    });
-    setDeployAttribute("deploy.cid", cid);
-    console.log("\n" + "=".repeat(60));
-    console.log("DotNS");
-    console.log("=".repeat(60));
-    await withSpan("deploy.dotns", "2. dotns", { "deploy.domain": name }, async () => {
-      const dotns = new DotNS();
-      await dotns.connect();
-      const { owned, owner } = await dotns.checkOwnership(name);
-      if (owned) {
-        console.log(`   Status: Already owned`);
-      } else if (owner && owner !== "0x0000000000000000000000000000000000000000") {
-        throw new Error(`Domain ${name}.dot is owned by ${owner}, not ${dotns.evmAddress}`);
-      } else {
-        console.log(`   Status: Registering...`);
-        await dotns.register(name);
-      }
-      const contenthashHex = `0x${encodeContenthash(cid)}`;
-      await dotns.setContenthash(name, contenthashHex);
-      dotns.disconnect();
-    });
-    if (options.playground) {
+      });
+      setDeployAttribute("deploy.cid", cid);
       console.log("\n" + "=".repeat(60));
-      console.log("Playground Registry");
+      console.log("DotNS");
       console.log("=".repeat(60));
-      await withSpan("deploy.registry", "3. registry", { "deploy.domain": name }, async () => {
-        const repoUrl = getGitRemoteUrl();
-        if (!fs.existsSync(CDM_JSON_PATH)) {
-          console.log("\n   Skipping registry: cdm.json not found");
-          return;
+      await withSpan("deploy.dotns", "2. dotns", { "deploy.domain": name }, async () => {
+        const dotns = new DotNS();
+        await dotns.connect(options.mnemonic ? { mnemonic: options.mnemonic } : {});
+        const { owned, owner } = await dotns.checkOwnership(name);
+        if (owned) {
+          console.log(`   Status: Already owned`);
+        } else if (owner && owner !== "0x0000000000000000000000000000000000000000") {
+          throw new Error(`Domain ${name}.dot is owned by ${owner}, not ${dotns.evmAddress}`);
+        } else {
+          console.log(`   Status: Registering...`);
+          await dotns.register(name);
         }
-        const metadata = {};
-        if (repoUrl) metadata.repository = repoUrl;
-        console.log(`
+        const contenthashHex = `0x${encodeContenthash(cid)}`;
+        await dotns.setContenthash(name, contenthashHex);
+        dotns.disconnect();
+      });
+      if (options.playground) {
+        console.log("\n" + "=".repeat(60));
+        console.log("Playground Registry");
+        console.log("=".repeat(60));
+        await withSpan("deploy.registry", "3. registry", { "deploy.domain": name }, async () => {
+          const repoUrl = getGitRemoteUrl();
+          if (!fs.existsSync(CDM_JSON_PATH)) {
+            console.log("\n   Skipping registry: cdm.json not found");
+            return;
+          }
+          const metadata = {};
+          if (repoUrl) metadata.repository = repoUrl;
+          console.log(`
    Metadata: ${JSON.stringify(metadata)}`);
-        const metadataBytes = new Uint8Array(Buffer.from(JSON.stringify(metadata), "utf-8"));
-        console.log(`   Uploading metadata to Bulletin...`);
-        const metadataCid = await storeFile(metadataBytes);
-        console.log(`   Metadata CID: ${metadataCid}`);
-        const cdmJson = JSON.parse(fs.readFileSync(CDM_JSON_PATH, "utf-8"));
-        const { signer, origin } = getRegistrySigner();
-        console.log(`   Publishing to registry as ${origin}...`);
-        const MAX_REGISTRY_RETRIES = 3;
-        for (let attempt = 1; attempt <= MAX_REGISTRY_RETRIES; attempt++) {
-          const cdm = createCdm(cdmJson, { defaultSigner: signer, defaultOrigin: origin });
-          try {
-            const registry = cdm.getContract("@example/playground-registry");
-            const result = await registry.publish.tx(`${name}.dot`, metadataCid);
-            if (!result.ok) throw new Error("Registry publish transaction failed");
-            console.log(`   Tx: ${result.txHash}`);
-            console.log(`   Registered ${name}.dot in playground registry!`);
-            break;
-          } catch (e) {
-            if (attempt < MAX_REGISTRY_RETRIES) {
-              captureWarning("Registry publish failed, retrying", { attempt, maxRetries: MAX_REGISTRY_RETRIES, error: e.message?.slice(0, 200) });
-              console.log(`   Attempt ${attempt} failed: ${e.message?.slice(0, 80)}`);
-              console.log(`   Retrying in 6s...`);
-              await new Promise((r) => setTimeout(r, 6e3));
-              continue;
+          const metadataBytes = new Uint8Array(Buffer.from(JSON.stringify(metadata), "utf-8"));
+          console.log(`   Uploading metadata to Bulletin...`);
+          const metadataCid = await storeFile(metadataBytes, provider);
+          console.log(`   Metadata CID: ${metadataCid}`);
+          const cdmJson = JSON.parse(fs.readFileSync(CDM_JSON_PATH, "utf-8"));
+          const { signer, origin } = getRegistrySigner(options.mnemonic);
+          console.log(`   Publishing to registry as ${origin}...`);
+          const MAX_REGISTRY_RETRIES = 3;
+          for (let attempt = 1; attempt <= MAX_REGISTRY_RETRIES; attempt++) {
+            const cdm = createCdm(cdmJson, { defaultSigner: signer, defaultOrigin: origin });
+            try {
+              const registry = cdm.getContract("@example/playground-registry");
+              const result = await registry.publish.tx(`${name}.dot`, metadataCid);
+              if (!result.ok) throw new Error("Registry publish transaction failed");
+              console.log(`   Tx: ${result.txHash}`);
+              console.log(`   Registered ${name}.dot in playground registry!`);
+              break;
+            } catch (e) {
+              if (attempt < MAX_REGISTRY_RETRIES) {
+                captureWarning("Registry publish failed, retrying", { attempt, maxRetries: MAX_REGISTRY_RETRIES, error: e.message?.slice(0, 200) });
+                console.log(`   Attempt ${attempt} failed: ${e.message?.slice(0, 80)}`);
+                console.log(`   Retrying in 6s...`);
+                await new Promise((r) => setTimeout(r, 6e3));
+                continue;
+              }
+              throw e;
+            } finally {
+              cdm.destroy();
             }
-            throw e;
-          } finally {
-            cdm.destroy();
           }
-        }
-      });
+        });
+      }
+      console.log("\n" + "=".repeat(60));
+      console.log("DEPLOYMENT COMPLETE!");
+      console.log("=".repeat(60));
+      console.log("\n\u{1F53A} Polkadot Triangle");
+      console.log(`   - Polkadot Desktop: ${name}.dot`);
+      console.log(`   - Polkadot Browser: https://${name}.dot.li`);
+      console.log("\n" + "=".repeat(60) + "\n");
+      return { domainName: name, fullDomain: `${name}.dot`, cid, ipfsCid };
+    } finally {
+      provider.client.destroy();
     }
-    console.log("\n" + "=".repeat(60));
-    console.log("DEPLOYMENT COMPLETE!");
-    console.log("=".repeat(60));
-    console.log("\n\u{1F53A} Polkadot Triangle");
-    console.log(`   - Polkadot Desktop: ${name}.dot`);
-    console.log(`   - Polkadot Browser: https://${name}.dot.li`);
-    console.log("\n" + "=".repeat(60) + "\n");
-    return { domainName: name, fullDomain: `${name}.dot`, cid, ipfsCid };
   });
 }
 
 export {
+  deriveRootSigner,
   createCID,
   encodeContenthash,
   storeFile,

package/dist/{chunk-WQ74BM5S.js → chunk-YTCA5JTA.js}

@@ -1,7 +1,7 @@
 import {
   captureWarning,
   withSpan
-} from "./chunk-2RURGSQW.js";
+} from "./chunk-4ZPXQDUZ.js";
 
 // src/dotns.ts
 import crypto from "crypto";

package/dist/deploy.d.ts

@@ -14,6 +14,10 @@ interface ExistingProvider {
     signer?: PolkadotSigner;
     ss58?: string;
 }
+declare function deriveRootSigner(mnemonic: string): {
+    signer: PolkadotSigner;
+    ss58: string;
+};
 declare function createCID(data: Uint8Array, codec?: number, hashCode?: number): CID;
 declare function encodeContenthash(cidString: string): string;
 declare function storeFile(contentBytes: Uint8Array, { client: existingClient, unsafeApi: existingApi, signer: existingSigner }?: ExistingProvider): Promise<string>;
@@ -24,13 +28,14 @@ declare function merkleize(directoryPath: string, outputCarPath: string): Promis
     carPath: string;
     cid: string;
 }>;
-declare function storeDirectory(directoryPath: string): Promise<{
+declare function storeDirectory(directoryPath: string, provider?: ExistingProvider): Promise<{
     storageCid: string;
     ipfsCid: string;
 }>;
 interface DeployOptions {
     playground?: boolean;
+    mnemonic?: string;
 }
 declare function deploy(content: DeployContent, domainName?: string | null, options?: DeployOptions): Promise<DeployResult>;
 
-export { type DeployContent, type DeployOptions, type DeployResult, chunk, createCID, deploy, encodeContenthash, hasIPFS, merkleize, storeChunkedContent, storeDirectory, storeFile };
+export { type DeployContent, type DeployOptions, type DeployResult, chunk, createCID, deploy, deriveRootSigner, encodeContenthash, hasIPFS, merkleize, storeChunkedContent, storeDirectory, storeFile };

package/dist/deploy.js

@@ -2,21 +2,23 @@ import {
   chunk,
   createCID,
   deploy,
+  deriveRootSigner,
   encodeContenthash,
   hasIPFS,
   merkleize,
   storeChunkedContent,
   storeDirectory,
   storeFile
-} from "./chunk-RS62TJNH.js";
-import "./chunk-WQ74BM5S.js";
+} from "./chunk-CXNOJQNX.js";
+import "./chunk-YTCA5JTA.js";
 import "./chunk-RV7XBIIO.js";
-import "./chunk-2RURGSQW.js";
+import "./chunk-4ZPXQDUZ.js";
 import "./chunk-QGM4M3NI.js";
 export {
   chunk,
   createCID,
   deploy,
+  deriveRootSigner,
   encodeContenthash,
   hasIPFS,
   merkleize,

package/dist/dotns.js

@@ -18,8 +18,8 @@ import {
   sanitizeDomainLabel,
   stripTrailingDigits,
   validateDomainLabel
-} from "./chunk-WQ74BM5S.js";
-import "./chunk-2RURGSQW.js";
+} from "./chunk-YTCA5JTA.js";
+import "./chunk-4ZPXQDUZ.js";
 import "./chunk-QGM4M3NI.js";
 export {
   CONTRACTS,

package/dist/index.js

@@ -1,9 +1,9 @@
 import {
   deploy
-} from "./chunk-RS62TJNH.js";
+} from "./chunk-CXNOJQNX.js";
 import {
   DotNS
-} from "./chunk-WQ74BM5S.js";
+} from "./chunk-YTCA5JTA.js";
 import {
   bootstrapPool,
   derivePoolAccounts,
@@ -11,7 +11,7 @@ import {
   fetchPoolAuthorizations,
   selectAccount
 } from "./chunk-RV7XBIIO.js";
-import "./chunk-2RURGSQW.js";
+import "./chunk-4ZPXQDUZ.js";
 import "./chunk-QGM4M3NI.js";
 export {
   DotNS,

package/dist/telemetry.d.ts

@@ -1,9 +1,10 @@
 declare function initTelemetry(): void;
 declare function resolveRepo(domain: string): string;
+declare function isExpectedError(msg: string): boolean;
 declare function withSpan<T>(op: string, description: string, attributes: Record<string, string | number | boolean | undefined>, fn: () => T | Promise<T>): Promise<T>;
 declare function withDeploySpan<T>(domain: string, fn: () => T | Promise<T>): Promise<T>;
 declare function setDeployAttribute(key: string, value: string | number | boolean): void;
 declare function captureWarning(message: string, context?: Record<string, unknown>): void;
 declare function flush(): Promise<void>;
 
-export { captureWarning, flush, initTelemetry, resolveRepo, setDeployAttribute, withDeploySpan, withSpan };
+export { captureWarning, flush, initTelemetry, isExpectedError, resolveRepo, setDeployAttribute, withDeploySpan, withSpan };

package/dist/telemetry.js

@@ -2,16 +2,18 @@ import {
   captureWarning,
   flush,
   initTelemetry,
+  isExpectedError,
   resolveRepo,
   setDeployAttribute,
   withDeploySpan,
   withSpan
-} from "./chunk-2RURGSQW.js";
+} from "./chunk-4ZPXQDUZ.js";
 import "./chunk-QGM4M3NI.js";
 export {
   captureWarning,
   flush,
   initTelemetry,
+  isExpectedError,
   resolveRepo,
   setDeployAttribute,
   withDeploySpan,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bulletin-deploy",
-  "version": "0.5.5",
+  "version": "0.5.6",
   "private": false,
   "repository": {
     "type": "git",