@parity/product-deploy 0.7.28-rc.0

package/dist/personhood/people-client.js

@@ -0,0 +1,48 @@
+import {
+  WS_HEARTBEAT_TIMEOUT_MS
+} from "../chunk-DNXH4QTI.js";
+import "../chunk-QMYW3D6E.js";
+import "../chunk-MFTODIIT.js";
+import "../chunk-KJH2T5TQ.js";
+import {
+  loadEnvironments
+} from "../chunk-OITUIM2E.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 {
+  PAID_PROOF_TAG,
+  PEOPLE_MEMBER_IDENTIFIER_HEX,
+  PROOF_BYTES
+} from "../chunk-T7EEVWNU.js";
+import {
+  blake2_256,
+  bytesToHex,
+  concatBytes,
+  encodeMembers,
+  hexToBytes
+} from "../chunk-ZYVGHDMU.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

@@ -0,0 +1,51 @@
+import { PolkadotSigner } from 'polkadot-api';
+
+declare function formatPasBalance(plancks: bigint): string;
+interface PoolAccount {
+    index: number;
+    path: string;
+    publicKey: Uint8Array;
+    signer: PolkadotSigner;
+    address: string;
+}
+interface PoolAuthorization extends PoolAccount {
+    transactions: bigint;
+    bytes: bigint;
+    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;
+interface SelectionResult {
+    account: PoolAuthorization;
+    eligibleCount: number;
+}
+declare function selectAccount(authorizations: PoolAuthorization[], random?: () => number, currentBlock?: number): SelectionResult | null;
+declare function fetchPoolAuthorizations(api: any, accounts: PoolAccount[]): Promise<PoolAuthorization[]>;
+interface AuthorizationNeeds {
+    txs: bigint;
+    bytes: bigint;
+}
+declare function computeTopUpTarget(current: {
+    transactions: bigint;
+    bytes: bigint;
+}, needs: AuthorizationNeeds): {
+    transactions: bigint;
+    bytes: bigint;
+} | null;
+type TxRetryDecision = "retry" | "abort";
+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, 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 AuthorizationCheck, type AuthorizationNeeds, type BootstrapOptions, type PoolAccount, type PoolAuthorization, type SelectionResult, type TxRetryDecision, _resetTestnetCacheForTests, bootstrapPool, classifyAliceTxError, computeTopUpTarget, derivePoolAccounts, detectTestnet, ensureAuthorized, fetchPoolAuthorizations, formatPasBalance, isAuthorizationSufficient, isTestnetSpecName, selectAccount, topUpBy };

package/dist/pool.js

@@ -0,0 +1,30 @@
+import {
+  _resetTestnetCacheForTests,
+  bootstrapPool,
+  classifyAliceTxError,
+  computeTopUpTarget,
+  derivePoolAccounts,
+  detectTestnet,
+  ensureAuthorized,
+  fetchPoolAuthorizations,
+  formatPasBalance,
+  isAuthorizationSufficient,
+  isTestnetSpecName,
+  selectAccount,
+  topUpBy
+} from "./chunk-QMYW3D6E.js";
+export {
+  _resetTestnetCacheForTests,
+  bootstrapPool,
+  classifyAliceTxError,
+  computeTopUpTarget,
+  derivePoolAccounts,
+  detectTestnet,
+  ensureAuthorized,
+  fetchPoolAuthorizations,
+  formatPasBalance,
+  isAuthorizationSufficient,
+  isTestnetSpecName,
+  selectAccount,
+  topUpBy
+};

package/dist/run-state.d.ts

@@ -0,0 +1,22 @@
+declare const VERSION: string;
+type RunStatus = "running" | "succeeded" | "failed" | "crashed";
+interface RunState {
+    status: RunStatus;
+    pid: number;
+    startedAt: number;
+    endedAt?: number;
+    toolVersion: string;
+    argv: string[];
+    lastPeakRssMb: number | null;
+    lastStage: string | null;
+    reason?: string;
+}
+declare function resolveStateDir(): string;
+declare function stateFilePath(): string;
+declare function loadRunState(): RunState | null;
+declare function writeRunState(patch: Partial<RunState>): void;
+declare function shouldSkipStaleWarning(prev: RunState): boolean;
+declare function probablyOomRssMb(override?: number): number;
+declare function shouldShowOomHint(prev: RunState): boolean;
+
+export { type RunState, type RunStatus, VERSION, loadRunState, probablyOomRssMb, resolveStateDir, shouldShowOomHint, shouldSkipStaleWarning, stateFilePath, writeRunState };

