bulletin-deploy 0.7.21 → 0.7.22-rc.1

package/dist/personhood/encoding.d.ts

@@ -0,0 +1,49 @@
+type ExtensionValues = {
+    /** Pipeline-ordered identifiers from `metadata.extrinsic.signedExtensions`. */
+    order: string[];
+    /** Per-identifier explicit + implicit bytes as papi computed them. */
+    byIdentifier: Record<string, {
+        value: Uint8Array;
+        additionalSigned: Uint8Array;
+    }>;
+};
+declare const concatBytes: (...arrays: Uint8Array[]) => Uint8Array;
+/** SCALE compact-encode a non-negative integer (length-prefix use only). */
+declare const compactEncode: (n: number) => Uint8Array;
+declare const blake2_256: (data: Uint8Array) => Uint8Array;
+/**
+ * Build the bytes the runtime hashes for `AsPersonalIdentityWithProof`.
+ *
+ * msg = blake2_256( encode((0u8, &call), &rest_ext, &rest_ext.implicit()) )
+ *
+ * The leading `0u8` is the extension-version byte that prefixes V5 General
+ * transactions (always `0` for the current extension scheme).
+ */
+declare const buildImplicationMessage: (callBytes: Uint8Array, extensions: ExtensionValues, excludeIdentifiers: string | Set<string>) => Uint8Array;
+/**
+ * Build the V5 General extrinsic wire bytes:
+ *
+ *   compactLen( 0x45 || 0x00 (ext_version) || concat(all_explicit) || callBytes )
+ *
+ * `0x45` = version 5 + type General (`5 + (1 << 6)`).
+ */
+declare const buildV5GeneralExtrinsic: (callBytes: Uint8Array, extensions: ExtensionValues) => Uint8Array;
+declare const toHex: (bytes: Uint8Array) => `0x${string}`;
+/** Convert a hex string (with or without 0x prefix) to Uint8Array. */
+declare const hexToBytes: (hex: string) => Uint8Array;
+/** Convert Uint8Array to a lowercase 0x-prefixed hex string. */
+declare const bytesToHex: (b: Uint8Array) => string;
+/**
+ * Parse the chain metadata (passed to `signer.signTx`) and return the
+ * pipeline-ordered list of signed-extension identifiers. Handles V14/V15
+ * (flat array) and V16 (nested under `[0]`).
+ */
+declare const readExtensionOrder: (metadata: Uint8Array) => Promise<string[]>;
+/**
+ * SCALE-encode `Vec<[u8; 32]>` — the shape that `verifiablejs.one_shot(...)`
+ * decodes as the ring members list. Each input must be exactly 32 bytes.
+ * Encoded as: compact(len) || member[0] || member[1] || ...
+ */
+declare const encodeMembers: (members: Uint8Array[]) => Uint8Array;
+
+export { type ExtensionValues, blake2_256, buildImplicationMessage, buildV5GeneralExtrinsic, bytesToHex, compactEncode, concatBytes, encodeMembers, hexToBytes, readExtensionOrder, toHex };

package/dist/personhood/encoding.js

@@ -0,0 +1,24 @@
+import {
+  blake2_256,
+  buildImplicationMessage,
+  buildV5GeneralExtrinsic,
+  bytesToHex,
+  compactEncode,
+  concatBytes,
+  encodeMembers,
+  hexToBytes,
+  readExtensionOrder,
+  toHex
+} from "../chunk-ZYVGHDMU.js";
+export {
+  blake2_256,
+  buildImplicationMessage,
+  buildV5GeneralExtrinsic,
+  bytesToHex,
+  compactEncode,
+  concatBytes,
+  encodeMembers,
+  hexToBytes,
+  readExtensionOrder,
+  toHex
+};

package/dist/personhood/hashing.d.ts

@@ -0,0 +1,4 @@
+declare function blake2b256(data: Uint8Array | string): Uint8Array;
+declare function blake2b256Keyed(data: Uint8Array, key: Uint8Array): Uint8Array;
+
+export { blake2b256, blake2b256Keyed };

package/dist/personhood/hashing.js

@@ -0,0 +1,8 @@
+import {
+  blake2b256,
+  blake2b256Keyed
+} from "../chunk-UPWEOGLQ.js";
+export {
+  blake2b256,
+  blake2b256Keyed
+};

