@parity/product-deploy 0.7.28-rc.0

package/dist/environments.d.ts

@@ -0,0 +1,104 @@
+declare const DEFAULT_ENV_ID = "paseo-next-v2";
+interface PopSelfServeConfig {
+    /** The label users select in the sudo.personhood.dev env dropdown — e.g. "Next V2". */
+    sudoEnvLabel: string;
+    /** Faucet URL for funding the service account on this env. */
+    faucetUrl: string;
+    /** Personhood recognition flow URL on the sudo app. */
+    personhoodFaucetUrl: string;
+    /** Asset-Hub alias-binding flow URL on the sudo app. */
+    dotnsBootstrapUrl: string;
+    /**
+     * Whether state-aware remediation messages (not-bound / bound-likely-stale / wrong-context)
+     * can be offered for this env. Requires the reprove tooling to know the env and the user
+     * to have access to the dotns-bootstrap UI. Defaults to false; opt in per-env.
+     */
+    stateAwareGuidance?: boolean;
+}
+interface Environment {
+    id: string;
+    name: string;
+    network: "testnet" | "mainnet";
+    description?: string;
+    badge?: string;
+    backend?: string;
+    ipfs?: string;
+    uptimeUrl?: string;
+    autoAccountMapping?: boolean;
+    bulletinAuthorizeV2?: boolean;
+    nativeToEthRatio?: number;
+    registerStorageDeposit?: number;
+    contracts?: Record<string, string>;
+    popSelfServe?: PopSelfServeConfig;
+}
+interface ChainEndpoint {
+    wss: string | string[];
+    parachainId?: number;
+    uptimeUrl?: string;
+}
+interface Chain {
+    id: string;
+    name: string;
+    endpoints: Record<string, ChainEndpoint>;
+}
+interface EnvironmentsDoc {
+    environments: Environment[];
+    chains: Chain[];
+}
+type EnvironmentsSource = "bundled" | "hardcoded-fallback";
+interface LoadResult {
+    doc: EnvironmentsDoc;
+    source: EnvironmentsSource;
+}
+interface LoadOptions {
+    bundledPath?: string;
+    warn?: (msg: string) => void;
+    capture?: (err: unknown) => void;
+}
+interface ResolvedEndpoints {
+    bulletin: string[];
+    assetHub: string[];
+    network: "testnet" | "mainnet";
+    envName: string;
+    ipfs?: string;
+    autoAccountMapping: boolean;
+    bulletinAuthorizeV2: boolean;
+    contracts: Record<string, string>;
+    nativeToEthRatio: bigint;
+    registerStorageDeposit?: bigint;
+}
+declare function defaultBundledPath(): string;
+/**
+ * Returns true for a well-formed, non-zero EVM address:
+ *   - 0x-prefixed, exactly 42 characters (0x + 40 hex digits)
+ *   - not the all-zeros address
+ *
+ * Does NOT require EIP-55 checksum — addresses in environments.json may be
+ * stored in any casing and the validation goal is structural correctness.
+ */
+declare function isValidContractAddress(addr: unknown): boolean;
+/**
+ * Validates all contract addresses in the given contracts map.
+ *
+ * Throws a clear error for the first invalid address found.
+ * Does NOT throw when the map is empty or a key is absent — the map is sparse
+ * by design (not all environments have contracts configured).
+ *
+ * @param contracts  The `contracts` record from an environment entry.
+ * @param envId      The environment ID, used in the error message.
+ */
+declare function validateContractAddresses(contracts: Record<string, string>, envId: string): void;
+declare function loadEnvironments(opts?: LoadOptions): Promise<LoadResult>;
+declare function resolveEndpoints(doc: EnvironmentsDoc, envId: string): ResolvedEndpoints;
+declare function getPopSelfServeConfig(doc: EnvironmentsDoc, envId: string): PopSelfServeConfig | null;
+interface EnvironmentListing {
+    id: string;
+    name: string;
+    network: string;
+    hasBulletin: boolean;
+    description: string;
+}
+declare function listEnvironments(doc: EnvironmentsDoc): EnvironmentListing[];
+declare function formatEnvironmentTable(rows: EnvironmentListing[]): string;
+
+export { type Chain, type ChainEndpoint, DEFAULT_ENV_ID, type Environment, type EnvironmentListing, type EnvironmentsDoc, type EnvironmentsSource, type LoadOptions, type LoadResult, type PopSelfServeConfig, type ResolvedEndpoints, defaultBundledPath, formatEnvironmentTable, getPopSelfServeConfig, isValidContractAddress, listEnvironments, loadEnvironments, resolveEndpoints, validateContractAddresses };