package/dist/run-state.js

@@ -0,0 +1,20 @@
+import {
+  VERSION,
+  loadRunState,
+  probablyOomRssMb,
+  resolveStateDir,
+  shouldShowOomHint,
+  shouldSkipStaleWarning,
+  stateFilePath,
+  writeRunState
+} from "./chunk-KJH2T5TQ.js";
+export {
+  VERSION,
+  loadRunState,
+  probablyOomRssMb,
+  resolveStateDir,
+  shouldShowOomHint,
+  shouldSkipStaleWarning,
+  stateFilePath,
+  writeRunState
+};

package/dist/telemetry.d.ts

@@ -0,0 +1,56 @@
+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;
+    gitRemote?: string;
+    hostApp?: string;
+}
+declare function isInternalContextFromSignals(signals: InternalContextSignals): boolean;
+declare function isInternalContext(): boolean;
+declare function scrubPaths(msg: string): string;
+declare function truncateAddress(ss58: string | undefined): string | undefined;
+declare function sanitizeBranch(name: string | undefined): string | undefined;
+declare function sanitizeRepo(slug: string | undefined): string | undefined;
+declare function setRunStateActive(v: boolean): void;
+declare function markRelaunchOomHintShown(): void;
+declare function closeTelemetry(timeoutMs: number): Promise<void>;
+declare function initTelemetry(): void;
+declare function resolveRepo(domain: string): string;
+declare function resolveRunner(): string;
+declare function resolveRunnerType(): string;
+declare function getDeployAttributes(domain: string): Record<string, string | number | boolean | undefined>;
+declare function isExpectedError(msg: string): boolean;
+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' | 'naming.pop_required' | 'naming.already_owned' | 'naming.subdomain_orphan' | 'verify.contenthash_mismatch' | 'verify.dagpb_not_finalised' | 'network.recovery_exhausted' | 'chain.api_timeout' | 'tool.invariant' | 'unknown';
+declare function classifyErrorKind(msg: string): DeployErrorKind;
+declare function sanitizeErrorMessage(msg: string): string;
+/**
+ * Classify an error message's *shape* (length, presence of certain patterns)
+ * without excerpting content. The result is a comma-joined list of tags;
+ * future analysis of scrubbed events will use this to identify which content
+ * shape triggered Sentry's PII scrubber, so we can build a real sanitiser.
+ */
+declare function analyseErrorPattern(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>;
+declare function setDeployReportContext(patch: Partial<DeployContextForReport> & {
+    outputDir?: string;
+}): 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 DeployErrorKind, type InternalContextSignals, VERSION, __setDeployRootSpanForTest, __setSentryForTest, analyseErrorPattern, 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

@@ -0,0 +1,71 @@
+import {
+  VERSION,
+  __setDeployRootSpanForTest,
+  __setSentryForTest,
+  analyseErrorPattern,
+  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
+} from "./chunk-MFTODIIT.js";
+import "./chunk-KJH2T5TQ.js";
+export {
+  VERSION,
+  __setDeployRootSpanForTest,
+  __setSentryForTest,
+  analyseErrorPattern,
+  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/version-check.d.ts

@@ -0,0 +1,38 @@
+import { Readable } from 'node:stream';
+
+interface VersionInfo {
+    latest: string;
+    minimumFromRegistry: string | null;
+    minimumFromKillSwitch: string | null;
+    killSwitchMessage: string | null;
+}
+declare function checkNodeVersion(enginesNode: string, currentVersion: string): string | null;
+declare function compareSemver(a: string, b: string): number;
+declare function isPreReleaseVersion(version: string): boolean;
+declare function preReleaseWarning(version: string): string | null;
+declare function fetchVersionInfo(): Promise<VersionInfo | null>;
+declare function handlePreflightVersionCheck(info: VersionInfo | null): "abort" | "nudge" | "ok";
+declare function isInternalUser(cwd?: string): boolean;
+declare function isInteractive(): boolean;
+declare function promptYesNo(question: string, input?: Readable): Promise<boolean>;
+declare function classifyErrorArea(msg: string): string | null;
+type VersionVerdict = {
+    action: "forced_update";
+    currentVersion: string;
+    minimumVersion: string;
+    message: string | null;
+} | {
+    action: "suggest_update";
+    currentVersion: string;
+    latestVersion: string;
+    internal: boolean;
+} | {
+    action: "bug_report";
+    internal: boolean;
+} | {
+    action: "none";
+};
+declare function assessVersion(currentVersion: string, info: VersionInfo, internal: boolean): VersionVerdict;
+declare function handleFailedDeploy(error: Error): Promise<void>;
+
+export { type VersionVerdict, assessVersion, checkNodeVersion, classifyErrorArea, compareSemver, fetchVersionInfo, handleFailedDeploy, handlePreflightVersionCheck, isInteractive, isInternalUser, isPreReleaseVersion, preReleaseWarning, promptYesNo };

package/dist/version-check.js

@@ -0,0 +1,30 @@
+import {
+  assessVersion,
+  checkNodeVersion,
+  classifyErrorArea,
+  compareSemver,
+  fetchVersionInfo,
+  handleFailedDeploy,
+  handlePreflightVersionCheck,
+  isInteractive,
+  isInternalUser,
+  isPreReleaseVersion,
+  preReleaseWarning,
+  promptYesNo
+} from "./chunk-43HLT335.js";
+import "./chunk-MFTODIIT.js";
+import "./chunk-KJH2T5TQ.js";
+export {
+  assessVersion,
+  checkNodeVersion,
+  classifyErrorArea,
+  compareSemver,
+  fetchVersionInfo,
+  handleFailedDeploy,
+  handlePreflightVersionCheck,
+  isInteractive,
+  isInternalUser,
+  isPreReleaseVersion,
+  preReleaseWarning,
+  promptYesNo
+};

package/docs/bootstrap.md

@@ -0,0 +1,49 @@
+# bulletin-bootstrap
+
+`bulletin-bootstrap` is the operator CLI for initializing Bulletin pool accounts. It is separate from `bulletin-deploy` on purpose: deploys are the normal user path, bootstrap is an admin/setup operation.
+
+## Usage
+
+```bash
+bulletin-bootstrap
+```
+
+Options:
+
+| Flag | What it does |
+|---|---|
+| `--rpc wss://...` | Override the Bulletin RPC endpoint. Also readable from `BULLETIN_RPC`. |
+| `--pool-size N` | Number of derived pool accounts to initialize. Default: `10`. |
+| `--mnemonic "..."` | Root mnemonic used to derive the pool accounts. Also readable from `BULLETIN_POOL_MNEMONIC`, then `MNEMONIC`. |
+| `--version` | Print the CLI version. |
+| `--help` | Show help. |
+
+## What it does
+
+The command derives the pool account set and initializes the on-chain authorization state needed for Bulletin uploads.
+
+Use it when:
+
+- you are bringing up a fresh pool on a testnet
+- the shared uploader pool has not been authorized yet
+- you want to pre-initialize a non-default pool mnemonic
+
+Do not use it as part of routine deploys. Normal deploys go through `bulletin-deploy`.
+
+## Examples
+
+```bash
+# Default testnet pool against the default RPC
+bulletin-bootstrap
+
+# Different RPC and larger pool
+bulletin-bootstrap --rpc wss://custom-bulletin.example.com --pool-size 20
+
+# Explicit pool mnemonic
+bulletin-bootstrap --mnemonic "..."
+```
+
+## Related Docs
+
+- [Main README](../README.md)
+- [E2E test setup](./e2e-bootstrap.md)