package/dist/personhood/member-key.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Derive the 32-byte keyed entropy used as input to verifiablejs.
+ * Deterministic: same mnemonic always produces the same output.
+ */
+declare function deriveMemberEntropy(mnemonic: string): Uint8Array;
+/**
+ * Derive the 32-byte bandersnatch member public key from a BIP39 mnemonic.
+ * This is the key stored in People.Members.Members.
+ */
+declare function deriveMemberKey(mnemonic: string): Uint8Array;
+
+export { deriveMemberEntropy, deriveMemberKey };

package/dist/personhood/member-key.js

@@ -0,0 +1,10 @@
+import {
+  deriveMemberEntropy,
+  deriveMemberKey
+} from "../chunk-EJ5TNGAY.js";
+import "../chunk-UPWEOGLQ.js";
+import "../chunk-T7EEVWNU.js";
+export {
+  deriveMemberEntropy,
+  deriveMemberKey
+};

package/dist/personhood/people-client.d.ts

@@ -0,0 +1,14 @@
+import { PolkadotClient } from 'polkadot-api';
+
+interface PeopleClientResult {
+    client: PolkadotClient;
+    unsafeApi: ReturnType<PolkadotClient["getUnsafeApi"]>;
+    disconnect: () => void;
+}
+/**
+ * Open a People-chain polkadot-api client for the given environment.
+ * The caller must call `disconnect()` when done to release the WS connection.
+ */
+declare function connectPeopleClient(environmentId: string): Promise<PeopleClientResult>;
+
+export { type PeopleClientResult, connectPeopleClient };

package/dist/personhood/people-client.js

@@ -0,0 +1,48 @@
+import {
+  WS_HEARTBEAT_TIMEOUT_MS
+} from "../chunk-CIXT75OF.js";
+import "../chunk-WVCIU6WM.js";
+import "../chunk-WNUWAA6F.js";
+import "../chunk-XWA3NPMX.js";
+import {
+  loadEnvironments
+} from "../chunk-F36C363Y.js";
+import "../chunk-ZOC4GITL.js";
+
+// src/personhood/people-client.ts
+import { createClient } from "polkadot-api";
+import { getWsProvider } from "polkadot-api/ws";
+async function connectPeopleClient(environmentId) {
+  const { doc } = await loadEnvironments();
+  const peopleChain = doc.chains.find((c) => c.id === "people");
+  if (!peopleChain) {
+    throw new Error(
+      `environments.json has no 'people' chain entry for env '${environmentId}'`
+    );
+  }
+  const entry = peopleChain.endpoints[environmentId];
+  if (!entry) {
+    throw new Error(
+      `No People-chain endpoint for environment '${environmentId}'. Bootstrap is only available on paseo-next-v2.`
+    );
+  }
+  const rawWss = entry.wss;
+  const wss = Array.isArray(rawWss) ? rawWss[0] : rawWss;
+  const client = createClient(
+    getWsProvider(wss, { heartbeatTimeout: WS_HEARTBEAT_TIMEOUT_MS })
+  );
+  const unsafeApi = client.getUnsafeApi();
+  return {
+    client,
+    unsafeApi,
+    disconnect: () => {
+      try {
+        client.destroy();
+      } catch {
+      }
+    }
+  };
+}
+export {
+  connectPeopleClient
+};

package/dist/personhood/reprove.d.ts

@@ -0,0 +1,43 @@
+import { SS58String, PolkadotSigner } from 'polkadot-api';
+
+type ReproveAliasErrorKind = "NoStoredAlias" | "NotPaid" | "RingRootNotFound" | "RevisionNotAdvanced" | "AliasMismatch" | "NotARecognizedPerson" | "BadProof" | "DispatchError" | "RpcError" | "ClientError" | "Unknown";
+declare class ReproveAliasError extends Error {
+    readonly kind: ReproveAliasErrorKind;
+    readonly dispatchError?: unknown;
+    constructor(message: string, options?: ErrorOptions & {
+        kind?: ReproveAliasErrorKind;
+        dispatchError?: unknown;
+    });
+}
+type RingExponent = 9 | 10 | 14;
+interface BuildRingProofInput {
+    ringExponent: RingExponent;
+    members: Uint8Array;
+    context: Uint8Array;
+    msg: Uint8Array;
+}
+type BuildRingProof = (input: BuildRingProofInput) => Promise<{
+    proof: Uint8Array;
+    alias: Uint8Array;
+}>;
+interface ReproveAliasProgress {
+    onBroadcasted?: () => void;
+    onBestBlock?: (blockHash: string) => void;
+}
+interface ReproveAliasParams {
+    peopleUnsafeApi: unknown;
+    ahUnsafeApi: unknown;
+    account: SS58String;
+    memberKey: Uint8Array;
+    signCall: PolkadotSigner;
+    buildRingProof: BuildRingProof;
+    progress?: ReproveAliasProgress;
+}
+interface ReproveAliasResult {
+    blockHash: string;
+    oldRevision: number;
+    newRevision: number;
+}
+declare const reproveAliasToAccount: ({ peopleUnsafeApi, ahUnsafeApi, account, memberKey, signCall, buildRingProof, progress, }: ReproveAliasParams) => Promise<ReproveAliasResult>;
+
+export { type BuildRingProof, type BuildRingProofInput, ReproveAliasError, type ReproveAliasErrorKind, type ReproveAliasParams, type ReproveAliasProgress, type ReproveAliasResult, type RingExponent, reproveAliasToAccount };