package/dist/environments.js

@@ -0,0 +1,23 @@
+import {
+  DEFAULT_ENV_ID,
+  defaultBundledPath,
+  formatEnvironmentTable,
+  getPopSelfServeConfig,
+  isValidContractAddress,
+  listEnvironments,
+  loadEnvironments,
+  resolveEndpoints,
+  validateContractAddresses
+} from "./chunk-OITUIM2E.js";
+import "./chunk-ZOC4GITL.js";
+export {
+  DEFAULT_ENV_ID,
+  defaultBundledPath,
+  formatEnvironmentTable,
+  getPopSelfServeConfig,
+  isValidContractAddress,
+  listEnvironments,
+  loadEnvironments,
+  resolveEndpoints,
+  validateContractAddresses
+};

package/dist/errors.d.ts

@@ -0,0 +1,6 @@
+declare class NonRetryableError extends Error {
+    constructor(message: string);
+}
+declare const EXIT_CODE_NO_RETRY = 78;
+
+export { EXIT_CODE_NO_RETRY, NonRetryableError };

package/dist/errors.js

@@ -0,0 +1,8 @@
+import {
+  EXIT_CODE_NO_RETRY,
+  NonRetryableError
+} from "./chunk-ZOC4GITL.js";
+export {
+  EXIT_CODE_NO_RETRY,
+  NonRetryableError
+};

package/dist/gh-pages-mirror.d.ts

@@ -0,0 +1,76 @@
+declare const GH_PAGES_MIRROR_MAX_BYTES: number;
+declare const GH_PAGES_MIRROR_DIR = "bulletin";
+declare const GH_PAGES_MIRROR_BRANCH = "gh-pages";
+interface MirrorInput {
+    domain: string;
+    carBytes: Uint8Array;
+    cid: string;
+    toolVersion: string;
+    bulletinRpc: string;
+    encrypted: boolean;
+    deployedAt?: string;
+    sourceCommit?: string;
+    sourceRepo?: string;
+    repoPath?: string;
+    githubToken?: string;
+}
+interface MirrorResult {
+    url: string;
+    owner: string;
+    repo: string;
+    carPath: string;
+    manifestPath: string;
+}
+interface MirrorManifest {
+    domain: string;
+    cid: string;
+    toolVersion: string;
+    deployedAt: string;
+    encrypted: boolean;
+    bulletinRpc: string;
+    sourceRepo?: string;
+    sourceCommit?: string;
+}
+declare class MirrorSkipped extends Error {
+    constructor(reason: string);
+}
+interface FreshnessPollResult {
+    verified: boolean;
+    attempts: number;
+    durationMs: number;
+    lastCid: string | null;
+    lastStatus: number;
+}
+/**
+ * Poll the mirror's manifest URL until its `cid` field equals the expected
+ * value. Pages is CDN-backed — a fresh commit may return HTTP 200 for
+ * several seconds to a few minutes while Fastly still serves stale bytes,
+ * so we can't just 200-check. Matching the manifest CID proves the edge
+ * has picked up the current deploy; the sibling .car URL is then guaranteed
+ * fresh for the same commit.
+ *
+ * Non-fatal to the deploy — returns `{ verified: false }` if the poll times
+ * out so the caller can log a warning without aborting a deploy whose
+ * on-chain state is already good.
+ */
+declare function pollMirrorFreshness(mirrorUrl: string, expectedCid: string, opts?: {
+    timeoutMs?: number;
+    intervalMs?: number;
+    fetchFn?: typeof fetch;
+}): Promise<FreshnessPollResult>;
+declare function parseGitRemoteUrl(url: string): {
+    owner: string;
+    repo: string;
+} | null;
+declare function resolveOwnerRepo(repoPath: string): {
+    owner: string;
+    repo: string;
+} | null;
+declare function resolveSourceCommit(repoPath: string): string | undefined;
+declare function normalizeDomainFilename(domain: string): string;
+declare function mirrorUrl(owner: string, repo: string, domainFilename: string): string;
+declare function buildManifest(input: Omit<MirrorInput, "carBytes" | "repoPath" | "githubToken">): MirrorManifest;
+declare const MIRROR_BOT_GIT_OVERRIDES: readonly string[];
+declare function mirrorToGitHubPages(input: MirrorInput): Promise<MirrorResult>;
+
+export { type FreshnessPollResult, GH_PAGES_MIRROR_BRANCH, GH_PAGES_MIRROR_DIR, GH_PAGES_MIRROR_MAX_BYTES, MIRROR_BOT_GIT_OVERRIDES, type MirrorInput, type MirrorManifest, type MirrorResult, MirrorSkipped, buildManifest, mirrorToGitHubPages, mirrorUrl, normalizeDomainFilename, parseGitRemoteUrl, pollMirrorFreshness, resolveOwnerRepo, resolveSourceCommit };

package/dist/gh-pages-mirror.js

@@ -0,0 +1,30 @@
+import {
+  GH_PAGES_MIRROR_BRANCH,
+  GH_PAGES_MIRROR_DIR,
+  GH_PAGES_MIRROR_MAX_BYTES,
+  MIRROR_BOT_GIT_OVERRIDES,
+  MirrorSkipped,
+  buildManifest,
+  mirrorToGitHubPages,
+  mirrorUrl,
+  normalizeDomainFilename,
+  parseGitRemoteUrl,
+  pollMirrorFreshness,
+  resolveOwnerRepo,
+  resolveSourceCommit
+} from "./chunk-HOTQDYHD.js";
+export {
+  GH_PAGES_MIRROR_BRANCH,
+  GH_PAGES_MIRROR_DIR,
+  GH_PAGES_MIRROR_MAX_BYTES,
+  MIRROR_BOT_GIT_OVERRIDES,
+  MirrorSkipped,
+  buildManifest,
+  mirrorToGitHubPages,
+  mirrorUrl,
+  normalizeDomainFilename,
+  parseGitRemoteUrl,
+  pollMirrorFreshness,
+  resolveOwnerRepo,
+  resolveSourceCommit
+};

package/dist/incremental-stats.d.ts

@@ -0,0 +1,69 @@
+import { ChunkProbeResult } from './chunk-probe.js';
+import { ManifestChunkEntry } from './manifest.js';
+
+interface IncrementalStats {
+    manifestSource: "embedded" | "heuristic_fallback" | "none";
+    manifestFetchAttempts: number;
+    manifestBytes: number;
+    framework: string | null;
+    filesTotal: number;
+    filesStable: number;
+    filesVolatile: number;
+    probedTotal: number;
+    probePresent: number;
+    probeAbsent: number;
+    probeFailed: number;
+    probeFailedRpc: number;
+    probeFailedDecode: number;
+    probeFailedMetadata: number;
+    recycledCids: number;
+    retentionPeriodBlocks: number;
+    bytesProbePresent: number;
+    bytesProbeAbsent: number;
+    bytesSkipped: number;
+    bytesUploaded: number;
+    chunksTotal: number;
+    chunksUploaded: number;
+    chunksSkipped: number;
+    carBytes: number;
+    section0Bytes: number;
+    section1Bytes: number;
+    section2Bytes: number;
+    estimatedSecondsSaved: number;
+    tier2VerifiedCount: number;
+    tier2InconclusiveCount: number;
+    tier2FallbackCount: number;
+}
+interface ComputeStatsInput {
+    manifestSource: IncrementalStats["manifestSource"];
+    manifestFetchAttempts: number;
+    manifestBytes?: number;
+    framework: string | null;
+    filesTotal: number;
+    filesStable: number;
+    filesVolatile: number;
+    probeResults: ChunkProbeResult[];
+    prevChunks: Record<string, ManifestChunkEntry>;
+    retentionPeriodBlocks: number;
+    bytesProbePresent: number;
+    bytesProbeAbsent?: number;
+    bytesSkipped: number;
+    bytesUploaded: number;
+    chunksTotal: number;
+    chunksUploaded: number;
+    chunksSkipped: number;
+    carBytes: number;
+    sectionSizes: {
+        section0: number;
+        section1: number;
+        section2: number;
+    };
+    tier2VerifiedCount: number;
+    tier2InconclusiveCount: number;
+    tier2FallbackCount: number;
+}
+declare function computeStats(input: ComputeStatsInput): IncrementalStats;
+declare function telemetryAttributes(s: IncrementalStats): Record<string, string | number>;
+declare function renderSummary(s: IncrementalStats): string;
+
+export { type ComputeStatsInput, type IncrementalStats, computeStats, renderSummary, telemetryAttributes };