package/dist/personhood/reprove.js

@@ -0,0 +1,225 @@
+import {
+  blake2_256,
+  bytesToHex,
+  concatBytes,
+  encodeMembers,
+  hexToBytes
+} from "../chunk-ZYVGHDMU.js";
+import {
+  PAID_PROOF_TAG,
+  PEOPLE_MEMBER_IDENTIFIER_HEX,
+  PROOF_BYTES
+} from "../chunk-T7EEVWNU.js";
+
+// src/personhood/reprove.ts
+import { getSs58AddressInfo } from "polkadot-api";
+var ReproveAliasError = class extends Error {
+  kind;
+  dispatchError;
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ReproveAliasError";
+    this.kind = options.kind ?? "Unknown";
+    this.dispatchError = options.dispatchError;
+  }
+};
+var reproveAliasToAccount = async ({
+  peopleUnsafeApi,
+  ahUnsafeApi,
+  account,
+  memberKey,
+  signCall,
+  buildRingProof,
+  progress
+}) => {
+  const people = peopleUnsafeApi;
+  const ah = ahUnsafeApi;
+  if (memberKey.length !== 32) {
+    throw new ReproveAliasError("memberKey must be 32 bytes", {
+      kind: "ClientError"
+    });
+  }
+  const stored = await ah.query.AliasAccounts.AccountToAlias.getValue(
+    account,
+    { at: "best" }
+  );
+  if (!stored) {
+    throw new ReproveAliasError(
+      "no AccountToAlias row for this account \u2014 bind first",
+      { kind: "NoStoredAlias" }
+    );
+  }
+  if (!stored.paid) {
+    throw new ReproveAliasError(
+      "AccountToAlias row is not paid \u2014 reprove_alias_account is only for paid aliases",
+      { kind: "NotPaid" }
+    );
+  }
+  const contextBytes = hexToBytes(stored.ca.context);
+  const storedRevision = stored.revision;
+  const storedRing = stored.ring;
+  const storedAliasHex = stored.ca.alias.toLowerCase();
+  const position = await people.query.Members.Members.getValue(
+    PEOPLE_MEMBER_IDENTIFIER_HEX,
+    bytesToHex(memberKey),
+    { at: "best" }
+  );
+  if (!position || position.type !== "Included") {
+    throw new ReproveAliasError(
+      `member position is '${position?.type ?? "absent"}', expected 'Included'`,
+      { kind: "NotARecognizedPerson" }
+    );
+  }
+  const ringIndex = position.value.ring_index;
+  const allEntries = await people.query.Members.RingKeys.getEntries({
+    at: "best"
+  });
+  const pages = [];
+  const identHex = PEOPLE_MEMBER_IDENTIFIER_HEX.toLowerCase();
+  for (const entry of allEntries) {
+    if (entry.keyArgs[0].toLowerCase() !== identHex) continue;
+    if (Number(entry.keyArgs[1]) !== ringIndex) continue;
+    pages.push([Number(entry.keyArgs[2]), [...entry.value]]);
+  }
+  pages.sort((a, b) => a[0] - b[0]);
+  const ringKeys = pages.flatMap(([, ks]) => ks);
+  if (ringKeys.length === 0) {
+    throw new ReproveAliasError("ring has no members on People", {
+      kind: "ClientError"
+    });
+  }
+  const membersBytes = encodeMembers(ringKeys.map((k) => hexToBytes(k)));
+  const ringExp = await ah.constants.AliasAccounts.PeopleRingExponent();
+  const ringExponent = ringExp.type === "R2e9" ? 9 : ringExp.type === "R2e10" ? 10 : 14;
+  const ringRoots = await ah.query.MembersSubscriber.RingRoots.getValue(
+    stored.collection,
+    ringIndex,
+    { at: "best" }
+  );
+  if (!ringRoots || ringRoots.length === 0) {
+    throw new ReproveAliasError(
+      "AH has no RingRoots for this (collection, ring_index)",
+      { kind: "RingRootNotFound" }
+    );
+  }
+  const latest = ringRoots[ringRoots.length - 1];
+  const newRevision = latest.revision;
+  if (newRevision <= storedRevision && ringIndex === storedRing) {
+    throw new ReproveAliasError(
+      `latest revision ${newRevision} is not strictly greater than stored ${storedRevision} on the same ring`,
+      { kind: "RevisionNotAdvanced" }
+    );
+  }
+  const ss58Info = getSs58AddressInfo(account);
+  if (!ss58Info.isValid) {
+    throw new ReproveAliasError(`invalid SS58: ${account}`, {
+      kind: "ClientError"
+    });
+  }
+  const paidMsg = blake2_256(concatBytes(PAID_PROOF_TAG, ss58Info.publicKey));
+  const { proof, alias } = await buildRingProof({
+    ringExponent,
+    members: membersBytes,
+    context: contextBytes,
+    msg: paidMsg
+  });
+  if (proof.length !== PROOF_BYTES) {
+    throw new ReproveAliasError(
+      `ring proof must be ${PROOF_BYTES} bytes, got ${proof.length}`,
+      { kind: "ClientError" }
+    );
+  }
+  if (bytesToHex(alias).toLowerCase() !== storedAliasHex) {
+    throw new ReproveAliasError(
+      `regenerated alias ${bytesToHex(alias)} differs from stored ${storedAliasHex} \u2014 would fail ReproveMismatch`,
+      { kind: "AliasMismatch" }
+    );
+  }
+  const tx = ah.tx.AliasAccounts.reprove_alias_account({
+    proof: bytesToHex(proof),
+    ring_index: ringIndex,
+    ring_revision: newRevision
+  });
+  const blockHash = await new Promise((resolve, reject) => {
+    let settled = false;
+    const fail = (err) => {
+      if (settled) return;
+      settled = true;
+      reject(err);
+    };
+    const succeed = (h) => {
+      if (settled) return;
+      settled = true;
+      resolve(h);
+    };
+    tx.signSubmitAndWatch(signCall).subscribe({
+      next: (event) => {
+        if (settled) return;
+        const ev = event;
+        if (ev.type === "broadcasted") {
+          progress?.onBroadcasted?.();
+          return;
+        }
+        if (ev.type === "txBestBlocksState" && ev.found) {
+          if (ev.ok === false) {
+            fail(
+              new ReproveAliasError(
+                "reprove_alias_account dispatched but failed in-block",
+                {
+                  kind: narrowDispatchError(ev.dispatchError),
+                  dispatchError: ev.dispatchError
+                }
+              )
+            );
+            return;
+          }
+          if (ev.block) progress?.onBestBlock?.(ev.block.hash);
+          return;
+        }
+        if (ev.type === "finalized") {
+          if (ev.ok === false) {
+            fail(
+              new ReproveAliasError(
+                "reprove_alias_account failed at finalization",
+                {
+                  kind: narrowDispatchError(ev.dispatchError),
+                  dispatchError: ev.dispatchError
+                }
+              )
+            );
+            return;
+          }
+          if (ev.block) succeed(ev.block.hash);
+        }
+      },
+      error: (err) => {
+        fail(
+          err instanceof ReproveAliasError ? err : new ReproveAliasError(
+            err instanceof Error ? `RPC rejected extrinsic: ${err.message}` : "RPC error during submitAndWatch",
+            { cause: err, kind: "RpcError" }
+          )
+        );
+      }
+    });
+  });
+  return { blockHash, oldRevision: storedRevision, newRevision };
+};
+var narrowDispatchError = (dispatchError) => {
+  if (typeof dispatchError === "object" && dispatchError !== null && "type" in dispatchError) {
+    const d = dispatchError;
+    if (d.type === "Module" && typeof d.value === "object" && d.value !== null) {
+      const v = d.value;
+      if (v.type === "AliasAccounts") {
+        if (v.value?.type === "BadProof") return "BadProof";
+        if (v.value?.type === "ReproveMismatch") return "AliasMismatch";
+        if (v.value?.type === "AliasAccountAlreadySet")
+          return "RevisionNotAdvanced";
+      }
+    }
+  }
+  return "DispatchError";
+};
+export {
+  ReproveAliasError,
+  reproveAliasToAccount
+};