package/dist/incremental-stats.js

@@ -0,0 +1,10 @@
+import {
+  computeStats,
+  renderSummary,
+  telemetryAttributes
+} from "./chunk-KHVTYIIX.js";
+export {
+  computeStats,
+  renderSummary,
+  telemetryAttributes
+};

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+export { DeployContent, DeployOptions, DeployResult, deploy } from './deploy.js';
+export { PoolAccount, PoolAuthorization, bootstrapPool, derivePoolAccounts, ensureAuthorized, fetchPoolAuthorizations, selectAccount } from './pool.js';
+export { DEFAULT_MNEMONIC, DotNS, DotNSConnectOptions, OwnershipResult, ParsedDomainName, PriceValidationResult, parseDomainName, sanitizeDomainLabel } from './dotns.js';
+export { MerkleizeResult, MerkleizeStableResult, merkleizeJS, merkleizeWithStableOrder } from './merkle.js';
+export { EmbeddedManifest, FileType, MANIFEST_DIR, MANIFEST_FILENAME, MANIFEST_PATH, MANIFEST_VERSION, ManifestFileEntry, ParseResult, classifyFile, isVolatilePath, parseManifest } from './manifest.js';
+export { ChainProbeOptions, ChunkProbeResult, probeChunks } from './chunk-probe.js';
+export { finaliseEmbeddedManifest, writeEmbeddedManifestPlaceholder } from './manifest-embed.js';
+export { FetchOptions, FetchOutcome, fetchPreviousManifest } from './manifest-fetch.js';
+export { ComputeStatsInput, IncrementalStats, computeStats, renderSummary, telemetryAttributes } from './incremental-stats.js';
+export { Chain, ChainEndpoint, DEFAULT_ENV_ID, Environment, EnvironmentListing, EnvironmentsDoc, EnvironmentsSource, LoadOptions, LoadResult, ResolvedEndpoints, defaultBundledPath, formatEnvironmentTable, isValidContractAddress, listEnvironments, loadEnvironments, resolveEndpoints, validateContractAddresses } from './environments.js';
+export { RunState, RunStatus, VERSION, loadRunState, probablyOomRssMb, resolveStateDir, shouldShowOomHint, shouldSkipStaleWarning, stateFilePath, writeRunState } from './run-state.js';
+export { AppExecutableConfig, AppManifest, AppVersion, ExecutableConfig, ExecutableKind, ExecutableManifest, Icon, IconConfig, IconFormat, ProductConfig, RootManifest, WidgetDimensions, WidgetExecutableConfig, WidgetManifest, WorkerExecutableConfig, WorkerIncludes, WorkerManifest, defineConfig } from './manifest/types.js';
+export { ValidationErr, ValidationOk, ValidationResult, validateExecutableManifest, validateProductConfig, validateRootManifest } from './manifest/schema.js';
+export { BudgetCheck, DEFAULT_TEXT_RECORD_BUDGET_BYTES, PLACEHOLDER_CID, PessimisticSizeReport, assertWithinBudget, getTextRecordBudgetBytes, pessimisticSizePreflight } from './manifest/byte-budget.js';
+export { LoadProductConfigOptions, LoadedProductConfig, loadProductConfig, tryLoadProductConfig } from './manifest/config-load.js';
+export { PublishManifestOptions, PublishManifestResult, publishManifest } from './manifest/publish.js';
+import 'multiformats/cid';
+import 'polkadot-api';
+import './errors.js';
+import './personhood/bootstrap.js';
+import './personhood/bind-personal-id.js';
+import './personhood/claim-pgas.js';
+import './personhood/bind-paid-alias.js';

package/dist/index.js

@@ -0,0 +1,146 @@
+import {
+  defineConfig
+} from "./chunk-GZD2UFLR.js";
+import {
+  loadProductConfig,
+  tryLoadProductConfig
+} from "./chunk-MMAZFJDG.js";
+import {
+  publishManifest
+} from "./chunk-NF2FL4ZO.js";
+import {
+  DEFAULT_TEXT_RECORD_BUDGET_BYTES,
+  PLACEHOLDER_CID,
+  assertWithinBudget,
+  getTextRecordBudgetBytes,
+  pessimisticSizePreflight
+} from "./chunk-RI3ZLNPN.js";
+import {
+  validateExecutableManifest,
+  validateProductConfig,
+  validateRootManifest
+} from "./chunk-LZJMVPYW.js";
+import {
+  deploy,
+  merkleizeJS,
+  merkleizeWithStableOrder
+} from "./chunk-P6CHOMN3.js";
+import {
+  computeStats,
+  renderSummary,
+  telemetryAttributes
+} from "./chunk-KHVTYIIX.js";
+import {
+  finaliseEmbeddedManifest,
+  writeEmbeddedManifestPlaceholder
+} from "./chunk-KOSF5FDO.js";
+import {
+  fetchPreviousManifest
+} from "./chunk-FZWJV5AD.js";
+import {
+  MANIFEST_DIR,
+  MANIFEST_FILENAME,
+  MANIFEST_PATH,
+  MANIFEST_VERSION,
+  classifyFile,
+  isVolatilePath,
+  parseManifest
+} from "./chunk-S7EM5VMW.js";
+import "./chunk-ADNBLFDP.js";
+import "./chunk-43HLT335.js";
+import {
+  probeChunks
+} from "./chunk-QTZNULSH.js";
+import "./chunk-C2TS5MER.js";
+import {
+  DEFAULT_MNEMONIC,
+  DotNS,
+  parseDomainName,
+  sanitizeDomainLabel
+} from "./chunk-DNXH4QTI.js";
+import {
+  bootstrapPool,
+  derivePoolAccounts,
+  ensureAuthorized,
+  fetchPoolAuthorizations,
+  selectAccount
+} from "./chunk-QMYW3D6E.js";
+import "./chunk-MFTODIIT.js";
+import {
+  VERSION,
+  loadRunState,
+  probablyOomRssMb,
+  resolveStateDir,
+  shouldShowOomHint,
+  shouldSkipStaleWarning,
+  stateFilePath,
+  writeRunState
+} from "./chunk-KJH2T5TQ.js";
+import {
+  DEFAULT_ENV_ID,
+  defaultBundledPath,
+  formatEnvironmentTable,
+  isValidContractAddress,
+  listEnvironments,
+  loadEnvironments,
+  resolveEndpoints,
+  validateContractAddresses
+} from "./chunk-OITUIM2E.js";
+import "./chunk-ZOC4GITL.js";
+import "./chunk-HOTQDYHD.js";
+export {
+  DEFAULT_ENV_ID,
+  DEFAULT_MNEMONIC,
+  DEFAULT_TEXT_RECORD_BUDGET_BYTES,
+  DotNS,
+  MANIFEST_DIR,
+  MANIFEST_FILENAME,
+  MANIFEST_PATH,
+  MANIFEST_VERSION,
+  PLACEHOLDER_CID,
+  VERSION,
+  assertWithinBudget,
+  bootstrapPool,
+  classifyFile,
+  computeStats,
+  defaultBundledPath,
+  defineConfig,
+  deploy,
+  derivePoolAccounts,
+  ensureAuthorized,
+  fetchPoolAuthorizations,
+  fetchPreviousManifest,
+  finaliseEmbeddedManifest,
+  formatEnvironmentTable,
+  getTextRecordBudgetBytes,
+  isValidContractAddress,
+  isVolatilePath,
+  listEnvironments,
+  loadEnvironments,
+  loadProductConfig,
+  loadRunState,
+  merkleizeJS,
+  merkleizeWithStableOrder,
+  parseDomainName,
+  parseManifest,
+  pessimisticSizePreflight,
+  probablyOomRssMb,
+  probeChunks,
+  publishManifest,
+  renderSummary,
+  resolveEndpoints,
+  resolveStateDir,
+  sanitizeDomainLabel,
+  selectAccount,
+  shouldShowOomHint,
+  shouldSkipStaleWarning,
+  stateFilePath,
+  telemetryAttributes,
+  tryLoadProductConfig,
+  validateContractAddresses,
+  validateExecutableManifest,
+  validateProductConfig,
+  validateRootManifest,
+  writeEmbeddedManifestPlaceholder,
+  writeRunState
+};