package/dist/pool.d.ts

@@ -14,6 +14,11 @@ interface PoolAuthorization extends PoolAccount {
     expiration: number;
 }
 declare function derivePoolAccounts(poolSize?: number, mnemonic?: string): PoolAccount[];
+interface AuthorizationCheck {
+    needs?: AuthorizationNeeds;
+    bulletinAuthorizeV2?: boolean;
+}
+declare function isAuthorizationSufficient(auth: any, currentBlock: number, check?: AuthorizationCheck): boolean;
 declare function selectAccount(authorizations: PoolAuthorization[], random?: () => number, currentBlock?: number): PoolAuthorization | null;
 declare function fetchPoolAuthorizations(api: any, accounts: PoolAccount[]): Promise<PoolAuthorization[]>;
 interface AuthorizationNeeds {
@@ -32,11 +37,11 @@ declare function classifyAliceTxError(err: unknown): TxRetryDecision;
 declare function isTestnetSpecName(specName: string | undefined | null): boolean;
 declare function detectTestnet(api: any): Promise<boolean>;
 declare function _resetTestnetCacheForTests(): void;
-declare function ensureAuthorized(api: any, address: string, label?: string, bulletinAuthorizeV2?: boolean): Promise<void>;
+declare function ensureAuthorized(api: any, address: string, label?: string, bulletinAuthorizeV2?: boolean, needs?: AuthorizationNeeds): Promise<void>;
 declare function topUpBy(api: any, address: string, needs: AuthorizationNeeds, label?: string, bulletinAuthorizeV2?: boolean): Promise<void>;
 interface BootstrapOptions {
     bulletinAuthorizeV2?: boolean;
 }
 declare function bootstrapPool(bulletinRpc: string, poolSize?: number, mnemonic?: string, opts?: BootstrapOptions): Promise<void>;
 
-export { type AuthorizationNeeds, type BootstrapOptions, type PoolAccount, type PoolAuthorization, type TxRetryDecision, _resetTestnetCacheForTests, bootstrapPool, classifyAliceTxError, computeTopUpTarget, derivePoolAccounts, detectTestnet, ensureAuthorized, fetchPoolAuthorizations, formatPasBalance, isTestnetSpecName, selectAccount, topUpBy };
+export { type AuthorizationCheck, type AuthorizationNeeds, type BootstrapOptions, type PoolAccount, type PoolAuthorization, type TxRetryDecision, _resetTestnetCacheForTests, bootstrapPool, classifyAliceTxError, computeTopUpTarget, derivePoolAccounts, detectTestnet, ensureAuthorized, fetchPoolAuthorizations, formatPasBalance, isAuthorizationSufficient, isTestnetSpecName, selectAccount, topUpBy };

package/dist/pool.js

@@ -8,10 +8,11 @@ import {
   ensureAuthorized,
   fetchPoolAuthorizations,
   formatPasBalance,
+  isAuthorizationSufficient,
   isTestnetSpecName,
   selectAccount,
   topUpBy
-} from "./chunk-4TS6R26J.js";
+} from "./chunk-WVCIU6WM.js";
 export {
   _resetTestnetCacheForTests,
   bootstrapPool,
@@ -22,6 +23,7 @@ export {
   ensureAuthorized,
   fetchPoolAuthorizations,
   formatPasBalance,
+  isAuthorizationSufficient,
   isTestnetSpecName,
   selectAccount,
   topUpBy

package/dist/run-state.js

@@ -7,7 +7,7 @@ import {
   shouldSkipStaleWarning,
   stateFilePath,
   writeRunState
-} from "./chunk-G2P5UIPX.js";
+} from "./chunk-XWA3NPMX.js";
 export {
   VERSION,
   loadRunState,

package/dist/telemetry.d.ts

@@ -1,7 +1,9 @@
+import * as _sentry_node from '@sentry/node';
 import { DeployContextForReport } from './memory-report.js';
 import 'node:v8';
 
 declare const VERSION: string;
+type SentryModule = typeof _sentry_node | null;
 interface InternalContextSignals {
     githubRepository?: string;
     runnerName?: string;
@@ -27,6 +29,9 @@ type DeployErrorCategory = 'user' | 'environment' | 'internal' | 'unknown';
 declare function classifyDeployError(msg: string): DeployErrorCategory;
 declare function classifySadReason(message: string): string;
 declare function computeDeployOutcome(errorCategory: DeployErrorCategory | null, isSad: boolean, sadReason: string): string;
+type DeployErrorKind = 'contract-revert' | 'chain-timeout' | 'nonce-stale' | 'connection' | 'unknown';
+declare function classifyErrorKind(msg: string): DeployErrorKind;
+declare function sanitizeErrorMessage(msg: string): string;
 declare function withSpan<T>(op: string, description: string, attributes: Record<string, string | number | boolean | undefined>, fn: () => T | Promise<T>): Promise<T>;
 declare function sampleMemory(stage: string): void;
 declare function withDeploySpan<T>(domain: string, fn: () => T | Promise<T>): Promise<T>;
@@ -35,9 +40,10 @@ declare function setDeployReportContext(patch: Partial<DeployContextForReport> &
 }): void;
 declare function setDeployAttribute(key: string, value: string | number | boolean): void;
 declare function __setDeployRootSpanForTest(span: any | null): void;
+declare function __setSentryForTest(stub: any): SentryModule;
 declare function getCurrentSentryTraceId(): string | undefined;
 declare function setDeploySentryTag(key: string, value: string): void;
 declare function captureWarning(message: string, context?: Record<string, unknown>): void;
 declare function flush(): Promise<void>;
 
-export { type DeployErrorCategory, type InternalContextSignals, VERSION, __setDeployRootSpanForTest, captureWarning, classifyDeployError, classifySadReason, closeTelemetry, computeDeployOutcome, flush, getCurrentSentryTraceId, getDeployAttributes, initTelemetry, isExpectedError, isInternalContext, isInternalContextFromSignals, markRelaunchOomHintShown, resolveRepo, resolveRunner, resolveRunnerType, sampleMemory, sanitizeBranch, sanitizeRepo, scrubPaths, setDeployAttribute, setDeployReportContext, setDeploySentryTag, setRunStateActive, truncateAddress, withDeploySpan, withSpan };
+export { type DeployErrorCategory, type DeployErrorKind, type InternalContextSignals, VERSION, __setDeployRootSpanForTest, __setSentryForTest, captureWarning, classifyDeployError, classifyErrorKind, classifySadReason, closeTelemetry, computeDeployOutcome, flush, getCurrentSentryTraceId, getDeployAttributes, initTelemetry, isExpectedError, isInternalContext, isInternalContextFromSignals, markRelaunchOomHintShown, resolveRepo, resolveRunner, resolveRunnerType, sampleMemory, sanitizeBranch, sanitizeErrorMessage, sanitizeRepo, scrubPaths, setDeployAttribute, setDeployReportContext, setDeploySentryTag, setRunStateActive, truncateAddress, withDeploySpan, withSpan };

package/dist/telemetry.js

@@ -1,8 +1,10 @@
 import {
   VERSION,
   __setDeployRootSpanForTest,
+  __setSentryForTest,
   captureWarning,
   classifyDeployError,
+  classifyErrorKind,
   classifySadReason,
   closeTelemetry,
   computeDeployOutcome,
@@ -19,6 +21,7 @@ import {
   resolveRunnerType,
   sampleMemory,
   sanitizeBranch,
+  sanitizeErrorMessage,
   sanitizeRepo,
   scrubPaths,
   setDeployAttribute,
@@ -28,13 +31,15 @@ import {
   truncateAddress,
   withDeploySpan,
   withSpan
-} from "./chunk-2VNGK2MU.js";
-import "./chunk-G2P5UIPX.js";
+} from "./chunk-WNUWAA6F.js";
+import "./chunk-XWA3NPMX.js";
 export {
   VERSION,
   __setDeployRootSpanForTest,
+  __setSentryForTest,
   captureWarning,
   classifyDeployError,
+  classifyErrorKind,
   classifySadReason,
   closeTelemetry,
   computeDeployOutcome,
@@ -51,6 +56,7 @@ export {
   resolveRunnerType,
   sampleMemory,
   sanitizeBranch,
+  sanitizeErrorMessage,
   sanitizeRepo,
   scrubPaths,
   setDeployAttribute,

package/dist/version-check.js

@@ -9,9 +9,9 @@ import {
   isPreReleaseVersion,
   preReleaseWarning,
   promptYesNo
-} from "./chunk-RJAFD4LO.js";
-import "./chunk-2VNGK2MU.js";
-import "./chunk-G2P5UIPX.js";
+} from "./chunk-FSSKFXTZ.js";
+import "./chunk-WNUWAA6F.js";
+import "./chunk-XWA3NPMX.js";
 export {
   assessVersion,
   checkNodeVersion,