package/dist/manifest/byte-budget.d.ts

@@ -0,0 +1,46 @@
+import { ProductConfig } from './types.js';
+
+/**
+ * Byte-budget guards for dotNS text-record writes.
+ *
+ * This module ships a conservative default with a `BULLETIN_TEXT_BUDGET` env override so
+ * publishers can probe larger payloads when the on-chain cap is raised.
+ */
+
+declare const DEFAULT_TEXT_RECORD_BUDGET_BYTES = 1024;
+/**
+ * Fixed-length stand-in for a Bulletin CID in the pre-upload size preflight.
+ *
+ * CIDv1(raw, sha256, 32B) base32-encodes to exactly 59 characters per the
+ * RFC §Constants table, so substituting any 59-char CID-like string lets us
+ * size manifests deterministically before the icon and executables have
+ * actually been uploaded.
+ */
+declare const PLACEHOLDER_CID = "bafkreigh2akiscaildc7zh3vznzaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+/** Resolved text-record byte budget, from `BULLETIN_TEXT_BUDGET` or the default. */
+declare function getTextRecordBudgetBytes(): number;
+interface BudgetCheck {
+    ok: boolean;
+    key: string;
+    bytes: number;
+    budget: number;
+}
+/** Check a single serialised value against the budget, in UTF-8 bytes. */
+declare function assertWithinBudget(key: string, serialized: string, budget: number): BudgetCheck;
+interface PessimisticSizeReport {
+    ok: boolean;
+    budget: number;
+    checks: BudgetCheck[];
+}
+/**
+ * Pre-upload size check for every text record the publish flow will write.
+ *
+ * Composes each manifest with `PLACEHOLDER_CID` substituted for the real
+ * Bulletin CIDs (which aren't known until Step 4 of the publish flow) and
+ * verifies the serialised JSON fits within `budget`. Lets the publisher
+ * abort cleanly before any chain writes when a config would otherwise
+ * trip the dotNS wire-level cap.
+ */
+declare function pessimisticSizePreflight(config: ProductConfig, budget?: number): PessimisticSizeReport;
+
+export { type BudgetCheck, DEFAULT_TEXT_RECORD_BUDGET_BYTES, PLACEHOLDER_CID, type PessimisticSizeReport, assertWithinBudget, getTextRecordBudgetBytes, pessimisticSizePreflight };

package/dist/manifest/byte-budget.js

@@ -0,0 +1,14 @@
+import {
+  DEFAULT_TEXT_RECORD_BUDGET_BYTES,
+  PLACEHOLDER_CID,
+  assertWithinBudget,
+  getTextRecordBudgetBytes,
+  pessimisticSizePreflight
+} from "../chunk-RI3ZLNPN.js";
+export {
+  DEFAULT_TEXT_RECORD_BUDGET_BYTES,
+  PLACEHOLDER_CID,
+  assertWithinBudget,
+  getTextRecordBudgetBytes,
+  pessimisticSizePreflight
+};

package/dist/manifest/config-load.d.ts

@@ -0,0 +1,36 @@
+import { ProductConfig } from './types.js';
+
+/**
+ * Load the developer-authored `bulletin-deploy.config.ts`.
+ *
+ * Configs are TypeScript so authors get IntelliSense on the discriminated
+ * `kind` union. We evaluate them at runtime via [jiti](https://github.com/unjs/jiti)
+ * and route the default export through [`validateProductConfig`](./schema.ts).
+ * TS types are erased at runtime, so a literal like `"jpg"` where the type
+ * says `"jpeg" | "png"` still needs a runtime check.
+ */
+
+interface LoadProductConfigOptions {
+    /** Explicit path to a config file. Takes precedence over auto-discovery. */
+    path?: string;
+    /** Directory to search when no explicit path is supplied. Defaults to process.cwd(). */
+    cwd?: string;
+    /** When true, walks up parent directories from `cwd` until a config is found or the fs root is reached. */
+    walkUp?: boolean;
+}
+interface LoadedProductConfig {
+    config: ProductConfig;
+    sourcePath: string;
+}
+/** Load + validate a product config, throwing on missing-file or schema errors. */
+declare function loadProductConfig(options?: LoadProductConfigOptions): Promise<LoadedProductConfig>;
+/**
+ * Like [`loadProductConfig`](./config-load.ts) but returns `null` when no config is discoverable.
+ *
+ * Schema errors and explicit-path-not-found still throw. This is the opt-in
+ * shape the deploy CLI uses to enter manifest mode only when a config is
+ * present, without making the user pass a flag.
+ */
+declare function tryLoadProductConfig(options?: LoadProductConfigOptions): Promise<LoadedProductConfig | null>;
+
+export { type LoadProductConfigOptions, type LoadedProductConfig, loadProductConfig, tryLoadProductConfig };

package/dist/manifest/config-load.js

@@ -0,0 +1,10 @@
+import {
+  loadProductConfig,
+  tryLoadProductConfig
+} from "../chunk-MMAZFJDG.js";
+import "../chunk-LZJMVPYW.js";
+import "../chunk-ZOC4GITL.js";
+export {
+  loadProductConfig,
+  tryLoadProductConfig
+};

package/dist/manifest/publish.d.ts

@@ -0,0 +1,54 @@
+import { LoadedProductConfig } from './config-load.js';
+import './types.js';
+
+/**
+ * Manifest publish orchestrator for RFC paritytech/triangle-js-sdks #0001 Steps 4 through 7.
+ *
+ * Wires [`storeFile`](../deploy.ts) and [`storeDirectory`](../deploy.ts) for
+ * Bulletin uploads with [`DotNS`](../dotns.ts) for the on-chain text-record
+ * writes. Phase 4/5 atomicity work (`Utility.batchAll`, snapshot/rollback,
+ * Step 8 round-trip verify) is deliberately deferred. Sequential
+ * best-effort writes keep this module small while the broader plan in
+ * `docs-internal/superpowers/plans/2026-05-20-product-manifest-support.md`
+ * tracks the follow-ups.
+ */
+
+interface PublishManifestOptions {
+    /** Loaded + validated product config (call loadProductConfig first). */
+    loaded: LoadedProductConfig;
+    /** Domain the legacy deploy targeted. Must match config.domain. */
+    domain: string;
+    /**
+     * Build-dir argument passed to the CLI plus the CID it produced. When the
+     * resolved path of an executable in the config matches buildDir, we reuse
+     * this CID instead of re-uploading the same bytes.
+     */
+    buildDirCid?: {
+        absPath: string;
+        cid: string;
+    };
+    /** Env id (e.g. "paseo-next-v2"). Drives RPC + contract resolution. */
+    env?: string;
+    /** Optional bulletin RPC override. */
+    rpc?: string;
+    /** Required: signer mnemonic. */
+    mnemonic?: string;
+    /** Optional Substrate-style derivation path. */
+    derivationPath?: string;
+}
+interface PublishManifestResult {
+    iconCid: string;
+    executableCids: Record<string, string>;
+    textRecordsWritten: number;
+}
+/**
+ * Publish a product manifest on top of an already-completed legacy deploy.
+ *
+ * Uploads the icon and any executables that aren't covered by `buildDirCid`,
+ * then writes the root + per-executable text records on dotNS. Subnames
+ * (`app|widget|worker.<domain>`) are created on demand and pointed at the
+ * content resolver before any `setText`.
+ */
+declare function publishManifest(opts: PublishManifestOptions): Promise<PublishManifestResult>;
+
+export { type PublishManifestOptions, type PublishManifestResult, publishManifest };